{"version":3,"mappings":"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","names":["bail","error","hasOwn","toStr","defineProperty","gOPD","isArray","arr","isPlainObject","obj","hasOwnConstructor","hasIsPrototypeOf","key","setProperty","target","options","getProperty","name","extend","src","copy","copyIsArray","clone","i","length","deep","value","prototype","trough","fns","pipeline","run","use","values","middlewareIndex","callback","next","output","fn","index","wrap","middelware","middleware","called","wrapped","parameters","fnExpectsCallback","result","done","exception","then","stringifyPosition","position","point","pos","VFileMessage","causeOrReason","optionsOrParentOrPlace","origin","reason","legacyCause","parent","start","minpath","basename","dirname","extname","join","path","assertPath","end","seenNonSlash","firstNonSlashEnd","extnameIndex","unmatchedSlash","startPart","startDot","preDotState","code","segments","joined","normalize","absolute","normalizeString","allowAboveRoot","lastSegmentLength","lastSlash","dots","lastSlashIndex","minproc","cwd","isUrl","fileUrlOrPath","urlToPath","getPathFromURLPosix","url","pathname","third","order","VFile","isUint8Array","field","assertNonEmpty","assertPart","stem","message","encoding","part","CallableInstance","property","proto","apply","own","Processor","destination","attacher","assertUnfrozen","self","transformer","file","realFile","vfile","parser","assertParser","assertCompiler","executor","resolve","reject","parseTree","tree","realDone","compileTree","compileResult","looksLikeAValue","complete","assertDone","assertNode","transformers","outputTree","resultingTree","compiler","attachers","namespace","addPlugin","addList","addPreset","add","plugin","plugins","thing","entryIndex","primary","rest","currentPrimary","isPlainObj","unified","frozen","node","asyncName","looksLikeAVFile","blockquote","state","hardBreak","properties","language","strikethrough","emphasis","asciiAlpha","regexCheck","asciiAlphanumeric","asciiAtext","asciiControl","asciiDigit","asciiHexDigit","asciiPunctuation","markdownLineEnding","markdownLineEndingOrSpace","markdownSpace","unicodePunctuation","unicodeWhitespace","regex","check","normalizeUri","skip","replace","footnoteReference","clobberPrefix","id","safeId","counter","reuseCounter","link","sup","heading","html","revert","subtype","suffix","contents","head","tail","imageReference","definition","image","inlineCode","text","linkReference","listItem","results","loose","listLoose","listItemLoose","children","paragraph","child","spread","list","root","strong","pointEnd","pointStart","type","table","rows","firstRow","tableContent","body","tableRow","siblings","tagName","align","cellIndex","cells","cell","alignValue","tableCell","tab","space","trimLines","source","search","match","last","lines","trimLine","startIndex","endIndex","thematicBreak","handlers","ignore","VOID","PRIMITIVE","ARRAY","OBJECT","DATE","REGEXP","MAP","SET","ERROR","BIGINT","env","deserializer","$","_","as","out","unpair","object","flags","map","set","buffer","deserialize","serialized","EMPTY","toString","keys","typeOf","asString","shouldSkip","TYPE","serializer","strict","json","pair","entry","entries","serialize","lossy","structuredClone$1","any","defaultFootnoteBackContent","rereferenceIndex","defaultFootnoteBackLabel","referenceIndex","footer","footnoteBackContent","footnoteBackLabel","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","listItems","content","backReferences","counts","tailTail","structuredClone","convert","test","ok","castFactory","anyFactory","propertiesFactory","typeFactory","tests","checks","checkAsRecord","all","nodeAsRecord","testFunction","looksLikeANode","empty","CONTINUE","EXIT","SKIP","visitParents","visitor","reverse","is","step","factory","parents","visit","subresult","offset","grandparents","toResult","nodeAsParent","testOrVisitor","visitorOrReverse","maybeReverse","overload","emptyOptions","createState","settings","definitionById","footnoteById","footnoteCounts","defaultHandlers","applyData","one","patch","handle","shallow","defaultUnknownHandler","nodes","trimMarkdownSpaceStart","from","to","hName","hChildren","hProperties","data","toHast","foot","remarkRehype","hastTree","htmlVoidElements","Schema","normal","merge","definitions","Info","attribute","powers","boolean","increment","booleanish","overloadedBoolean","number","spaceSeparated","commaSeparated","commaOrSpaceSeparated","types","DefinedInfo","mask","mark","create","normals","info","aria","caseSensitiveTransform","attributes","caseInsensitiveTransform","svg","xlink","xmlns","xml","cap","dash","valid","find","schema","Type","camelcase","dashes","kebab","$0","htmlBase","svgBase","zwitch","defaultSubsetRegex","surrogatePairsRegex","controlCharactersRegex","regexEscapeRegex","subsetToRegexCache","core","charactersToExpressionCached","basic","surrogate","character","subset","cached","charactersToExpression","groups","hexadecimalRegex","toHexadecimal","omit","decimalRegex","toDecimal","characterEntitiesLegacy","characterEntitiesHtml4","dangerous","characters","notAlphanumericRegex","toNamed","formatSmart","numeric","named","decimal","stringifyEntities","htmlCommentRegex","bogusCommentEntitySubset","commentEntitySubset","comment","_1","_2","encode","doctype","_3","ccount","count","stringify","re","whitespace","siblingAfter","siblingBefore","emptyChildren","sibling","includeWhitespace","omission","closing","headOrColgroupOrCaption","dd","dt","li","optgroup","option","p","rubyElement","tbody","tfoot","thead","tr","opening","colgroup","seen","previous","constants","element","selfClosing","parts","serializeAttributes","serializeAttribute","x","y","quote","commas","spaces","textEntitySubset","raw","invalid","unknown","node_","emptyCharacterReferences","toHtml","options_","alternative","rehypeStringify","processor","ctx","html_tag","raw_value","$$props","$$invalidate","insert_hydration","div","anchor","portal","el","targetEl","update","newTarget","tick","destroy","constants_0","div_1","if_block","create_if_block","show","onHide","updatePosition","rect","divWidth","top","left","showing","maybeFadeIn","transitionend_handler","$$value","t_value","dirty","set_data","t","t1_value","current","t1","t0_value","_a","t2_value","_b","div2","append_hydration","div0","div1","t0","t2","inspect","watch","ref","inspection","callbacks","stopWatching","onDestroy","outerColor","classColor","valueColor","mouseenter_handler","attr","a","a_href_value","a_title_value","currentConsole","writable","currentConsolePush","includeImageAlt","includeHtml","decodeNamedCharacterReference","characterReference","splice","remove","items","chunkStart","push","hasOwnProperty","combineExtensions","extensions","syntaxExtension","extension","hook","right","constructs","existing","before","decodeNumericCharacterReference","base","normalizeIdentifier","factorySpace","effects","max","limit","size","prefix","initializeContent","contentStart","afterContentStartConstruct","paragraphInitial","lineStart","token","document","initializeDocument","containerConstruct","tokenizeContainer","stack","continued","childFlow","childToken","lineStartOffset","item","documentContinue","checkNewContainers","closeFlow","indexBeforeExits","indexBeforeFlow","exitContainers","documentContinued","flowStart","thereIsANewContainer","thereIsNoNewContainer","containerContinue","flowContinue","writeToChild","endOfFile","stream","nok","classifyCharacter","resolveAll","events","context","attention","resolveAllAttention","tokenizeAttention","open","group","openingSequence","closingSequence","nextEvents","movePoint","attentionMarkers","marker","inside","after","close","autolink","tokenizeAutolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","blankLine","tokenizeBlankLine","blockQuote","tokenizeBlockQuoteContinuation","exit","tokenizeBlockQuoteStart","contStart","contBefore","characterEscape","tokenizeCharacterEscape","tokenizeCharacterReference","nonLazyContinuation","tokenizeNonLazyContinuation","codeFenced","tokenizeCodeFenced","closeStart","tokenizeCloseStart","initialPrefix","sizeOpen","beforeSequenceOpen","sequenceOpen","infoBefore","atNonLazyBreak","metaBefore","meta","contentBefore","beforeContentChunk","contentChunk","startBefore","beforeSequenceClose","sequenceClose","sequenceCloseAfter","codeIndented","tokenizeCodeIndented","furtherStart","tokenizeFurtherStart","afterPrefix","atBreak","codeText","resolveCodeText","tokenizeCodeText","tailExitIndex","headEnterIndex","enter","between","SpliceBuffer","initial","stop","deleteCount","removed","chunkedPush","n","subtokenize","eventsArray","jumps","event","lineIndex","otherIndex","otherEvent","subevents","more","subcontent","eventIndex","startPosition","startPositions","tokenizer","childEvents","gaps","adjust","breaks","slice","resolveContent","tokenizeContent","continuationConstruct","tokenizeContinuation","chunkInside","contentEnd","contentContinue","startLookahead","prefixed","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","enclosedBefore","enclosed","enclosedEscape","rawEscape","factoryLabel","markerType","labelInside","labelEscape","factoryTitle","begin","escape","factoryWhitespace","tokenizeDefinition","titleBefore","tokenizeTitleBefore","identifier","labelAfter","markerAfter","destinationBefore","destinationAfter","afterWhitespace","beforeMarker","titleAfter","titleAfterOptionalWhitespace","hardBreakEscape","tokenizeHardBreakEscape","headingAtx","resolveHeadingAtx","tokenizeHeadingAtx","sequenceFurther","htmlBlockNames","htmlRawNames","htmlFlow","resolveToHtmlFlow","tokenizeHtmlFlow","blankLineBefore","tokenizeBlankLineBefore","nonLazyContinuationStart","tokenizeNonLazyContinuationStart","closingTag","markerB","declarationOpen","tagCloseStart","continuationDeclarationInside","commentOpenInside","cdataOpenInside","continuation","slash","basicSelfClosing","completeClosingTagAfter","completeAttributeNameBefore","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCdataInside","continuationAfter","continuationStart","continuationStartNonLazy","continuationBefore","continuationRawEndTag","htmlText","tokenizeHtmlText","returnState","instruction","tagOpen","declaration","commentEnd","commentClose","lineEndingBefore","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","lineEndingAfter","lineEndingAfterPrefix","labelEnd","resolveAllLabelEnd","resolveToLabelEnd","tokenizeLabelEnd","resourceConstruct","tokenizeResource","referenceFullConstruct","tokenizeReferenceFull","referenceCollapsedConstruct","tokenizeReferenceCollapsed","newEvents","media","label","labelStart","defined","labelEndNok","labelEndOk","referenceNotFull","resourceStart","resourceBefore","resourceOpen","resourceEnd","resourceDestinationAfter","resourceDestinationMissing","resourceBetween","resourceTitleAfter","referenceFull","referenceFullAfter","referenceFullMissing","referenceCollapsedStart","referenceCollapsedOpen","labelStartImage","tokenizeLabelStartImage","labelStartLink","tokenizeLabelStartLink","lineEnding","tokenizeLineEnding","tokenizeThematicBreak","sequence","tokenizeListContinuation","tokenizeListEnd","tokenizeListStart","listItemPrefixWhitespaceConstruct","tokenizeListItemPrefixWhitespace","indentConstruct","tokenizeIndent","initialSize","kind","atMarker","onBlank","endOfPrefix","otherPrefix","notBlank","notInCurrentItem","setextUnderline","resolveToSetextUnderline","tokenizeSetextUnderline","flow","initializeFlow","atBlankEnding","afterConstruct","resolver","createResolver","string","initializeFactory","resolveAllLineSuffixes","initializeText","notText","extraResolver","resolveAllText","chunks","bufferIndex","tabs","chunk","contentInitial","flowInitial","insideSpan","resolveText","disable","createTokenizer","initialize","columnStart","resolveAllConstructs","constructFactory","onsuccessfulconstruct","onsuccessfulcheck","consume","defineSkip","now","sliceSerialize","sliceStream","write","main","addResult","expandTabs","serializeChunks","sliceChunks","_bufferIndex","_index","line","column","accountForPotentialSkip","chunkIndex","go","fields","construct","onreturn","bogusState","listOfConstructs","constructIndex","currentConstruct","handleListOfConstructs","handleMapOfConstructs","handleConstruct","store","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","restore","startBufferIndex","endBufferIndex","view","atTab","parse","defaultConstructs","creator","postprocess","preprocess","atCarriageReturn","preprocessor","endPosition","characterEscapeOrReference","decodeString","decode","$1","$2","hex","fromMarkdown","config","opener","onenterdata","codeFlow","onenterlistitemvalue","onenterlistordered","onenterreference","closer","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","onexitdata","onexitcharacterreferencemarker","onexitcharacterreferencevalue","onexitcharacterreference","onexitcodefenced","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","onexitresource","onexitsetextheading","onexitsetextheadinglinesequence","onexitsetextheadingtext","configure","compile","resume","listStack","prepareList","handler","defaultOnError","containerBalance","listSpread","firstBlankLineIndex","tailIndex","tailEvent","and","errorHandler","onExitError","ancestor","depth","referenceType","fragment","d","combined","remarkParse","doc","escapeStringRegexp","findAndReplace","ignored","pairs","toPairs","pairIndex","grandparent","change","matchObject","tupleOrList","tuple","toExpression","toFunction","inConstruct","notInConstruct","gfmAutolinkLiteralFromMarkdown","transformGfmAutolinkLiterals","enterLiteralAutolink","enterLiteralAutolinkValue","exitLiteralAutolink","exitLiteralAutolinkEmail","exitLiteralAutolinkHttp","exitLiteralAutolinkWww","gfmAutolinkLiteralToMarkdown","findUrl","findEmail","protocol","domain","isCorrectDomain","splitUrl","atext","trailExec","trail","closingParenIndex","openingParens","closingParens","email","footnoteReferencePeek","enterFootnoteCallString","enterFootnoteCall","enterFootnoteDefinitionLabelString","enterFootnoteDefinition","exitFootnoteCallString","exitFootnoteCall","exitFootnoteDefinitionLabelString","exitFootnoteDefinition","tracker","subexit","gfmFootnoteFromMarkdown","gfmFootnoteToMarkdown","firstLineBlank","footnoteDefinition","mapAll","mapExceptFirst","blank","constructsWithoutStrikethrough","handleDelete","peekDelete","gfmStrikethroughFromMarkdown","enterStrikethrough","exitStrikethrough","gfmStrikethroughToMarkdown","defaultStringLength","markdownTable","stringLength","alignments","cellMatrix","sizeMatrix","longestCellByColumn","mostCellsPerRow","rowIndex","row","sizes","columnIndex","toAlignment","patternInScope","pattern","listInScope","none","longestStreak","substring","expected","formatCodeAsIndented","checkFence","checkQuote","checkEmphasis","encodeCharacterReference","encodeInfo","outside","outsideKind","insideKind","emphasisPeek","betweenHead","betweenTail","formatHeadingAsSetext","literalWithBreak","rank","htmlPeek","imagePeek","imageReferencePeek","alt","reference","inlineCodePeek","expression","formatLinkAsAutolink","linkPeek","linkReferencePeek","checkBullet","checkBulletOther","bullet","bulletOther","checkBulletOrdered","checkRule","bulletCurrent","useDifferentMarker","firstListItem","checkListItemIndent","style","listItemIndent","phrasing","checkStrong","strongPeek","checkRuleRepetition","repetition","gfmTableFromMarkdown","enterTable","enterCell","enterRow","exitCodeText","exitTable","gfmTableToMarkdown","padding","alignDelimiters","around","inlineCodeWithTable","handleTable","handleTableCell","handleTableRow","serializeData","handleTableAsData","handleTableRowAsData","matrix","gfmTaskListItemFromMarkdown","exitCheck","exitParagraphWithTaskListItem","gfmTaskListItemToMarkdown","listItemWithTaskListItem","firstParaghraph","checkable","checkbox","gfmFromMarkdown","gfmToMarkdown","wwwPrefix","tokenizeWwwPrefix","tokenizeDomain","tokenizePath","tokenizeTrail","emailDomainDotTrail","tokenizeEmailDomainDotTrail","wwwAutolink","tokenizeWwwAutolink","previousWww","protocolAutolink","tokenizeProtocolAutolink","previousProtocol","emailAutolink","tokenizeEmailAutolink","previousEmail","gfmAutolinkLiteral","dot","gfmAtext","previousUnbalanced","emailDomain","emailDomainAfter","emailDomainDot","wwwStart","wwwAfter","protocolStart","protocolPrefixInside","protocolSlashesInside","afterProtocol","protocolAfter","wwwPrefixInside","wwwPrefixAfter","underscoreInLastSegment","underscoreInLastLastSegment","domainInside","domainAfter","domainAtPunctuation","sizeClose","pathInside","pathAtPunctuation","trailCharacterReferenceStart","trailBracketAfter","trailCharacterReferenceInside","indent","gfmFootnote","tokenizeDefinitionStart","tokenizeDefinitionContinuation","gfmFootnoteDefinitionEnd","tokenizeGfmFootnoteCall","tokenizePotentialGfmFootnoteCall","resolveToPotentialGfmFootnoteCall","call","replacement","callStart","callData","callEscape","labelAtMarker","whitespaceAfter","gfmStrikethrough","single","tokenizeStrikethrough","resolveAllStrikethrough","EditMap","addImplementation","b","vecs","editMap","at","gfmTableAlign","inDelimiterRow","alignIndex","gfmTable","tokenizeTable","resolveTable","sizeB","bodyRowStart","headRowBefore","headRowStart","headRowBreak","headDelimiterStart","headRowData","headRowEscape","headDelimiterBefore","headDelimiterValueBefore","headDelimiterCellBefore","headDelimiterNok","headDelimiterLeftAlignmentAfter","headDelimiterCellAfter","headDelimiterFiller","headDelimiterRightAlignmentAfter","bodyRowBreak","bodyRowData","bodyRowEscape","inFirstCellAwaitingPipe","rowKind","lastCell","afterHeadAwaitingFirstBodyRow","lastTableEnd","currentTable","currentBody","currentCell","flushTableEnd","flushCell","range","rowEnd","previousCell","groupName","valueName","getPoint","relatedStart","relatedEnd","valueToken","tableBody","exits","related","side","tasklistCheck","tokenizeTasklistCheck","gfmTaskListItem","spaceThenNonSpace","gfm","remarkGfm","micromarkExtensions","fromMarkdownExtensions","toMarkdownExtensions","article","router_changes","withToast","anyFunction","args","promise","toast","toastMarkdown","markdown","BaseMarkdown","handleClick","if_block0","create_if_block_2","if_block1","create_if_block_1","usecopy_changes","button","is_function","fadeIn","runnable","$currentConsolePush","globalCache","cacheGlobally","cache","cacheSingleton","UNSET","something","doClone","cloneArray","cloneObj","r","len","mergeObjects","sources","idx","CAPTURING_REGEX_SOURCE","RegexSource","regexSource","captureSource","captureIndices","commandIndex","command","capture","strcmp","strArrCmp","len1","len2","res","isValidHexColor","escapeRegExpCharacters","CachedFn","__publicField","Theme","_colorMap","_defaults","_root","scopeName","colorMap","parseTheme","resolveParsedThemeRules","scopePath","effectiveRule","v","_scopePathMatchesParentScopes","StyleAttributes","ScopeStack","_ScopeStack","scopeNames","other","parentScopes","scopePattern","scopeMustMatch","_matchesScope","fontStyle","foregroundId","backgroundId","resultLen","scopes","_scope","j","lenJ","foreground","background","scope","ParsedThemeRule","FontStyle","FontStyle2","parsedThemeRules","defaultFontStyle","defaultForeground","defaultBackground","incomingDefaults","ColorMap","defaults","ThemeTrieElement","ThemeTrieElementRule","rule","color","emptyParentScopes","_ThemeTrieElementRule","scopeDepth","_ThemeTrieElement","_mainRule","rulesWithParentScopes","_children","aParentIndex","bParentIndex","parentScopeLengthDiff","dotIndex","rules","EncodedTokenMetadata","_EncodedTokenMetadata","encodedTokenAttributes","languageId","tokenType","containsBalancedBrackets","_languageId","_tokenType","_containsBalancedBracketsBit","_fontStyle","_foreground","_background","createMatchers","selector","matchesName","newTokenizer","priority","matcher","parseConjunction","parseOperand","expressionToNegate","matcherInput","expressionInParents","parseInnerExpression","isIdentifier","identifiers","matchers","matcher2","input","disposeOnigString","str","TopLevelRuleReference","TopLevelRepositoryRuleReference","ruleName","ExternalReferenceCollector","ScopeDependencyProcessor","repo","initialScopeName","q","deps","dep","collectReferencesOfReference","baseGrammarScopeName","selfGrammar","baseGrammar","collectExternalReferencesInTopLevelRule","collectExternalReferencesInTopLevelRepositoryRule","injections","injection","collectExternalReferencesInRules","patternRepository","include","parseInclude","newContext","BaseReference","SelfReference","RelativeReference","TopLevelReference","TopLevelRepositoryReference","indexOfSharp","HAS_BACK_REFERENCES","BACK_REFERENCING_END","endRuleId","whileRuleId","Rule","$location","contentName","location","lineText","CaptureRule","retokenizeCapturedWithRuleId","grammar","endRegexSource","allowA","allowG","MatchRule","captures","RegExpSource","RegExpSourceList","IncludeOnlyRule","patterns","BeginEndRule","beginCaptures","endCaptures","applyEndPatternLast","BeginWhileRule","_while","whileCaptures","RuleFactory","_RuleFactory","helper","desc","repository","maximumCaptureId","captureId","numericCaptureId","ruleId","localIncludedRule","externalGrammarName","externalGrammarInclude","externalGrammar","externalIncludedRule","skipRule","_RegExpSource","regExpSource","lastPushedPos","hasAnchor","nextCh","newSource","capturedValues","g1","A0_G0_result","A0_G1_result","A1_G0_result","A1_G1_result","ch","onigLib","regExps","e","CompiledRule","BasicScopeAttributes","BasicScopeAttributesProvider","initialLanguageId","embeddedLanguages","standardTokenType","ScopeMatcher","m","escapedScopes","TokenizeStringResult","stoppedEarly","_tokenizeString","isFirstLine","linePos","lineTokens","checkWhileConditions","timeLimit","lineLength","STOP","anchorPosition","whileCheckResult","_checkWhileConditions","startTime","scanNext","matchRuleOrInjections","matchedRuleId","hasAdvanced","poppedRule","handleCaptures","popped","_rule","beforePush","nameScopesList","pushedRule","contentNameScopesList","whileRules","nodeRule","whileRule","ruleScanner","findOptions","prepareRuleWhileSearch","matchResult","matchRule","injectionResult","matchInjections","matchResultScore","injectionResultScore","prepareRuleSearch","bestMatchRating","bestMatchCaptureIndices","bestMatchRuleId","bestMatchResultPriority","matchRating","lineTextContent","localStack","maxEnd","captureRule","captureIndex","stackClone","onigSubStr","captureRuleScopeName","captureRuleScopesList","LocalStackElement","endPos","createGrammar","initialLanguage","tokenTypes","balancedBracketSelectors","grammarRepository","Grammar","collectInjections","ruleFactoryHelper","nameMatcher","identifers","lastIndex","scopesAreMatching","thisScopeName","_rootScopeName","_onigLib","initGrammar","scopeName2","rawInjections","injectionScopeNames","injectionScopeName","injectionGrammar","i1","i2","rawIncludedGrammar","prevState","emitBinaryTokens","StateStackImpl","rawDefaultMetadata","defaultStyle","defaultMetadata","rootScopeName","scopeList","AttributedScopeStack","onigLineText","LineTokens","_AttributedScopeStack","tokenAttributes","namesScopeList","frame","rawRootMetadata","rootStyle","resolvedTokenAttributes","existingTokenAttributes","basicScopeAttributes","styleAttributes","rawMetadata","newPath","scopeThemeMatchResult","metadata","enterPos","anchorPos","beginRuleCapturedEOL","endRule","outIndex","contentNameScopeStack","_c","BalancedBracketSelectors","balancedBracketScopes","unbalancedBracketScopes","excluder","includer","tokenTypeOverrides","scopesList","scopes2","SyncRegistry","theme","targetScope","rawGrammar","Registry","configuration","dependencyProcessor","request","INITIAL","resolveColorReplacements","replacements","themeName","applyColorReplacements","toArray","normalizeGetter","isPlainLang","lang","isSpecialLang","isNoneTheme","isSpecialTheme","addClassToHast","className","targets","c","splitLines","preserveEnding","createPositionConverter","indexToPos","posToIndex","DEFAULT_COLOR_LIGHT_DARK","COLOR_KEYS","splitToken","offsets","lastOffset","tokens","splitTokens","breakpoints","sorted","breakpointsInToken","flatTokenVariants","merged","variantsOrder","cssVariablePrefix","defaultColor","colorsRendering","styles","getTokenStyleObject","styleKeys","mergedStyles","varKey","keyName","cur","lightIndex","darkIndex","ShikiError$1","lightValue","darkValue","decorations","stringifyTokenStyle","_grammarStateMap","setLastGrammarStateToMap","getLastGrammarStateFromMap","GrammarState","stacksMap","themes","getScopes","visited","pushScope","stack2","getGrammarStack","transformerDecorations","getContext","shiki","normalizePosition","converter","verifyIntersections","codeEl","applyLineSection","decoration","lineEl","applyDecoration","wrapper","applyLine","transform","lineApplies","foo","bar","isFooHasBarStart","isFooHasBarEnd","isBarHasFooStart","isBarHasFooEnd","builtInTransformers","getTransformers","sortTransformersByEnforcement","pre","post","namedColors","findSequence","nextEscape","nextClose","parseColor","colorMode","rgb","parseSequence","commands","codeInt","createAnsiSequenceParser","decorations2","findResult","styleToken","defaultNamedColorsMap","createColorPalette","namedColorsMap","namedColor","rgbColor","colorTable","getColorTable","levels","g","level","tableColor","defaultAnsiColors","tokenizeAnsiWithTheme","fileContents","colorReplacements","ansiPalette","themeColor","colorPalette","bgColor","dimColor","hexMatch","alpha","cssVarMatch","codeToTokensBase","internal","_grammar","tokenizeWithTheme","getLastGrammarState","_tokenizeWithTheme","grammarState","tokenizeMaxLineLength","tokenizeTimeLimit","stateStack","actual","final","lineOffset","resultWithScopes","tokensWithScopes","tokensWithScopesIndex","tokensLength","nextStartIndex","themeSettingsSelectors","setting","selectors","tokenWithScopes","tokenWithScopesText","explainThemeScopesNameOnly","explainThemeScopesFull","themeSelectors","explainThemeScope","matchesOne","matches","selectorParentIndex","parentIndex","selectorPieces","codeToTokensWithThemes","themedTokens","tokens2","syncThemesTokenization","mergedTokens","lineIdx","_token","tokenIdx","mergedToken","themeIdx","__","___","mergedGrammarState","s","outThemes","outLines","indexes","l","minLength","codeToTokens","bg","fg","themeTokens","themeRegs","themesOrder","themeColorReplacements","mapThemeColors","_theme","cssVar","codeToHast","transformerContext","_code","_options","mergeWhitespaces","mergeSameStyleTokens","mergeWhitespaceTokens","splitWhitespaceTokens","mergeAdjacentStyledTokens","contextSource","tokensToHast","structure","tabindex","preNode","codeNode","lineNodes","lineNode","col","tokenNode","newLine","carryOnContent","firstOffset","couldMerge","leading","trailing","expanded","prevToken","prevStyle","currentStyle","isPrevDecorated","isDecorated","hastToHtml","codeToHtml","VSCODE_FALLBACK_EDITOR_FG","VSCODE_FALLBACK_EDITOR_BG","RESOLVED_KEY","normalizeTheme","rawTheme","globalSetting","_d","replacementCount","replacementMap","getReplacementColor","replaceFg","replaceBg","_e","resolveLangs","langs","resolveThemes","_emitDeprecation","warnDeprecated","version","Registry$1","_resolver","_themes","_langs","_alias","textmateTheme","resolved","ShikiError","embeddedLazilyBy","grammarConfig","alias","langsGraphArray","missingLangs","dependents","embeddedLang","Resolver","engine","langIdOrAlias","scopeParts","subScopeName","instancesCount","createShikiInternalSync","isDisposed","_registry","_lastTheme","getLanguage","ensureNotDisposed","_lang","getTheme","setTheme","getLoadedThemes","getLoadedLanguages","loadLanguageSync","langs2","loadLanguage","loadThemeSync","themes2","loadTheme","dispose","createShikiInternal","createHighlighterCore","options2","createdBundledHighlighter","bundledLanguages","bundledThemes","createHighlighter","resolveLang","bundle","resolveTheme","bundledThemesInfo","__vitePreload","getHeapMax","_emscripten_get_now","alignUp","multiple","init","wasmMemory","binding","updateGlobalBufferAndViews","buf","_emscripten_memcpy_big","dest","num","emscripten_realloc_buffer","_emscripten_resize_heap","requestedSize","oldSize","maxHeapSize","cutDown","overGrownHeapSize","newSize","UTF8Decoder","UTF8ArrayToString","heapOrArray","maxBytesToRead","endIdx","endPtr","u0","u1","u2","UTF8ToString","ptr","asmLibraryArg","createWasm","exports","__defProp","__defNormalProp","onigBinding","throwLastOnigError","onigBinding2","UtfString","utf16Length","utf8Length","computeIndicesMapping","utf16OffsetToUtf8","utf8OffsetToUtf16","utf8Value","i8","i16","charCode","codePoint","wasSurrogatePair","nextCharCode","codepoint","_OnigString","utfString","utf8Offset","utf16Offset","OnigString","OnigScanner","strPtrsArr","strLenArr","strPtrsPtr","strLenPtr","scannerPtr","arg","debugCall","resultPtr","HEAPU32","beg","isInstantiatorOptionsObject","dataOrOptions","isInstantiatorModule","isDataOptionsObject","isResponse","isArrayBuffer","initPromise","loadWasm","_load","instance","_makeResponseStreamingLoader","_makeResponseNonStreamingLoader","_makeArrayBufferLoader","importObject","arrayBuffer","createOnigurumaEngine","bundledLanguagesInfo","bundledLanguagesBase","bundledLanguagesAlias","languages","getHighlighter","highlight","handle_promise","create_if_block_3","if_block2","section","codeblock_changes","each_value_4","ensure_array_like","th","each_blocks","each_value_2","td","each_value_1","each_value_3","each_value","table_1","each_blocks_1","previous_tag","getTagName","svelte_element","create_dynamic_element","safe_not_equal","switch_value","Code","claim_element","show_if","OverrideCode","codeProps","inlineCodeProps"],"ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,99,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,216,217,218,219,220,221],"sources":["../../../../../../node_modules/bail/index.js","../../../../../../node_modules/extend/index.js","../../../../../../node_modules/is-plain-obj/index.js","../../../../../../node_modules/trough/lib/index.js","../../../../../../node_modules/unist-util-stringify-position/lib/index.js","../../../../../../node_modules/vfile-message/lib/index.js","../../../../../../node_modules/vfile/lib/minpath.browser.js","../../../../../../node_modules/vfile/lib/minproc.browser.js","../../../../../../node_modules/vfile/lib/minurl.shared.js","../../../../../../node_modules/vfile/lib/minurl.browser.js","../../../../../../node_modules/vfile/lib/index.js","../../../../../../node_modules/unified/lib/callable-instance.js","../../../../../../node_modules/unified/lib/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/break.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/code.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/delete.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","../../../../../../node_modules/micromark-util-character/index.js","../../../../../../node_modules/micromark-util-sanitize-uri/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/heading.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/html.js","../../../../../../node_modules/mdast-util-to-hast/lib/revert.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/image.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/link.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/list-item.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/list.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/root.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/strong.js","../../../../../../node_modules/unist-util-position/lib/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-row.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/table-cell.js","../../../../../../node_modules/trim-lines/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/text.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","../../../../../../node_modules/mdast-util-to-hast/lib/handlers/index.js","../../../../../../node_modules/@ungap/structured-clone/esm/types.js","../../../../../../node_modules/@ungap/structured-clone/esm/deserialize.js","../../../../../../node_modules/@ungap/structured-clone/esm/serialize.js","../../../../../../node_modules/@ungap/structured-clone/esm/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/footer.js","../../../../../../node_modules/unist-util-is/lib/index.js","../../../../../../node_modules/unist-util-visit-parents/lib/index.js","../../../../../../node_modules/unist-util-visit/lib/index.js","../../../../../../node_modules/mdast-util-to-hast/lib/state.js","../../../../../../node_modules/mdast-util-to-hast/lib/index.js","../../../../../../node_modules/remark-rehype/lib/index.js","../../../../../../node_modules/html-void-elements/index.js","../../../../../../node_modules/property-information/lib/util/schema.js","../../../../../../node_modules/property-information/lib/util/merge.js","../../../../../../node_modules/property-information/lib/normalize.js","../../../../../../node_modules/property-information/lib/util/info.js","../../../../../../node_modules/property-information/lib/util/types.js","../../../../../../node_modules/property-information/lib/util/defined-info.js","../../../../../../node_modules/property-information/lib/util/create.js","../../../../../../node_modules/property-information/lib/aria.js","../../../../../../node_modules/property-information/lib/util/case-sensitive-transform.js","../../../../../../node_modules/property-information/lib/util/case-insensitive-transform.js","../../../../../../node_modules/property-information/lib/html.js","../../../../../../node_modules/property-information/lib/svg.js","../../../../../../node_modules/property-information/lib/xlink.js","../../../../../../node_modules/property-information/lib/xmlns.js","../../../../../../node_modules/property-information/lib/xml.js","../../../../../../node_modules/property-information/lib/find.js","../../../../../../node_modules/property-information/index.js","../../../../../../node_modules/zwitch/index.js","../../../../../../node_modules/stringify-entities/lib/core.js","../../../../../../node_modules/stringify-entities/lib/util/to-hexadecimal.js","../../../../../../node_modules/stringify-entities/lib/util/to-decimal.js","../../../../../../node_modules/character-entities-legacy/index.js","../../../../../../node_modules/character-entities-html4/index.js","../../../../../../node_modules/stringify-entities/lib/constant/dangerous.js","../../../../../../node_modules/stringify-entities/lib/util/to-named.js","../../../../../../node_modules/stringify-entities/lib/util/format-smart.js","../../../../../../node_modules/stringify-entities/lib/index.js","../../../../../../node_modules/hast-util-to-html/lib/handle/comment.js","../../../../../../node_modules/hast-util-to-html/lib/handle/doctype.js","../../../../../../node_modules/ccount/index.js","../../../../../../node_modules/comma-separated-tokens/index.js","../../../../../../node_modules/space-separated-tokens/index.js","../../../../../../node_modules/hast-util-whitespace/lib/index.js","../../../../../../node_modules/hast-util-to-html/lib/omission/util/siblings.js","../../../../../../node_modules/hast-util-to-html/lib/omission/omission.js","../../../../../../node_modules/hast-util-to-html/lib/omission/closing.js","../../../../../../node_modules/hast-util-to-html/lib/omission/opening.js","../../../../../../node_modules/hast-util-to-html/lib/handle/element.js","../../../../../../node_modules/hast-util-to-html/lib/handle/text.js","../../../../../../node_modules/hast-util-to-html/lib/handle/raw.js","../../../../../../node_modules/hast-util-to-html/lib/handle/root.js","../../../../../../node_modules/hast-util-to-html/lib/handle/index.js","../../../../../../node_modules/hast-util-to-html/lib/index.js","../../../../../../node_modules/rehype-stringify/lib/index.js","../../../../../../src/lib/components/markdown/Fallback.svelte","../../../../../../node_modules/svelte-portal/src/Portal.svelte","../../../../../../src/lib/components/Tooltip.svelte","../../../../../../src/lib/components/markdown/InlineCode.svelte","../../../../../../src/lib/components/markdown/Link.svelte","../../../../../../src/lib/components/console/store.ts","../../../../../../node_modules/mdast-util-to-string/lib/index.js","../../../../../../node_modules/decode-named-character-reference/index.dom.js","../../../../../../node_modules/micromark-util-chunked/index.js","../../../../../../node_modules/micromark-util-combine-extensions/index.js","../../../../../../node_modules/micromark-util-decode-numeric-character-reference/index.js","../../../../../../node_modules/micromark-util-normalize-identifier/index.js","../../../../../../node_modules/micromark-factory-space/index.js","../../../../../../node_modules/micromark/lib/initialize/content.js","../../../../../../node_modules/micromark/lib/initialize/document.js","../../../../../../node_modules/micromark-util-classify-character/index.js","../../../../../../node_modules/micromark-util-resolve-all/index.js","../../../../../../node_modules/micromark-core-commonmark/lib/attention.js","../../../../../../node_modules/micromark-core-commonmark/lib/autolink.js","../../../../../../node_modules/micromark-core-commonmark/lib/blank-line.js","../../../../../../node_modules/micromark-core-commonmark/lib/block-quote.js","../../../../../../node_modules/micromark-core-commonmark/lib/character-escape.js","../../../../../../node_modules/micromark-core-commonmark/lib/character-reference.js","../../../../../../node_modules/micromark-core-commonmark/lib/code-fenced.js","../../../../../../node_modules/micromark-core-commonmark/lib/code-indented.js","../../../../../../node_modules/micromark-core-commonmark/lib/code-text.js","../../../../../../node_modules/micromark-util-subtokenize/lib/splice-buffer.js","../../../../../../node_modules/micromark-util-subtokenize/index.js","../../../../../../node_modules/micromark-core-commonmark/lib/content.js","../../../../../../node_modules/micromark-factory-destination/index.js","../../../../../../node_modules/micromark-factory-label/index.js","../../../../../../node_modules/micromark-factory-title/index.js","../../../../../../node_modules/micromark-factory-whitespace/index.js","../../../../../../node_modules/micromark-core-commonmark/lib/definition.js","../../../../../../node_modules/micromark-core-commonmark/lib/hard-break-escape.js","../../../../../../node_modules/micromark-core-commonmark/lib/heading-atx.js","../../../../../../node_modules/micromark-util-html-tag-name/index.js","../../../../../../node_modules/micromark-core-commonmark/lib/html-flow.js","../../../../../../node_modules/micromark-core-commonmark/lib/html-text.js","../../../../../../node_modules/micromark-core-commonmark/lib/label-end.js","../../../../../../node_modules/micromark-core-commonmark/lib/label-start-image.js","../../../../../../node_modules/micromark-core-commonmark/lib/label-start-link.js","../../../../../../node_modules/micromark-core-commonmark/lib/line-ending.js","../../../../../../node_modules/micromark-core-commonmark/lib/thematic-break.js","../../../../../../node_modules/micromark-core-commonmark/lib/list.js","../../../../../../node_modules/micromark-core-commonmark/lib/setext-underline.js","../../../../../../node_modules/micromark/lib/initialize/flow.js","../../../../../../node_modules/micromark/lib/initialize/text.js","../../../../../../node_modules/micromark/lib/constructs.js","../../../../../../node_modules/micromark/lib/create-tokenizer.js","../../../../../../node_modules/micromark/lib/parse.js","../../../../../../node_modules/micromark/lib/postprocess.js","../../../../../../node_modules/micromark/lib/preprocess.js","../../../../../../node_modules/micromark-util-decode-string/index.js","../../../../../../node_modules/mdast-util-from-markdown/lib/index.js","../../../../../../node_modules/remark-parse/lib/index.js","../../../../../../node_modules/escape-string-regexp/index.js","../../../../../../node_modules/mdast-util-find-and-replace/lib/index.js","../../../../../../node_modules/mdast-util-gfm-autolink-literal/lib/index.js","../../../../../../node_modules/mdast-util-gfm-footnote/lib/index.js","../../../../../../node_modules/mdast-util-gfm-strikethrough/lib/index.js","../../../../../../node_modules/markdown-table/index.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/blockquote.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/pattern-in-scope.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/break.js","../../../../../../node_modules/longest-streak/index.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-code-as-indented.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-fence.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/code.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-quote.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/definition.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-emphasis.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/encode-character-reference.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/encode-info.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/emphasis.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-heading-as-setext.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/heading.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/html.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/image.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/image-reference.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/inline-code.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/format-link-as-autolink.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/link.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/link-reference.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-other.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-bullet-ordered.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-rule.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/list.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-list-item-indent.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/list-item.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/paragraph.js","../../../../../../node_modules/mdast-util-phrasing/lib/index.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/root.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-strong.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/strong.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/text.js","../../../../../../node_modules/mdast-util-to-markdown/lib/util/check-rule-repetition.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js","../../../../../../node_modules/mdast-util-to-markdown/lib/handle/index.js","../../../../../../node_modules/mdast-util-gfm-table/lib/index.js","../../../../../../node_modules/mdast-util-gfm-task-list-item/lib/index.js","../../../../../../node_modules/mdast-util-gfm/lib/index.js","../../../../../../node_modules/micromark-extension-gfm-autolink-literal/lib/syntax.js","../../../../../../node_modules/micromark-extension-gfm-footnote/lib/syntax.js","../../../../../../node_modules/micromark-extension-gfm-strikethrough/lib/syntax.js","../../../../../../node_modules/micromark-extension-gfm-table/lib/edit-map.js","../../../../../../node_modules/micromark-extension-gfm-table/lib/infer.js","../../../../../../node_modules/micromark-extension-gfm-table/lib/syntax.js","../../../../../../node_modules/micromark-extension-gfm-task-list-item/lib/syntax.js","../../../../../../node_modules/micromark-extension-gfm/index.js","../../../../../../node_modules/remark-gfm/lib/index.js","../../../../../../src/lib/components/reusable/WithMarkdown.svelte","../../../../../../src/lib/components/markdown/BaseMarkdown.svelte","../../../../../../src/lib/utils/toast.ts","../../../../../../src/lib/components/console/UseCopy.svelte","../../../../../../src/lib/components/reusable/WithCodeActions.svelte","../../../../../../src/lib/utils/cache.ts","../../../../../../node_modules/@shikijs/types/dist/index.mjs","../../../../../../node_modules/@shikijs/vscode-textmate/dist/index.js","../../../../../../node_modules/@shikijs/core/dist/index.mjs","../../../../../../node_modules/shiki/dist/themes.mjs","../../../../../../node_modules/@shikijs/engine-oniguruma/dist/index.mjs","../../../../../../node_modules/shiki/dist/bundle-web.mjs","../../../../../../src/lib/highlight.ts","../../../../../../src/lib/components/CodeBlock.svelte","../../../../../../src/lib/components/markdown/Pre.svelte","../../../../../../src/lib/components/markdown/Table.svelte","../../../../../../src/lib/components/markdown/Router.svelte"],"sourcesContent":["/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error\n  }\n}\n","'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n\tif (typeof Array.isArray === 'function') {\n\t\treturn Array.isArray(arr);\n\t}\n\n\treturn toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n\tif (!obj || toStr.call(obj) !== '[object Object]') {\n\t\treturn false;\n\t}\n\n\tvar hasOwnConstructor = hasOwn.call(obj, 'constructor');\n\tvar hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');\n\t// Not own constructor property must be Object\n\tif (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n\t\treturn false;\n\t}\n\n\t// Own properties are enumerated firstly, so to speed up,\n\t// if last one is own, then all properties are own.\n\tvar key;\n\tfor (key in obj) { /**/ }\n\n\treturn typeof key === 'undefined' || hasOwn.call(obj, key);\n};\n\n// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\nvar setProperty = function setProperty(target, options) {\n\tif (defineProperty && options.name === '__proto__') {\n\t\tdefineProperty(target, options.name, {\n\t\t\tenumerable: true,\n\t\t\tconfigurable: true,\n\t\t\tvalue: options.newValue,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\ttarget[options.name] = options.newValue;\n\t}\n};\n\n// Return undefined instead of __proto__ if '__proto__' is not an own property\nvar getProperty = function getProperty(obj, name) {\n\tif (name === '__proto__') {\n\t\tif (!hasOwn.call(obj, name)) {\n\t\t\treturn void 0;\n\t\t} else if (gOPD) {\n\t\t\t// In early versions of node, obj['__proto__'] is buggy when obj has\n\t\t\t// __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n\t\t\treturn gOPD(obj, name).value;\n\t\t}\n\t}\n\n\treturn obj[name];\n};\n\nmodule.exports = function extend() {\n\tvar options, name, src, copy, copyIsArray, clone;\n\tvar target = arguments[0];\n\tvar i = 1;\n\tvar length = arguments.length;\n\tvar deep = false;\n\n\t// Handle a deep copy situation\n\tif (typeof target === 'boolean') {\n\t\tdeep = target;\n\t\ttarget = arguments[1] || {};\n\t\t// skip the boolean and the target\n\t\ti = 2;\n\t}\n\tif (target == null || (typeof target !== 'object' && typeof target !== 'function')) {\n\t\ttarget = {};\n\t}\n\n\tfor (; i < length; ++i) {\n\t\toptions = arguments[i];\n\t\t// Only deal with non-null/undefined values\n\t\tif (options != null) {\n\t\t\t// Extend the base object\n\t\t\tfor (name in options) {\n\t\t\t\tsrc = getProperty(target, name);\n\t\t\t\tcopy = getProperty(options, name);\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif (target !== copy) {\n\t\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\t\tif (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n\t\t\t\t\t\tif (copyIsArray) {\n\t\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\t\tclone = src && isArray(src) ? src : [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tclone = src && isPlainObject(src) ? src : {};\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: extend(deep, clone, copy) });\n\n\t\t\t\t\t// Don't bring in undefined values\n\t\t\t\t\t} else if (typeof copy !== 'undefined') {\n\t\t\t\t\t\tsetProperty(target, { name: name, newValue: copy });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n","export default function isPlainObject(value) {\n\tif (typeof value !== 'object' || value === null) {\n\t\treturn false;\n\t}\n\n\tconst prototype = Object.getPrototypeOf(value);\n\treturn (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}\n","// To do: remove `void`s\n// To do: remove `null` from output of our APIs, allow it as user APIs.\n\n/**\n * @typedef {(error?: Error | null | undefined, ...output: Array<any>) => void} Callback\n *   Callback.\n *\n * @typedef {(...input: Array<any>) => any} Middleware\n *   Ware.\n *\n * @typedef Pipeline\n *   Pipeline.\n * @property {Run} run\n *   Run the pipeline.\n * @property {Use} use\n *   Add middleware.\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n *\n *   Calls `done` on completion with either an error or the output of the\n *   last middleware.\n *\n *   > 👉 **Note**: as the length of input defines whether async functions get a\n *   > `next` function,\n *   > it’s recommended to keep `input` at one value normally.\n\n *\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n *   Pipeline.\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = []\n  /** @type {Pipeline} */\n  const pipeline = {run, use}\n\n  return pipeline\n\n  /** @type {Run} */\n  function run(...values) {\n    let middlewareIndex = -1\n    /** @type {Callback} */\n    const callback = values.pop()\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback)\n    }\n\n    next(null, ...values)\n\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error | null | undefined} error\n     * @param {Array<any>} output\n     */\n    function next(error, ...output) {\n      const fn = fns[++middlewareIndex]\n      let index = -1\n\n      if (error) {\n        callback(error)\n        return\n      }\n\n      // Copy non-nullish input into values.\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index]\n        }\n      }\n\n      // Save the newly created `output` for the next call.\n      values = output\n\n      // Next or done.\n      if (fn) {\n        wrap(fn, next)(...output)\n      } else {\n        callback(null, ...output)\n      }\n    }\n  }\n\n  /** @type {Use} */\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError(\n        'Expected `middelware` to be a function, not ' + middelware\n      )\n    }\n\n    fns.push(middelware)\n    return pipeline\n  }\n}\n\n/**\n * Wrap `middleware` into a uniform interface.\n *\n * You can pass all input to the resulting function.\n * `callback` is then called with the output of `middleware`.\n *\n * If `middleware` accepts more arguments than the later given in input,\n * an extra `done` function is passed to it after that input,\n * which must be called by `middleware`.\n *\n * The first value in `input` is the main input value.\n * All other input values are the rest input values.\n * The values given to `callback` are the input values,\n * merged with every non-nullish output value.\n *\n * * if `middleware` throws an error,\n *   returns a promise that is rejected,\n *   or calls the given `done` function with an error,\n *   `callback` is called with that error\n * * if `middleware` returns a value or returns a promise that is resolved,\n *   that value is the main output value\n * * if `middleware` calls `done`,\n *   all non-nullish values except for the first one (the error) overwrite the\n *   output values\n *\n * @param {Middleware} middleware\n *   Function to wrap.\n * @param {Callback} callback\n *   Callback called with the output of `middleware`.\n * @returns {Run}\n *   Wrapped middleware.\n */\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called\n\n  return wrapped\n\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n  function wrapped(...parameters) {\n    const fnExpectsCallback = middleware.length > parameters.length\n    /** @type {any} */\n    let result\n\n    if (fnExpectsCallback) {\n      parameters.push(done)\n    }\n\n    try {\n      result = middleware.apply(this, parameters)\n    } catch (error) {\n      const exception = /** @type {Error} */ (error)\n\n      // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n      if (fnExpectsCallback && called) {\n        throw exception\n      }\n\n      return done(exception)\n    }\n\n    if (!fnExpectsCallback) {\n      if (result && result.then && 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  }\n\n  /**\n   * Call `callback`, only once.\n   *\n   * @type {Callback}\n   */\n  function done(error, ...output) {\n    if (!called) {\n      called = true\n      callback(error, ...output)\n    }\n  }\n\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n  function then(value) {\n    done(null, value)\n  }\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n */\n\n/**\n * Serialize the positional info of a point, position (start and end points),\n * or node.\n *\n * @param {Node | NodeLike | Point | PointLike | Position | PositionLike | null | undefined} [value]\n *   Node, position, or point.\n * @returns {string}\n *   Pretty printed positional info of a node (`string`).\n *\n *   In the format of a range `ls:cs-le:ce` (when given `node` or `position`)\n *   or a point `l:c` (when given `point`), where `l` stands for line, `c` for\n *   column, `s` for `start`, and `e` for end.\n *   An empty string (`''`) is returned if the given value is neither `node`,\n *   `position`, nor `point`.\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return ''\n  }\n\n  // Node.\n  if ('position' in value || 'type' in value) {\n    return position(value.position)\n  }\n\n  // Position.\n  if ('start' in value || 'end' in value) {\n    return position(value)\n  }\n\n  // Point.\n  if ('line' in value || 'column' in value) {\n    return point(value)\n  }\n\n  // ?\n  return ''\n}\n\n/**\n * @param {Point | PointLike | null | undefined} point\n * @returns {string}\n */\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column)\n}\n\n/**\n * @param {Position | PositionLike | null | undefined} pos\n * @returns {string}\n */\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end)\n}\n\n/**\n * @param {number | null | undefined} value\n * @returns {number}\n */\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n *\n * @typedef Options\n *   Configuration.\n * @property {Array<Node> | null | undefined} [ancestors]\n *   Stack of (inclusive) ancestor nodes surrounding the message (optional).\n * @property {Error | null | undefined} [cause]\n *   Original error cause of the message (optional).\n * @property {Point | Position | null | undefined} [place]\n *   Place of message (optional).\n * @property {string | null | undefined} [ruleId]\n *   Category of message (optional, example: `'my-rule'`).\n * @property {string | null | undefined} [source]\n *   Namespace of who sent the message (optional, example: `'my-package'`).\n */\n\nimport {stringifyPosition} from 'unist-util-stringify-position'\n\n/**\n * Message.\n */\nexport class VFileMessage extends Error {\n  /**\n   * Create a message for `reason`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Options | null | undefined} [options]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | Options | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns\n   *   Instance of `VFileMessage`.\n   */\n  // eslint-disable-next-line complexity\n  constructor(causeOrReason, optionsOrParentOrPlace, origin) {\n    super()\n\n    if (typeof optionsOrParentOrPlace === 'string') {\n      origin = optionsOrParentOrPlace\n      optionsOrParentOrPlace = undefined\n    }\n\n    /** @type {string} */\n    let reason = ''\n    /** @type {Options} */\n    let options = {}\n    let legacyCause = false\n\n    if (optionsOrParentOrPlace) {\n      // Point.\n      if (\n        'line' in optionsOrParentOrPlace &&\n        'column' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Position.\n      else if (\n        'start' in optionsOrParentOrPlace &&\n        'end' in optionsOrParentOrPlace\n      ) {\n        options = {place: optionsOrParentOrPlace}\n      }\n      // Node.\n      else if ('type' in optionsOrParentOrPlace) {\n        options = {\n          ancestors: [optionsOrParentOrPlace],\n          place: optionsOrParentOrPlace.position\n        }\n      }\n      // Options.\n      else {\n        options = {...optionsOrParentOrPlace}\n      }\n    }\n\n    if (typeof causeOrReason === 'string') {\n      reason = causeOrReason\n    }\n    // Error.\n    else if (!options.cause && causeOrReason) {\n      legacyCause = true\n      reason = causeOrReason.message\n      options.cause = causeOrReason\n    }\n\n    if (!options.ruleId && !options.source && typeof origin === 'string') {\n      const index = origin.indexOf(':')\n\n      if (index === -1) {\n        options.ruleId = origin\n      } else {\n        options.source = origin.slice(0, index)\n        options.ruleId = origin.slice(index + 1)\n      }\n    }\n\n    if (!options.place && options.ancestors && options.ancestors) {\n      const parent = options.ancestors[options.ancestors.length - 1]\n\n      if (parent) {\n        options.place = parent.position\n      }\n    }\n\n    const start =\n      options.place && 'start' in options.place\n        ? options.place.start\n        : options.place\n\n    /**\n     * Stack of ancestor nodes surrounding the message.\n     *\n     * @type {Array<Node> | undefined}\n     */\n    this.ancestors = options.ancestors || undefined\n\n    /**\n     * Original error cause of the message.\n     *\n     * @type {Error | undefined}\n     */\n    this.cause = options.cause || undefined\n\n    /**\n     * Starting column of message.\n     *\n     * @type {number | undefined}\n     */\n    this.column = start ? start.column : undefined\n\n    /**\n     * State of problem.\n     *\n     * * `true` — error, file not usable\n     * * `false` — warning, change may be needed\n     * * `undefined` — change likely not needed\n     *\n     * @type {boolean | null | undefined}\n     */\n    this.fatal = undefined\n\n    /**\n     * Path of a file (used throughout the `VFile` ecosystem).\n     *\n     * @type {string | undefined}\n     */\n    this.file = ''\n\n    // Field from `Error`.\n    /**\n     * Reason for message.\n     *\n     * @type {string}\n     */\n    this.message = reason\n\n    /**\n     * Starting line of error.\n     *\n     * @type {number | undefined}\n     */\n    this.line = start ? start.line : undefined\n\n    // Field from `Error`.\n    /**\n     * Serialized positional info of message.\n     *\n     * On normal errors, this would be something like `ParseError`, buit in\n     * `VFile` messages we use this space to show where an error happened.\n     */\n    this.name = stringifyPosition(options.place) || '1:1'\n\n    /**\n     * Place of message.\n     *\n     * @type {Point | Position | undefined}\n     */\n    this.place = options.place || undefined\n\n    /**\n     * Reason for message, should use markdown.\n     *\n     * @type {string}\n     */\n    this.reason = this.message\n\n    /**\n     * Category of message (example: `'my-rule'`).\n     *\n     * @type {string | undefined}\n     */\n    this.ruleId = options.ruleId || undefined\n\n    /**\n     * Namespace of message (example: `'my-package'`).\n     *\n     * @type {string | undefined}\n     */\n    this.source = options.source || undefined\n\n    // Field from `Error`.\n    /**\n     * Stack of message.\n     *\n     * This is used by normal errors to show where something happened in\n     * programming code, irrelevant for `VFile` messages,\n     *\n     * @type {string}\n     */\n    this.stack =\n      legacyCause && options.cause && typeof options.cause.stack === 'string'\n        ? options.cause.stack\n        : ''\n\n    // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /**\n     * Specify the source value that’s being reported, which is deemed\n     * incorrect.\n     *\n     * @type {string | undefined}\n     */\n    this.actual = undefined\n\n    /**\n     * Suggest acceptable values that can be used instead of `actual`.\n     *\n     * @type {Array<string> | undefined}\n     */\n    this.expected = undefined\n\n    /**\n     * Long form description of the message (you should use markdown).\n     *\n     * @type {string | undefined}\n     */\n    this.note = undefined\n\n    /**\n     * Link to docs for the message.\n     *\n     * > 👉 **Note**: this must be an absolute URL that can be passed as `x`\n     * > to `new URL(x)`.\n     *\n     * @type {string | undefined}\n     */\n    this.url = undefined\n  }\n}\n\nVFileMessage.prototype.file = ''\nVFileMessage.prototype.name = ''\nVFileMessage.prototype.reason = ''\nVFileMessage.prototype.message = ''\nVFileMessage.prototype.stack = ''\nVFileMessage.prototype.column = undefined\nVFileMessage.prototype.line = undefined\nVFileMessage.prototype.ancestors = undefined\nVFileMessage.prototype.cause = undefined\nVFileMessage.prototype.fatal = undefined\nVFileMessage.prototype.place = undefined\nVFileMessage.prototype.ruleId = undefined\nVFileMessage.prototype.source = undefined\n","// 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\nexport const minpath = {basename, dirname, extname, join, sep: '/'}\n\n/* eslint-disable max-depth, complexity */\n\n/**\n * Get the basename from a path.\n *\n * @param {string} path\n *   File path.\n * @param {string | null | undefined} [extname]\n *   Extension to strip.\n * @returns {string}\n *   Stem or basename.\n */\nfunction basename(path, extname) {\n  if (extname !== undefined && typeof extname !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string')\n  }\n\n  assertPath(path)\n  let start = 0\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let seenNonSlash\n\n  if (\n    extname === undefined ||\n    extname.length === 0 ||\n    extname.length > path.length\n  ) {\n    while (index--) {\n      if (path.codePointAt(index) === 47 /* `/` */) {\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 (extname === path) {\n    return ''\n  }\n\n  let firstNonSlashEnd = -1\n  let extnameIndex = extname.length - 1\n\n  while (index--) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\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 (extnameIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.codePointAt(index) === extname.codePointAt(extnameIndex--)) {\n          if (extnameIndex < 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          extnameIndex = -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\n/**\n * Get the dirname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\nfunction dirname(path) {\n  assertPath(path)\n\n  if (path.length === 0) {\n    return '.'\n  }\n\n  let end = -1\n  let index = path.length\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  // Prefix `--` is important to not run on `0`.\n  while (--index) {\n    if (path.codePointAt(index) === 47 /* `/` */) {\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\n    ? path.codePointAt(0) === 47 /* `/` */\n      ? '/'\n      : '.'\n    : end === 1 && path.codePointAt(0) === 47 /* `/` */\n      ? '//'\n      : path.slice(0, end)\n}\n\n/**\n * Get an extname from a path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   Extname.\n */\nfunction extname(path) {\n  assertPath(path)\n\n  let index = path.length\n\n  let end = -1\n  let startPart = 0\n  let startDot = -1\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n  let preDotState = 0\n  /** @type {boolean | undefined} */\n  let unmatchedSlash\n\n  while (index--) {\n    const code = path.codePointAt(index)\n\n    if (code === 47 /* `/` */) {\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      // 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 (\n    startDot < 0 ||\n    end < 0 ||\n    // We saw a non-dot character immediately before the dot.\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly `..`.\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return ''\n  }\n\n  return path.slice(startDot, end)\n}\n\n/**\n * Join segments from a path.\n *\n * @param {Array<string>} segments\n *   Path segments.\n * @returns {string}\n *   File path.\n */\nfunction join(...segments) {\n  let index = -1\n  /** @type {string | undefined} */\n  let joined\n\n  while (++index < segments.length) {\n    assertPath(segments[index])\n\n    if (segments[index]) {\n      joined =\n        joined === undefined ? segments[index] : joined + '/' + segments[index]\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined)\n}\n\n/**\n * Normalize a basic file path.\n *\n * @param {string} path\n *   File path.\n * @returns {string}\n *   File path.\n */\n// Note: `normalize` is not exposed as `path.normalize`, so some code is\n// manually removed from it.\nfunction normalize(path) {\n  assertPath(path)\n\n  const absolute = path.codePointAt(0) === 47 /* `/` */\n\n  // Normalize the path according to POSIX rules.\n  let value = normalizeString(path, !absolute)\n\n  if (value.length === 0 && !absolute) {\n    value = '.'\n  }\n\n  if (value.length > 0 && path.codePointAt(path.length - 1) === 47 /* / */) {\n    value += '/'\n  }\n\n  return absolute ? '/' + value : value\n}\n\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n *   File path.\n * @param {boolean} allowAboveRoot\n *   Whether `..` can move above root.\n * @returns {string}\n *   File path.\n */\nfunction normalizeString(path, allowAboveRoot) {\n  let result = ''\n  let lastSegmentLength = 0\n  let lastSlash = -1\n  let dots = 0\n  let index = -1\n  /** @type {number | undefined} */\n  let code\n  /** @type {number} */\n  let lastSlashIndex\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.codePointAt(index)\n    } else if (code === 47 /* `/` */) {\n      break\n    } else {\n      code = 47 /* `/` */\n    }\n\n    if (code === 47 /* `/` */) {\n      if (lastSlash === index - 1 || dots === 1) {\n        // Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (\n          result.length < 2 ||\n          lastSegmentLength !== 2 ||\n          result.codePointAt(result.length - 1) !== 46 /* `.` */ ||\n          result.codePointAt(result.length - 2) !== 46 /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/')\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 > 0) {\n            result = ''\n            lastSegmentLength = 0\n            lastSlash = index\n            dots = 0\n            continue\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..'\n          lastSegmentLength = 2\n        }\n      } else {\n        if (result.length > 0) {\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 /* `.` */ && dots > -1) {\n      dots++\n    } else {\n      dots = -1\n    }\n  }\n\n  return result\n}\n\n/**\n * Make sure `path` is a string.\n *\n * @param {string} path\n *   File path.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError(\n      'Path must be a string. Received ' + JSON.stringify(path)\n    )\n  }\n}\n\n/* eslint-enable max-depth, complexity */\n","// 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. 😅\nexport const minproc = {cwd}\n\nfunction cwd() {\n  return '/'\n}\n","/**\n * Checks if a value has the shape of a WHATWG URL object.\n *\n * Using a symbol or instanceof would not be able to recognize URL objects\n * coming from other implementations (e.g. in Electron), so instead we are\n * checking some well known properties for a lack of a better test.\n *\n * We use `href` and `protocol` as they are the only properties that are\n * easy to retrieve and calculate due to the lazy nature of the getters.\n *\n * We check for auth attribute to distinguish legacy url instance with\n * WHATWG URL instance.\n *\n * @param {unknown} fileUrlOrPath\n *   File path or URL.\n * @returns {fileUrlOrPath is URL}\n *   Whether it’s a URL.\n */\n// From: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js#L720>\nexport function isUrl(fileUrlOrPath) {\n  return Boolean(\n    fileUrlOrPath !== null &&\n      typeof fileUrlOrPath === 'object' &&\n      'href' in fileUrlOrPath &&\n      fileUrlOrPath.href &&\n      'protocol' in fileUrlOrPath &&\n      fileUrlOrPath.protocol &&\n      // @ts-expect-error: indexing is fine.\n      fileUrlOrPath.auth === undefined\n  )\n}\n","import {isUrl} from './minurl.shared.js'\n\nexport {isUrl} from './minurl.shared.js'\n\n// See: <https://github.com/nodejs/node/blob/6a3403c/lib/internal/url.js>\n\n/**\n * @param {URL | string} path\n *   File URL.\n * @returns {string}\n *   File URL.\n */\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path)\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'The \"path\" argument must be of type string or an instance of URL. Received `' +\n        path +\n        '`'\n    )\n    error.code = 'ERR_INVALID_ARG_TYPE'\n    throw error\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file')\n    error.code = 'ERR_INVALID_URL_SCHEME'\n    throw error\n  }\n\n  return getPathFromURLPosix(path)\n}\n\n/**\n * Get a path from a POSIX URL.\n *\n * @param {URL} url\n *   URL.\n * @returns {string}\n *   File path.\n */\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError(\n      'File URL host must be \"localhost\" or empty on darwin'\n    )\n    error.code = 'ERR_INVALID_FILE_URL_HOST'\n    throw error\n  }\n\n  const pathname = url.pathname\n  let index = -1\n\n  while (++index < pathname.length) {\n    if (\n      pathname.codePointAt(index) === 37 /* `%` */ &&\n      pathname.codePointAt(index + 1) === 50 /* `2` */\n    ) {\n      const third = pathname.codePointAt(index + 2)\n      if (third === 70 /* `F` */ || third === 102 /* `f` */) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError(\n          'File URL path must not include encoded / characters'\n        )\n        error.code = 'ERR_INVALID_FILE_URL_PATH'\n        throw error\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname)\n}\n","/**\n * @import {Node, Point, Position} from 'unist'\n * @import {Options as MessageOptions} from 'vfile-message'\n * @import {Compatible, Data, Map, Options, Value} from 'vfile'\n */\n\n/**\n * @typedef {object & {type: string, position?: Position | undefined}} NodeLike\n */\n\nimport {VFileMessage} from 'vfile-message'\nimport {minpath} from '#minpath'\nimport {minproc} from '#minproc'\nimport {urlToPath, isUrl} from '#minurl'\n\n/**\n * 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 */\nconst order = /** @type {const} */ ([\n  'history',\n  'path',\n  'basename',\n  'stem',\n  'extname',\n  'dirname'\n])\n\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * `options` is treated as:\n   *\n   * *   `string` or `Uint8Array` — `{value: options}`\n   * *   `URL` — `{path: options}`\n   * *   `VFile` — shallow copies its data over to the new file\n   * *   `object` — all fields are shallow copied over to the new file\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * You cannot set `dirname` or `extname` without setting either `history`,\n   * `path`, `basename`, or `stem` too.\n   *\n   * @param {Compatible | null | undefined} [value]\n   *   File value.\n   * @returns\n   *   New instance.\n   */\n  constructor(value) {\n    /** @type {Options | VFile} */\n    let options\n\n    if (!value) {\n      options = {}\n    } else if (isUrl(value)) {\n      options = {path: value}\n    } else if (typeof value === 'string' || isUint8Array(value)) {\n      options = {value}\n    } else {\n      options = value\n    }\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     *\n     * @type {string}\n     */\n    // Prevent calling `cwd` (which could be expensive) if it’s not needed;\n    // the empty string will be overridden in the next block.\n    this.cwd = 'cwd' in options ? '' : minproc.cwd()\n\n    /**\n     * Place to store custom info (default: `{}`).\n     *\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     *\n     * @type {Data}\n     */\n    this.data = {}\n\n    /**\n     * List of file paths the file moved between.\n     *\n     * The first is the original path and the last is the current path.\n     *\n     * @type {Array<string>}\n     */\n    this.history = []\n\n    /**\n     * List of messages associated with the file.\n     *\n     * @type {Array<VFileMessage>}\n     */\n    this.messages = []\n\n    /**\n     * Raw value.\n     *\n     * @type {Value}\n     */\n    this.value\n\n    // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n    /**\n     * Source map.\n     *\n     * This type is equivalent to the `RawSourceMap` type from the `source-map`\n     * module.\n     *\n     * @type {Map | null | undefined}\n     */\n    this.map\n\n    /**\n     * Custom, non-string, compiled, representation.\n     *\n     * This is used by unified to store non-string results.\n     * One example is when turning markdown into React nodes.\n     *\n     * @type {unknown}\n     */\n    this.result\n\n    /**\n     * Whether a file was saved to disk.\n     *\n     * This is used by vfile reporters.\n     *\n     * @type {boolean}\n     */\n    this.stored\n    /* eslint-enable no-unused-expressions */\n\n    // Set path related properties in the correct order.\n    let index = -1\n\n    while (++index < order.length) {\n      const field = order[index]\n\n      // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n      if (\n        field in options &&\n        options[field] !== undefined &&\n        options[field] !== null\n      ) {\n        // @ts-expect-error: TS doesn’t understand basic reality.\n        this[field] = field === 'history' ? [...options[field]] : options[field]\n      }\n    }\n\n    /** @type {string} */\n    let field\n\n    // Set non-path related properties.\n    for (field in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(field)) {\n        // @ts-expect-error: fine to set other things.\n        this[field] = options[field]\n      }\n    }\n  }\n\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   *\n   * @returns {string | undefined}\n   *   Basename.\n   */\n  get basename() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path)\n      : undefined\n  }\n\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} basename\n   *   Basename.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename')\n    assertPart(basename, 'basename')\n    this.path = minpath.join(this.dirname || '', basename)\n  }\n\n  /**\n   * Get the parent path (example: `'~'`).\n   *\n   * @returns {string | undefined}\n   *   Dirname.\n   */\n  get dirname() {\n    return typeof this.path === 'string'\n      ? minpath.dirname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the parent path (example: `'~'`).\n   *\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} dirname\n   *   Dirname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname')\n    this.path = minpath.join(dirname || '', this.basename)\n  }\n\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   *\n   * @returns {string | undefined}\n   *   Extname.\n   */\n  get extname() {\n    return typeof this.path === 'string'\n      ? minpath.extname(this.path)\n      : undefined\n  }\n\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   *\n   * @param {string | undefined} extname\n   *   Extname.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set extname(extname) {\n    assertPart(extname, 'extname')\n    assertPath(this.dirname, 'extname')\n\n    if (extname) {\n      if (extname.codePointAt(0) !== 46 /* `.` */) {\n        throw new Error('`extname` must start with `.`')\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots')\n      }\n    }\n\n    this.path = minpath.join(this.dirname, this.stem + (extname || ''))\n  }\n\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   *\n   * @returns {string}\n   *   Path.\n   */\n  get path() {\n    return this.history[this.history.length - 1]\n  }\n\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   *\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   *\n   * @param {URL | string} path\n   *   Path.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path)\n    }\n\n    assertNonEmpty(path, 'path')\n\n    if (this.path !== path) {\n      this.history.push(path)\n    }\n  }\n\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * @returns {string | undefined}\n   *   Stem.\n   */\n  get stem() {\n    return typeof this.path === 'string'\n      ? minpath.basename(this.path, this.extname)\n      : undefined\n  }\n\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   *\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   *\n   * @param {string} stem\n   *   Stem.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem')\n    assertPart(stem, 'stem')\n    this.path = minpath.join(this.dirname || '', stem + (this.extname || ''))\n  }\n\n  // Normal prototypal methods.\n  /**\n   * Create a fatal message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `true` (error; file not usable)\n   * and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {never}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {never}\n   *   Never.\n   * @throws {VFileMessage}\n   *   Message.\n   */\n  fail(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = true\n\n    throw message\n  }\n\n  /**\n   * Create an info message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `undefined` (info; change\n   * likely not needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  info(causeOrReason, optionsOrParentOrPlace, origin) {\n    // @ts-expect-error: the overloads are fine.\n    const message = this.message(causeOrReason, optionsOrParentOrPlace, origin)\n\n    message.fatal = undefined\n\n    return message\n  }\n\n  /**\n   * Create a message for `reason` associated with the file.\n   *\n   * The `fatal` field of the message is set to `false` (warning; change may be\n   * needed) and the `file` field is set to the current file path.\n   * The message is added to the `messages` field on `file`.\n   *\n   * > 🪦 **Note**: also has obsolete signatures.\n   *\n   * @overload\n   * @param {string} reason\n   * @param {MessageOptions | null | undefined} [options]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {string} reason\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Node | NodeLike | null | undefined} parent\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {Point | Position | null | undefined} place\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @overload\n   * @param {Error | VFileMessage} cause\n   * @param {string | null | undefined} [origin]\n   * @returns {VFileMessage}\n   *\n   * @param {Error | VFileMessage | string} causeOrReason\n   *   Reason for message, should use markdown.\n   * @param {Node | NodeLike | MessageOptions | Point | Position | string | null | undefined} [optionsOrParentOrPlace]\n   *   Configuration (optional).\n   * @param {string | null | undefined} [origin]\n   *   Place in code where the message originates (example:\n   *   `'my-package:my-rule'` or `'my-rule'`).\n   * @returns {VFileMessage}\n   *   Message.\n   */\n  message(causeOrReason, optionsOrParentOrPlace, origin) {\n    const message = new VFileMessage(\n      // @ts-expect-error: the overloads are fine.\n      causeOrReason,\n      optionsOrParentOrPlace,\n      origin\n    )\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name\n      message.file = this.path\n    }\n\n    message.fatal = false\n\n    this.messages.push(message)\n\n    return message\n  }\n\n  /**\n   * Serialize the file.\n   *\n   * > **Note**: which encodings are supported depends on the engine.\n   * > For info on Node.js, see:\n   * > <https://nodejs.org/api/util.html#whatwg-supported-encodings>.\n   *\n   * @param {string | null | undefined} [encoding='utf8']\n   *   Character encoding to understand `value` as when it’s a `Uint8Array`\n   *   (default: `'utf-8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n  toString(encoding) {\n    if (this.value === undefined) {\n      return ''\n    }\n\n    if (typeof this.value === 'string') {\n      return this.value\n    }\n\n    const decoder = new TextDecoder(encoding || undefined)\n    return decoder.decode(this.value)\n  }\n}\n\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string | null | undefined} part\n *   File path part.\n * @param {string} name\n *   Part name.\n * @returns {undefined}\n *   Nothing.\n */\nfunction assertPart(part, name) {\n  if (part && part.includes(minpath.sep)) {\n    throw new Error(\n      '`' + name + '` cannot be a path: did not expect `' + minpath.sep + '`'\n    )\n  }\n}\n\n/**\n * Assert that `part` is not empty.\n *\n * @param {string | undefined} part\n *   Thing.\n * @param {string} name\n *   Part name.\n * @returns {asserts part is string}\n *   Nothing.\n */\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty')\n  }\n}\n\n/**\n * Assert `path` exists.\n *\n * @param {string | undefined} path\n *   Path.\n * @param {string} name\n *   Dependency name.\n * @returns {asserts path is string}\n *   Nothing.\n */\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too')\n  }\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","export const CallableInstance =\n  /**\n   * @type {new <Parameters extends Array<unknown>, Result>(property: string | symbol) => (...parameters: Parameters) => Result}\n   */\n  (\n    /** @type {unknown} */\n    (\n      /**\n       * @this {Function}\n       * @param {string | symbol} property\n       * @returns {(...parameters: Array<unknown>) => unknown}\n       */\n      function (property) {\n        const self = this\n        const constr = self.constructor\n        const proto = /** @type {Record<string | symbol, Function>} */ (\n          // Prototypes do exist.\n          // type-coverage:ignore-next-line\n          constr.prototype\n        )\n        const value = proto[property]\n        /** @type {(...parameters: Array<unknown>) => unknown} */\n        const apply = function () {\n          return value.apply(apply, arguments)\n        }\n\n        Object.setPrototypeOf(apply, proto)\n\n        // Not needed for us in `unified`: we only call this on the `copy`\n        // function,\n        // and we don't need to add its fields (`length`, `name`)\n        // over.\n        // See also: GH-246.\n        // const names = Object.getOwnPropertyNames(value)\n        //\n        // for (const p of names) {\n        //   const descriptor = Object.getOwnPropertyDescriptor(value, p)\n        //   if (descriptor) Object.defineProperty(apply, p, descriptor)\n        // }\n\n        return apply\n      }\n    )\n  )\n","/**\n * @typedef {import('trough').Pipeline} Pipeline\n *\n * @typedef {import('unist').Node} Node\n *\n * @typedef {import('vfile').Compatible} Compatible\n * @typedef {import('vfile').Value} Value\n *\n * @typedef {import('../index.js').CompileResultMap} CompileResultMap\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Settings} Settings\n */\n\n/**\n * @typedef {CompileResultMap[keyof CompileResultMap]} CompileResults\n *   Acceptable results from compilers.\n *\n *   To register custom results, add them to\n *   {@linkcode CompileResultMap}.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the compiler receives (default: `Node`).\n * @template {CompileResults} [Result=CompileResults]\n *   The thing that the compiler yields (default: `CompileResults`).\n * @callback Compiler\n *   A **compiler** handles the compiling of a syntax tree to something else\n *   (in most cases, text) (TypeScript type).\n *\n *   It is used in the stringify phase and called with a {@linkcode Node}\n *   and {@linkcode VFile} representation of the document to compile.\n *   It should return the textual representation of the given tree (typically\n *   `string`).\n *\n *   > **Note**: unified typically compiles by serializing: most compilers\n *   > return `string` (or `Uint8Array`).\n *   > Some compilers, such as the one configured with\n *   > [`rehype-react`][rehype-react], return other values (in this case, a\n *   > React tree).\n *   > If you’re using a compiler that doesn’t serialize, expect different\n *   > result values.\n *   >\n *   > To register custom results in TypeScript, add them to\n *   > {@linkcode CompileResultMap}.\n *\n *   [rehype-react]: https://github.com/rehypejs/rehype-react\n * @param {Tree} tree\n *   Tree to compile.\n * @param {VFile} file\n *   File associated with `tree`.\n * @returns {Result}\n *   New content: compiled text (`string` or `Uint8Array`, for `file.value`) or\n *   something else (for `file.result`).\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The node that the parser yields (default: `Node`)\n * @callback Parser\n *   A **parser** handles the parsing of text to a syntax tree.\n *\n *   It is used in the parse phase and is called with a `string` and\n *   {@linkcode VFile} of the document to parse.\n *   It must return the syntax tree representation of the given file\n *   ({@linkcode Node}).\n * @param {string} document\n *   Document to parse.\n * @param {VFile} file\n *   File associated with `document`.\n * @returns {Tree}\n *   Node representing the given file.\n */\n\n/**\n * @typedef {(\n *   Plugin<Array<any>, any, any> |\n *   PluginTuple<Array<any>, any, any> |\n *   Preset\n * )} Pluggable\n *   Union of the different ways to add plugins and settings.\n */\n\n/**\n * @typedef {Array<Pluggable>} PluggableList\n *   List of plugins and presets.\n */\n\n// Note: we can’t use `callback` yet as it messes up `this`:\n//  <https://github.com/microsoft/TypeScript/issues/55197>.\n/**\n * @template {Array<unknown>} [PluginParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=Node]\n *   Value that is expected as input (default: `Node`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=Input]\n *   Value that is yielded as output (default: `Input`).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   (this: Processor, ...parameters: PluginParameters) =>\n *     Input extends string ? // Parser.\n *        Output extends Node | undefined ? undefined | void : never :\n *     Output extends CompileResults ? // Compiler.\n *        Input extends Node | undefined ? undefined | void : never :\n *     Transformer<\n *       Input extends Node ? Input : Node,\n *       Output extends Node ? Output : Node\n *     > | undefined | void\n * )} Plugin\n *   Single plugin.\n *\n *   Plugins configure the processors they are applied on in the following\n *   ways:\n *\n *   *   they change the processor, such as the parser, the compiler, or by\n *       configuring data\n *   *   they specify how to handle trees and files\n *\n *   In practice, they are functions that can receive options and configure the\n *   processor (`this`).\n *\n *   > **Note**: plugins are called when the processor is *frozen*, not when\n *   > they are applied.\n */\n\n/**\n * Tuple of a plugin and its configuration.\n *\n * The first item is a plugin, the rest are its parameters.\n *\n * @template {Array<unknown>} [TupleParameters=[]]\n *   Arguments passed to the plugin (default: `[]`, the empty tuple).\n * @template {Node | string | undefined} [Input=undefined]\n *   Value that is expected as input (optional).\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node it expects.\n *   *   If the plugin sets a {@linkcode Parser}, this should be\n *       `string`.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be the\n *       node it expects.\n * @template [Output=undefined] (optional).\n *   Value that is yielded as output.\n *\n *   *   If the plugin returns a {@linkcode Transformer}, this\n *       should be the node that that yields.\n *   *   If the plugin sets a {@linkcode Parser}, this should be the\n *       node that it yields.\n *   *   If the plugin sets a {@linkcode Compiler}, this should be\n *       result it yields.\n * @typedef {(\n *   [\n *     plugin: Plugin<TupleParameters, Input, Output>,\n *     ...parameters: TupleParameters\n *   ]\n * )} PluginTuple\n */\n\n/**\n * @typedef Preset\n *   Sharable configuration.\n *\n *   They can contain plugins and settings.\n * @property {PluggableList | undefined} [plugins]\n *   List of plugins and presets (optional).\n * @property {Settings | undefined} [settings]\n *   Shared settings for parsers and compilers (optional).\n */\n\n/**\n * @template {VFile} [File=VFile]\n *   The file that the callback receives (default: `VFile`).\n * @callback ProcessCallback\n *   Callback called when the process is done.\n *\n *   Called with either an error or a result.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {File | undefined} [file]\n *   Processed file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Tree=Node]\n *   The tree that the callback receives (default: `Node`).\n * @callback RunCallback\n *   Callback called when transformers are done.\n *\n *   Called with either an error or results.\n * @param {Error | undefined} [error]\n *   Fatal error (optional).\n * @param {Tree | undefined} [tree]\n *   Transformed tree (optional).\n * @param {VFile | undefined} [file]\n *   File (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Output=Node]\n *   Node type that the transformer yields (default: `Node`).\n * @callback TransformCallback\n *   Callback passed to transforms.\n *\n *   If the signature of a `transformer` accepts a third argument, the\n *   transformer may perform asynchronous operations, and must call it.\n * @param {Error | undefined} [error]\n *   Fatal error to stop the process (optional).\n * @param {Output | undefined} [tree]\n *   New, changed, tree (optional).\n * @param {VFile | undefined} [file]\n *   New, changed, file (optional).\n * @returns {undefined}\n *   Nothing.\n */\n\n/**\n * @template {Node} [Input=Node]\n *   Node type that the transformer expects (default: `Node`).\n * @template {Node} [Output=Input]\n *   Node type that the transformer yields (default: `Input`).\n * @callback Transformer\n *   Transformers handle syntax trees and files.\n *\n *   They are functions that are called each time a syntax tree and file are\n *   passed through the run phase.\n *   When an error occurs in them (either because it’s thrown, returned,\n *   rejected, or passed to `next`), the process stops.\n *\n *   The run phase is handled by [`trough`][trough], see its documentation for\n *   the exact semantics of these functions.\n *\n *   > **Note**: you should likely ignore `next`: don’t accept it.\n *   > it supports callback-style async work.\n *   > But promises are likely easier to reason about.\n *\n *   [trough]: https://github.com/wooorm/trough#function-fninput-next\n * @param {Input} tree\n *   Tree to handle.\n * @param {VFile} file\n *   File to handle.\n * @param {TransformCallback<Output>} next\n *   Callback.\n * @returns {(\n *   Promise<Output | undefined | void> |\n *   Promise<never> | // For some reason this is needed separately.\n *   Output |\n *   Error |\n *   undefined |\n *   void\n * )}\n *   If you accept `next`, nothing.\n *   Otherwise:\n *\n *   *   `Error` — fatal error to stop the process\n *   *   `Promise<undefined>` or `undefined` — the next transformer keeps using\n *       same tree\n *   *   `Promise<Node>` or `Node` — new, changed, tree\n */\n\n/**\n * @template {Node | undefined} ParseTree\n *   Output of `parse`.\n * @template {Node | undefined} HeadTree\n *   Input for `run`.\n * @template {Node | undefined} TailTree\n *   Output for `run`.\n * @template {Node | undefined} CompileTree\n *   Input of `stringify`.\n * @template {CompileResults | undefined} CompileResult\n *   Output of `stringify`.\n * @template {Node | string | undefined} Input\n *   Input of plugin.\n * @template Output\n *   Output of plugin (optional).\n * @typedef {(\n *   Input extends string\n *     ? Output extends Node | undefined\n *       ? // Parser.\n *         Processor<\n *           Output extends undefined ? ParseTree : Output,\n *           HeadTree,\n *           TailTree,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Output extends CompileResults\n *     ? Input extends Node | undefined\n *       ? // Compiler.\n *         Processor<\n *           ParseTree,\n *           HeadTree,\n *           TailTree,\n *           Input extends undefined ? CompileTree : Input,\n *           Output extends undefined ? CompileResult : Output\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : Input extends Node | undefined\n *     ? Output extends Node | undefined\n *       ? // Transform.\n *         Processor<\n *           ParseTree,\n *           HeadTree extends undefined ? Input : HeadTree,\n *           Output extends undefined ? TailTree : Output,\n *           CompileTree,\n *           CompileResult\n *         >\n *       : // Unknown.\n *         Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n *     : // Unknown.\n *       Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>\n * )} UsePlugin\n *   Create a processor based on the input/output of a {@link Plugin plugin}.\n */\n\n/**\n * @template {CompileResults | undefined} Result\n *   Node type that the transformer yields.\n * @typedef {(\n *   Result extends Value | undefined ?\n *     VFile :\n *     VFile & {result: Result}\n *   )} VFileWithOutput\n *   Type to generate a {@linkcode VFile} corresponding to a compiler result.\n *\n *   If a result that is not acceptable on a `VFile` is used, that will\n *   be stored on the `result` field of {@linkcode VFile}.\n */\n\nimport {bail} from 'bail'\nimport extend from 'extend'\nimport {ok as assert} from 'devlop'\nimport isPlainObj from 'is-plain-obj'\nimport {trough} from 'trough'\nimport {VFile} from 'vfile'\nimport {CallableInstance} from './callable-instance.js'\n\n// To do: next major: drop `Compiler`, `Parser`: prefer lowercase.\n\n// To do: we could start yielding `never` in TS when a parser is missing and\n// `parse` is called.\n// Currently, we allow directly setting `processor.parser`, which is untyped.\n\nconst own = {}.hasOwnProperty\n\n/**\n * @template {Node | undefined} [ParseTree=undefined]\n *   Output of `parse` (optional).\n * @template {Node | undefined} [HeadTree=undefined]\n *   Input for `run` (optional).\n * @template {Node | undefined} [TailTree=undefined]\n *   Output for `run` (optional).\n * @template {Node | undefined} [CompileTree=undefined]\n *   Input of `stringify` (optional).\n * @template {CompileResults | undefined} [CompileResult=undefined]\n *   Output of `stringify` (optional).\n * @extends {CallableInstance<[], Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>>}\n */\nexport class Processor extends CallableInstance {\n  /**\n   * Create a processor.\n   */\n  constructor() {\n    // If `Processor()` is called (w/o new), `copy` is called instead.\n    super('copy')\n\n    /**\n     * Compiler to use (deprecated).\n     *\n     * @deprecated\n     *   Use `compiler` instead.\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.Compiler = undefined\n\n    /**\n     * Parser to use (deprecated).\n     *\n     * @deprecated\n     *   Use `parser` instead.\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.Parser = undefined\n\n    // Note: the following fields are considered private.\n    // However, they are needed for tests, and TSC generates an untyped\n    // `private freezeIndex` field for, which trips `type-coverage` up.\n    // Instead, we use `@deprecated` to visualize that they shouldn’t be used.\n    /**\n     * Internal list of configured plugins.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Array<PluginTuple<Array<unknown>>>}\n     */\n    this.attachers = []\n\n    /**\n     * Compiler to use.\n     *\n     * @type {(\n     *   Compiler<\n     *     CompileTree extends undefined ? Node : CompileTree,\n     *     CompileResult extends undefined ? CompileResults : CompileResult\n     *   > |\n     *   undefined\n     * )}\n     */\n    this.compiler = undefined\n\n    /**\n     * Internal state to track where we are while freezing.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {number}\n     */\n    this.freezeIndex = -1\n\n    /**\n     * Internal state to track whether we’re frozen.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {boolean | undefined}\n     */\n    this.frozen = undefined\n\n    /**\n     * Internal state.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Data}\n     */\n    this.namespace = {}\n\n    /**\n     * Parser to use.\n     *\n     * @type {(\n     *   Parser<ParseTree extends undefined ? Node : ParseTree> |\n     *   undefined\n     * )}\n     */\n    this.parser = undefined\n\n    /**\n     * Internal list of configured transformers.\n     *\n     * @deprecated\n     *   This is a private internal property and should not be used.\n     * @type {Pipeline}\n     */\n    this.transformers = trough()\n  }\n\n  /**\n   * Copy a processor.\n   *\n   * @deprecated\n   *   This is a private internal method and should not be used.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   New *unfrozen* processor ({@linkcode Processor}) that is\n   *   configured to work the same as its ancestor.\n   *   When the descendant processor is configured in the future it does not\n   *   affect the ancestral processor.\n   */\n  copy() {\n    // Cast as the type parameters will be the same after attaching.\n    const destination =\n      /** @type {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>} */ (\n        new Processor()\n      )\n    let index = -1\n\n    while (++index < this.attachers.length) {\n      const attacher = this.attachers[index]\n      destination.use(...attacher)\n    }\n\n    destination.data(extend(true, {}, this.namespace))\n\n    return destination\n  }\n\n  /**\n   * Configure the processor with info available to all plugins.\n   * Information is stored in an object.\n   *\n   * Typically, options can be given to a specific plugin, but sometimes it\n   * makes sense to have information shared with several plugins.\n   * For example, a list of HTML elements that are self-closing, which is\n   * needed during all phases.\n   *\n   * > **Note**: setting information cannot occur on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * > **Note**: to register custom data in TypeScript, augment the\n   * > {@linkcode Data} interface.\n   *\n   * @example\n   *   This example show how to get and set info:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   const processor = unified().data('alpha', 'bravo')\n   *\n   *   processor.data('alpha') // => 'bravo'\n   *\n   *   processor.data() // => {alpha: 'bravo'}\n   *\n   *   processor.data({charlie: 'delta'})\n   *\n   *   processor.data() // => {charlie: 'delta'}\n   *   ```\n   *\n   * @template {keyof Data} Key\n   *\n   * @overload\n   * @returns {Data}\n   *\n   * @overload\n   * @param {Data} dataset\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Key} key\n   * @returns {Data[Key]}\n   *\n   * @overload\n   * @param {Key} key\n   * @param {Data[Key]} value\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @param {Data | Key} [key]\n   *   Key to get or set, or entire dataset to set, or nothing to get the\n   *   entire dataset (optional).\n   * @param {Data[Key]} [value]\n   *   Value to set (optional).\n   * @returns {unknown}\n   *   The current processor when setting, the value at `key` when getting, or\n   *   the entire dataset when getting without key.\n   */\n  data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', this.frozen)\n        this.namespace[key] = value\n        return this\n      }\n\n      // Get `key`.\n      return (own.call(this.namespace, key) && this.namespace[key]) || undefined\n    }\n\n    // Set space.\n    if (key) {\n      assertUnfrozen('data', this.frozen)\n      this.namespace = key\n      return this\n    }\n\n    // Get space.\n    return this.namespace\n  }\n\n  /**\n   * Freeze a processor.\n   *\n   * Frozen processors are meant to be extended and not to be configured\n   * directly.\n   *\n   * When a processor is frozen it cannot be unfrozen.\n   * New processors working the same way can be created by calling the\n   * processor.\n   *\n   * It’s possible to freeze processors explicitly by calling `.freeze()`.\n   * Processors freeze automatically when `.parse()`, `.run()`, `.runSync()`,\n   * `.stringify()`, `.process()`, or `.processSync()` are called.\n   *\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   The current processor.\n   */\n  freeze() {\n    if (this.frozen) {\n      return this\n    }\n\n    // Cast so that we can type plugins easier.\n    // Plugins are supposed to be usable on different processors, not just on\n    // this exact processor.\n    const self = /** @type {Processor} */ (/** @type {unknown} */ (this))\n\n    while (++this.freezeIndex < this.attachers.length) {\n      const [attacher, ...options] = this.attachers[this.freezeIndex]\n\n      if (options[0] === false) {\n        continue\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined\n      }\n\n      const transformer = attacher.call(self, ...options)\n\n      if (typeof transformer === 'function') {\n        this.transformers.use(transformer)\n      }\n    }\n\n    this.frozen = true\n    this.freezeIndex = Number.POSITIVE_INFINITY\n\n    return this\n  }\n\n  /**\n   * Parse text to a syntax tree.\n   *\n   * > **Note**: `parse` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `parse` performs the parse phase, not the run phase or other\n   * > phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   file to parse (optional); typically `string` or `VFile`; any value\n   *   accepted as `x` in `new VFile(x)`.\n   * @returns {ParseTree extends undefined ? Node : ParseTree}\n   *   Syntax tree representing `file`.\n   */\n  parse(file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const parser = this.parser || this.Parser\n    assertParser('parse', parser)\n    return parser(String(realFile), realFile)\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * > **Note**: `process` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `process` performs the parse, run, and stringify phases.\n   *\n   * @overload\n   * @param {Compatible | undefined} file\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<VFileWithOutput<CompileResult>>}\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`]; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @param {ProcessCallback<VFileWithOutput<CompileResult>> | undefined} [done]\n   *   Callback (optional).\n   * @returns {Promise<VFile> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise a promise, rejected with a fatal error or resolved with the\n   *   processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  process(file, done) {\n    const self = this\n\n    this.freeze()\n    assertParser('process', this.parser || this.Parser)\n    assertCompiler('process', this.compiler || this.Compiler)\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {((file: VFileWithOutput<CompileResult>) => undefined | void) | undefined} resolve\n     * @param {(error: Error | undefined) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      const realFile = vfile(file)\n      // Assume `ParseTree` (the result of the parser) matches `HeadTree` (the\n      // input of the first transform).\n      const parseTree =\n        /** @type {HeadTree extends undefined ? Node : HeadTree} */ (\n          /** @type {unknown} */ (self.parse(realFile))\n        )\n\n      self.run(parseTree, realFile, function (error, tree, file) {\n        if (error || !tree || !file) {\n          return realDone(error)\n        }\n\n        // Assume `TailTree` (the output of the last transform) matches\n        // `CompileTree` (the input of the compiler).\n        const compileTree =\n          /** @type {CompileTree extends undefined ? Node : CompileTree} */ (\n            /** @type {unknown} */ (tree)\n          )\n\n        const compileResult = self.stringify(compileTree, file)\n\n        if (looksLikeAValue(compileResult)) {\n          file.value = compileResult\n        } else {\n          file.result = compileResult\n        }\n\n        realDone(error, /** @type {VFileWithOutput<CompileResult>} */ (file))\n      })\n\n      /**\n       * @param {Error | undefined} error\n       * @param {VFileWithOutput<CompileResult> | undefined} [file]\n       * @returns {undefined}\n       */\n      function realDone(error, file) {\n        if (error || !file) {\n          reject(error)\n        } else if (resolve) {\n          resolve(file)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Process the given file as configured on the processor.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `processSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `processSync` performs the parse, run, and stringify phases.\n   *\n   * @param {Compatible | undefined} [file]\n   *   File (optional); typically `string` or `VFile`; any value accepted as\n   *   `x` in `new VFile(x)`.\n   * @returns {VFileWithOutput<CompileResult>}\n   *   The processed file.\n   *\n   *   The parsed, transformed, and compiled value is available at\n   *   `file.value` (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most\n   *   > compilers return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  processSync(file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {VFileWithOutput<CompileResult> | undefined} */\n    let result\n\n    this.freeze()\n    assertParser('processSync', this.parser || this.Parser)\n    assertCompiler('processSync', this.compiler || this.Compiler)\n\n    this.process(file, realDone)\n    assertDone('processSync', 'process', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n\n    return result\n\n    /**\n     * @type {ProcessCallback<VFileWithOutput<CompileResult>>}\n     */\n    function realDone(error, file) {\n      complete = true\n      bail(error)\n      result = file\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * > **Note**: `run` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `run` performs the run phase, not other phases.\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} file\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} done\n   * @returns {undefined}\n   *\n   * @overload\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   * @param {Compatible | undefined} [file]\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree>}\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {(\n   *   RunCallback<TailTree extends undefined ? Node : TailTree> |\n   *   Compatible\n   * )} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @param {RunCallback<TailTree extends undefined ? Node : TailTree>} [done]\n   *   Callback (optional).\n   * @returns {Promise<TailTree extends undefined ? Node : TailTree> | undefined}\n   *   Nothing if `done` is given.\n   *   Otherwise, a promise rejected with a fatal error or resolved with the\n   *   transformed tree.\n   */\n  run(tree, file, done) {\n    assertNode(tree)\n    this.freeze()\n\n    const transformers = this.transformers\n\n    if (!done && typeof file === 'function') {\n      done = file\n      file = undefined\n    }\n\n    return done ? executor(undefined, done) : new Promise(executor)\n\n    // Note: `void`s needed for TS.\n    /**\n     * @param {(\n     *   ((tree: TailTree extends undefined ? Node : TailTree) => undefined | void) |\n     *   undefined\n     * )} resolve\n     * @param {(error: Error) => undefined | void} reject\n     * @returns {undefined}\n     */\n    function executor(resolve, reject) {\n      assert(\n        typeof file !== 'function',\n        '`file` can’t be a `done` anymore, we checked'\n      )\n      const realFile = vfile(file)\n      transformers.run(tree, realFile, realDone)\n\n      /**\n       * @param {Error | undefined} error\n       * @param {Node} outputTree\n       * @param {VFile} file\n       * @returns {undefined}\n       */\n      function realDone(error, outputTree, file) {\n        const resultingTree =\n          /** @type {TailTree extends undefined ? Node : TailTree} */ (\n            outputTree || tree\n          )\n\n        if (error) {\n          reject(error)\n        } else if (resolve) {\n          resolve(resultingTree)\n        } else {\n          assert(done, '`done` is defined if `resolve` is not')\n          done(undefined, resultingTree, file)\n        }\n      }\n    }\n  }\n\n  /**\n   * Run *transformers* on a syntax tree.\n   *\n   * An error is thrown if asynchronous transforms are configured.\n   *\n   * > **Note**: `runSync` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `runSync` performs the run phase, not other phases.\n   *\n   * @param {HeadTree extends undefined ? Node : HeadTree} tree\n   *   Tree to transform and inspect.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {TailTree extends undefined ? Node : TailTree}\n   *   Transformed tree.\n   */\n  runSync(tree, file) {\n    /** @type {boolean} */\n    let complete = false\n    /** @type {(TailTree extends undefined ? Node : TailTree) | undefined} */\n    let result\n\n    this.run(tree, file, realDone)\n\n    assertDone('runSync', 'run', complete)\n    assert(result, 'we either bailed on an error or have a tree')\n    return result\n\n    /**\n     * @type {RunCallback<TailTree extends undefined ? Node : TailTree>}\n     */\n    function realDone(error, tree) {\n      bail(error)\n      result = tree\n      complete = true\n    }\n  }\n\n  /**\n   * Compile a syntax tree.\n   *\n   * > **Note**: `stringify` freezes the processor if not already *frozen*.\n   *\n   * > **Note**: `stringify` performs the stringify phase, not the run phase\n   * > or other phases.\n   *\n   * @param {CompileTree extends undefined ? Node : CompileTree} tree\n   *   Tree to compile.\n   * @param {Compatible | undefined} [file]\n   *   File associated with `node` (optional); any value accepted as `x` in\n   *   `new VFile(x)`.\n   * @returns {CompileResult extends undefined ? Value : CompileResult}\n   *   Textual representation of the tree (see note).\n   *\n   *   > **Note**: unified typically compiles by serializing: most compilers\n   *   > return `string` (or `Uint8Array`).\n   *   > Some compilers, such as the one configured with\n   *   > [`rehype-react`][rehype-react], return other values (in this case, a\n   *   > React tree).\n   *   > If you’re using a compiler that doesn’t serialize, expect different\n   *   > result values.\n   *   >\n   *   > To register custom results in TypeScript, add them to\n   *   > {@linkcode CompileResultMap}.\n   *\n   *   [rehype-react]: https://github.com/rehypejs/rehype-react\n   */\n  stringify(tree, file) {\n    this.freeze()\n    const realFile = vfile(file)\n    const compiler = this.compiler || this.Compiler\n    assertCompiler('stringify', compiler)\n    assertNode(tree)\n\n    return compiler(tree, realFile)\n  }\n\n  /**\n   * Configure the processor to use a plugin, a list of usable values, or a\n   * preset.\n   *\n   * If the processor is already using a plugin, the previous plugin\n   * configuration is changed based on the options that are passed in.\n   * In other words, the plugin is not added a second time.\n   *\n   * > **Note**: `use` cannot be called on *frozen* processors.\n   * > Call the processor first to create a new unfrozen processor.\n   *\n   * @example\n   *   There are many ways to pass plugins to `.use()`.\n   *   This example gives an overview:\n   *\n   *   ```js\n   *   import {unified} from 'unified'\n   *\n   *   unified()\n   *     // Plugin with options:\n   *     .use(pluginA, {x: true, y: true})\n   *     // Passing the same plugin again merges configuration (to `{x: true, y: false, z: true}`):\n   *     .use(pluginA, {y: false, z: true})\n   *     // Plugins:\n   *     .use([pluginB, pluginC])\n   *     // Two plugins, the second with options:\n   *     .use([pluginD, [pluginE, {}]])\n   *     // Preset with plugins and settings:\n   *     .use({plugins: [pluginF, [pluginG, {}]], settings: {position: false}})\n   *     // Settings only:\n   *     .use({settings: {position: false}})\n   *   ```\n   *\n   * @template {Array<unknown>} [Parameters=[]]\n   * @template {Node | string | undefined} [Input=undefined]\n   * @template [Output=Input]\n   *\n   * @overload\n   * @param {Preset | null | undefined} [preset]\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {PluggableList} list\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *\n   * @overload\n   * @param {Plugin<Parameters, Input, Output>} plugin\n   * @param {...(Parameters | [boolean])} parameters\n   * @returns {UsePlugin<ParseTree, HeadTree, TailTree, CompileTree, CompileResult, Input, Output>}\n   *\n   * @param {PluggableList | Plugin | Preset | null | undefined} value\n   *   Usable value.\n   * @param {...unknown} parameters\n   *   Parameters, when a plugin is given as a usable value.\n   * @returns {Processor<ParseTree, HeadTree, TailTree, CompileTree, CompileResult>}\n   *   Current processor.\n   */\n  use(value, ...parameters) {\n    const attachers = this.attachers\n    const namespace = this.namespace\n\n    assertUnfrozen('use', this.frozen)\n\n    if (value === null || value === undefined) {\n      // Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, parameters)\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value)\n      } else {\n        addPreset(value)\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`')\n    }\n\n    return this\n\n    /**\n     * @param {Pluggable} value\n     * @returns {undefined}\n     */\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value, [])\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...parameters] =\n            /** @type {PluginTuple<Array<unknown>>} */ (value)\n          addPlugin(plugin, parameters)\n        } else {\n          addPreset(value)\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`')\n      }\n    }\n\n    /**\n     * @param {Preset} result\n     * @returns {undefined}\n     */\n    function addPreset(result) {\n      if (!('plugins' in result) && !('settings' in result)) {\n        throw new Error(\n          'Expected usable value but received an empty preset, which is probably a mistake: presets typically come with `plugins` and sometimes with `settings`, but this has neither'\n        )\n      }\n\n      addList(result.plugins)\n\n      if (result.settings) {\n        namespace.settings = extend(true, namespace.settings, result.settings)\n      }\n    }\n\n    /**\n     * @param {PluggableList | null | undefined} plugins\n     * @returns {undefined}\n     */\n    function addList(plugins) {\n      let index = -1\n\n      if (plugins === null || plugins === undefined) {\n        // Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index]\n          add(thing)\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`')\n      }\n    }\n\n    /**\n     * @param {Plugin} plugin\n     * @param {Array<unknown>} parameters\n     * @returns {undefined}\n     */\n    function addPlugin(plugin, parameters) {\n      let index = -1\n      let entryIndex = -1\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entryIndex = index\n          break\n        }\n      }\n\n      if (entryIndex === -1) {\n        attachers.push([plugin, ...parameters])\n      }\n      // Only set if there was at least a `primary` value, otherwise we’d change\n      // `arguments.length`.\n      else if (parameters.length > 0) {\n        let [primary, ...rest] = parameters\n        const currentPrimary = attachers[entryIndex][1]\n        if (isPlainObj(currentPrimary) && isPlainObj(primary)) {\n          primary = extend(true, currentPrimary, primary)\n        }\n\n        attachers[entryIndex] = [plugin, primary, ...rest]\n      }\n    }\n  }\n}\n\n// Note: this returns a *callable* instance.\n// That’s why it’s documented as a function.\n/**\n * Create a new processor.\n *\n * @example\n *   This example shows how a new processor can be created (from `remark`) and linked\n *   to **stdin**(4) and **stdout**(4).\n *\n *   ```js\n *   import process from 'node:process'\n *   import concatStream from 'concat-stream'\n *   import {remark} from 'remark'\n *\n *   process.stdin.pipe(\n *     concatStream(function (buf) {\n *       process.stdout.write(String(remark().processSync(buf)))\n *     })\n *   )\n *   ```\n *\n * @returns\n *   New *unfrozen* processor (`processor`).\n *\n *   This processor is configured to work the same as its ancestor.\n *   When the descendant processor is configured in the future it does not\n *   affect the ancestral processor.\n */\nexport const unified = new Processor().freeze()\n\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `parser`')\n  }\n}\n\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `compiler`')\n  }\n}\n\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error(\n      'Cannot call `' +\n        name +\n        '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.'\n    )\n  }\n}\n\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`')\n    // Fine.\n  }\n}\n\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error(\n      '`' + name + '` finished async. Use `' + asyncName + '` instead'\n    )\n  }\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {VFile}\n */\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value)\n}\n\n/**\n * @param {Compatible | undefined} [value]\n * @returns {value is VFile}\n */\nfunction looksLikeAVFile(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'message' in value &&\n      'messages' in value\n  )\n}\n\n/**\n * @param {unknown} [value]\n * @returns {value is Value}\n */\nfunction looksLikeAValue(value) {\n  return typeof value === 'string' || isUint8Array(value)\n}\n\n/**\n * Assert `value` is an `Uint8Array`.\n *\n * @param {unknown} value\n *   thing.\n * @returns {value is Uint8Array}\n *   Whether `value` is an `Uint8Array`.\n */\nfunction isUint8Array(value) {\n  return Boolean(\n    value &&\n      typeof value === 'object' &&\n      'byteLength' in value &&\n      'byteOffset' in value\n  )\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Blockquote} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `blockquote` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Blockquote} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function blockquote(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'blockquote',\n    properties: {},\n    children: state.wrap(state.all(node), true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element, Text} from 'hast'\n * @import {Break} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `break` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Break} node\n *   mdast node.\n * @returns {Array<Element | Text>}\n *   hast element content.\n */\nexport function hardBreak(state, node) {\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'br', properties: {}, children: []}\n  state.patch(node, result)\n  return [state.applyData(node, result), {type: 'text', value: '\\n'}]\n}\n","/**\n * @import {Element, Properties} from 'hast'\n * @import {Code} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `code` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Code} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function code(state, node) {\n  const value = node.value ? node.value + '\\n' : ''\n  /** @type {Properties} */\n  const properties = {}\n  // Someone can write `js&#x20;python&#x9;ruby`.\n  const language = node.lang ? node.lang.split(/\\s+/) : []\n\n  // GH/CM still drop the non-first languages.\n  if (language.length > 0) {\n    properties.className = ['language-' + language[0]]\n  }\n\n  // Create `<code>`.\n  /** @type {Element} */\n  let result = {\n    type: 'element',\n    tagName: 'code',\n    properties,\n    children: [{type: 'text', value}]\n  }\n\n  if (node.meta) {\n    result.data = {meta: node.meta}\n  }\n\n  state.patch(node, result)\n  result = state.applyData(node, result)\n\n  // Create `<pre>`.\n  result = {type: 'element', tagName: 'pre', properties: {}, children: [result]}\n  state.patch(node, result)\n  return result\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Delete} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `delete` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Delete} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strikethrough(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'del',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Emphasis} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `emphasis` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Emphasis} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function emphasis(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'em',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Code} from 'micromark-util-types'\n */\n\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function asciiControl(code) {\n  return (\n    // Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiDigit = regexCheck(/\\d/);\n\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n *\n * @param code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n *   Code.\n * @returns {boolean}\n *   Whether it matches.\n */\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodePunctuation = regexCheck(/\\p{P}|\\p{S}/u);\n\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n *\n * @param code\n *   Code.\n * @returns\n *   Whether it matches.\n */\nexport const unicodeWhitespace = regexCheck(/\\s/);\n\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n *   Expression.\n * @returns {(code: Code) => boolean}\n *   Check.\n */\nfunction regexCheck(regex) {\n  return check;\n\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code\n   *   Character code.\n   * @returns {boolean}\n   *   Whether the character code matches the bound regex.\n   */\n  function check(code) {\n    return code !== null && code > -1 && regex.test(String.fromCharCode(code));\n  }\n}","import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri`).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * A regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`, or\n * `/^https?$/i` for `img[src]` (this is what `github.com` allows).\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string | null | undefined} url\n *   URI to sanitize.\n * @param {RegExp | null | undefined} [protocol]\n *   Allowed protocols.\n * @returns {string}\n *   Sanitized URI.\n */\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n  if (!protocol) {\n    return value;\n  }\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n  if (\n  // If there is no protocol, it’s relative.\n  colon < 0 ||\n  // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign ||\n  // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n  return '';\n}\n\n/**\n * Normalize a URL.\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n *   URI to normalize.\n * @returns {string}\n *   Normalized URI.\n */\nexport function normalizeUri(value) {\n  /** @type {Array<string>} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n    let replace = '';\n\n    // A correct percent encoded value.\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    }\n    // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    }\n    // Astral.\n    else if (code > 55_295 && code < 57_344) {\n      const next = value.charCodeAt(index + 1);\n\n      // A correct surrogate pair.\n      if (code < 56_320 && next > 56_319 && next < 57_344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      }\n      // Lone surrogate.\n      else {\n        replace = \"\\uFFFD\";\n      }\n    }\n    // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n  return result.join('') + value.slice(start);\n}","/**\n * @import {Element} from 'hast'\n * @import {FootnoteReference} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `footnoteReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {FootnoteReference} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function footnoteReference(state, node) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const id = String(node.identifier).toUpperCase()\n  const safeId = normalizeUri(id.toLowerCase())\n  const index = state.footnoteOrder.indexOf(id)\n  /** @type {number} */\n  let counter\n\n  let reuseCounter = state.footnoteCounts.get(id)\n\n  if (reuseCounter === undefined) {\n    reuseCounter = 0\n    state.footnoteOrder.push(id)\n    counter = state.footnoteOrder.length\n  } else {\n    counter = index + 1\n  }\n\n  reuseCounter += 1\n  state.footnoteCounts.set(id, reuseCounter)\n\n  /** @type {Element} */\n  const link = {\n    type: 'element',\n    tagName: 'a',\n    properties: {\n      href: '#' + clobberPrefix + 'fn-' + safeId,\n      id:\n        clobberPrefix +\n        'fnref-' +\n        safeId +\n        (reuseCounter > 1 ? '-' + reuseCounter : ''),\n      dataFootnoteRef: true,\n      ariaDescribedBy: ['footnote-label']\n    },\n    children: [{type: 'text', value: String(counter)}]\n  }\n  state.patch(node, link)\n\n  /** @type {Element} */\n  const sup = {\n    type: 'element',\n    tagName: 'sup',\n    properties: {},\n    children: [link]\n  }\n  state.patch(node, sup)\n  return state.applyData(node, sup)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Heading} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `heading` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Heading} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function heading(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'h' + node.depth,\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Html} from 'mdast'\n * @import {State} from '../state.js'\n * @import {Raw} from '../../index.js'\n */\n\n/**\n * Turn an mdast `html` node into hast (`raw` node in dangerous mode, otherwise\n * nothing).\n *\n * @param {State} state\n *   Info passed around.\n * @param {Html} node\n *   mdast node.\n * @returns {Element | Raw | undefined}\n *   hast node.\n */\nexport function html(state, node) {\n  if (state.options.allowDangerousHtml) {\n    /** @type {Raw} */\n    const result = {type: 'raw', value: node.value}\n    state.patch(node, result)\n    return state.applyData(node, result)\n  }\n\n  return undefined\n}\n","/**\n * @import {ElementContent} from 'hast'\n * @import {Reference, Nodes} from 'mdast'\n * @import {State} from './state.js'\n */\n\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Extract<Nodes, Reference>} node\n *   Reference node (image, link).\n * @returns {Array<ElementContent>}\n *   hast content.\n */\nexport function revert(state, node) {\n  const subtype = node.referenceType\n  let suffix = ']'\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 [{type: 'text', value: '![' + node.alt + suffix}]\n  }\n\n  const contents = state.all(node)\n  const head = contents[0]\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value\n  } else {\n    contents.unshift({type: 'text', value: '['})\n  }\n\n  const tail = contents[contents.length - 1]\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix\n  } else {\n    contents.push({type: 'text', value: suffix})\n  }\n\n  return contents\n}\n","/**\n * @import {ElementContent, Element, Properties} from 'hast'\n * @import {ImageReference} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `imageReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ImageReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function imageReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(definition.url || ''), alt: node.alt}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element, Properties} from 'hast'\n * @import {Image} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `image` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Image} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function image(state, node) {\n  /** @type {Properties} */\n  const properties = {src: normalizeUri(node.url)}\n\n  if (node.alt !== null && node.alt !== undefined) {\n    properties.alt = node.alt\n  }\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'img', properties, children: []}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element, Text} from 'hast'\n * @import {InlineCode} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `inlineCode` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {InlineCode} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function inlineCode(state, node) {\n  /** @type {Text} */\n  const text = {type: 'text', value: node.value.replace(/\\r?\\n|\\r/g, ' ')}\n  state.patch(node, text)\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'code',\n    properties: {},\n    children: [text]\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {ElementContent, Element, Properties} from 'hast'\n * @import {LinkReference} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\nimport {revert} from '../revert.js'\n\n/**\n * Turn an mdast `linkReference` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {LinkReference} node\n *   mdast node.\n * @returns {Array<ElementContent> | ElementContent}\n *   hast node.\n */\nexport function linkReference(state, node) {\n  const id = String(node.identifier).toUpperCase()\n  const definition = state.definitionById.get(id)\n\n  if (!definition) {\n    return revert(state, node)\n  }\n\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(definition.url || '')}\n\n  if (definition.title !== null && definition.title !== undefined) {\n    properties.title = definition.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element, Properties} from 'hast'\n * @import {Link} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Turn an mdast `link` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Link} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function link(state, node) {\n  /** @type {Properties} */\n  const properties = {href: normalizeUri(node.url)}\n\n  if (node.title !== null && node.title !== undefined) {\n    properties.title = node.title\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'a',\n    properties,\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {ElementContent, Element, Properties} from 'hast'\n * @import {ListItem, Parents} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `listItem` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ListItem} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function listItem(state, node, parent) {\n  const results = state.all(node)\n  const loose = parent ? listLoose(parent) : listItemLoose(node)\n  /** @type {Properties} */\n  const properties = {}\n  /** @type {Array<ElementContent>} */\n  const children = []\n\n  if (typeof node.checked === 'boolean') {\n    const head = results[0]\n    /** @type {Element} */\n    let paragraph\n\n    if (head && head.type === 'element' && head.tagName === 'p') {\n      paragraph = head\n    } else {\n      paragraph = {type: 'element', tagName: 'p', properties: {}, children: []}\n      results.unshift(paragraph)\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift({type: 'text', value: ' '})\n    }\n\n    paragraph.children.unshift({\n      type: 'element',\n      tagName: 'input',\n      properties: {type: 'checkbox', checked: node.checked, disabled: true},\n      children: []\n    })\n\n    // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n    properties.className = ['task-list-item']\n  }\n\n  let index = -1\n\n  while (++index < results.length) {\n    const child = results[index]\n\n    // Add eols before nodes, except if this is a loose, first paragraph.\n    if (\n      loose ||\n      index !== 0 ||\n      child.type !== 'element' ||\n      child.tagName !== 'p'\n    ) {\n      children.push({type: 'text', value: '\\n'})\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      children.push(...child.children)\n    } else {\n      children.push(child)\n    }\n  }\n\n  const tail = results[results.length - 1]\n\n  // Add a final eol.\n  if (tail && (loose || tail.type !== 'element' || tail.tagName !== 'p')) {\n    children.push({type: 'text', value: '\\n'})\n  }\n\n  /** @type {Element} */\n  const result = {type: 'element', tagName: 'li', properties, children}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * @param {Parents} node\n * @return {Boolean}\n */\nfunction listLoose(node) {\n  let loose = false\n  if (node.type === 'list') {\n    loose = node.spread || false\n    const children = node.children\n    let index = -1\n\n    while (!loose && ++index < children.length) {\n      loose = listItemLoose(children[index])\n    }\n  }\n\n  return loose\n}\n\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\nfunction listItemLoose(node) {\n  const spread = node.spread\n\n  return spread === null || spread === undefined\n    ? node.children.length > 1\n    : spread\n}\n","/**\n * @import {Element, Properties} from 'hast'\n * @import {List} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `list` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {List} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function list(state, node) {\n  /** @type {Properties} */\n  const properties = {}\n  const results = state.all(node)\n  let index = -1\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    properties.start = node.start\n  }\n\n  // Like GitHub, add a class for custom styling.\n  while (++index < results.length) {\n    const child = results[index]\n\n    if (\n      child.type === 'element' &&\n      child.tagName === 'li' &&\n      child.properties &&\n      Array.isArray(child.properties.className) &&\n      child.properties.className.includes('task-list-item')\n    ) {\n      properties.className = ['contains-task-list']\n      break\n    }\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: node.ordered ? 'ol' : 'ul',\n    properties,\n    children: state.wrap(results, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Paragraph} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `paragraph` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Paragraph} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function paragraph(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'p',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Parents as HastParents, Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `root` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastRoot} node\n *   mdast node.\n * @returns {HastParents}\n *   hast node.\n */\nexport function root(state, node) {\n  /** @type {HastRoot} */\n  const result = {type: 'root', children: state.wrap(state.all(node))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {Strong} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `strong` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Strong} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function strong(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'strong',\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Position} Position\n */\n\n/**\n * @typedef NodeLike\n * @property {string} type\n * @property {PositionLike | null | undefined} [position]\n *\n * @typedef PositionLike\n * @property {PointLike | null | undefined} [start]\n * @property {PointLike | null | undefined} [end]\n *\n * @typedef PointLike\n * @property {number | null | undefined} [line]\n * @property {number | null | undefined} [column]\n * @property {number | null | undefined} [offset]\n */\n\n/**\n * Get the ending point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointEnd = point('end')\n\n/**\n * Get the starting point of `node`.\n *\n * @param node\n *   Node.\n * @returns\n *   Point.\n */\nexport const pointStart = point('start')\n\n/**\n * Get the positional info of `node`.\n *\n * @param {'end' | 'start'} type\n *   Side.\n * @returns\n *   Getter.\n */\nfunction point(type) {\n  return point\n\n  /**\n   * Get the point info of `node` at a bound side.\n   *\n   * @param {Node | NodeLike | null | undefined} [node]\n   * @returns {Point | undefined}\n   */\n  function point(node) {\n    const point = (node && node.position && node.position[type]) || {}\n\n    if (\n      typeof point.line === 'number' &&\n      point.line > 0 &&\n      typeof point.column === 'number' &&\n      point.column > 0\n    ) {\n      return {\n        line: point.line,\n        column: point.column,\n        offset:\n          typeof point.offset === 'number' && point.offset > -1\n            ? point.offset\n            : undefined\n      }\n    }\n  }\n}\n\n/**\n * Get the positional info of `node`.\n *\n * @param {Node | NodeLike | null | undefined} [node]\n *   Node.\n * @returns {Position | undefined}\n *   Position.\n */\nexport function position(node) {\n  const start = pointStart(node)\n  const end = pointEnd(node)\n\n  if (start && end) {\n    return {start, end}\n  }\n}\n","/**\n * @import {Table} from 'mdast'\n * @import {Element} from 'hast'\n * @import {State} from '../state.js'\n */\n\nimport {pointEnd, pointStart} from 'unist-util-position'\n\n/**\n * Turn an mdast `table` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {Table} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function table(state, node) {\n  const rows = state.all(node)\n  const firstRow = rows.shift()\n  /** @type {Array<Element>} */\n  const tableContent = []\n\n  if (firstRow) {\n    /** @type {Element} */\n    const head = {\n      type: 'element',\n      tagName: 'thead',\n      properties: {},\n      children: state.wrap([firstRow], true)\n    }\n    state.patch(node.children[0], head)\n    tableContent.push(head)\n  }\n\n  if (rows.length > 0) {\n    /** @type {Element} */\n    const body = {\n      type: 'element',\n      tagName: 'tbody',\n      properties: {},\n      children: state.wrap(rows, true)\n    }\n\n    const start = pointStart(node.children[1])\n    const end = pointEnd(node.children[node.children.length - 1])\n    if (start && end) body.position = {start, end}\n    tableContent.push(body)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'table',\n    properties: {},\n    children: state.wrap(tableContent, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element, ElementContent, Properties} from 'hast'\n * @import {Parents, TableRow} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `tableRow` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableRow} node\n *   mdast node.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {Element}\n *   hast node.\n */\nexport function tableRow(state, node, parent) {\n  const siblings = parent ? parent.children : undefined\n  // Generate a body row when without parent.\n  const rowIndex = siblings ? siblings.indexOf(node) : 1\n  const tagName = rowIndex === 0 ? 'th' : 'td'\n  // To do: option to use `style`?\n  const align = parent && parent.type === 'table' ? parent.align : undefined\n  const length = align ? align.length : node.children.length\n  let cellIndex = -1\n  /** @type {Array<ElementContent>} */\n  const cells = []\n\n  while (++cellIndex < length) {\n    // Note: can also be undefined.\n    const cell = node.children[cellIndex]\n    /** @type {Properties} */\n    const properties = {}\n    const alignValue = align ? align[cellIndex] : undefined\n\n    if (alignValue) {\n      properties.align = alignValue\n    }\n\n    /** @type {Element} */\n    let result = {type: 'element', tagName, properties, children: []}\n\n    if (cell) {\n      result.children = state.all(cell)\n      state.patch(cell, result)\n      result = state.applyData(cell, result)\n    }\n\n    cells.push(result)\n  }\n\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'tr',\n    properties: {},\n    children: state.wrap(cells, true)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {TableCell} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `tableCell` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {TableCell} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function tableCell(state, node) {\n  // Note: this function is normally not called: see `table-row` for how rows\n  // and their cells are compiled.\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'td', // Assume body cell.\n    properties: {},\n    children: state.all(node)\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","const tab = 9 /* `\\t` */\nconst space = 32 /* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\nexport function trimLines(value) {\n  const source = String(value)\n  const search = /\\r?\\n|\\r/g\n  let match = search.exec(source)\n  let last = 0\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (match) {\n    lines.push(\n      trimLine(source.slice(last, match.index), last > 0, true),\n      match[0]\n    )\n\n    last = match.index + match[0].length\n    match = search.exec(source)\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false))\n\n  return lines.join('')\n}\n\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\nfunction trimLine(value, start, end) {\n  let startIndex = 0\n  let endIndex = value.length\n\n  if (start) {\n    let code = value.codePointAt(startIndex)\n\n    while (code === tab || code === space) {\n      startIndex++\n      code = value.codePointAt(startIndex)\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1)\n\n    while (code === tab || code === space) {\n      endIndex--\n      code = value.codePointAt(endIndex - 1)\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : ''\n}\n","/**\n * @import {Element as HastElement, Text as HastText} from 'hast'\n * @import {Text as MdastText} from 'mdast'\n * @import {State} from '../state.js'\n */\n\nimport {trimLines} from 'trim-lines'\n\n/**\n * Turn an mdast `text` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastText} node\n *   mdast node.\n * @returns {HastElement | HastText}\n *   hast node.\n */\nexport function text(state, node) {\n  /** @type {HastText} */\n  const result = {type: 'text', value: trimLines(String(node.value))}\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Element} from 'hast'\n * @import {ThematicBreak} from 'mdast'\n * @import {State} from '../state.js'\n */\n\n/**\n * Turn an mdast `thematicBreak` node into hast.\n *\n * @param {State} state\n *   Info passed around.\n * @param {ThematicBreak} node\n *   mdast node.\n * @returns {Element}\n *   hast node.\n */\nexport function thematicBreak(state, node) {\n  /** @type {Element} */\n  const result = {\n    type: 'element',\n    tagName: 'hr',\n    properties: {},\n    children: []\n  }\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n","/**\n * @import {Handlers} from '../state.js'\n */\n\nimport {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {strikethrough} from './delete.js'\nimport {emphasis} from './emphasis.js'\nimport {footnoteReference} from './footnote-reference.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {imageReference} from './image-reference.js'\nimport {image} from './image.js'\nimport {inlineCode} from './inline-code.js'\nimport {linkReference} from './link-reference.js'\nimport {link} from './link.js'\nimport {listItem} from './list-item.js'\nimport {list} from './list.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {table} from './table.js'\nimport {tableRow} from './table-row.js'\nimport {tableCell} from './table-cell.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default handlers for nodes.\n *\n * @satisfies {Handlers}\n */\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  // @ts-expect-error: root is different, but hard to type.\n  root,\n  strong,\n  table,\n  tableCell,\n  tableRow,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}\n\n// Return nothing for nodes that are ignored.\nfunction ignore() {\n  return undefined\n}\n","export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n      case 'ArrayBuffer':\n        return as(new Uint8Array(value).buffer, value);\n      case 'DataView': {\n        const { buffer } = new Uint8Array(value);\n        return as(new DataView(buffer), value);\n      }\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n","import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n    case 'DataView':\n      return [ARRAY, asString];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type) {\n          let spread = value;\n          if (type === 'DataView') {\n            spread = new Uint8Array(value.buffer);\n          }\n          else if (type === 'ArrayBuffer') {\n            spread = new Uint8Array(value);\n          }\n          return as([type, [...spread]], value);\n        }\n\n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n","import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n","/**\n * @import {ElementContent, Element} from 'hast'\n * @import {State} from './state.js'\n */\n\n/**\n * @callback FootnoteBackContentTemplate\n *   Generate content for the backreference dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent> | ElementContent | string}\n *   Content for the backreference when linking back from definitions to their\n *   reference.\n *\n * @callback FootnoteBackLabelTemplate\n *   Generate a back label dynamically.\n *\n *   For the following markdown:\n *\n *   ```markdown\n *   Alpha[^micromark], bravo[^micromark], and charlie[^remark].\n *\n *   [^remark]: things about remark\n *   [^micromark]: things about micromark\n *   ```\n *\n *   This function will be called with:\n *\n *   *  `0` and `0` for the backreference from `things about micromark` to\n *      `alpha`, as it is the first used definition, and the first call to it\n *   *  `0` and `1` for the backreference from `things about micromark` to\n *      `bravo`, as it is the first used definition, and the second call to it\n *   *  `1` and `0` for the backreference from `things about remark` to\n *      `charlie`, as it is the second used definition\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Back label to use when linking back from definitions to their reference.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {normalizeUri} from 'micromark-util-sanitize-uri'\n\n/**\n * Generate the default content that GitHub uses on backreferences.\n *\n * @param {number} _\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {Array<ElementContent>}\n *   Content.\n */\nexport function defaultFootnoteBackContent(_, rereferenceIndex) {\n  /** @type {Array<ElementContent>} */\n  const result = [{type: 'text', value: '↩'}]\n\n  if (rereferenceIndex > 1) {\n    result.push({\n      type: 'element',\n      tagName: 'sup',\n      properties: {},\n      children: [{type: 'text', value: String(rereferenceIndex)}]\n    })\n  }\n\n  return result\n}\n\n/**\n * Generate the default label that GitHub uses on backreferences.\n *\n * @param {number} referenceIndex\n *   Index of the definition in the order that they are first referenced,\n *   0-indexed.\n * @param {number} rereferenceIndex\n *   Index of calls to the same definition, 0-indexed.\n * @returns {string}\n *   Label.\n */\nexport function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n  return (\n    'Back to reference ' +\n    (referenceIndex + 1) +\n    (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n  )\n}\n\n/**\n * Generate a hast footer for called footnote definitions.\n *\n * @param {State} state\n *   Info passed around.\n * @returns {Element | undefined}\n *   `section` element or `undefined`.\n */\n// eslint-disable-next-line complexity\nexport function footer(state) {\n  const clobberPrefix =\n    typeof state.options.clobberPrefix === 'string'\n      ? state.options.clobberPrefix\n      : 'user-content-'\n  const footnoteBackContent =\n    state.options.footnoteBackContent || defaultFootnoteBackContent\n  const footnoteBackLabel =\n    state.options.footnoteBackLabel || defaultFootnoteBackLabel\n  const footnoteLabel = state.options.footnoteLabel || 'Footnotes'\n  const footnoteLabelTagName = state.options.footnoteLabelTagName || 'h2'\n  const footnoteLabelProperties = state.options.footnoteLabelProperties || {\n    className: ['sr-only']\n  }\n  /** @type {Array<ElementContent>} */\n  const listItems = []\n  let referenceIndex = -1\n\n  while (++referenceIndex < state.footnoteOrder.length) {\n    const definition = state.footnoteById.get(\n      state.footnoteOrder[referenceIndex]\n    )\n\n    if (!definition) {\n      continue\n    }\n\n    const content = state.all(definition)\n    const id = String(definition.identifier).toUpperCase()\n    const safeId = normalizeUri(id.toLowerCase())\n    let rereferenceIndex = 0\n    /** @type {Array<ElementContent>} */\n    const backReferences = []\n    const counts = state.footnoteCounts.get(id)\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (counts !== undefined && ++rereferenceIndex <= counts) {\n      if (backReferences.length > 0) {\n        backReferences.push({type: 'text', value: ' '})\n      }\n\n      let children =\n        typeof footnoteBackContent === 'string'\n          ? footnoteBackContent\n          : footnoteBackContent(referenceIndex, rereferenceIndex)\n\n      if (typeof children === 'string') {\n        children = {type: 'text', value: children}\n      }\n\n      backReferences.push({\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href:\n            '#' +\n            clobberPrefix +\n            'fnref-' +\n            safeId +\n            (rereferenceIndex > 1 ? '-' + rereferenceIndex : ''),\n          dataFootnoteBackref: '',\n          ariaLabel:\n            typeof footnoteBackLabel === 'string'\n              ? footnoteBackLabel\n              : footnoteBackLabel(referenceIndex, rereferenceIndex),\n          className: ['data-footnote-backref']\n        },\n        children: Array.isArray(children) ? children : [children]\n      })\n    }\n\n    const tail = content[content.length - 1]\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1]\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' '\n      } else {\n        tail.children.push({type: 'text', value: ' '})\n      }\n\n      tail.children.push(...backReferences)\n    } else {\n      content.push(...backReferences)\n    }\n\n    /** @type {Element} */\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {id: clobberPrefix + 'fn-' + safeId},\n      children: state.wrap(content, true)\n    }\n\n    state.patch(definition, listItem)\n\n    listItems.push(listItem)\n  }\n\n  if (listItems.length === 0) {\n    return\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {dataFootnotes: true, className: ['footnotes']},\n    children: [\n      {\n        type: 'element',\n        tagName: footnoteLabelTagName,\n        properties: {\n          ...structuredClone(footnoteLabelProperties),\n          id: 'footnote-label'\n        },\n        children: [{type: 'text', value: footnoteLabel}]\n      },\n      {type: 'text', value: '\\n'},\n      {\n        type: 'element',\n        tagName: 'ol',\n        properties: {},\n        children: state.wrap(listItems, true)\n      },\n      {type: 'text', value: '\\n'}\n    ]\n  }\n}\n","/**\n * @import {Node, Parent} from 'unist'\n */\n\n/**\n * @template Fn\n * @template Fallback\n * @typedef {Fn extends (value: any) => value is infer Thing ? Thing : Fallback} Predicate\n */\n\n/**\n * @callback Check\n *   Check that an arbitrary value is a node.\n * @param {unknown} this\n *   The given context.\n * @param {unknown} [node]\n *   Anything (typically a node).\n * @param {number | null | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean}\n *   Whether this is a node and passes a test.\n *\n * @typedef {Record<string, unknown> | Node} Props\n *   Object to check for equivalence.\n *\n *   Note: `Node` is included as it is common but is not indexable.\n *\n * @typedef {Array<Props | TestFunction | string> | ReadonlyArray<Props | TestFunction | string> | Props | TestFunction | string | null | undefined} Test\n *   Check for an arbitrary node.\n *\n * @callback TestFunction\n *   Check if a node passes a test.\n * @param {unknown} this\n *   The given context.\n * @param {Node} node\n *   A node.\n * @param {number | undefined} [index]\n *   The node’s position in its parent.\n * @param {Parent | undefined} [parent]\n *   The node’s parent.\n * @returns {boolean | undefined | void}\n *   Whether this node passes the test.\n *\n *   Note: `void` is included until TS sees no return as `undefined`.\n */\n\n/**\n * Check if `node` is a `Node` and whether it passes the given test.\n *\n * @param {unknown} node\n *   Thing to check, typically `Node`.\n * @param {Test} test\n *   A check for a specific node.\n * @param {number | null | undefined} index\n *   The node’s position in its parent.\n * @param {Parent | null | undefined} parent\n *   The node’s parent.\n * @param {unknown} context\n *   Context object (`this`) to pass to `test` functions.\n * @returns {boolean}\n *   Whether `node` is a node and passes a test.\n */\nexport const is =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends ReadonlyArray<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends Array<string>>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition[number]}) &\n   *   (<Condition extends string>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(node: unknown, test: Condition, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((node?: null | undefined) => false) &\n   *   ((node: unknown, test?: null | undefined, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((node: unknown, test?: Test, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => boolean)\n   * )}\n   */\n  (\n    /**\n     * @param {unknown} [node]\n     * @param {Test} [test]\n     * @param {number | null | undefined} [index]\n     * @param {Parent | null | undefined} [parent]\n     * @param {unknown} [context]\n     * @returns {boolean}\n     */\n    // eslint-disable-next-line max-params\n    function (node, test, index, parent, context) {\n      const check = convert(test)\n\n      if (\n        index !== undefined &&\n        index !== null &&\n        (typeof index !== 'number' ||\n          index < 0 ||\n          index === Number.POSITIVE_INFINITY)\n      ) {\n        throw new Error('Expected positive finite index')\n      }\n\n      if (\n        parent !== undefined &&\n        parent !== null &&\n        (!is(parent) || !parent.children)\n      ) {\n        throw new Error('Expected parent node')\n      }\n\n      if (\n        (parent === undefined || parent === null) !==\n        (index === undefined || index === null)\n      ) {\n        throw new Error('Expected both parent and index')\n      }\n\n      return looksLikeANode(node)\n        ? check.call(context, node, index, parent)\n        : false\n    }\n  )\n\n/**\n * Generate an assertion from a test.\n *\n * Useful if you’re going to test many nodes, for example when creating a\n * utility where something else passes a compatible test.\n *\n * The created function is a bit faster because it expects valid input only:\n * a `node`, `index`, and `parent`.\n *\n * @param {Test} test\n *   *   when nullish, checks if `node` is a `Node`.\n *   *   when `string`, works like passing `(node) => node.type === test`.\n *   *   when `function` checks if function passed the node is true.\n *   *   when `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n *   *   when `array`, checks if any one of the subtests pass.\n * @returns {Check}\n *   An assertion.\n */\nexport const convert =\n  // Note: overloads in JSDoc can’t yet use different `@template`s.\n  /**\n   * @type {(\n   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &\n   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &\n   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &\n   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &\n   *   ((test?: Test) => Check)\n   * )}\n   */\n  (\n    /**\n     * @param {Test} [test]\n     * @returns {Check}\n     */\n    function (test) {\n      if (test === null || test === undefined) {\n        return ok\n      }\n\n      if (typeof test === 'function') {\n        return castFactory(test)\n      }\n\n      if (typeof test === 'object') {\n        return Array.isArray(test)\n          ? anyFactory(test)\n          : // Cast because `ReadonlyArray` goes into the above but `isArray`\n            // narrows to `Array`.\n            propertiesFactory(/** @type {Props} */ (test))\n      }\n\n      if (typeof test === 'string') {\n        return typeFactory(test)\n      }\n\n      throw new Error('Expected function, string, or object as test')\n    }\n  )\n\n/**\n * @param {Array<Props | TestFunction | string>} tests\n * @returns {Check}\n */\nfunction anyFactory(tests) {\n  /** @type {Array<Check>} */\n  const checks = []\n  let index = -1\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index])\n  }\n\n  return castFactory(any)\n\n  /**\n   * @this {unknown}\n   * @type {TestFunction}\n   */\n  function any(...parameters) {\n    let index = -1\n\n    while (++index < checks.length) {\n      if (checks[index].apply(this, parameters)) return true\n    }\n\n    return false\n  }\n}\n\n/**\n * Turn an object into a test for a node with a certain fields.\n *\n * @param {Props} check\n * @returns {Check}\n */\nfunction propertiesFactory(check) {\n  const checkAsRecord = /** @type {Record<string, unknown>} */ (check)\n\n  return castFactory(all)\n\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n  function all(node) {\n    const nodeAsRecord = /** @type {Record<string, unknown>} */ (\n      /** @type {unknown} */ (node)\n    )\n\n    /** @type {string} */\n    let key\n\n    for (key in check) {\n      if (nodeAsRecord[key] !== checkAsRecord[key]) return false\n    }\n\n    return true\n  }\n}\n\n/**\n * Turn a string into a test for a node with a certain type.\n *\n * @param {string} check\n * @returns {Check}\n */\nfunction typeFactory(check) {\n  return castFactory(type)\n\n  /**\n   * @param {Node} node\n   */\n  function type(node) {\n    return node && node.type === check\n  }\n}\n\n/**\n * Turn a custom test into a test for a node that passes that test.\n *\n * @param {TestFunction} testFunction\n * @returns {Check}\n */\nfunction castFactory(testFunction) {\n  return check\n\n  /**\n   * @this {unknown}\n   * @type {Check}\n   */\n  function check(value, index, parent) {\n    return Boolean(\n      looksLikeANode(value) &&\n        testFunction.call(\n          this,\n          value,\n          typeof index === 'number' ? index : undefined,\n          parent || undefined\n        )\n    )\n  }\n}\n\nfunction ok() {\n  return true\n}\n\n/**\n * @param {unknown} value\n * @returns {value is Node}\n */\nfunction looksLikeANode(value) {\n  return value !== null && typeof value === 'object' && 'type' in value\n}\n","/**\n * @import {Node as UnistNode, Parent as UnistParent} from 'unist'\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends ReadonlyArray<infer T>\n *   ? MatchesOne<Value, T>\n *   : Check extends Array<infer T>\n *   ? MatchesOne<Value, T>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {InternalAncestor<InclusiveDescendant<Tree>, Child>} Ancestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {'skip' | boolean} Action\n *   Union of the action types.\n *\n * @typedef {number} Index\n *   Move to the sibling at `index` next (after node itself is completely\n *   traversed).\n *\n *   Useful if mutating the tree, such as removing the node the visitor is\n *   currently on, or any of its previous siblings.\n *   Results less than 0 or greater than or equal to `children.length` stop\n *   traversing the parent.\n *\n * @typedef {[(Action | null | undefined | void)?, (Index | null | undefined)?]} ActionTuple\n *   List with one or two values, the first an action, the second an index.\n *\n * @typedef {Action | ActionTuple | Index | null | undefined | void} VisitorResult\n *   Any value that can be returned from a visitor.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform the parent of node (the last of `ancestors`).\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of an ancestor still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Array<VisitedParents>} ancestors\n *   Ancestors of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [VisitedParents=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Matches<InclusiveDescendant<Tree>, Check>, Ancestor<Tree, Matches<InclusiveDescendant<Tree>, Check>>>} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parents`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Tree type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {convert} from 'unist-util-is'\nimport {color} from 'unist-util-visit-parents/do-not-use-color'\n\n/** @type {Readonly<ActionTuple>} */\nconst empty = []\n\n/**\n * Continue traversing as normal.\n */\nexport const CONTINUE = true\n\n/**\n * Stop traversing immediately.\n */\nexport const EXIT = false\n\n/**\n * Do not traverse this node’s children.\n */\nexport const SKIP = 'skip'\n\n/**\n * Visit nodes, with ancestral information.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} test\n *   `unist-util-is`-compatible test\n * @param {Visitor | boolean | null | undefined} [visitor]\n *   Handle each node.\n * @param {boolean | null | undefined} [reverse]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visitParents(tree, test, visitor, reverse) {\n  /** @type {Test} */\n  let check\n\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor\n    // @ts-expect-error no visitor given, so `visitor` is test.\n    visitor = test\n  } else {\n    // @ts-expect-error visitor given, so `test` isn’t a visitor.\n    check = test\n  }\n\n  const is = convert(check)\n  const step = reverse ? -1 : 1\n\n  factory(tree, undefined, [])()\n\n  /**\n   * @param {UnistNode} node\n   * @param {number | undefined} index\n   * @param {Array<UnistParent>} parents\n   */\n  function factory(node, index, parents) {\n    const value = /** @type {Record<string, unknown>} */ (\n      node && typeof node === 'object' ? node : {}\n    )\n\n    if (typeof value.type === 'string') {\n      const name =\n        // `hast`\n        typeof value.tagName === 'string'\n          ? value.tagName\n          : // `xast`\n            typeof value.name === 'string'\n            ? value.name\n            : undefined\n\n      Object.defineProperty(visit, 'name', {\n        value:\n          'node (' + color(node.type + (name ? '<' + name + '>' : '')) + ')'\n      })\n    }\n\n    return visit\n\n    function visit() {\n      /** @type {Readonly<ActionTuple>} */\n      let result = empty\n      /** @type {Readonly<ActionTuple>} */\n      let subresult\n      /** @type {number} */\n      let offset\n      /** @type {Array<UnistParent>} */\n      let grandparents\n\n      if (!test || is(node, index, parents[parents.length - 1] || undefined)) {\n        // @ts-expect-error: `visitor` is now a visitor.\n        result = toResult(visitor(node, parents))\n\n        if (result[0] === EXIT) {\n          return result\n        }\n      }\n\n      if ('children' in node && node.children) {\n        const nodeAsParent = /** @type {UnistParent} */ (node)\n\n        if (nodeAsParent.children && result[0] !== SKIP) {\n          offset = (reverse ? nodeAsParent.children.length : -1) + step\n          grandparents = parents.concat(nodeAsParent)\n\n          while (offset > -1 && offset < nodeAsParent.children.length) {\n            const child = nodeAsParent.children[offset]\n\n            subresult = factory(child, offset, grandparents)()\n\n            if (subresult[0] === EXIT) {\n              return subresult\n            }\n\n            offset =\n              typeof subresult[1] === 'number' ? subresult[1] : offset + step\n          }\n        }\n      }\n\n      return result\n    }\n  }\n}\n\n/**\n * Turn a return value into a clean result.\n *\n * @param {VisitorResult} value\n *   Valid return values from visitors.\n * @returns {Readonly<ActionTuple>}\n *   Clean result.\n */\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value]\n  }\n\n  return value === null || value === undefined ? empty : [value]\n}\n","/**\n * @typedef {import('unist').Node} UnistNode\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n */\n\n/**\n * @typedef {Exclude<import('unist-util-is').Test, undefined> | undefined} Test\n *   Test from `unist-util-is`.\n *\n *   Note: we have remove and add `undefined`, because otherwise when generating\n *   automatic `.d.ts` files, TS tries to flatten paths from a local perspective,\n *   which doesn’t work when publishing on npm.\n */\n\n// To do: use types from `unist-util-visit-parents` when it’s released.\n\n/**\n * @typedef {(\n *   Fn extends (value: any) => value is infer Thing\n *   ? Thing\n *   : Fallback\n * )} Predicate\n *   Get the value of a type guard `Fn`.\n * @template Fn\n *   Value; typically function that is a type guard (such as `(x): x is Y`).\n * @template Fallback\n *   Value to yield if `Fn` is not a type guard.\n */\n\n/**\n * @typedef {(\n *   Check extends null | undefined // No test.\n *   ? Value\n *   : Value extends {type: Check} // String (type) test.\n *   ? Value\n *   : Value extends Check // Partial test.\n *   ? Value\n *   : Check extends Function // Function test.\n *   ? Predicate<Check, Value> extends Value\n *     ? Predicate<Check, Value>\n *     : never\n *   : never // Some other test?\n * )} MatchesOne\n *   Check whether a node matches a primitive check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test, but not arrays.\n */\n\n/**\n * @typedef {(\n *   Check extends Array<any>\n *   ? MatchesOne<Value, Check[keyof Check]>\n *   : MatchesOne<Value, Check>\n * )} Matches\n *   Check whether a node matches a check in the type system.\n * @template Value\n *   Value; typically unist `Node`.\n * @template Check\n *   Value; typically `unist-util-is`-compatible test.\n */\n\n/**\n * @typedef {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10} Uint\n *   Number; capped reasonably.\n */\n\n/**\n * @typedef {I extends 0 ? 1 : I extends 1 ? 2 : I extends 2 ? 3 : I extends 3 ? 4 : I extends 4 ? 5 : I extends 5 ? 6 : I extends 6 ? 7 : I extends 7 ? 8 : I extends 8 ? 9 : 10} Increment\n *   Increment a number in the type system.\n * @template {Uint} [I=0]\n *   Index.\n */\n\n/**\n * @typedef {(\n *   Node extends UnistParent\n *   ? Node extends {children: Array<infer Children>}\n *     ? Child extends Children ? Node : never\n *     : never\n *   : never\n * )} InternalParent\n *   Collect nodes that can be parents of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {InternalParent<InclusiveDescendant<Tree>, Child>} Parent\n *   Collect nodes in `Tree` that can be parents of `Child`.\n * @template {UnistNode} Tree\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n */\n\n/**\n * @typedef {(\n *   Depth extends Max\n *   ? never\n *   :\n *     | InternalParent<Node, Child>\n *     | InternalAncestor<Node, InternalParent<Node, Child>, Max, Increment<Depth>>\n * )} InternalAncestor\n *   Collect nodes in `Tree` that can be ancestors of `Child`.\n * @template {UnistNode} Node\n *   All node types in a tree.\n * @template {UnistNode} Child\n *   Node to search for.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @typedef {(\n *   Tree extends UnistParent\n *     ? Depth extends Max\n *       ? Tree\n *       : Tree | InclusiveDescendant<Tree['children'][number], Max, Increment<Depth>>\n *     : Tree\n * )} InclusiveDescendant\n *   Collect all (inclusive) descendants of `Tree`.\n *\n *   > 👉 **Note**: for performance reasons, this seems to be the fastest way to\n *   > recurse without actually running into an infinite loop, which the\n *   > previous version did.\n *   >\n *   > Practically, a max of `2` is typically enough assuming a `Root` is\n *   > passed, but it doesn’t improve performance.\n *   > It gets higher with `List > ListItem > Table > TableRow > TableCell`.\n *   > Using up to `10` doesn’t hurt or help either.\n * @template {UnistNode} Tree\n *   Tree type.\n * @template {Uint} [Max=10]\n *   Max; searches up to this depth.\n * @template {Uint} [Depth=0]\n *   Current depth.\n */\n\n/**\n * @callback Visitor\n *   Handle a node (matching `test`, if given).\n *\n *   Visitors are free to transform `node`.\n *   They can also transform `parent`.\n *\n *   Replacing `node` itself, if `SKIP` is not returned, still causes its\n *   descendants to be walked (which is a bug).\n *\n *   When adding or removing previous siblings of `node` (or next siblings, in\n *   case of reverse), the `Visitor` should return a new `Index` to specify the\n *   sibling to traverse after `node` is traversed.\n *   Adding or removing next siblings of `node` (or previous siblings, in case\n *   of reverse) is handled as expected without needing to return a new `Index`.\n *\n *   Removing the children property of `parent` still results in them being\n *   traversed.\n * @param {Visited} node\n *   Found node.\n * @param {Visited extends UnistNode ? number | undefined : never} index\n *   Index of `node` in `parent`.\n * @param {Ancestor extends UnistParent ? Ancestor | undefined : never} parent\n *   Parent of `node`.\n * @returns {VisitorResult}\n *   What to do next.\n *\n *   An `Index` is treated as a tuple of `[CONTINUE, Index]`.\n *   An `Action` is treated as a tuple of `[Action]`.\n *\n *   Passing a tuple back only makes sense if the `Action` is `SKIP`.\n *   When the `Action` is `EXIT`, that action can be returned.\n *   When the `Action` is `CONTINUE`, `Index` can be returned.\n * @template {UnistNode} [Visited=UnistNode]\n *   Visited node type.\n * @template {UnistParent} [Ancestor=UnistParent]\n *   Ancestor type.\n */\n\n/**\n * @typedef {Visitor<Visited, Parent<Ancestor, Visited>>} BuildVisitorFromMatch\n *   Build a typed `Visitor` function from a node and all possible parents.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Visited\n *   Node type.\n * @template {UnistParent} Ancestor\n *   Parent type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromMatch<\n *     Matches<Descendant, Check>,\n *     Extract<Descendant, UnistParent>\n *   >\n * )} BuildVisitorFromDescendants\n *   Build a typed `Visitor` function from a list of descendants and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} Descendant\n *   Node type.\n * @template {Test} Check\n *   Test type.\n */\n\n/**\n * @typedef {(\n *   BuildVisitorFromDescendants<\n *     InclusiveDescendant<Tree>,\n *     Check\n *   >\n * )} BuildVisitor\n *   Build a typed `Visitor` function from a tree and a test.\n *\n *   It will infer which values are passed as `node` and which as `parent`.\n * @template {UnistNode} [Tree=UnistNode]\n *   Node type.\n * @template {Test} [Check=Test]\n *   Test type.\n */\n\nimport {visitParents} from 'unist-util-visit-parents'\n\nexport {CONTINUE, EXIT, SKIP} from 'unist-util-visit-parents'\n\n/**\n * Visit nodes.\n *\n * This algorithm performs *depth-first* *tree traversal* in *preorder*\n * (**NLR**) or if `reverse` is given, in *reverse preorder* (**NRL**).\n *\n * You can choose for which nodes `visitor` is called by passing a `test`.\n * For complex tests, you should test yourself in `visitor`, as it will be\n * faster and will have improved type information.\n *\n * Walking the tree is an intensive task.\n * Make use of the return values of the visitor when possible.\n * Instead of walking a tree multiple times, walk it once, use `unist-util-is`\n * to check if a node matches, and then perform different operations.\n *\n * You can change the tree.\n * See `Visitor` for more info.\n *\n * @overload\n * @param {Tree} tree\n * @param {Check} check\n * @param {BuildVisitor<Tree, Check>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @overload\n * @param {Tree} tree\n * @param {BuildVisitor<Tree>} visitor\n * @param {boolean | null | undefined} [reverse]\n * @returns {undefined}\n *\n * @param {UnistNode} tree\n *   Tree to traverse.\n * @param {Visitor | Test} testOrVisitor\n *   `unist-util-is`-compatible test (optional, omit to pass a visitor).\n * @param {Visitor | boolean | null | undefined} [visitorOrReverse]\n *   Handle each node (when test is omitted, pass `reverse`).\n * @param {boolean | null | undefined} [maybeReverse=false]\n *   Traverse in reverse preorder (NRL) instead of the default preorder (NLR).\n * @returns {undefined}\n *   Nothing.\n *\n * @template {UnistNode} Tree\n *   Node type.\n * @template {Test} Check\n *   `unist-util-is`-compatible test.\n */\nexport function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {\n  /** @type {boolean | null | undefined} */\n  let reverse\n  /** @type {Test} */\n  let test\n  /** @type {Visitor} */\n  let visitor\n\n  if (\n    typeof testOrVisitor === 'function' &&\n    typeof visitorOrReverse !== 'function'\n  ) {\n    test = undefined\n    visitor = testOrVisitor\n    reverse = visitorOrReverse\n  } else {\n    // @ts-expect-error: assume the overload with test was given.\n    test = testOrVisitor\n    // @ts-expect-error: assume the overload with test was given.\n    visitor = visitorOrReverse\n    reverse = maybeReverse\n  }\n\n  visitParents(tree, test, overload, reverse)\n\n  /**\n   * @param {UnistNode} node\n   * @param {Array<UnistParent>} parents\n   */\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1]\n    const index = parent ? parent.children.indexOf(node) : undefined\n    return visitor(node, index, parent)\n  }\n}\n","/**\n * @import {\n *   ElementContent as HastElementContent,\n *   Element as HastElement,\n *   Nodes as HastNodes,\n *   Properties as HastProperties,\n *   RootContent as HastRootContent,\n *   Text as HastText\n * } from 'hast'\n * @import {\n *   Definition as MdastDefinition,\n *   FootnoteDefinition as MdastFootnoteDefinition,\n *   Nodes as MdastNodes,\n *   Parents as MdastParents\n * } from 'mdast'\n * @import {VFile} from 'vfile'\n * @import {\n *   FootnoteBackContentTemplate,\n *   FootnoteBackLabelTemplate\n * } from './footer.js'\n */\n\n/**\n * @callback Handler\n *   Handle a node.\n * @param {State} state\n *   Info passed around.\n * @param {any} node\n *   mdast node to handle.\n * @param {MdastParents | undefined} parent\n *   Parent of `node`.\n * @returns {Array<HastElementContent> | HastElementContent | undefined}\n *   hast node.\n *\n * @typedef {Partial<Record<MdastNodes['type'], Handler>>} Handlers\n *   Handle nodes.\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Whether to persist raw HTML in markdown in the hast tree (default:\n *   `false`).\n * @property {string | null | undefined} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` property on footnotes to prevent them from\n *   *clobbering* (default: `'user-content-'`).\n *\n *   Pass `''` for trusted markdown and when you are careful with\n *   polyfilling.\n *   You could pass a different prefix.\n *\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=\"x\"></p>\n *   <script>alert(x) // `x` now refers to the `p#x` DOM element</script>\n *   ```\n *\n *   The above example shows that elements are made available by browsers, by\n *   their ID, on the `window` object.\n *   This is a security risk because you might be expecting some other variable\n *   at that place.\n *   It can also break polyfills.\n *   Using a prefix solves these problems.\n * @property {VFile | null | undefined} [file]\n *   Corresponding virtual file representing the input document (optional).\n * @property {FootnoteBackContentTemplate | string | null | undefined} [footnoteBackContent]\n *   Content of the backreference back to references (default: `defaultFootnoteBackContent`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackContent(_, rereferenceIndex) {\n *     const result = [{type: 'text', value: '↩'}]\n *\n *     if (rereferenceIndex > 1) {\n *       result.push({\n *         type: 'element',\n *         tagName: 'sup',\n *         properties: {},\n *         children: [{type: 'text', value: String(rereferenceIndex)}]\n *       })\n *     }\n *\n *     return result\n *   }\n *   ```\n *\n *   This content is used in the `a` element of each backreference (the `↩`\n *   links).\n * @property {FootnoteBackLabelTemplate | string | null | undefined} [footnoteBackLabel]\n *   Label to describe the backreference back to references (default:\n *   `defaultFootnoteBackLabel`).\n *\n *   The default value is:\n *\n *   ```js\n *   function defaultFootnoteBackLabel(referenceIndex, rereferenceIndex) {\n *    return (\n *      'Back to reference ' +\n *      (referenceIndex + 1) +\n *      (rereferenceIndex > 1 ? '-' + rereferenceIndex : '')\n *    )\n *   }\n *   ```\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is used in the `ariaLabel` property on each backreference\n *   (the `↩` links).\n *   It affects users of assistive technology.\n * @property {string | null | undefined} [footnoteLabel='Footnotes']\n *   Textual label to use for the footnotes section (default: `'Footnotes'`).\n *\n *   Change it when the markdown is not in English.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {HastProperties | null | undefined} [footnoteLabelProperties={className: ['sr-only']}]\n *   Properties to use on the footnote label (default: `{className:\n *   ['sr-only']}`).\n *\n *   Change it to show the label and add other properties.\n *\n *   This label is typically hidden visually (assuming an `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass an empty string.\n *   You can also add different properties.\n *\n *   > **Note**: `id: 'footnote-label'` is always added, because footnote\n *   > calls use it with `aria-describedby` to provide an accessible label.\n * @property {string | null | undefined} [footnoteLabelTagName='h2']\n *   HTML tag name to use for the footnote label element (default: `'h2'`).\n *\n *   Change it to match your document structure.\n *\n *   This label is typically hidden visually (assuming a `sr-only` CSS class\n *   is defined that does that) and so affects screen readers only.\n *   If you do have such a class, but want to show this section to everyone,\n *   pass different properties with the `footnoteLabelProperties` option.\n * @property {Handlers | null | undefined} [handlers]\n *   Extra handlers for nodes (optional).\n * @property {Array<MdastNodes['type']> | null | undefined} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast (note that\n *   the node itself is passed, but eventual children are transformed)\n *   (optional).\n * @property {Handler | null | undefined} [unknownHandler]\n *   Handler for all unknown nodes (optional).\n *\n * @typedef State\n *   Info passed around.\n * @property {(node: MdastNodes) => Array<HastElementContent>} all\n *   Transform the children of an mdast parent to hast.\n * @property {<Type extends HastNodes>(from: MdastNodes, to: Type) => HastElement | Type} applyData\n *   Honor the `data` of `from`, and generate an element instead of `node`.\n * @property {Map<string, MdastDefinition>} definitionById\n *   Definitions by their identifier.\n * @property {Map<string, MdastFootnoteDefinition>} footnoteById\n *   Footnote definitions by their identifier.\n * @property {Map<string, number>} footnoteCounts\n *   Counts for how often the same footnote was called.\n * @property {Array<string>} footnoteOrder\n *   Identifiers of order when footnote calls first appear in tree order.\n * @property {Handlers} handlers\n *   Applied handlers.\n * @property {(node: MdastNodes, parent: MdastParents | undefined) => Array<HastElementContent> | HastElementContent | undefined} one\n *   Transform an mdast node to hast.\n * @property {Options} options\n *   Configuration.\n * @property {(from: MdastNodes, node: HastNodes) => undefined} patch\n *   Copy a node’s positional info.\n * @property {<Type extends HastRootContent>(nodes: Array<Type>, loose?: boolean | undefined) => Array<HastText | Type>} wrap\n *   Wrap `nodes` with line endings between each node, adds initial/final line endings when `loose`.\n */\n\nimport structuredClone from '@ungap/structured-clone'\nimport {visit} from 'unist-util-visit'\nimport {position} from 'unist-util-position'\nimport {handlers as defaultHandlers} from './handlers/index.js'\n\nconst own = {}.hasOwnProperty\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Create `state` from an mdast tree.\n *\n * @param {MdastNodes} tree\n *   mdast node to transform.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {State}\n *   `state` function.\n */\nexport function createState(tree, options) {\n  const settings = options || emptyOptions\n  /** @type {Map<string, MdastDefinition>} */\n  const definitionById = new Map()\n  /** @type {Map<string, MdastFootnoteDefinition>} */\n  const footnoteById = new Map()\n  /** @type {Map<string, number>} */\n  const footnoteCounts = new Map()\n  /** @type {Handlers} */\n  // @ts-expect-error: the root handler returns a root.\n  // Hard to type.\n  const handlers = {...defaultHandlers, ...settings.handlers}\n\n  /** @type {State} */\n  const state = {\n    all,\n    applyData,\n    definitionById,\n    footnoteById,\n    footnoteCounts,\n    footnoteOrder: [],\n    handlers,\n    one,\n    options: settings,\n    patch,\n    wrap\n  }\n\n  visit(tree, function (node) {\n    if (node.type === 'definition' || node.type === 'footnoteDefinition') {\n      const map = node.type === 'definition' ? definitionById : footnoteById\n      const id = String(node.identifier).toUpperCase()\n\n      // Mimick CM behavior of link definitions.\n      // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/9032189/lib/index.js#L20-L21>.\n      if (!map.has(id)) {\n        // @ts-expect-error: node type matches map.\n        map.set(id, node)\n      }\n    }\n  })\n\n  return state\n\n  /**\n   * Transform an mdast node into a hast node.\n   *\n   * @param {MdastNodes} node\n   *   mdast node.\n   * @param {MdastParents | undefined} [parent]\n   *   Parent of `node`.\n   * @returns {Array<HastElementContent> | HastElementContent | undefined}\n   *   Resulting hast node.\n   */\n  function one(node, parent) {\n    const type = node.type\n    const handle = state.handlers[type]\n\n    if (own.call(state.handlers, type) && handle) {\n      return handle(state, node, parent)\n    }\n\n    if (state.options.passThrough && state.options.passThrough.includes(type)) {\n      if ('children' in node) {\n        const {children, ...shallow} = node\n        const result = structuredClone(shallow)\n        // @ts-expect-error: TS doesn’t understand…\n        result.children = state.all(node)\n        // @ts-expect-error: TS doesn’t understand…\n        return result\n      }\n\n      // @ts-expect-error: it’s custom.\n      return structuredClone(node)\n    }\n\n    const unknown = state.options.unknownHandler || defaultUnknownHandler\n\n    return unknown(state, node, parent)\n  }\n\n  /**\n   * Transform the children of an mdast node into hast nodes.\n   *\n   * @param {MdastNodes} parent\n   *   mdast node to compile\n   * @returns {Array<HastElementContent>}\n   *   Resulting hast nodes.\n   */\n  function all(parent) {\n    /** @type {Array<HastElementContent>} */\n    const values = []\n\n    if ('children' in parent) {\n      const nodes = parent.children\n      let index = -1\n      while (++index < nodes.length) {\n        const result = state.one(nodes[index], parent)\n\n        // To do: see if we van clean this? Can we merge texts?\n        if (result) {\n          if (index && nodes[index - 1].type === 'break') {\n            if (!Array.isArray(result) && result.type === 'text') {\n              result.value = trimMarkdownSpaceStart(result.value)\n            }\n\n            if (!Array.isArray(result) && result.type === 'element') {\n              const head = result.children[0]\n\n              if (head && head.type === 'text') {\n                head.value = trimMarkdownSpaceStart(head.value)\n              }\n            }\n          }\n\n          if (Array.isArray(result)) {\n            values.push(...result)\n          } else {\n            values.push(result)\n          }\n        }\n      }\n    }\n\n    return values\n  }\n}\n\n/**\n * Copy a node’s positional info.\n *\n * @param {MdastNodes} from\n *   mdast node to copy from.\n * @param {HastNodes} to\n *   hast node to copy into.\n * @returns {undefined}\n *   Nothing.\n */\nfunction patch(from, to) {\n  if (from.position) to.position = position(from)\n}\n\n/**\n * Honor the `data` of `from` and maybe generate an element instead of `to`.\n *\n * @template {HastNodes} Type\n *   Node type.\n * @param {MdastNodes} from\n *   mdast node to use data from.\n * @param {Type} to\n *   hast node to change.\n * @returns {HastElement | Type}\n *   Nothing.\n */\nfunction applyData(from, to) {\n  /** @type {HastElement | Type} */\n  let result = to\n\n  // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n  if (from && from.data) {\n    const hName = from.data.hName\n    const hChildren = from.data.hChildren\n    const hProperties = from.data.hProperties\n\n    if (typeof hName === 'string') {\n      // Transforming the node resulted in an element with a different name\n      // than wanted:\n      if (result.type === 'element') {\n        result.tagName = hName\n      }\n      // Transforming the node resulted in a non-element, which happens for\n      // raw, text, and root nodes (unless custom handlers are passed).\n      // The intent of `hName` is to create an element, but likely also to keep\n      // the content around (otherwise: pass `hChildren`).\n      else {\n        /** @type {Array<HastElementContent>} */\n        // @ts-expect-error: assume no doctypes in `root`.\n        const children = 'children' in result ? result.children : [result]\n        result = {type: 'element', tagName: hName, properties: {}, children}\n      }\n    }\n\n    if (result.type === 'element' && hProperties) {\n      Object.assign(result.properties, structuredClone(hProperties))\n    }\n\n    if (\n      'children' in result &&\n      result.children &&\n      hChildren !== null &&\n      hChildren !== undefined\n    ) {\n      result.children = hChildren\n    }\n  }\n\n  return result\n}\n\n/**\n * Transform an unknown node.\n *\n * @param {State} state\n *   Info passed around.\n * @param {MdastNodes} node\n *   Unknown mdast node.\n * @returns {HastElement | HastText}\n *   Resulting hast node.\n */\nfunction defaultUnknownHandler(state, node) {\n  const data = node.data || {}\n  /** @type {HastElement | HastText} */\n  const result =\n    'value' in node &&\n    !(own.call(data, 'hProperties') || own.call(data, 'hChildren'))\n      ? {type: 'text', value: node.value}\n      : {\n          type: 'element',\n          tagName: 'div',\n          properties: {},\n          children: state.all(node)\n        }\n\n  state.patch(node, result)\n  return state.applyData(node, result)\n}\n\n/**\n * Wrap `nodes` with line endings between each node.\n *\n * @template {HastRootContent} Type\n *   Node type.\n * @param {Array<Type>} nodes\n *   List of nodes to wrap.\n * @param {boolean | undefined} [loose=false]\n *   Whether to add line endings at start and end (default: `false`).\n * @returns {Array<HastText | Type>}\n *   Wrapped nodes.\n */\nexport function wrap(nodes, loose) {\n  /** @type {Array<HastText | Type>} */\n  const result = []\n  let index = -1\n\n  if (loose) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push({type: 'text', value: '\\n'})\n    result.push(nodes[index])\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push({type: 'text', value: '\\n'})\n  }\n\n  return result\n}\n\n/**\n * Trim spaces and tabs at the start of `value`.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Result.\n */\nfunction trimMarkdownSpaceStart(value) {\n  let index = 0\n  let code = value.charCodeAt(index)\n\n  while (code === 9 || code === 32) {\n    index++\n    code = value.charCodeAt(index)\n  }\n\n  return value.slice(index)\n}\n","/**\n * @import {Nodes as HastNodes} from 'hast'\n * @import {Nodes as MdastNodes} from 'mdast'\n * @import {Options} from './state.js'\n */\n\nimport {ok as assert} from 'devlop'\nimport {footer} from './footer.js'\nimport {createState} from './state.js'\n\n/**\n * Transform mdast to hast.\n *\n * ##### Notes\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most utilities ignore `raw` nodes but two notable ones don’t:\n *\n * *   `hast-util-to-html` also has an option `allowDangerousHtml` which will\n *     output the raw HTML.\n *     This is typically discouraged as noted by the option name but is useful\n *     if you completely trust authors\n * *   `hast-util-raw` can handle the raw embedded HTML strings by parsing them\n *     into standard hast nodes (`element`, `text`, etc).\n *     This is a heavy task as it needs a full HTML parser, but it is the only\n *     way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark, which we follow by default.\n * They are supported by GitHub, so footnotes can be enabled in markdown with\n * `mdast-util-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes, which is hidden for sighted users but shown to\n * assistive technology.\n * When your page is not in English, you must define translated values.\n *\n * Back references use ARIA attributes, but the section label itself uses a\n * heading that is hidden with an `sr-only` class.\n * To show it to sighted users, define different attributes in\n * `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem, as it links footnote calls to footnote\n * definitions on the page through `id` attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * Example: headings (DOM clobbering) in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * *   when the node has a `value` (and doesn’t have `data.hName`,\n *     `data.hProperties`, or `data.hChildren`, see later), create a hast `text`\n *     node\n * *   otherwise, create a `<div>` element (which could be changed with\n *     `data.hName`), with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @param {MdastNodes} tree\n *   mdast tree.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {HastNodes}\n *   hast tree.\n */\nexport function toHast(tree, options) {\n  const state = createState(tree, options)\n  const node = state.one(tree, undefined)\n  const foot = footer(state)\n  /** @type {HastNodes} */\n  const result = Array.isArray(node)\n    ? {type: 'root', children: node}\n    : node || {type: 'root', children: []}\n\n  if (foot) {\n    // If there’s a footer, there were definitions, meaning block\n    // content.\n    // So `result` is a parent node.\n    assert('children' in result)\n    result.children.push({type: 'text', value: '\\n'}, foot)\n  }\n\n  return result\n}\n","/**\n * @import {Root as HastRoot} from 'hast'\n * @import {Root as MdastRoot} from 'mdast'\n * @import {Options as ToHastOptions} from 'mdast-util-to-hast'\n * @import {Processor} from 'unified'\n * @import {VFile} from 'vfile'\n */\n\n/**\n * @typedef {Omit<ToHastOptions, 'file'>} Options\n *\n * @callback TransformBridge\n *   Bridge-mode.\n *\n *   Runs the destination with the new hast tree.\n *   Discards result.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {Promise<undefined>}\n *   Nothing.\n *\n * @callback TransformMutate\n *  Mutate-mode.\n *\n *  Further transformers run on the hast tree.\n * @param {MdastRoot} tree\n *   Tree.\n * @param {VFile} file\n *   File.\n * @returns {HastRoot}\n *   Tree (hast).\n */\n\nimport {toHast} from 'mdast-util-to-hast'\n\n/**\n * Turn markdown into HTML.\n *\n * ##### Notes\n *\n * ###### Signature\n *\n * * if a processor is given,\n *   runs the (rehype) plugins used on it with a hast tree,\n *   then discards the result (*bridge mode*)\n * * otherwise,\n *   returns a hast tree,\n *   the plugins used after `remarkRehype` are rehype plugins (*mutate mode*)\n *\n * > 👉 **Note**:\n * > It’s highly unlikely that you want to pass a `processor`.\n *\n * ###### HTML\n *\n * Raw HTML is available in mdast as `html` nodes and can be embedded in hast\n * as semistandard `raw` nodes.\n * Most plugins ignore `raw` nodes but two notable ones don’t:\n *\n * * `rehype-stringify` also has an option `allowDangerousHtml` which will\n *   output the raw HTML.\n *   This is typically discouraged as noted by the option name but is useful if\n *   you completely trust authors\n * * `rehype-raw` can handle the raw embedded HTML strings by parsing them\n *   into standard hast nodes (`element`, `text`, etc);\n *   this is a heavy task as it needs a full HTML parser,\n *   but it is the only way to support untrusted content\n *\n * ###### Footnotes\n *\n * Many options supported here relate to footnotes.\n * Footnotes are not specified by CommonMark,\n * which we follow by default.\n * They are supported by GitHub,\n * so footnotes can be enabled in markdown with `remark-gfm`.\n *\n * The options `footnoteBackLabel` and `footnoteLabel` define natural language\n * that explains footnotes,\n * which is hidden for sighted users but shown to assistive technology.\n * When your page is not in English,\n * you must define translated values.\n *\n * Back references use ARIA attributes,\n * but the section label itself uses a heading that is hidden with an\n * `sr-only` class.\n * To show it to sighted users,\n * define different attributes in `footnoteLabelProperties`.\n *\n * ###### Clobbering\n *\n * Footnotes introduces a problem,\n * as it links footnote calls to footnote definitions on the page through `id`\n * attributes generated from user content,\n * which results in DOM clobbering.\n *\n * DOM clobbering is this:\n *\n * ```html\n * <p id=x></p>\n * <script>alert(x) // `x` now refers to the DOM `p#x` element</script>\n * ```\n *\n * Elements by their ID are made available by browsers on the `window` object,\n * which is a security risk.\n * Using a prefix solves this problem.\n *\n * More information on how to handle clobbering and the prefix is explained in\n * *Example: headings (DOM clobbering)* in `rehype-sanitize`.\n *\n * ###### Unknown nodes\n *\n * Unknown nodes are nodes with a type that isn’t in `handlers` or `passThrough`.\n * The default behavior for unknown nodes is:\n *\n * * when the node has a `value`\n *   (and doesn’t have `data.hName`, `data.hProperties`, or `data.hChildren`,\n *   see later),\n *   create a hast `text` node\n * * otherwise,\n *   create a `<div>` element (which could be changed with `data.hName`),\n *   with its children mapped from mdast to hast as well\n *\n * This behavior can be changed by passing an `unknownHandler`.\n *\n * @overload\n * @param {Processor} processor\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge}\n *\n * @overload\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformMutate}\n *\n * @overload\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n * @param {Readonly<Options> | null | undefined} [options]\n * @returns {TransformBridge | TransformMutate}\n *\n * @param {Readonly<Options> | Processor | null | undefined} [destination]\n *   Processor or configuration (optional).\n * @param {Readonly<Options> | null | undefined} [options]\n *   When a processor was given,\n *   configuration (optional).\n * @returns {TransformBridge | TransformMutate}\n *   Transform.\n */\nexport default function remarkRehype(destination, options) {\n  if (destination && 'run' in destination) {\n    /**\n     * @type {TransformBridge}\n     */\n    return async function (tree, file) {\n      // Cast because root in -> root out.\n      const hastTree = /** @type {HastRoot} */ (\n        toHast(tree, {file, ...options})\n      )\n      await destination.run(hastTree, file)\n    }\n  }\n\n  /**\n   * @type {TransformMutate}\n   */\n  return function (tree, file) {\n    // Cast because root in -> root out.\n    // To do: in the future, disallow ` || options` fallback.\n    // With `unified-engine`, `destination` can be `undefined` but\n    // `options` will be the file set.\n    // We should not pass that as `options`.\n    return /** @type {HastRoot} */ (\n      toHast(tree, {file, ...(destination || options)})\n    )\n  }\n}\n","/**\n * List of HTML void tag names.\n *\n * @type {Array<string>}\n */\nexport const htmlVoidElements = [\n  'area',\n  'base',\n  'basefont',\n  'bgsound',\n  'br',\n  'col',\n  'command',\n  'embed',\n  'frame',\n  'hr',\n  'image',\n  'img',\n  'input',\n  'keygen',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr'\n]\n","/**\n * @import {Schema as SchemaType, Space} from 'property-information'\n */\n\n/** @type {SchemaType} */\nexport class Schema {\n  /**\n   * @param {SchemaType['property']} property\n   *   Property.\n   * @param {SchemaType['normal']} normal\n   *   Normal.\n   * @param {Space | undefined} [space]\n   *   Space.\n   * @returns\n   *   Schema.\n   */\n  constructor(property, normal, space) {\n    this.normal = normal\n    this.property = property\n\n    if (space) {\n      this.space = space\n    }\n  }\n}\n\nSchema.prototype.normal = {}\nSchema.prototype.property = {}\nSchema.prototype.space = undefined\n","/**\n * @import {Info, Space} from 'property-information'\n */\n\nimport {Schema} from './schema.js'\n\n/**\n * @param {ReadonlyArray<Schema>} definitions\n *   Definitions.\n * @param {Space | undefined} [space]\n *   Space.\n * @returns {Schema}\n *   Schema.\n */\nexport function merge(definitions, space) {\n  /** @type {Record<string, Info>} */\n  const property = {}\n  /** @type {Record<string, string>} */\n  const normal = {}\n\n  for (const definition of definitions) {\n    Object.assign(property, definition.property)\n    Object.assign(normal, definition.normal)\n  }\n\n  return new Schema(property, normal, space)\n}\n","/**\n * Get the cleaned case insensitive form of an attribute or property.\n *\n * @param {string} value\n *   An attribute-like or property-like name.\n * @returns {string}\n *   Value that can be used to look up the properly cased property on a\n *   `Schema`.\n */\nexport function normalize(value) {\n  return value.toLowerCase()\n}\n","/**\n * @import {Info as InfoType} from 'property-information'\n */\n\n/** @type {InfoType} */\nexport class Info {\n  /**\n   * @param {string} property\n   *   Property.\n   * @param {string} attribute\n   *   Attribute.\n   * @returns\n   *   Info.\n   */\n  constructor(property, attribute) {\n    this.attribute = attribute\n    this.property = property\n  }\n}\n\nInfo.prototype.attribute = ''\nInfo.prototype.booleanish = false\nInfo.prototype.boolean = false\nInfo.prototype.commaOrSpaceSeparated = false\nInfo.prototype.commaSeparated = false\nInfo.prototype.defined = false\nInfo.prototype.mustUseProperty = false\nInfo.prototype.number = false\nInfo.prototype.overloadedBoolean = false\nInfo.prototype.property = ''\nInfo.prototype.spaceSeparated = false\nInfo.prototype.space = undefined\n","let powers = 0\n\nexport const boolean = increment()\nexport const booleanish = increment()\nexport const overloadedBoolean = increment()\nexport const number = increment()\nexport const spaceSeparated = increment()\nexport const commaSeparated = increment()\nexport const commaOrSpaceSeparated = increment()\n\nfunction increment() {\n  return 2 ** ++powers\n}\n","/**\n * @import {Space} from 'property-information'\n */\n\nimport {Info} from './info.js'\nimport * as types from './types.js'\n\nconst checks = /** @type {ReadonlyArray<keyof typeof types>} */ (\n  Object.keys(types)\n)\n\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   *   Property.\n   * @param {string} attribute\n   *   Attribute.\n   * @param {number | null | undefined} [mask]\n   *   Mask.\n   * @param {Space | undefined} [space]\n   *   Space.\n   * @returns\n   *   Info.\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1\n\n    super(property, attribute)\n\n    mark(this, 'space', space)\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index]\n        mark(this, checks[index], (mask & types[check]) === types[check])\n      }\n    }\n  }\n}\n\nDefinedInfo.prototype.defined = true\n\n/**\n * @template {keyof DefinedInfo} Key\n *   Key type.\n * @param {DefinedInfo} values\n *   Info.\n * @param {Key} key\n *   Key.\n * @param {DefinedInfo[Key]} value\n *   Value.\n * @returns {undefined}\n *   Nothing.\n */\nfunction mark(values, key, value) {\n  if (value) {\n    values[key] = value\n  }\n}\n","/**\n * @import {Info, Space} from 'property-information'\n */\n\n/**\n * @typedef Definition\n *   Definition of a schema.\n * @property {Record<string, string> | undefined} [attributes]\n *   Normalzed names to special attribute case.\n * @property {ReadonlyArray<string> | undefined} [mustUseProperty]\n *   Normalized names that must be set as properties.\n * @property {Record<string, number | null>} properties\n *   Property names to their types.\n * @property {Space | undefined} [space]\n *   Space.\n * @property {Transform} transform\n *   Transform a property name.\n */\n\n/**\n * @callback Transform\n *   Transform.\n * @param {Record<string, string>} attributes\n *   Attributes.\n * @param {string} property\n *   Property.\n * @returns {string}\n *   Attribute.\n */\n\nimport {normalize} from '../normalize.js'\nimport {DefinedInfo} from './defined-info.js'\nimport {Schema} from './schema.js'\n\n/**\n * @param {Definition} definition\n *   Definition.\n * @returns {Schema}\n *   Schema.\n */\nexport function create(definition) {\n  /** @type {Record<string, Info>} */\n  const properties = {}\n  /** @type {Record<string, string>} */\n  const normals = {}\n\n  for (const [property, value] of Object.entries(definition.properties)) {\n    const info = new DefinedInfo(\n      property,\n      definition.transform(definition.attributes || {}, property),\n      value,\n      definition.space\n    )\n\n    if (\n      definition.mustUseProperty &&\n      definition.mustUseProperty.includes(property)\n    ) {\n      info.mustUseProperty = true\n    }\n\n    properties[property] = info\n\n    normals[normalize(property)] = property\n    normals[normalize(info.attribute)] = property\n  }\n\n  return new Schema(properties, normals, definition.space)\n}\n","import {create} from './util/create.js'\nimport {booleanish, number, spaceSeparated} from './util/types.js'\n\nexport const aria = create({\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  transform(_, property) {\n    return property === 'role'\n      ? property\n      : 'aria-' + property.slice(4).toLowerCase()\n  }\n})\n","/**\n * @param {Record<string, string>} attributes\n *   Attributes.\n * @param {string} attribute\n *   Attribute.\n * @returns {string}\n *   Transformed attribute.\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute\n}\n","import {caseSensitiveTransform} from './case-sensitive-transform.js'\n\n/**\n * @param {Record<string, string>} attributes\n *   Attributes.\n * @param {string} property\n *   Property.\n * @returns {string}\n *   Transformed property.\n */\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase())\n}\n","import {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\nimport {create} from './util/create.js'\nimport {\n  booleanish,\n  boolean,\n  commaSeparated,\n  number,\n  overloadedBoolean,\n  spaceSeparated\n} from './util/types.js'\n\nexport const html = create({\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\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    blocking: spaceSeparated,\n    capture: null,\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    fetchPriority: 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: overloadedBoolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inert: boolean,\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    onBeforeMatch: null,\n    onBeforePrint: null,\n    onBeforeToggle: 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    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: 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    onScrollEnd: 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    popover: null,\n    popoverTarget: null,\n    popoverTargetAction: null,\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    shadowRootClonable: boolean,\n    shadowRootDelegatesFocus: boolean,\n    shadowRootMode: null,\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: null,\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    writingSuggestions: null,\n\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null, // Several. Use CSS `text-align` instead,\n    aLink: null, // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated, // `<object>`. List of URIs to archives\n    axis: null, // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null, // `<body>`. Use CSS `background-image` instead\n    bgColor: null, // `<body>` and table elements. Use CSS `background-color` instead\n    border: number, // `<table>`. Use CSS `border-width` instead,\n    borderColor: null, // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number, // `<body>`\n    cellPadding: null, // `<table>`\n    cellSpacing: null, // `<table>`\n    char: null, // Several table elements. When `align=char`, sets the character to align on\n    charOff: null, // Several table elements. When `char`, offsets the alignment\n    classId: null, // `<object>`\n    clear: null, // `<br>`. Use CSS `clear` instead\n    code: null, // `<object>`\n    codeBase: null, // `<object>`\n    codeType: null, // `<object>`\n    color: null, // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean, // Lists. Use CSS to reduce space between items instead\n    declare: boolean, // `<object>`\n    event: null, // `<script>`\n    face: null, // `<font>`. Use CSS instead\n    frame: null, // `<table>`\n    frameBorder: null, // `<iframe>`. Use CSS `border` instead\n    hSpace: number, // `<img>` and `<object>`\n    leftMargin: number, // `<body>`\n    link: null, // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null, // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null, // `<img>`. Use a `<picture>`\n    marginHeight: number, // `<body>`\n    marginWidth: number, // `<body>`\n    noResize: boolean, // `<frame>`\n    noHref: boolean, // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean, // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean, // `<td>` and `<th>`\n    object: null, // `<applet>`\n    profile: null, // `<head>`\n    prompt: null, // `<isindex>`\n    rev: null, // `<link>`\n    rightMargin: number, // `<body>`\n    rules: null, // `<table>`\n    scheme: null, // `<meta>`\n    scrolling: booleanish, // `<frame>`. Use overflow in the child context\n    standby: null, // `<object>`\n    summary: null, // `<table>`\n    text: null, // `<body>`. Use CSS `color` instead\n    topMargin: number, // `<body>`\n    valueType: null, // `<param>`\n    version: null, // `<html>`. Use a doctype.\n    vAlign: null, // Several. Use CSS `vertical-align` instead\n    vLink: null, // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number, // `<img>` and `<object>`\n\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  },\n  space: 'html',\n  transform: caseInsensitiveTransform\n})\n","import {caseSensitiveTransform} from './util/case-sensitive-transform.js'\nimport {create} from './util/create.js'\nimport {\n  boolean,\n  commaOrSpaceSeparated,\n  commaSeparated,\n  number,\n  spaceSeparated\n} from './util/types.js'\n\nexport const svg = create({\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    transformOrigin: 'transform-origin',\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  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null, // SEMI_COLON_SEPARATED\n    keySplines: null, // SEMI_COLON_SEPARATED\n    keyTimes: null, // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    transformOrigin: 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  space: 'svg',\n  transform: caseSensitiveTransform\n})\n","import {create} from './util/create.js'\n\nexport const xlink = create({\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  space: 'xlink',\n  transform(_, property) {\n    return 'xlink:' + property.slice(5).toLowerCase()\n  }\n})\n","import {create} from './util/create.js'\nimport {caseInsensitiveTransform} from './util/case-insensitive-transform.js'\n\nexport const xmlns = create({\n  attributes: {xmlnsxlink: 'xmlns:xlink'},\n  properties: {xmlnsXLink: null, xmlns: null},\n  space: 'xmlns',\n  transform: caseInsensitiveTransform\n})\n","import {create} from './util/create.js'\n\nexport const xml = create({\n  properties: {xmlBase: null, xmlLang: null, xmlSpace: null},\n  space: 'xml',\n  transform(_, property) {\n    return 'xml:' + property.slice(3).toLowerCase()\n  }\n})\n","/**\n * @import {Schema} from 'property-information'\n */\n\nimport {DefinedInfo} from './util/defined-info.js'\nimport {Info} from './util/info.js'\nimport {normalize} from './normalize.js'\n\nconst cap = /[A-Z]/g\nconst dash = /-[a-z]/g\nconst valid = /^data[-\\w.:]+$/i\n\n/**\n * Look up info on a property.\n *\n * In most cases the given `schema` contains info on the property.\n * All standard,\n * most legacy,\n * and some non-standard properties are supported.\n * For these cases,\n * the returned `Info` has hints about the value of the property.\n *\n * `name` can also be a valid data attribute or property,\n * in which case an `Info` object with the correctly cased `attribute` and\n * `property` is returned.\n *\n * `name` can be an unknown attribute,\n * in which case an `Info` object with `attribute` and `property` set to the\n * given name is returned.\n * It is not recommended to provide unsupported legacy or recently specced\n * properties.\n *\n *\n * @param {Schema} schema\n *   Schema;\n *   either the `html` or `svg` export.\n * @param {string} value\n *   An attribute-like or property-like name;\n *   it will be passed through `normalize` to hopefully find the correct info.\n * @returns {Info}\n *   Info.\n */\nexport function find(schema, value) {\n  const normal = normalize(value)\n  let property = value\n  let 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      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase)\n      property = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1)\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4)\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab)\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes\n        }\n\n        value = 'data' + dashes\n      }\n    }\n\n    Type = DefinedInfo\n  }\n\n  return new Type(property, value)\n}\n\n/**\n * @param {string} $0\n *   Value.\n * @returns {string}\n *   Kebab.\n */\nfunction kebab($0) {\n  return '-' + $0.toLowerCase()\n}\n\n/**\n * @param {string} $0\n *   Value.\n * @returns {string}\n *   Camel.\n */\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase()\n}\n","// Note: types exposed from `index.d.ts`.\nimport {merge} from './lib/util/merge.js'\nimport {aria} from './lib/aria.js'\nimport {html as htmlBase} from './lib/html.js'\nimport {svg as svgBase} from './lib/svg.js'\nimport {xlink} from './lib/xlink.js'\nimport {xmlns} from './lib/xmlns.js'\nimport {xml} from './lib/xml.js'\n\nexport {hastToReact} from './lib/hast-to-react.js'\n\nexport const html = merge([aria, htmlBase, xlink, xmlns, xml], 'html')\n\nexport {find} from './lib/find.js'\nexport {normalize} from './lib/normalize.js'\n\nexport const svg = merge([aria, svgBase, xlink, xmlns, xml], 'svg')\n","/**\n * @callback Handler\n *   Handle a value, with a certain ID field set to a certain value.\n *   The ID field is passed to `zwitch`, and it’s value is this function’s\n *   place on the `handlers` record.\n * @param {...any} parameters\n *   Arbitrary parameters passed to the zwitch.\n *   The first will be an object with a certain ID field set to a certain value.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback UnknownHandler\n *   Handle values that do have a certain ID field, but it’s set to a value\n *   that is not listed in the `handlers` record.\n * @param {unknown} value\n *   An object with a certain ID field set to an unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {any}\n *   Anything!\n */\n\n/**\n * @callback InvalidHandler\n *   Handle values that do not have a certain ID field.\n * @param {unknown} value\n *   Any unknown value.\n * @param {...any} rest\n *   Arbitrary parameters passed to the zwitch.\n * @returns {void|null|undefined|never}\n *   This should crash or return nothing.\n */\n\n/**\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @typedef Options\n *   Configuration (required).\n * @property {Invalid} [invalid]\n *   Handler to use for invalid values.\n * @property {Unknown} [unknown]\n *   Handler to use for unknown values.\n * @property {Handlers} [handlers]\n *   Handlers to use.\n */\n\nconst own = {}.hasOwnProperty\n\n/**\n * Handle values based on a field.\n *\n * @template {InvalidHandler} [Invalid=InvalidHandler]\n * @template {UnknownHandler} [Unknown=UnknownHandler]\n * @template {Record<string, Handler>} [Handlers=Record<string, Handler>]\n * @param {string} key\n *   Field to switch on.\n * @param {Options<Invalid, Unknown, Handlers>} [options]\n *   Configuration (required).\n * @returns {{unknown: Unknown, invalid: Invalid, handlers: Handlers, (...parameters: Parameters<Handlers[keyof Handlers]>): ReturnType<Handlers[keyof Handlers]>, (...parameters: Parameters<Unknown>): ReturnType<Unknown>}}\n */\nexport function zwitch(key, options) {\n  const settings = options || {}\n\n  /**\n   * Handle one value.\n   *\n   * Based on the bound `key`, a respective handler will be called.\n   * If `value` is not an object, or doesn’t have a `key` property, the special\n   * “invalid” handler will be called.\n   * If `value` has an unknown `key`, the special “unknown” handler will be\n   * called.\n   *\n   * All arguments, and the context object, are passed through to the handler,\n   * and it’s result is returned.\n   *\n   * @this {unknown}\n   *   Any context object.\n   * @param {unknown} [value]\n   *   Any value.\n   * @param {...unknown} parameters\n   *   Arbitrary parameters passed to the zwitch.\n   * @property {Handler} invalid\n   *   Handle for values that do not have a certain ID field.\n   * @property {Handler} unknown\n   *   Handle values that do have a certain ID field, but it’s set to a value\n   *   that is not listed in the `handlers` record.\n   * @property {Handlers} handlers\n   *   Record of handlers.\n   * @returns {unknown}\n   *   Anything.\n   */\n  function one(value, ...parameters) {\n    /** @type {Handler|undefined} */\n    let fn = one.invalid\n    const handlers = one.handlers\n\n    if (value && own.call(value, key)) {\n      // @ts-expect-error Indexable.\n      const id = String(value[key])\n      // @ts-expect-error Indexable.\n      fn = own.call(handlers, id) ? handlers[id] : one.unknown\n    }\n\n    if (fn) {\n      return fn.call(this, value, ...parameters)\n    }\n  }\n\n  one.handlers = settings.handlers || {}\n  one.invalid = settings.invalid\n  one.unknown = settings.unknown\n\n  // @ts-expect-error: matches!\n  return one\n}\n","/**\n * @typedef CoreOptions\n * @property {ReadonlyArray<string>} [subset=[]]\n *   Whether to only escape the given subset of characters.\n * @property {boolean} [escapeOnly=false]\n *   Whether to only escape possibly dangerous characters.\n *   Those characters are `\"`, `&`, `'`, `<`, `>`, and `` ` ``.\n *\n * @typedef FormatOptions\n * @property {(code: number, next: number, options: CoreWithFormatOptions) => string} format\n *   Format strategy.\n *\n * @typedef {CoreOptions & FormatOptions & import('./util/format-smart.js').FormatSmartOptions} CoreWithFormatOptions\n */\n\nconst defaultSubsetRegex = /[\"&'<>`]/g\nconst surrogatePairsRegex = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]/g\nconst controlCharactersRegex =\n  // eslint-disable-next-line no-control-regex, unicorn/no-hex-escape\n  /[\\x01-\\t\\v\\f\\x0E-\\x1F\\x7F\\x81\\x8D\\x8F\\x90\\x9D\\xA0-\\uFFFF]/g\nconst regexEscapeRegex = /[|\\\\{}()[\\]^$+*?.]/g\n\n/** @type {WeakMap<ReadonlyArray<string>, RegExp>} */\nconst subsetToRegexCache = new WeakMap()\n\n/**\n * Encode certain characters in `value`.\n *\n * @param {string} value\n * @param {CoreWithFormatOptions} options\n * @returns {string}\n */\nexport function core(value, options) {\n  value = value.replace(\n    options.subset\n      ? charactersToExpressionCached(options.subset)\n      : defaultSubsetRegex,\n    basic\n  )\n\n  if (options.subset || options.escapeOnly) {\n    return value\n  }\n\n  return (\n    value\n      // Surrogate pairs.\n      .replace(surrogatePairsRegex, surrogate)\n      // BMP control characters (C0 except for LF, CR, SP; DEL; and some more\n      // non-ASCII ones).\n      .replace(controlCharactersRegex, basic)\n  )\n\n  /**\n   * @param {string} pair\n   * @param {number} index\n   * @param {string} all\n   */\n  function surrogate(pair, index, all) {\n    return options.format(\n      (pair.charCodeAt(0) - 0xd800) * 0x400 +\n        pair.charCodeAt(1) -\n        0xdc00 +\n        0x10000,\n      all.charCodeAt(index + 2),\n      options\n    )\n  }\n\n  /**\n   * @param {string} character\n   * @param {number} index\n   * @param {string} all\n   */\n  function basic(character, index, all) {\n    return options.format(\n      character.charCodeAt(0),\n      all.charCodeAt(index + 1),\n      options\n    )\n  }\n}\n\n/**\n * A wrapper function that caches the result of `charactersToExpression` with a WeakMap.\n * This can improve performance when tooling calls `charactersToExpression` repeatedly\n * with the same subset.\n *\n * @param {ReadonlyArray<string>} subset\n * @returns {RegExp}\n */\nfunction charactersToExpressionCached(subset) {\n  let cached = subsetToRegexCache.get(subset)\n\n  if (!cached) {\n    cached = charactersToExpression(subset)\n    subsetToRegexCache.set(subset, cached)\n  }\n\n  return cached\n}\n\n/**\n * @param {ReadonlyArray<string>} subset\n * @returns {RegExp}\n */\nfunction charactersToExpression(subset) {\n  /** @type {Array<string>} */\n  const groups = []\n  let index = -1\n\n  while (++index < subset.length) {\n    groups.push(subset[index].replace(regexEscapeRegex, '\\\\$&'))\n  }\n\n  return new RegExp('(?:' + groups.join('|') + ')', 'g')\n}\n","const hexadecimalRegex = /[\\dA-Fa-f]/\n\n/**\n * Configurable ways to encode characters as hexadecimal references.\n *\n * @param {number} code\n * @param {number} next\n * @param {boolean|undefined} omit\n * @returns {string}\n */\nexport function toHexadecimal(code, next, omit) {\n  const value = '&#x' + code.toString(16).toUpperCase()\n  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next))\n    ? value\n    : value + ';'\n}\n","const decimalRegex = /\\d/\n\n/**\n * Configurable ways to encode characters as decimal references.\n *\n * @param {number} code\n * @param {number} next\n * @param {boolean|undefined} omit\n * @returns {string}\n */\nexport function toDecimal(code, next, omit) {\n  const value = '&#' + String(code)\n  return omit && next && !decimalRegex.test(String.fromCharCode(next))\n    ? value\n    : value + ';'\n}\n","/**\n * List of legacy HTML named character references that don’t need a trailing semicolon.\n *\n * @type {Array<string>}\n */\nexport const characterEntitiesLegacy = [\n  'AElig',\n  'AMP',\n  'Aacute',\n  'Acirc',\n  'Agrave',\n  'Aring',\n  'Atilde',\n  'Auml',\n  'COPY',\n  'Ccedil',\n  'ETH',\n  'Eacute',\n  'Ecirc',\n  'Egrave',\n  'Euml',\n  'GT',\n  'Iacute',\n  'Icirc',\n  'Igrave',\n  'Iuml',\n  'LT',\n  'Ntilde',\n  'Oacute',\n  'Ocirc',\n  'Ograve',\n  'Oslash',\n  'Otilde',\n  'Ouml',\n  'QUOT',\n  'REG',\n  'THORN',\n  'Uacute',\n  'Ucirc',\n  'Ugrave',\n  'Uuml',\n  'Yacute',\n  'aacute',\n  'acirc',\n  'acute',\n  'aelig',\n  'agrave',\n  'amp',\n  'aring',\n  'atilde',\n  'auml',\n  'brvbar',\n  'ccedil',\n  'cedil',\n  'cent',\n  'copy',\n  'curren',\n  'deg',\n  'divide',\n  'eacute',\n  'ecirc',\n  'egrave',\n  'eth',\n  'euml',\n  'frac12',\n  'frac14',\n  'frac34',\n  'gt',\n  'iacute',\n  'icirc',\n  'iexcl',\n  'igrave',\n  'iquest',\n  'iuml',\n  'laquo',\n  'lt',\n  'macr',\n  'micro',\n  'middot',\n  'nbsp',\n  'not',\n  'ntilde',\n  'oacute',\n  'ocirc',\n  'ograve',\n  'ordf',\n  'ordm',\n  'oslash',\n  'otilde',\n  'ouml',\n  'para',\n  'plusmn',\n  'pound',\n  'quot',\n  'raquo',\n  'reg',\n  'sect',\n  'shy',\n  'sup1',\n  'sup2',\n  'sup3',\n  'szlig',\n  'thorn',\n  'times',\n  'uacute',\n  'ucirc',\n  'ugrave',\n  'uml',\n  'uuml',\n  'yacute',\n  'yen',\n  'yuml'\n]\n","/**\n * Map of named character references from HTML 4.\n *\n * @type {Record<string, string>}\n */\nexport const characterEntitiesHtml4 = {\n  nbsp: ' ',\n  iexcl: '¡',\n  cent: '¢',\n  pound: '£',\n  curren: '¤',\n  yen: '¥',\n  brvbar: '¦',\n  sect: '§',\n  uml: '¨',\n  copy: '©',\n  ordf: 'ª',\n  laquo: '«',\n  not: '¬',\n  shy: '­',\n  reg: '®',\n  macr: '¯',\n  deg: '°',\n  plusmn: '±',\n  sup2: '²',\n  sup3: '³',\n  acute: '´',\n  micro: 'µ',\n  para: '¶',\n  middot: '·',\n  cedil: '¸',\n  sup1: '¹',\n  ordm: 'º',\n  raquo: '»',\n  frac14: '¼',\n  frac12: '½',\n  frac34: '¾',\n  iquest: '¿',\n  Agrave: 'À',\n  Aacute: 'Á',\n  Acirc: 'Â',\n  Atilde: 'Ã',\n  Auml: 'Ä',\n  Aring: 'Å',\n  AElig: 'Æ',\n  Ccedil: 'Ç',\n  Egrave: 'È',\n  Eacute: 'É',\n  Ecirc: 'Ê',\n  Euml: 'Ë',\n  Igrave: 'Ì',\n  Iacute: 'Í',\n  Icirc: 'Î',\n  Iuml: 'Ï',\n  ETH: 'Ð',\n  Ntilde: 'Ñ',\n  Ograve: 'Ò',\n  Oacute: 'Ó',\n  Ocirc: 'Ô',\n  Otilde: 'Õ',\n  Ouml: 'Ö',\n  times: '×',\n  Oslash: 'Ø',\n  Ugrave: 'Ù',\n  Uacute: 'Ú',\n  Ucirc: 'Û',\n  Uuml: 'Ü',\n  Yacute: 'Ý',\n  THORN: 'Þ',\n  szlig: 'ß',\n  agrave: 'à',\n  aacute: 'á',\n  acirc: 'â',\n  atilde: 'ã',\n  auml: 'ä',\n  aring: 'å',\n  aelig: 'æ',\n  ccedil: 'ç',\n  egrave: 'è',\n  eacute: 'é',\n  ecirc: 'ê',\n  euml: 'ë',\n  igrave: 'ì',\n  iacute: 'í',\n  icirc: 'î',\n  iuml: 'ï',\n  eth: 'ð',\n  ntilde: 'ñ',\n  ograve: 'ò',\n  oacute: 'ó',\n  ocirc: 'ô',\n  otilde: 'õ',\n  ouml: 'ö',\n  divide: '÷',\n  oslash: 'ø',\n  ugrave: 'ù',\n  uacute: 'ú',\n  ucirc: 'û',\n  uuml: 'ü',\n  yacute: 'ý',\n  thorn: 'þ',\n  yuml: 'ÿ',\n  fnof: 'ƒ',\n  Alpha: 'Α',\n  Beta: 'Β',\n  Gamma: 'Γ',\n  Delta: 'Δ',\n  Epsilon: 'Ε',\n  Zeta: 'Ζ',\n  Eta: 'Η',\n  Theta: 'Θ',\n  Iota: 'Ι',\n  Kappa: 'Κ',\n  Lambda: 'Λ',\n  Mu: 'Μ',\n  Nu: 'Ν',\n  Xi: 'Ξ',\n  Omicron: 'Ο',\n  Pi: 'Π',\n  Rho: 'Ρ',\n  Sigma: 'Σ',\n  Tau: 'Τ',\n  Upsilon: 'Υ',\n  Phi: 'Φ',\n  Chi: 'Χ',\n  Psi: 'Ψ',\n  Omega: 'Ω',\n  alpha: 'α',\n  beta: 'β',\n  gamma: 'γ',\n  delta: 'δ',\n  epsilon: 'ε',\n  zeta: 'ζ',\n  eta: 'η',\n  theta: 'θ',\n  iota: 'ι',\n  kappa: 'κ',\n  lambda: 'λ',\n  mu: 'μ',\n  nu: 'ν',\n  xi: 'ξ',\n  omicron: 'ο',\n  pi: 'π',\n  rho: 'ρ',\n  sigmaf: 'ς',\n  sigma: 'σ',\n  tau: 'τ',\n  upsilon: 'υ',\n  phi: 'φ',\n  chi: 'χ',\n  psi: 'ψ',\n  omega: 'ω',\n  thetasym: 'ϑ',\n  upsih: 'ϒ',\n  piv: 'ϖ',\n  bull: '•',\n  hellip: '…',\n  prime: '′',\n  Prime: '″',\n  oline: '‾',\n  frasl: '⁄',\n  weierp: '℘',\n  image: 'ℑ',\n  real: 'ℜ',\n  trade: '™',\n  alefsym: 'ℵ',\n  larr: '←',\n  uarr: '↑',\n  rarr: '→',\n  darr: '↓',\n  harr: '↔',\n  crarr: '↵',\n  lArr: '⇐',\n  uArr: '⇑',\n  rArr: '⇒',\n  dArr: '⇓',\n  hArr: '⇔',\n  forall: '∀',\n  part: '∂',\n  exist: '∃',\n  empty: '∅',\n  nabla: '∇',\n  isin: '∈',\n  notin: '∉',\n  ni: '∋',\n  prod: '∏',\n  sum: '∑',\n  minus: '−',\n  lowast: '∗',\n  radic: '√',\n  prop: '∝',\n  infin: '∞',\n  ang: '∠',\n  and: '∧',\n  or: '∨',\n  cap: '∩',\n  cup: '∪',\n  int: '∫',\n  there4: '∴',\n  sim: '∼',\n  cong: '≅',\n  asymp: '≈',\n  ne: '≠',\n  equiv: '≡',\n  le: '≤',\n  ge: '≥',\n  sub: '⊂',\n  sup: '⊃',\n  nsub: '⊄',\n  sube: '⊆',\n  supe: '⊇',\n  oplus: '⊕',\n  otimes: '⊗',\n  perp: '⊥',\n  sdot: '⋅',\n  lceil: '⌈',\n  rceil: '⌉',\n  lfloor: '⌊',\n  rfloor: '⌋',\n  lang: '〈',\n  rang: '〉',\n  loz: '◊',\n  spades: '♠',\n  clubs: '♣',\n  hearts: '♥',\n  diams: '♦',\n  quot: '\"',\n  amp: '&',\n  lt: '<',\n  gt: '>',\n  OElig: 'Œ',\n  oelig: 'œ',\n  Scaron: 'Š',\n  scaron: 'š',\n  Yuml: 'Ÿ',\n  circ: 'ˆ',\n  tilde: '˜',\n  ensp: ' ',\n  emsp: ' ',\n  thinsp: ' ',\n  zwnj: '‌',\n  zwj: '‍',\n  lrm: '‎',\n  rlm: '‏',\n  ndash: '–',\n  mdash: '—',\n  lsquo: '‘',\n  rsquo: '’',\n  sbquo: '‚',\n  ldquo: '“',\n  rdquo: '”',\n  bdquo: '„',\n  dagger: '†',\n  Dagger: '‡',\n  permil: '‰',\n  lsaquo: '‹',\n  rsaquo: '›',\n  euro: '€'\n}\n","/**\n * List of legacy (that don’t need a trailing `;`) named references which could,\n * depending on what follows them, turn into a different meaning\n *\n * @type {Array<string>}\n */\nexport const dangerous = [\n  'cent',\n  'copy',\n  'divide',\n  'gt',\n  'lt',\n  'not',\n  'para',\n  'times'\n]\n","import {characterEntitiesLegacy} from 'character-entities-legacy'\nimport {characterEntitiesHtml4} from 'character-entities-html4'\nimport {dangerous} from '../constant/dangerous.js'\n\nconst own = {}.hasOwnProperty\n\n/**\n * `characterEntitiesHtml4` but inverted.\n *\n * @type {Record<string, string>}\n */\nconst characters = {}\n\n/** @type {string} */\nlet key\n\nfor (key in characterEntitiesHtml4) {\n  if (own.call(characterEntitiesHtml4, key)) {\n    characters[characterEntitiesHtml4[key]] = key\n  }\n}\n\nconst notAlphanumericRegex = /[^\\dA-Za-z]/\n\n/**\n * Configurable ways to encode characters as named references.\n *\n * @param {number} code\n * @param {number} next\n * @param {boolean|undefined} omit\n * @param {boolean|undefined} attribute\n * @returns {string}\n */\nexport function toNamed(code, next, omit, attribute) {\n  const character = String.fromCharCode(code)\n\n  if (own.call(characters, character)) {\n    const name = characters[character]\n    const value = '&' + name\n\n    if (\n      omit &&\n      characterEntitiesLegacy.includes(name) &&\n      !dangerous.includes(name) &&\n      (!attribute ||\n        (next &&\n          next !== 61 /* `=` */ &&\n          notAlphanumericRegex.test(String.fromCharCode(next))))\n    ) {\n      return value\n    }\n\n    return value + ';'\n  }\n\n  return ''\n}\n","/**\n * @typedef FormatSmartOptions\n * @property {boolean} [useNamedReferences=false]\n *   Prefer named character references (`&amp;`) where possible.\n * @property {boolean} [useShortestReferences=false]\n *   Prefer the shortest possible reference, if that results in less bytes.\n *   **Note**: `useNamedReferences` can be omitted when using `useShortestReferences`.\n * @property {boolean} [omitOptionalSemicolons=false]\n *   Whether to omit semicolons when possible.\n *   **Note**: This creates what HTML calls “parse errors” but is otherwise still valid HTML — don’t use this except when building a minifier.\n *   Omitting semicolons is possible for certain named and numeric references in some cases.\n * @property {boolean} [attribute=false]\n *   Create character references which don’t fail in attributes.\n *   **Note**: `attribute` only applies when operating dangerously with\n *   `omitOptionalSemicolons: true`.\n */\n\nimport {toHexadecimal} from './to-hexadecimal.js'\nimport {toDecimal} from './to-decimal.js'\nimport {toNamed} from './to-named.js'\n\n/**\n * Configurable ways to encode a character yielding pretty or small results.\n *\n * @param {number} code\n * @param {number} next\n * @param {FormatSmartOptions} options\n * @returns {string}\n */\nexport function formatSmart(code, next, options) {\n  let numeric = toHexadecimal(code, next, options.omitOptionalSemicolons)\n  /** @type {string|undefined} */\n  let named\n\n  if (options.useNamedReferences || options.useShortestReferences) {\n    named = toNamed(\n      code,\n      next,\n      options.omitOptionalSemicolons,\n      options.attribute\n    )\n  }\n\n  // Use the shortest numeric reference when requested.\n  // A simple algorithm would use decimal for all code points under 100, as\n  // those are shorter than hexadecimal:\n  //\n  // * `&#99;` vs `&#x63;` (decimal shorter)\n  // * `&#100;` vs `&#x64;` (equal)\n  //\n  // However, because we take `next` into consideration when `omit` is used,\n  // And it would be possible that decimals are shorter on bigger values as\n  // well if `next` is hexadecimal but not decimal, we instead compare both.\n  if (\n    (options.useShortestReferences || !named) &&\n    options.useShortestReferences\n  ) {\n    const decimal = toDecimal(code, next, options.omitOptionalSemicolons)\n\n    if (decimal.length < numeric.length) {\n      numeric = decimal\n    }\n  }\n\n  return named &&\n    (!options.useShortestReferences || named.length < numeric.length)\n    ? named\n    : numeric\n}\n","/**\n * @typedef {import('./core.js').CoreOptions & import('./util/format-smart.js').FormatSmartOptions} Options\n * @typedef {import('./core.js').CoreOptions} LightOptions\n */\n\nimport {core} from './core.js'\nimport {formatSmart} from './util/format-smart.js'\nimport {formatBasic} from './util/format-basic.js'\n\n/**\n * Encode special characters in `value`.\n *\n * @param {string} value\n *   Value to encode.\n * @param {Options} [options]\n *   Configuration.\n * @returns {string}\n *   Encoded value.\n */\nexport function stringifyEntities(value, options) {\n  return core(value, Object.assign({format: formatSmart}, options))\n}\n\n/**\n * Encode special characters in `value` as hexadecimals.\n *\n * @param {string} value\n *   Value to encode.\n * @param {LightOptions} [options]\n *   Configuration.\n * @returns {string}\n *   Encoded value.\n */\nexport function stringifyEntitiesLight(value, options) {\n  return core(value, Object.assign({format: formatBasic}, options))\n}\n","/**\n * @import {Comment, Parents} from 'hast'\n * @import {State} from '../index.js'\n */\n\nimport {stringifyEntities} from 'stringify-entities'\n\nconst htmlCommentRegex = /^>|^->|<!--|-->|--!>|<!-$/g\n\n// Declare arrays as variables so it can be cached by `stringifyEntities`\nconst bogusCommentEntitySubset = ['>']\nconst commentEntitySubset = ['<', '>']\n\n/**\n * Serialize a comment.\n *\n * @param {Comment} node\n *   Node to handle.\n * @param {number | undefined} _1\n *   Index of `node` in `parent.\n * @param {Parents | undefined} _2\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function comment(node, _1, _2, state) {\n  // See: <https://html.spec.whatwg.org/multipage/syntax.html#comments>\n  return state.settings.bogusComments\n    ? '<?' +\n        stringifyEntities(\n          node.value,\n          Object.assign({}, state.settings.characterReferences, {\n            subset: bogusCommentEntitySubset\n          })\n        ) +\n        '>'\n    : '<!--' + node.value.replace(htmlCommentRegex, encode) + '-->'\n\n  /**\n   * @param {string} $0\n   */\n  function encode($0) {\n    return stringifyEntities(\n      $0,\n      Object.assign({}, state.settings.characterReferences, {\n        subset: commentEntitySubset\n      })\n    )\n  }\n}\n","/**\n * @import {Doctype, Parents} from 'hast'\n * @import {State} from '../index.js'\n */\n\n/**\n * Serialize a doctype.\n *\n * @param {Doctype} _1\n *   Node to handle.\n * @param {number | undefined} _2\n *   Index of `node` in `parent.\n * @param {Parents | undefined} _3\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function doctype(_1, _2, _3, state) {\n  return (\n    '<!' +\n    (state.settings.upperDoctype ? 'DOCTYPE' : 'doctype') +\n    (state.settings.tightDoctype ? '' : ' ') +\n    'html>'\n  )\n}\n","/**\n * Count how often a character (or substring) is used in a string.\n *\n * @param {string} value\n *   Value to search in.\n * @param {string} character\n *   Character (or substring) to look for.\n * @return {number}\n *   Number of times `character` occurred in `value`.\n */\nexport function ccount(value, character) {\n  const source = String(value)\n\n  if (typeof character !== 'string') {\n    throw new TypeError('Expected character')\n  }\n\n  let count = 0\n  let index = source.indexOf(character)\n\n  while (index !== -1) {\n    count++\n    index = source.indexOf(character, index + character.length)\n  }\n\n  return count\n}\n","/**\n * @typedef Options\n *   Configuration for `stringify`.\n * @property {boolean} [padLeft=true]\n *   Whether to pad a space before a token.\n * @property {boolean} [padRight=false]\n *   Whether to pad a space after a token.\n */\n\n/**\n * @typedef {Options} StringifyOptions\n *   Please use `StringifyOptions` instead.\n */\n\n/**\n * Parse comma-separated tokens to an array.\n *\n * @param {string} value\n *   Comma-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  /** @type {Array<string>} */\n  const tokens = []\n  const input = String(value || '')\n  let index = input.indexOf(',')\n  let start = 0\n  /** @type {boolean} */\n  let end = false\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length\n      end = true\n    }\n\n    const token = input.slice(start, index).trim()\n\n    if (token || !end) {\n      tokens.push(token)\n    }\n\n    start = index + 1\n    index = input.indexOf(',', start)\n  }\n\n  return tokens\n}\n\n/**\n * Serialize an array of strings or numbers to comma-separated tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @param {Options} [options]\n *   Configuration for `stringify` (optional).\n * @returns {string}\n *   Comma-separated tokens.\n */\nexport function stringify(values, options) {\n  const settings = options || {}\n\n  // Ensure the last empty entry is seen.\n  const input = values[values.length - 1] === '' ? [...values, ''] : values\n\n  return input\n    .join(\n      (settings.padRight ? ' ' : '') +\n        ',' +\n        (settings.padLeft === false ? '' : ' ')\n    )\n    .trim()\n}\n","/**\n * Parse space-separated tokens to an array of strings.\n *\n * @param {string} value\n *   Space-separated tokens.\n * @returns {Array<string>}\n *   List of tokens.\n */\nexport function parse(value) {\n  const input = String(value || '').trim()\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : []\n}\n\n/**\n * Serialize an array of strings as space separated-tokens.\n *\n * @param {Array<string|number>} values\n *   List of tokens.\n * @returns {string}\n *   Space-separated tokens.\n */\nexport function stringify(values) {\n  return values.join(' ').trim()\n}\n","/**\n * @typedef {import('hast').Nodes} Nodes\n */\n\n// HTML whitespace expression.\n// See <https://infra.spec.whatwg.org/#ascii-whitespace>.\nconst re = /[ \\t\\n\\f\\r]/g\n\n/**\n * Check if the given value is *inter-element whitespace*.\n *\n * @param {Nodes | string} thing\n *   Thing to check (`Node` or `string`).\n * @returns {boolean}\n *   Whether the `value` is inter-element whitespace (`boolean`): consisting of\n *   zero or more of space, tab (`\\t`), line feed (`\\n`), carriage return\n *   (`\\r`), or form feed (`\\f`); if a node is passed it must be a `Text` node,\n *   whose `value` field is checked.\n */\nexport function whitespace(thing) {\n  return typeof thing === 'object'\n    ? thing.type === 'text'\n      ? empty(thing.value)\n      : false\n    : empty(thing)\n}\n\n/**\n * @param {string} value\n * @returns {boolean}\n */\nfunction empty(value) {\n  return value.replace(re, '') === ''\n}\n","/**\n * @import {Parents, RootContent} from 'hast'\n */\n\nimport {whitespace} from 'hast-util-whitespace'\n\nexport const siblingAfter = siblings(1)\nexport const siblingBefore = siblings(-1)\n\n/** @type {Array<RootContent>} */\nconst emptyChildren = []\n\n/**\n * Factory to check siblings in a direction.\n *\n * @param {number} increment\n */\nfunction siblings(increment) {\n  return sibling\n\n  /**\n   * Find applicable siblings in a direction.\n   *\n   * @template {Parents} Parent\n   *   Parent type.\n   * @param {Parent | undefined} parent\n   *   Parent.\n   * @param {number | undefined} index\n   *   Index of child in `parent`.\n   * @param {boolean | undefined} [includeWhitespace=false]\n   *   Whether to include whitespace (default: `false`).\n   * @returns {Parent extends {children: Array<infer Child>} ? Child | undefined : never}\n   *   Child of parent.\n   */\n  function sibling(parent, index, includeWhitespace) {\n    const siblings = parent ? parent.children : emptyChildren\n    let offset = (index || 0) + increment\n    let next = siblings[offset]\n\n    if (!includeWhitespace) {\n      while (next && whitespace(next)) {\n        offset += increment\n        next = siblings[offset]\n      }\n    }\n\n    // @ts-expect-error: it’s a correct child.\n    return next\n  }\n}\n","/**\n * @import {Element, Parents} from 'hast'\n */\n\n/**\n * @callback OmitHandle\n *   Check if a tag can be omitted.\n * @param {Element} element\n *   Element to check.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether to omit a tag.\n *\n */\n\nconst own = {}.hasOwnProperty\n\n/**\n * Factory to check if a given node can have a tag omitted.\n *\n * @param {Record<string, OmitHandle>} handlers\n *   Omission handlers, where each key is a tag name, and each value is the\n *   corresponding handler.\n * @returns {OmitHandle}\n *   Whether to omit a tag of an element.\n */\nexport function omission(handlers) {\n  return omit\n\n  /**\n   * Check if a given node can have a tag omitted.\n   *\n   * @type {OmitHandle}\n   */\n  function omit(node, index, parent) {\n    return (\n      own.call(handlers, node.tagName) &&\n      handlers[node.tagName](node, index, parent)\n    )\n  }\n}\n","/**\n * @import {Element, Parents} from 'hast'\n */\n\nimport {whitespace} from 'hast-util-whitespace'\nimport {siblingAfter} from './util/siblings.js'\nimport {omission} from './omission.js'\n\nexport const closing = omission({\n  body,\n  caption: headOrColgroupOrCaption,\n  colgroup: headOrColgroupOrCaption,\n  dd,\n  dt,\n  head: headOrColgroupOrCaption,\n  html,\n  li,\n  optgroup,\n  option,\n  p,\n  rp: rubyElement,\n  rt: rubyElement,\n  tbody,\n  td: cells,\n  tfoot,\n  th: cells,\n  thead,\n  tr\n})\n\n/**\n * Macro for `</head>`, `</colgroup>`, and `</caption>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction headOrColgroupOrCaption(_, index, parent) {\n  const next = siblingAfter(parent, index, true)\n  return (\n    !next ||\n    (next.type !== 'comment' &&\n      !(next.type === 'text' && whitespace(next.value.charAt(0))))\n  )\n}\n\n/**\n * Whether to omit `</html>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction html(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return !next || next.type !== 'comment'\n}\n\n/**\n * Whether to omit `</body>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction body(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return !next || next.type !== 'comment'\n}\n\n/**\n * Whether to omit `</p>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction p(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return next\n    ? next.type === 'element' &&\n        (next.tagName === 'address' ||\n          next.tagName === 'article' ||\n          next.tagName === 'aside' ||\n          next.tagName === 'blockquote' ||\n          next.tagName === 'details' ||\n          next.tagName === 'div' ||\n          next.tagName === 'dl' ||\n          next.tagName === 'fieldset' ||\n          next.tagName === 'figcaption' ||\n          next.tagName === 'figure' ||\n          next.tagName === 'footer' ||\n          next.tagName === 'form' ||\n          next.tagName === 'h1' ||\n          next.tagName === 'h2' ||\n          next.tagName === 'h3' ||\n          next.tagName === 'h4' ||\n          next.tagName === 'h5' ||\n          next.tagName === 'h6' ||\n          next.tagName === 'header' ||\n          next.tagName === 'hgroup' ||\n          next.tagName === 'hr' ||\n          next.tagName === 'main' ||\n          next.tagName === 'menu' ||\n          next.tagName === 'nav' ||\n          next.tagName === 'ol' ||\n          next.tagName === 'p' ||\n          next.tagName === 'pre' ||\n          next.tagName === 'section' ||\n          next.tagName === 'table' ||\n          next.tagName === 'ul')\n    : !parent ||\n        // Confusing parent.\n        !(\n          parent.type === 'element' &&\n          (parent.tagName === 'a' ||\n            parent.tagName === 'audio' ||\n            parent.tagName === 'del' ||\n            parent.tagName === 'ins' ||\n            parent.tagName === 'map' ||\n            parent.tagName === 'noscript' ||\n            parent.tagName === 'video')\n        )\n}\n\n/**\n * Whether to omit `</li>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction li(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return !next || (next.type === 'element' && next.tagName === 'li')\n}\n\n/**\n * Whether to omit `</dt>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction dt(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return Boolean(\n    next &&\n      next.type === 'element' &&\n      (next.tagName === 'dt' || next.tagName === 'dd')\n  )\n}\n\n/**\n * Whether to omit `</dd>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction dd(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return (\n    !next ||\n    (next.type === 'element' &&\n      (next.tagName === 'dt' || next.tagName === 'dd'))\n  )\n}\n\n/**\n * Whether to omit `</rt>` or `</rp>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction rubyElement(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return (\n    !next ||\n    (next.type === 'element' &&\n      (next.tagName === 'rp' || next.tagName === 'rt'))\n  )\n}\n\n/**\n * Whether to omit `</optgroup>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction optgroup(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return !next || (next.type === 'element' && next.tagName === 'optgroup')\n}\n\n/**\n * Whether to omit `</option>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction option(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return (\n    !next ||\n    (next.type === 'element' &&\n      (next.tagName === 'option' || next.tagName === 'optgroup'))\n  )\n}\n\n/**\n * Whether to omit `</thead>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction thead(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return Boolean(\n    next &&\n      next.type === 'element' &&\n      (next.tagName === 'tbody' || next.tagName === 'tfoot')\n  )\n}\n\n/**\n * Whether to omit `</tbody>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction tbody(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return (\n    !next ||\n    (next.type === 'element' &&\n      (next.tagName === 'tbody' || next.tagName === 'tfoot'))\n  )\n}\n\n/**\n * Whether to omit `</tfoot>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction tfoot(_, index, parent) {\n  return !siblingAfter(parent, index)\n}\n\n/**\n * Whether to omit `</tr>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction tr(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return !next || (next.type === 'element' && next.tagName === 'tr')\n}\n\n/**\n * Whether to omit `</td>` or `</th>`.\n *\n * @param {Element} _\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the closing tag can be omitted.\n */\nfunction cells(_, index, parent) {\n  const next = siblingAfter(parent, index)\n  return (\n    !next ||\n    (next.type === 'element' &&\n      (next.tagName === 'td' || next.tagName === 'th'))\n  )\n}\n","/**\n * @import {Element, Parents} from 'hast'\n */\n\nimport {whitespace} from 'hast-util-whitespace'\nimport {siblingAfter, siblingBefore} from './util/siblings.js'\nimport {closing} from './closing.js'\nimport {omission} from './omission.js'\n\nexport const opening = omission({\n  body,\n  colgroup,\n  head,\n  html,\n  tbody\n})\n\n/**\n * Whether to omit `<html>`.\n *\n * @param {Element} node\n *   Element.\n * @returns {boolean}\n *   Whether the opening tag can be omitted.\n */\nfunction html(node) {\n  const head = siblingAfter(node, -1)\n  return !head || head.type !== 'comment'\n}\n\n/**\n * Whether to omit `<head>`.\n *\n * @param {Element} node\n *   Element.\n * @returns {boolean}\n *   Whether the opening tag can be omitted.\n */\nfunction head(node) {\n  /** @type {Set<string>} */\n  const seen = new Set()\n\n  // Whether `srcdoc` or not,\n  // make sure the content model at least doesn’t have too many `base`s/`title`s.\n  for (const child of node.children) {\n    if (\n      child.type === 'element' &&\n      (child.tagName === 'base' || child.tagName === 'title')\n    ) {\n      if (seen.has(child.tagName)) return false\n      seen.add(child.tagName)\n    }\n  }\n\n  // “May be omitted if the element is empty,\n  // or if the first thing inside the head element is an element.”\n  const child = node.children[0]\n  return !child || child.type === 'element'\n}\n\n/**\n * Whether to omit `<body>`.\n *\n * @param {Element} node\n *   Element.\n * @returns {boolean}\n *   Whether the opening tag can be omitted.\n */\nfunction body(node) {\n  const head = siblingAfter(node, -1, true)\n\n  return (\n    !head ||\n    (head.type !== 'comment' &&\n      !(head.type === 'text' && whitespace(head.value.charAt(0))) &&\n      !(\n        head.type === 'element' &&\n        (head.tagName === 'meta' ||\n          head.tagName === 'link' ||\n          head.tagName === 'script' ||\n          head.tagName === 'style' ||\n          head.tagName === 'template')\n      ))\n  )\n}\n\n/**\n * Whether to omit `<colgroup>`.\n * The spec describes some logic for the opening tag, but it’s easier to\n * implement in the closing tag, to the same effect, so we handle it there\n * instead.\n *\n * @param {Element} node\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the opening tag can be omitted.\n */\nfunction colgroup(node, index, parent) {\n  const previous = siblingBefore(parent, index)\n  const head = siblingAfter(node, -1, true)\n\n  // Previous colgroup was already omitted.\n  if (\n    parent &&\n    previous &&\n    previous.type === 'element' &&\n    previous.tagName === 'colgroup' &&\n    closing(previous, parent.children.indexOf(previous), parent)\n  ) {\n    return false\n  }\n\n  return Boolean(head && head.type === 'element' && head.tagName === 'col')\n}\n\n/**\n * Whether to omit `<tbody>`.\n *\n * @param {Element} node\n *   Element.\n * @param {number | undefined} index\n *   Index of element in parent.\n * @param {Parents | undefined} parent\n *   Parent of element.\n * @returns {boolean}\n *   Whether the opening tag can be omitted.\n */\nfunction tbody(node, index, parent) {\n  const previous = siblingBefore(parent, index)\n  const head = siblingAfter(node, -1)\n\n  // Previous table section was already omitted.\n  if (\n    parent &&\n    previous &&\n    previous.type === 'element' &&\n    (previous.tagName === 'thead' || previous.tagName === 'tbody') &&\n    closing(previous, parent.children.indexOf(previous), parent)\n  ) {\n    return false\n  }\n\n  return Boolean(head && head.type === 'element' && head.tagName === 'tr')\n}\n","/**\n * @import {Element, Parents, Properties} from 'hast'\n * @import {State} from '../index.js'\n */\n\nimport {ccount} from 'ccount'\nimport {stringify as commas} from 'comma-separated-tokens'\nimport {find, svg} from 'property-information'\nimport {stringify as spaces} from 'space-separated-tokens'\nimport {stringifyEntities} from 'stringify-entities'\nimport {closing} from '../omission/closing.js'\nimport {opening} from '../omission/opening.js'\n\n/**\n * Maps of subsets.\n *\n * Each value is a matrix of tuples.\n * The value at `0` causes parse errors, the value at `1` is valid.\n * Of both, the value at `0` is unsafe, and the value at `1` is safe.\n *\n * @type {Record<'double' | 'name' | 'single' | 'unquoted', Array<[Array<string>, Array<string>]>>}\n */\nconst constants = {\n  // See: <https://html.spec.whatwg.org/#attribute-name-state>.\n  name: [\n    ['\\t\\n\\f\\r &/=>'.split(''), '\\t\\n\\f\\r \"&\\'/=>`'.split('')],\n    ['\\0\\t\\n\\f\\r \"&\\'/<=>'.split(''), '\\0\\t\\n\\f\\r \"&\\'/<=>`'.split('')]\n  ],\n  // See: <https://html.spec.whatwg.org/#attribute-value-(unquoted)-state>.\n  unquoted: [\n    ['\\t\\n\\f\\r &>'.split(''), '\\0\\t\\n\\f\\r \"&\\'<=>`'.split('')],\n    ['\\0\\t\\n\\f\\r \"&\\'<=>`'.split(''), '\\0\\t\\n\\f\\r \"&\\'<=>`'.split('')]\n  ],\n  // See: <https://html.spec.whatwg.org/#attribute-value-(single-quoted)-state>.\n  single: [\n    [\"&'\".split(''), '\"&\\'`'.split('')],\n    [\"\\0&'\".split(''), '\\0\"&\\'`'.split('')]\n  ],\n  // See: <https://html.spec.whatwg.org/#attribute-value-(double-quoted)-state>.\n  double: [\n    ['\"&'.split(''), '\"&\\'`'.split('')],\n    ['\\0\"&'.split(''), '\\0\"&\\'`'.split('')]\n  ]\n}\n\n/**\n * Serialize an element node.\n *\n * @param {Element} node\n *   Node to handle.\n * @param {number | undefined} index\n *   Index of `node` in `parent.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function element(node, index, parent, state) {\n  const schema = state.schema\n  const omit = schema.space === 'svg' ? false : state.settings.omitOptionalTags\n  let selfClosing =\n    schema.space === 'svg'\n      ? state.settings.closeEmptyElements\n      : state.settings.voids.includes(node.tagName.toLowerCase())\n  /** @type {Array<string>} */\n  const parts = []\n  /** @type {string} */\n  let last\n\n  if (schema.space === 'html' && node.tagName === 'svg') {\n    state.schema = svg\n  }\n\n  const attributes = serializeAttributes(state, node.properties)\n\n  const content = state.all(\n    schema.space === 'html' && node.tagName === 'template' ? node.content : node\n  )\n\n  state.schema = schema\n\n  // If the node is categorised as void, but it has children, remove the\n  // categorisation.\n  // This enables for example `menuitem`s, which are void in W3C HTML but not\n  // void in WHATWG HTML, to be stringified properly.\n  // Note: `menuitem` has since been removed from the HTML spec, and so is no\n  // longer void.\n  if (content) selfClosing = false\n\n  if (attributes || !omit || !opening(node, index, parent)) {\n    parts.push('<', node.tagName, attributes ? ' ' + attributes : '')\n\n    if (\n      selfClosing &&\n      (schema.space === 'svg' || state.settings.closeSelfClosing)\n    ) {\n      last = attributes.charAt(attributes.length - 1)\n      if (\n        !state.settings.tightSelfClosing ||\n        last === '/' ||\n        (last && last !== '\"' && last !== \"'\")\n      ) {\n        parts.push(' ')\n      }\n\n      parts.push('/')\n    }\n\n    parts.push('>')\n  }\n\n  parts.push(content)\n\n  if (!selfClosing && (!omit || !closing(node, index, parent))) {\n    parts.push('</' + node.tagName + '>')\n  }\n\n  return parts.join('')\n}\n\n/**\n * @param {State} state\n * @param {Properties | null | undefined} properties\n * @returns {string}\n */\nfunction serializeAttributes(state, properties) {\n  /** @type {Array<string>} */\n  const values = []\n  let index = -1\n  /** @type {string} */\n  let key\n\n  if (properties) {\n    for (key in properties) {\n      if (properties[key] !== null && properties[key] !== undefined) {\n        const value = serializeAttribute(state, key, properties[key])\n        if (value) values.push(value)\n      }\n    }\n  }\n\n  while (++index < values.length) {\n    const last = state.settings.tightAttributes\n      ? values[index].charAt(values[index].length - 1)\n      : undefined\n\n    // In tight mode, don’t add a space after quoted attributes.\n    if (index !== values.length - 1 && last !== '\"' && last !== \"'\") {\n      values[index] += ' '\n    }\n  }\n\n  return values.join('')\n}\n\n/**\n * @param {State} state\n * @param {string} key\n * @param {Properties[keyof Properties]} value\n * @returns {string}\n */\nfunction serializeAttribute(state, key, value) {\n  const info = find(state.schema, key)\n  const x =\n    state.settings.allowParseErrors && state.schema.space === 'html' ? 0 : 1\n  const y = state.settings.allowDangerousCharacters ? 0 : 1\n  let quote = state.quote\n  /** @type {string | undefined} */\n  let result\n\n  if (info.overloadedBoolean && (value === info.attribute || value === '')) {\n    value = true\n  } else if (\n    (info.boolean || info.overloadedBoolean) &&\n    (typeof value !== 'string' || value === info.attribute || value === '')\n  ) {\n    value = Boolean(value)\n  }\n\n  if (\n    value === null ||\n    value === undefined ||\n    value === false ||\n    (typeof value === 'number' && Number.isNaN(value))\n  ) {\n    return ''\n  }\n\n  const name = stringifyEntities(\n    info.attribute,\n    Object.assign({}, state.settings.characterReferences, {\n      // Always encode without parse errors in non-HTML.\n      subset: constants.name[x][y]\n    })\n  )\n\n  // No value.\n  // There is currently only one boolean property in SVG: `[download]` on\n  // `<a>`.\n  // This property does not seem to work in browsers (Firefox, Safari, Chrome),\n  // so I can’t test if dropping the value works.\n  // But I assume that it should:\n  //\n  // ```html\n  // <!doctype html>\n  // <svg viewBox=\"0 0 100 100\">\n  //   <a href=https://example.com download>\n  //     <circle cx=50 cy=40 r=35 />\n  //   </a>\n  // </svg>\n  // ```\n  //\n  // See: <https://github.com/wooorm/property-information/blob/main/lib/svg.js>\n  if (value === true) return name\n\n  // `spaces` doesn’t accept a second argument, but it’s given here just to\n  // keep the code cleaner.\n  value = Array.isArray(value)\n    ? (info.commaSeparated ? commas : spaces)(value, {\n        padLeft: !state.settings.tightCommaSeparatedLists\n      })\n    : String(value)\n\n  if (state.settings.collapseEmptyAttributes && !value) return name\n\n  // Check unquoted value.\n  if (state.settings.preferUnquoted) {\n    result = stringifyEntities(\n      value,\n      Object.assign({}, state.settings.characterReferences, {\n        attribute: true,\n        subset: constants.unquoted[x][y]\n      })\n    )\n  }\n\n  // If we don’t want unquoted, or if `value` contains character references when\n  // unquoted…\n  if (result !== value) {\n    // If the alternative is less common than `quote`, switch.\n    if (\n      state.settings.quoteSmart &&\n      ccount(value, quote) > ccount(value, state.alternative)\n    ) {\n      quote = state.alternative\n    }\n\n    result =\n      quote +\n      stringifyEntities(\n        value,\n        Object.assign({}, state.settings.characterReferences, {\n          // Always encode without parse errors in non-HTML.\n          subset: (quote === \"'\" ? constants.single : constants.double)[x][y],\n          attribute: true\n        })\n      ) +\n      quote\n  }\n\n  // Don’t add a `=` for unquoted empties.\n  return name + (result ? '=' + result : result)\n}\n","/**\n * @import {Parents, Text} from 'hast'\n * @import {Raw} from 'mdast-util-to-hast'\n * @import {State} from '../index.js'\n */\n\nimport {stringifyEntities} from 'stringify-entities'\n\n// Declare array as variable so it can be cached by `stringifyEntities`\nconst textEntitySubset = ['<', '&']\n\n/**\n * Serialize a text node.\n *\n * @param {Raw | Text} node\n *   Node to handle.\n * @param {number | undefined} _\n *   Index of `node` in `parent.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function text(node, _, parent, state) {\n  // Check if content of `node` should be escaped.\n  return parent &&\n    parent.type === 'element' &&\n    (parent.tagName === 'script' || parent.tagName === 'style')\n    ? node.value\n    : stringifyEntities(\n        node.value,\n        Object.assign({}, state.settings.characterReferences, {\n          subset: textEntitySubset\n        })\n      )\n}\n","/**\n * @import {Parents} from 'hast'\n * @import {Raw} from 'mdast-util-to-hast'\n * @import {State} from '../index.js'\n */\n\nimport {text} from './text.js'\n\n/**\n * Serialize a raw node.\n *\n * @param {Raw} node\n *   Node to handle.\n * @param {number | undefined} index\n *   Index of `node` in `parent.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function raw(node, index, parent, state) {\n  return state.settings.allowDangerousHtml\n    ? node.value\n    : text(node, index, parent, state)\n}\n","/**\n * @import {Parents, Root} from 'hast'\n * @import {State} from '../index.js'\n */\n\n/**\n * Serialize a root.\n *\n * @param {Root} node\n *   Node to handle.\n * @param {number | undefined} _1\n *   Index of `node` in `parent.\n * @param {Parents | undefined} _2\n *   Parent of `node`.\n * @param {State} state\n *   Info passed around about the current state.\n * @returns {string}\n *   Serialized node.\n */\nexport function root(node, _1, _2, state) {\n  return state.all(node)\n}\n","/**\n * @import {Nodes, Parents} from 'hast'\n * @import {State} from '../index.js'\n */\n\nimport {zwitch} from 'zwitch'\nimport {comment} from './comment.js'\nimport {doctype} from './doctype.js'\nimport {element} from './element.js'\nimport {raw} from './raw.js'\nimport {root} from './root.js'\nimport {text} from './text.js'\n\n/**\n * @type {(node: Nodes, index: number | undefined, parent: Parents | undefined, state: State) => string}\n */\nexport const handle = zwitch('type', {\n  invalid,\n  unknown,\n  handlers: {comment, doctype, element, raw, root, text}\n})\n\n/**\n * Fail when a non-node is found in the tree.\n *\n * @param {unknown} node\n *   Unknown value.\n * @returns {never}\n *   Never.\n */\nfunction invalid(node) {\n  throw new Error('Expected node, not `' + node + '`')\n}\n\n/**\n * Fail when a node with an unknown type is found in the tree.\n *\n * @param {unknown} node_\n *  Unknown node.\n * @returns {never}\n *   Never.\n */\nfunction unknown(node_) {\n  // `type` is guaranteed by runtime JS.\n  const node = /** @type {Nodes} */ (node_)\n  throw new Error('Cannot compile unknown node `' + node.type + '`')\n}\n","/**\n * @import {Nodes, Parents, RootContent} from 'hast'\n * @import {Schema} from 'property-information'\n * @import {Options as StringifyEntitiesOptions} from 'stringify-entities'\n */\n\n/**\n * @typedef {Omit<StringifyEntitiesOptions, 'attribute' | 'escapeOnly' | 'subset'>} CharacterReferences\n *\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [allowDangerousCharacters=false]\n *   Do not encode some characters which cause XSS vulnerabilities in older\n *   browsers (default: `false`).\n *\n *   > ⚠️ **Danger**: only set this if you completely trust the content.\n * @property {boolean | null | undefined} [allowDangerousHtml=false]\n *   Allow `raw` nodes and insert them as raw HTML (default: `false`).\n *\n *   When `false`, `Raw` nodes are encoded.\n *\n *   > ⚠️ **Danger**: only set this if you completely trust the content.\n * @property {boolean | null | undefined} [allowParseErrors=false]\n *   Do not encode characters which cause parse errors (even though they work),\n *   to save bytes (default: `false`).\n *\n *   Not used in the SVG space.\n *\n *   > 👉 **Note**: intentionally creates parse errors in markup (how parse\n *   > errors are handled is well defined, so this works but isn’t pretty).\n * @property {boolean | null | undefined} [bogusComments=false]\n *   Use “bogus comments” instead of comments to save byes: `<?charlie>`\n *   instead of `<!--charlie-->` (default: `false`).\n *\n *   > 👉 **Note**: intentionally creates parse errors in markup (how parse\n *   > errors are handled is well defined, so this works but isn’t pretty).\n * @property {CharacterReferences | null | undefined} [characterReferences]\n *   Configure how to serialize character references (optional).\n * @property {boolean | null | undefined} [closeEmptyElements=false]\n *   Close SVG elements without any content with slash (`/`) on the opening tag\n *   instead of an end tag: `<circle />` instead of `<circle></circle>`\n *   (default: `false`).\n *\n *   See `tightSelfClosing` to control whether a space is used before the\n *   slash.\n *\n *   Not used in the HTML space.\n * @property {boolean | null | undefined} [closeSelfClosing=false]\n *   Close self-closing nodes with an extra slash (`/`): `<img />` instead of\n *   `<img>` (default: `false`).\n *\n *   See `tightSelfClosing` to control whether a space is used before the\n *   slash.\n *\n *   Not used in the SVG space.\n * @property {boolean | null | undefined} [collapseEmptyAttributes=false]\n *   Collapse empty attributes: get `class` instead of `class=\"\"` (default:\n *   `false`).\n *\n *   Not used in the SVG space.\n *\n *   > 👉 **Note**: boolean attributes (such as `hidden`) are always collapsed.\n * @property {boolean | null | undefined} [omitOptionalTags=false]\n *   Omit optional opening and closing tags (default: `false`).\n *\n *   For example, in `<ol><li>one</li><li>two</li></ol>`, both `</li>` closing\n *   tags can be omitted.\n *   The first because it’s followed by another `li`, the last because it’s\n *   followed by nothing.\n *\n *   Not used in the SVG space.\n * @property {boolean | null | undefined} [preferUnquoted=false]\n *   Leave attributes unquoted if that results in less bytes (default: `false`).\n *\n *   Not used in the SVG space.\n * @property {boolean | null | undefined} [quoteSmart=false]\n *   Use the other quote if that results in less bytes (default: `false`).\n * @property {Quote | null | undefined} [quote='\"']\n *   Preferred quote to use (default: `'\"'`).\n * @property {Space | null | undefined} [space='html']\n *   When an `<svg>` element is found in the HTML space, this package already\n *   automatically switches to and from the SVG space when entering and exiting\n *   it (default: `'html'`).\n *\n *   > 👉 **Note**: hast is not XML.\n *   > It supports SVG as embedded in HTML.\n *   > It does not support the features available in XML.\n *   > Passing SVG might break but fragments of modern SVG should be fine.\n *   > Use [`xast`][xast] if you need to support SVG as XML.\n * @property {boolean | null | undefined} [tightAttributes=false]\n *   Join attributes together, without whitespace, if possible: get\n *   `class=\"a b\"title=\"c d\"` instead of `class=\"a b\" title=\"c d\"` to save\n *   bytes (default: `false`).\n *\n *   Not used in the SVG space.\n *\n *   > 👉 **Note**: intentionally creates parse errors in markup (how parse\n *   > errors are handled is well defined, so this works but isn’t pretty).\n * @property {boolean | null | undefined} [tightCommaSeparatedLists=false]\n *   Join known comma-separated attribute values with just a comma (`,`),\n *   instead of padding them on the right as well (`,␠`, where `␠` represents a\n *   space) (default: `false`).\n * @property {boolean | null | undefined} [tightDoctype=false]\n *   Drop unneeded spaces in doctypes: `<!doctypehtml>` instead of\n *   `<!doctype html>` to save bytes (default: `false`).\n *\n *   > 👉 **Note**: intentionally creates parse errors in markup (how parse\n *   > errors are handled is well defined, so this works but isn’t pretty).\n * @property {boolean | null | undefined} [tightSelfClosing=false]\n *   Do not use an extra space when closing self-closing elements: `<img/>`\n *   instead of `<img />` (default: `false`).\n *\n *   > 👉 **Note**: only used if `closeSelfClosing: true` or\n *   > `closeEmptyElements: true`.\n * @property {boolean | null | undefined} [upperDoctype=false]\n *   Use a `<!DOCTYPE…` instead of `<!doctype…` (default: `false`).\n *\n *   Useless except for XHTML.\n * @property {ReadonlyArray<string> | null | undefined} [voids]\n *   Tag names of elements to serialize without closing tag (default: `html-void-elements`).\n *\n *   Not used in the SVG space.\n *\n *   > 👉 **Note**: It’s highly unlikely that you want to pass this, because\n *   > hast is not for XML, and HTML will not add more void elements.\n *\n * @typedef {'\"' | \"'\"} Quote\n *   HTML quotes for attribute values.\n *\n * @typedef {Omit<Required<{[key in keyof Options]: Exclude<Options[key], null | undefined>}>, 'space' | 'quote'>} Settings\n *\n * @typedef {'html' | 'svg'} Space\n *   Namespace.\n *\n * @typedef State\n *   Info passed around about the current state.\n * @property {(node: Parents | undefined) => string} all\n *   Serialize the children of a parent node.\n * @property {Quote} alternative\n *   Alternative quote.\n * @property {(node: Nodes, index: number | undefined, parent: Parents | undefined) => string} one\n *   Serialize one node.\n * @property {Quote} quote\n *   Preferred quote.\n * @property {Schema} schema\n *   Current schema.\n * @property {Settings} settings\n *   User configuration.\n */\n\nimport {htmlVoidElements} from 'html-void-elements'\nimport {html, svg} from 'property-information'\nimport {handle} from './handle/index.js'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/** @type {CharacterReferences} */\nconst emptyCharacterReferences = {}\n\n/** @type {Array<never>} */\nconst emptyChildren = []\n\n/**\n * Serialize hast as HTML.\n *\n * @param {Array<RootContent> | Nodes} tree\n *   Tree to serialize.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized HTML.\n */\nexport function toHtml(tree, options) {\n  const options_ = options || emptyOptions\n  const quote = options_.quote || '\"'\n  const alternative = quote === '\"' ? \"'\" : '\"'\n\n  if (quote !== '\"' && quote !== \"'\") {\n    throw new Error('Invalid quote `' + quote + '`, expected `\\'` or `\"`')\n  }\n\n  /** @type {State} */\n  const state = {\n    one,\n    all,\n    settings: {\n      omitOptionalTags: options_.omitOptionalTags || false,\n      allowParseErrors: options_.allowParseErrors || false,\n      allowDangerousCharacters: options_.allowDangerousCharacters || false,\n      quoteSmart: options_.quoteSmart || false,\n      preferUnquoted: options_.preferUnquoted || false,\n      tightAttributes: options_.tightAttributes || false,\n      upperDoctype: options_.upperDoctype || false,\n      tightDoctype: options_.tightDoctype || false,\n      bogusComments: options_.bogusComments || false,\n      tightCommaSeparatedLists: options_.tightCommaSeparatedLists || false,\n      tightSelfClosing: options_.tightSelfClosing || false,\n      collapseEmptyAttributes: options_.collapseEmptyAttributes || false,\n      allowDangerousHtml: options_.allowDangerousHtml || false,\n      voids: options_.voids || htmlVoidElements,\n      characterReferences:\n        options_.characterReferences || emptyCharacterReferences,\n      closeSelfClosing: options_.closeSelfClosing || false,\n      closeEmptyElements: options_.closeEmptyElements || false\n    },\n    schema: options_.space === 'svg' ? svg : html,\n    quote,\n    alternative\n  }\n\n  return state.one(\n    Array.isArray(tree) ? {type: 'root', children: tree} : tree,\n    undefined,\n    undefined\n  )\n}\n\n/**\n * Serialize a node.\n *\n * @this {State}\n *   Info passed around about the current state.\n * @param {Nodes} node\n *   Node to handle.\n * @param {number | undefined} index\n *   Index of `node` in `parent.\n * @param {Parents | undefined} parent\n *   Parent of `node`.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(node, index, parent) {\n  return handle(node, index, parent, this)\n}\n\n/**\n * Serialize all children of `parent`.\n *\n * @this {State}\n *   Info passed around about the current state.\n * @param {Parents | undefined} parent\n *   Parent whose children to serialize.\n * @returns {string}\n */\nexport function all(parent) {\n  /** @type {Array<string>} */\n  const results = []\n  const children = (parent && parent.children) || emptyChildren\n  let index = -1\n\n  while (++index < children.length) {\n    results[index] = this.one(children[index], index, parent)\n  }\n\n  return results.join('')\n}\n","/**\n * @import {Root} from 'hast'\n * @import {Options} from 'hast-util-to-html'\n * @import {Compiler, Processor} from 'unified'\n */\n\nimport {toHtml} from 'hast-util-to-html'\n\n/**\n * Plugin to add support for serializing as HTML.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function rehypeStringify(options) {\n  /** @type {Processor<undefined, undefined, undefined, Root, string>} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n  const settings = {...self.data('settings'), ...options}\n\n  self.compiler = compiler\n\n  /**\n   * @type {Compiler<Root, string>}\n   */\n  function compiler(tree) {\n    return toHtml(tree, settings)\n  }\n}\n","<script context=\"module\">\n  import rehypeStringify from \"rehype-stringify\";\n  import remarkRehype from \"remark-rehype\";\n  import { unified } from \"unified\";\n\n  const processor = unified().use(remarkRehype).use(rehypeStringify);\n</script>\n\n<script lang=\"ts\">\n  import type { Node, Root } from \"mdast\";\n\n  export let node: Node;\n\n  $: root = node as Root;\n</script>\n\n{@html String(processor.stringify(processor.runSync(root)))}\n","<script context=\"module\">\n  import { tick } from \"svelte\";\n\n  /**\n   * Usage: <div use:portal={'css selector'}> or <div use:portal={document.body}>\n   *\n   * @param {HTMLElement} el\n   * @param {HTMLElement|string} target DOM Element or CSS Selector\n   */\n  export function portal(el, target = \"body\") {\n    let targetEl;\n    async function update(newTarget) {\n      target = newTarget;\n      if (typeof target === \"string\") {\n        targetEl = document.querySelector(target);\n        if (targetEl === null) {\n          await tick();\n          targetEl = document.querySelector(target);\n        }\n        if (targetEl === null) {\n          throw new Error(\n            `No element found matching css selector: \"${target}\"`\n          );\n        }\n      } else if (target instanceof HTMLElement) {\n        targetEl = target;\n      } else {\n        throw new TypeError(\n          `Unknown portal target type: ${\n            target === null ? \"null\" : typeof target\n          }. Allowed types: string (CSS selector) or HTMLElement.`\n        );\n      }\n      targetEl.appendChild(el);\n      el.hidden = false;\n    }\n\n    function destroy() {\n      if (el.parentNode) {\n        el.parentNode.removeChild(el);\n      }\n    }\n\n    update(target);\n    return {\n      update,\n      destroy,\n    };\n  }\n</script>\n\n<script>\n  /**\n   * DOM Element or CSS Selector\n   * @type { HTMLElement|string}\n   */\n  export let target = \"body\";\n</script>\n\n<div use:portal={target} hidden>\n  <slot />\n</div>\n","<script lang=\"ts\">\n  import { tick } from \"svelte\";\n  import Portal from \"svelte-portal\";\n\n  export let target: HTMLElement;\n  export let show: boolean;\n  export let onHide: () => void = () => {};\n\n  let position = { top: 0, left: 0 };\n  let div: HTMLDivElement;\n\n  async function updatePosition() {\n    await tick();\n\n    const rect = target.getBoundingClientRect();\n    const divWidth = div.offsetWidth;\n\n    const top = rect.top - div.offsetHeight;\n\n    let left = rect.left;\n\n    if (left + divWidth > window.innerWidth) {\n      left = rect.right - divWidth;\n    }\n\n    if (left < 0) {\n      left = 0;\n    }\n\n    position = { top, left };\n  }\n\n  $: show && updatePosition();\n\n  $: top = `${position.top}px`;\n  $: left = `${position.left}px`;\n\n  let showing = show;\n\n  async function maybeFadeIn(show: boolean) {\n    if (show && !showing) {\n      await tick();\n      showing = show;\n    }\n  }\n\n  $: maybeFadeIn(show);\n</script>\n\n{#if show || showing}\n  <Portal>\n    {@const hiding = !show || !showing}\n    <div on:transitionend={() => [(showing = show), !show && onHide()]} class:op-0={hiding} class:pointer-events-none={hiding} class=\"fixed transition-opacity\" style:top style:left bind:this={div}>\n      <slot />\n    </div>\n  </Portal>\n{/if}\n","<script lang=\"ts\">\n  import type { ConsoleAPI, Inspection } from \"$py/console/console\";\n  import type { NotebookAPI } from \"$py/notebook/notebook\";\n  import type { InlineCode, Node } from \"mdast\";\n\n  import Tooltip from \"../Tooltip.svelte\";\n  import { onDestroy } from \"svelte\";\n\n  export let node: Node;\n  export let inspect: typeof ConsoleAPI.prototype.inspect | null = null;\n  export let watch: typeof NotebookAPI.prototype.watch | null = null;\n\n  let ref: HTMLElement;\n\n  $: inlineCode = (node as InlineCode);\n\n  let show = false;\n  let inspection: Inspection;\n\n  $: show && inspect && (inspection = inspect(inlineCode.value));\n\n  const callbacks: (() => void)[] = [];\n\n  $: show && watch && !callbacks.length && callbacks.push(watch(inlineCode.value, result => (inspection = result)));\n\n  function stopWatching() {\n    while (callbacks.length) callbacks.pop()!();\n  }\n\n  onDestroy(stopWatching);\n\n  let outerColor: string;\n  let classColor: string;\n  let valueColor: string;\n\n  $: {\n    switch (inspection?.type) {\n      case \"class\": {\n        outerColor = \"ring-orange-3/80\";\n        classColor = \"bg-orange-3/10 text-orange-3\";\n        valueColor = \"text-orange-50\";\n        break;\n      }\n      case \"exception\": {\n        outerColor = \"ring-rose-3/80\";\n        classColor = \"bg-rose-3/10 text-rose-3\";\n        valueColor = \"text-rose-50\";\n        break;\n      }\n      default: {\n        outerColor = \"ring-blue-3/80\";\n        classColor = \"bg-blue-3/10 text-blue-3\";\n        valueColor = \"text-blue-50\";\n      }\n    }\n  }\n</script>\n\n{#if inspect || watch}\n  <Tooltip target={ref} show={show && inspection !== undefined} onHide={stopWatching}>\n    <div class=\"{outerColor} max-w-lg flex flex-row items-center gap-1.5 overflow-x-hidden ws-nowrap rounded bg-neutral-8/80 p-1.5 pr-2 text-sm text-xs font-mono ring-(1.5 inset) backdrop-blur -translate-y-0.4em <lg:(text-2.75 ring-1.3) <sm:(text-2.5 ring-1.1)\">\n      <div class=\"{classColor} rounded-sm px-1 py-0.5 font-bold <lg:(px-0.75 py-0.25) <sm:(px-0.5 py-0)\">{inspection?.class}</div>\n      <div class=\"{valueColor} overflow-x-hidden text-ellipsis\">{inspection?.value}</div>\n    </div>\n  </Tooltip>\n\n  <code on:mouseenter={() => show = true} on:mouseleave={() => [(show = false), stopWatching()]} bind:this={ref}>{inlineCode.value}</code>\n{:else}\n  <code>{inlineCode.value}</code>\n{/if}\n","<script lang=\"ts\">\n  import type { Link, Node } from \"mdast\";\n\n  export let node: Node;\n\n  $: link = node as Link;\n</script>\n\n<a href={link.url} title={link.title}>\n  <slot />\n</a>\n","import type { ConsoleAPI } from \"$py/console/console\";\n\nimport { writable } from \"svelte/store\";\n\nexport const currentConsole = writable<ConsoleAPI | null>(null);\nexport const currentConsolePush = writable<((source: string) => any) | null>(null);\n","/**\n * @typedef {import('mdast').Nodes} Nodes\n *\n * @typedef Options\n *   Configuration (optional).\n * @property {boolean | null | undefined} [includeImageAlt=true]\n *   Whether to use `alt` for `image`s (default: `true`).\n * @property {boolean | null | undefined} [includeHtml=true]\n *   Whether to use `value` of HTML (default: `true`).\n */\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Get the text content of a node or list of nodes.\n *\n * Prefers the node’s plain-text fields, otherwise serializes its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} [value]\n *   Thing to serialize, typically `Node`.\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Serialized `value`.\n */\nexport function toString(value, options) {\n  const settings = options || emptyOptions\n  const includeImageAlt =\n    typeof settings.includeImageAlt === 'boolean'\n      ? settings.includeImageAlt\n      : true\n  const includeHtml =\n    typeof settings.includeHtml === 'boolean' ? settings.includeHtml : true\n\n  return one(value, includeImageAlt, includeHtml)\n}\n\n/**\n * One node or several nodes.\n *\n * @param {unknown} value\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized node.\n */\nfunction one(value, includeImageAlt, includeHtml) {\n  if (node(value)) {\n    if ('value' in value) {\n      return value.type === 'html' && !includeHtml ? '' : value.value\n    }\n\n    if (includeImageAlt && 'alt' in value && value.alt) {\n      return value.alt\n    }\n\n    if ('children' in value) {\n      return all(value.children, includeImageAlt, includeHtml)\n    }\n  }\n\n  if (Array.isArray(value)) {\n    return all(value, includeImageAlt, includeHtml)\n  }\n\n  return ''\n}\n\n/**\n * Serialize a list of nodes.\n *\n * @param {Array<unknown>} values\n *   Thing to serialize.\n * @param {boolean} includeImageAlt\n *   Include image `alt`s.\n * @param {boolean} includeHtml\n *   Include HTML.\n * @returns {string}\n *   Serialized nodes.\n */\nfunction all(values, includeImageAlt, includeHtml) {\n  /** @type {Array<string>} */\n  const result = []\n  let index = -1\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt, includeHtml)\n  }\n\n  return result.join('')\n}\n\n/**\n * Check if `value` looks like a node.\n *\n * @param {unknown} value\n *   Thing.\n * @returns {value is Nodes}\n *   Whether `value` is a node.\n */\nfunction node(value) {\n  return Boolean(value && typeof value === 'object')\n}\n","/// <reference lib=\"dom\" />\n\n/* global document */\n\nconst element = document.createElement('i')\n\n/**\n * @param {string} value\n * @returns {string | false}\n */\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';'\n  element.innerHTML = characterReference\n  const character = element.textContent\n\n  // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  if (\n    // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n    // yield `null`.\n    character.charCodeAt(character.length - 1) === 59 /* `;` */ &&\n    value !== 'semi'\n  ) {\n    return false\n  }\n\n  // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n  return character === characterReference ? false : character\n}\n","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {number} start\n *   Index to remove/insert at (can be negative).\n * @param {number} remove\n *   Number of items to remove.\n * @param {Array<T>} items\n *   Items to inject into `list`.\n * @returns {undefined}\n *   Nothing.\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {Array<unknown>} */\n  let parameters;\n\n  // Make start between zero and `end` (included).\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n  remove = remove > 0 ? remove : 0;\n\n  // No need to chunk the items if there’s only a couple (10k) items.\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove);\n    // @ts-expect-error Hush, it’s fine.\n    list.splice(...parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) list.splice(start, remove);\n\n    // Insert the items in chunks to not cause stack overflows.\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0);\n      // @ts-expect-error Hush, it’s fine.\n      list.splice(...parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n *   Item type.\n * @param {Array<T>} list\n *   List to operate on.\n * @param {Array<T>} items\n *   Items to add to `list`.\n * @returns {Array<T>}\n *   Either `list` or `items`.\n */\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n  return items;\n}","/**\n * @import {\n *   Extension,\n *   Handles,\n *   HtmlExtension,\n *   NormalizedExtension\n * } from 'micromark-util-types'\n */\n\nimport {splice} from 'micromark-util-chunked'\n\nconst hasOwnProperty = {}.hasOwnProperty\n\n/**\n * Combine multiple syntax extensions into one.\n *\n * @param {ReadonlyArray<Extension>} extensions\n *   List of syntax extensions.\n * @returns {NormalizedExtension}\n *   A single combined extension.\n */\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {}\n  let index = -1\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index])\n  }\n\n  return all\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all\n *   Extension to merge into.\n * @param {Extension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction syntaxExtension(all, extension) {\n  /** @type {keyof Extension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    /** @type {Record<string, unknown>} */\n    const left = maybe || (all[hook] = {})\n    /** @type {Record<string, unknown> | undefined} */\n    const right = extension[hook]\n    /** @type {string} */\n    let code\n\n    if (right) {\n      for (code in right) {\n        if (!hasOwnProperty.call(left, code)) left[code] = []\n        const value = right[code]\n        constructs(\n          // @ts-expect-error Looks like a list.\n          left[code],\n          Array.isArray(value) ? value : value ? [value] : []\n        )\n      }\n    }\n  }\n}\n\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {Array<unknown>} existing\n *   List of constructs to merge into.\n * @param {Array<unknown>} list\n *   List of constructs to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction constructs(existing, list) {\n  let index = -1\n  /** @type {Array<unknown>} */\n  const before = []\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;(list[index].add === 'after' ? existing : before).push(list[index])\n  }\n\n  splice(existing, 0, 0, before)\n}\n\n/**\n * Combine multiple HTML extensions into one.\n *\n * @param {ReadonlyArray<HtmlExtension>} htmlExtensions\n *   List of HTML extensions.\n * @returns {HtmlExtension}\n *   Single combined HTML extension.\n */\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {}\n  let index = -1\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index])\n  }\n\n  return handlers\n}\n\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all\n *   Extension to merge into.\n * @param {HtmlExtension} extension\n *   Extension to merge.\n * @returns {undefined}\n *   Nothing.\n */\nfunction htmlExtension(all, extension) {\n  /** @type {keyof HtmlExtension} */\n  let hook\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined\n    const left = maybe || (all[hook] = {})\n    const right = extension[hook]\n    /** @type {keyof Handles} */\n    let type\n\n    if (right) {\n      for (type in right) {\n        // @ts-expect-error assume document vs regular handler are managed correctly.\n        left[type] = right[type]\n      }\n    }\n  }\n}\n","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * Sort of like `String.fromCodePoint(Number.parseInt(value, base))`, but makes\n * non-characters and control characters safe.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n *   Character.\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n  if (\n  // C0 except for HT, LF, FF, CR, space.\n  code < 9 || code === 11 || code > 13 && code < 32 ||\n  // Control character (DEL) of C0, and C1 controls.\n  code > 126 && code < 160 ||\n  // Lone high surrogates and low surrogates.\n  code > 55_295 && code < 57_344 ||\n  // Noncharacters.\n  code > 64_975 && code < 65_008 || /* eslint-disable no-bitwise */\n  (code & 65_535) === 65_535 || (code & 65_535) === 65_534 || /* eslint-enable no-bitwise */\n  // Out of range\n  code > 1_114_111) {\n    return \"\\uFFFD\";\n  }\n  return String.fromCodePoint(code);\n}","/**\n * Normalize an identifier (as found in references, definitions).\n *\n * Collapses markdown whitespace, trim, and then lower- and uppercase.\n *\n * Some characters are considered “uppercase”, such as U+03F4 (`ϴ`), but if their\n * lowercase counterpart (U+03B8 (`θ`)) is uppercased will result in a different\n * uppercase character (U+0398 (`Θ`)).\n * So, to get a canonical form, we perform both lower- and uppercase.\n *\n * Using uppercase last makes sure keys will never interact with default\n * prototypal values (such as `constructor`): nothing in the prototype of\n * `Object` is uppercase.\n *\n * @param {string} value\n *   Identifier to normalize.\n * @returns {string}\n *   Normalized identifier.\n */\nexport function normalizeIdentifier(value) {\n  return value\n  // Collapse markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, \" \")\n  // Trim.\n  .replace(/^ | $/g, '')\n  // 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 method is uppercase.\n  .toLowerCase().toUpperCase();\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { markdownSpace } from 'micromark-util-character';\n\n// To do: implement `spaceOrTab`, `spaceOrTabMinMax`, `spaceOrTabWithOptions`.\n\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   spaces in markdown are often optional, in which case this factory can be\n *     used and `ok` will be switched to whether spaces were found or not\n * *   one line ending or space can be detected with `markdownSpace(code)` right\n *     before using `factorySpace`\n *\n * ###### Examples\n *\n * Where `␉` represents a tab (plus how much it expands) and `␠` represents a\n * single space.\n *\n * ```markdown\n * ␉\n * ␠␠␠␠\n * ␉␠\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {TokenType} type\n *   Type (`' \\t'`).\n * @param {number | undefined} [max=Infinity]\n *   Max (exclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n    return ok(code);\n  }\n\n  /** @type {State} */\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const content = {\n  tokenize: initializeContent\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Initializer}\n *   Content.\n */\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n  let previous;\n  return contentStart;\n\n  /** @type {State} */\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, contentStart, \"linePrefix\");\n  }\n\n  /** @type {State} */\n  function paragraphInitial(code) {\n    effects.enter(\"paragraph\");\n    return lineStart(code);\n  }\n\n  /** @type {State} */\n  function lineStart(code) {\n    const token = effects.enter(\"chunkText\", {\n      contentType: \"text\",\n      previous\n    });\n    if (previous) {\n      previous.next = token;\n    }\n    previous = token;\n    return data(code);\n  }\n\n  /** @type {State} */\n  function data(code) {\n    if (code === null) {\n      effects.exit(\"chunkText\");\n      effects.exit(\"paragraph\");\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit(\"chunkText\");\n      return lineStart;\n    }\n\n    // Data.\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @import {\n *   Construct,\n *   ContainerState,\n *   InitialConstruct,\n *   Initializer,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @typedef {[Construct, ContainerState]} StackItem\n *   Construct and its state.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\nexport const document = {\n  tokenize: initializeDocument\n};\n\n/** @type {Construct} */\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {Array<StackItem>} */\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext | undefined} */\n  let childFlow;\n  /** @type {Token | undefined} */\n  let childToken;\n  /** @type {number} */\n  let lineStartOffset;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    }\n\n    // Done.\n    return checkNewContainers(code);\n  }\n\n  /** @type {State} */\n  function documentContinue(code) {\n    continued++;\n\n    // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n      if (childFlow) {\n        closeFlow();\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the flow chunk.\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      let index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n    return start(code);\n  }\n\n  /** @type {State} */\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      }\n\n      // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      }\n\n      // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer\n      // needed in micromark-extension-gfm-table@1.0.6).\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    }\n\n    // Check if there is a new container.\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n\n  /** @type {State} */\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n\n  /** @type {State} */\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n\n  /** @type {State} */\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]);\n    // Try another.\n    return documentContinued(code);\n  }\n\n  /** @type {State} */\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter(\"chunkFlow\", {\n      _tokenizer: childFlow,\n      contentType: \"flow\",\n      previous: childToken\n    });\n    return flowContinue(code);\n  }\n\n  /** @type {State} */\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit(\"chunkFlow\"), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit(\"chunkFlow\"));\n      // Get ready for the next line.\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n    effects.consume(code);\n    return flowContinue;\n  }\n\n  /**\n   * @param {Token} token\n   *   Token.\n   * @param {boolean | undefined} [endOfFile]\n   *   Whether the token is at the end of the file (default: `false`).\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function writeToChild(token, endOfFile) {\n    const stream = self.sliceStream(token);\n    if (endOfFile) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream);\n\n    // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n      while (index--) {\n        if (\n        // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && (\n        // …and either is not ended yet…\n        !childFlow.events[index][1].end ||\n        // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      }\n\n      // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean | undefined} */\n      let seen;\n      /** @type {Point | undefined} */\n      let point;\n\n      // Find the previous chunk (the one before the lazy line).\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === \"chunkFlow\") {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n          seen = true;\n        }\n      }\n      exitContainers(continued);\n\n      // Fix positions.\n      index = indexBeforeExits;\n      while (index < self.events.length) {\n        self.events[index][1].end = {\n          ...point\n        };\n        index++;\n      }\n\n      // Inject the exits earlier (they’re still also at the end).\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits));\n\n      // Discard the duplicate exits.\n      self.events.length = index;\n    }\n  }\n\n  /**\n   * @param {number} size\n   *   Size.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function exitContainers(size) {\n    let index = stack.length;\n\n    // Exit open containers.\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n    stack.length = size;\n  }\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n *   Tokenizer.\n */\nfunction tokenizeContainer(effects, ok, nok) {\n  // Always populated by defaults.\n\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), \"linePrefix\", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @import {Code} from 'micromark-util-types'\n */\n\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a code represents whitespace, punctuation, or something\n * else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * > 👉 **Note**: eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n *   Code.\n * @returns {typeof constants.characterGroupWhitespace | typeof constants.characterGroupPunctuation | undefined}\n *   Group.\n */\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @import {Event, Resolver, TokenizeContext} from 'micromark-util-types'\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {ReadonlyArray<{resolveAll?: Resolver | undefined}>} constructs\n *   List of constructs, optionally with `resolveAll`s.\n * @param {Array<Event>} events\n *   List of events.\n * @param {TokenizeContext} context\n *   Context used by `tokenize`.\n * @returns {Array<Event>}\n *   Changed events.\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Array<Resolver>} */\n  const called = []\n  let index = -1\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context)\n      called.push(resolve)\n    }\n  }\n\n  return events\n}\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   Event,\n *   Point,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const attention = {\n  name: 'attention',\n  resolveAll: resolveAllAttention,\n  tokenize: tokenizeAttention\n};\n\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n// eslint-disable-next-line complexity\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n  let open;\n  /** @type {Token} */\n  let group;\n  /** @type {Token} */\n  let text;\n  /** @type {Token} */\n  let openingSequence;\n  /** @type {Token} */\n  let closingSequence;\n  /** @type {number} */\n  let use;\n  /** @type {Array<Event>} */\n  let nextEvents;\n  /** @type {number} */\n  let offset;\n\n  // 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  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;\n\n      // Now walk back to find an opener.\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 &&\n        // 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          }\n\n          // Number of markers to use from the sequence.\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          const start = {\n            ...events[open][1].end\n          };\n          const end = {\n            ...events[index][1].start\n          };\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start,\n            end: {\n              ...events[open][1].end\n            }\n          };\n          closingSequence = {\n            type: use > 1 ? \"strongSequence\" : \"emphasisSequence\",\n            start: {\n              ...events[index][1].start\n            },\n            end\n          };\n          text = {\n            type: use > 1 ? \"strongText\" : \"emphasisText\",\n            start: {\n              ...events[open][1].end\n            },\n            end: {\n              ...events[index][1].start\n            }\n          };\n          group = {\n            type: use > 1 ? \"strong\" : \"emphasis\",\n            start: {\n              ...openingSequence.start\n            },\n            end: {\n              ...closingSequence.end\n            }\n          };\n          events[open][1].end = {\n            ...openingSequence.start\n          };\n          events[index][1].start = {\n            ...closingSequence.end\n          };\n          nextEvents = [];\n\n          // If there are more markers in the opening, add them before.\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          }\n\n          // Opening.\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]);\n\n          // Always populated by defaults.\n\n          // Between.\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context));\n\n          // Closing.\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]);\n\n          // If there are more markers in the closing, add them after.\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  }\n\n  // Remove remaining sequences.\n  index = -1;\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Before a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    marker = code;\n    effects.enter('attentionSequence');\n    return inside(code);\n  }\n\n  /**\n   * In a sequence.\n   *\n   * ```markdown\n   * > | **\n   *     ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    const token = effects.exit('attentionSequence');\n\n    // To do: next major: move this to resolver, just like `markdown-rs`.\n    const after = classifyCharacter(code);\n\n    // Always populated by defaults.\n\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n *   Point.\n * @param {number} offset\n *   Amount to move.\n * @returns {undefined}\n *   Nothing.\n */\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of an autolink.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *      ^\n   * > | a<user@example.com>b\n   *      ^\n   * ```\n   *\n   * @type {State}\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  /**\n   * After `<`, at protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *       ^\n   * > | a<user@example.com>b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n    if (code === 64) {\n      return nok(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * At second byte of protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeOrEmailAtext(code) {\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) {\n      // Count the previous alphabetical from `open` too.\n      size = 1;\n      return schemeInsideOrEmailAtext(code);\n    }\n    return emailAtext(code);\n  }\n\n  /**\n   * In ambiguous protocol or atext.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *        ^\n   * > | a<user@example.com>b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      size = 0;\n      return urlInside;\n    }\n\n    // ASCII alphanumeric and `+`, `-`, and `.`.\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n    size = 0;\n    return emailAtext(code);\n  }\n\n  /**\n   * After protocol, in URL.\n   *\n   * ```markdown\n   * > | a<https://example.com>b\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit(\"autolinkProtocol\");\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n\n    // ASCII control, space, or `<`.\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return urlInside;\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      return emailAtSignOrDot;\n    }\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label, after at-sign or dot.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                 ^       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are allowed.\n   *\n   * ```markdown\n   * > | a<user.name@example.com>b\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n    if (code === 62) {\n      // Exit, then change the token type.\n      effects.exit(\"autolinkProtocol\").type = \"autolinkEmail\";\n      effects.enter(\"autolinkMarker\");\n      effects.consume(code);\n      effects.exit(\"autolinkMarker\");\n      effects.exit(\"autolink\");\n      return ok;\n    }\n    return emailValue(code);\n  }\n\n  /**\n   * In label, where `.` and `>` are *not* allowed.\n   *\n   * Though, this is also used in `emailLabel` to parse other values.\n   *\n   * ```markdown\n   * > | a<user.name@ex-ample.com>b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailValue(code) {\n    // ASCII alphanumeric or `-`.\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      const next = code === 45 ? emailValue : emailLabel;\n      effects.consume(code);\n      return next;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blankLine = {\n  partial: true,\n  tokenize: tokenizeBlankLine\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of blank line.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *     ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    return markdownSpace(code) ? factorySpace(effects, after, \"linePrefix\")(code) : after(code);\n  }\n\n  /**\n   * At eof/eol, after optional whitespace.\n   *\n   * > 👉 **Note**: `␠` represents a space character.\n   *\n   * ```markdown\n   * > | ␠␠␊\n   *       ^\n   * > | ␊\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const blockQuote = {\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit,\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of block quote.\n   *\n   * ```markdown\n   * > | > a\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n      if (!state.open) {\n        effects.enter(\"blockQuote\", {\n          _container: true\n        });\n        state.open = true;\n      }\n      effects.enter(\"blockQuotePrefix\");\n      effects.enter(\"blockQuoteMarker\");\n      effects.consume(code);\n      effects.exit(\"blockQuoteMarker\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>`, before optional whitespace.\n   *\n   * ```markdown\n   * > | > a\n   *      ^\n   * ```\n   *\n   * @type {State}\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    effects.exit(\"blockQuotePrefix\");\n    return ok(code);\n  }\n}\n\n/**\n * Start of block quote continuation.\n *\n * ```markdown\n *   | > a\n * > | > b\n *     ^\n * ```\n *\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  const self = this;\n  return contStart;\n\n  /**\n   * Start of block quote continuation.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contStart(code) {\n    if (markdownSpace(code)) {\n      // Always populated by defaults.\n\n      return factorySpace(effects, contBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return contBefore(code);\n  }\n\n  /**\n   * At `>`, after optional whitespace.\n   *\n   * Also used to parse the first block quote opening.\n   *\n   * ```markdown\n   *   | > a\n   * > | > b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function contBefore(code) {\n    return effects.attempt(blockQuote, ok, nok)(code);\n  }\n}\n\n/** @type {Exiter} */\nfunction exit(effects) {\n  effects.exit(\"blockQuote\");\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of character escape.\n   *\n   * ```markdown\n   * > | a\\*b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"characterEscape\");\n    effects.enter(\"escapeMarker\");\n    effects.consume(code);\n    effects.exit(\"escapeMarker\");\n    return inside;\n  }\n\n  /**\n   * After `\\`, at punctuation.\n   *\n   * ```markdown\n   * > | a\\*b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // ASCII punctuation.\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    return nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n  let max;\n  /** @type {(code: Code) => boolean} */\n  let test;\n  return start;\n\n  /**\n   * Start of character reference.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *      ^\n   * > | a&#123;b\n   *      ^\n   * > | a&#x9;b\n   *      ^\n   * ```\n   *\n   * @type {State}\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  /**\n   * After `&`, at `#` for numeric references or alphanumeric for named\n   * references.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^\n   * > | a&#123;b\n   *       ^\n   * > | a&#x9;b\n   *       ^\n   * ```\n   *\n   * @type {State}\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    effects.enter(\"characterReferenceValue\");\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n\n  /**\n   * After `#`, at `x` for hexadecimals or digit for decimals.\n   *\n   * ```markdown\n   * > | a&#123;b\n   *        ^\n   * > | a&#x9;b\n   *        ^\n   * ```\n   *\n   * @type {State}\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    effects.enter(\"characterReferenceValue\");\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n\n  /**\n   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.\n   *\n   * The character reference kind defines what and how many characters are\n   * allowed.\n   *\n   * ```markdown\n   * > | a&amp;b\n   *       ^^^\n   * > | a&#123;b\n   *        ^^^\n   * > | a&#x9;b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function value(code) {\n    if (code === 59 && size) {\n      const token = effects.exit(\"characterReferenceValue\");\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      // To do: `markdown-rs` uses a different name:\n      // `CharacterReferenceMarkerSemi`.\n      effects.enter(\"characterReferenceMarker\");\n      effects.consume(code);\n      effects.exit(\"characterReferenceMarker\");\n      effects.exit(\"characterReference\");\n      return ok;\n    }\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nconst nonLazyContinuation = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuation\n};\n\n/** @type {Construct} */\nexport const codeFenced = {\n  concrete: true,\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n  const closeStart = {\n    partial: true,\n    tokenize: tokenizeCloseStart\n  };\n  let initialPrefix = 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of code.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse whitespace like `markdown-rs`.\n    return beforeSequenceOpen(code);\n  }\n\n  /**\n   * In opening fence, after prefix, at sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *     ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeSequenceOpen(code) {\n    const tail = self.events[self.events.length - 1];\n    initialPrefix = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n    marker = code;\n    effects.enter(\"codeFenced\");\n    effects.enter(\"codeFencedFence\");\n    effects.enter(\"codeFencedFenceSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening fence sequence.\n   *\n   * ```markdown\n   * > | ~~~js\n   *      ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === marker) {\n      sizeOpen++;\n      effects.consume(code);\n      return sequenceOpen;\n    }\n    if (sizeOpen < 3) {\n      return nok(code);\n    }\n    effects.exit(\"codeFencedFenceSequence\");\n    return markdownSpace(code) ? factorySpace(effects, infoBefore, \"whitespace\")(code) : infoBefore(code);\n  }\n\n  /**\n   * In opening fence, after the sequence (and optional whitespace), before info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function infoBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFencedFence\");\n      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFencedFenceInfo\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return info(code);\n  }\n\n  /**\n   * In info.\n   *\n   * ```markdown\n   * > | ~~~js\n   *        ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function info(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return infoBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceInfo\");\n      return factorySpace(effects, metaBefore, \"whitespace\")(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return info;\n  }\n\n  /**\n   * In opening fence, after info and whitespace, before meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function metaBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return infoBefore(code);\n    }\n    effects.enter(\"codeFencedFenceMeta\");\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return meta(code);\n  }\n\n  /**\n   * In meta.\n   *\n   * ```markdown\n   * > | ~~~js eval\n   *           ^\n   *   | alert(1)\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      effects.exit(\"codeFencedFenceMeta\");\n      return infoBefore(code);\n    }\n    if (code === 96 && code === marker) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return meta;\n  }\n\n  /**\n   * At eol/eof in code, before a non-lazy closing fence or content.\n   *\n   * ```markdown\n   * > | ~~~js\n   *          ^\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function atNonLazyBreak(code) {\n    return effects.attempt(closeStart, after, contentBefore)(code);\n  }\n\n  /**\n   * Before code content, not a closing fence, at eol.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *             ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentBefore(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return contentStart;\n  }\n\n  /**\n   * Before code content, not a closing fence.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentStart(code) {\n    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, \"linePrefix\", initialPrefix + 1)(code) : beforeContentChunk(code);\n  }\n\n  /**\n   * Before code content, after optional prefix.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeContentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return contentChunk(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   *   | ~~~js\n   * > | alert(1)\n   *     ^^^^^^^^\n   *   | ~~~\n   * ```\n   *\n   * @type {State}\n   */\n  function contentChunk(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return beforeContentChunk(code);\n    }\n    effects.consume(code);\n    return contentChunk;\n  }\n\n  /**\n   * After code.\n   *\n   * ```markdown\n   *   | ~~~js\n   *   | alert(1)\n   * > | ~~~\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    effects.exit(\"codeFenced\");\n    return ok(code);\n  }\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Tokenizer}\n   */\n  function tokenizeCloseStart(effects, ok, nok) {\n    let size = 0;\n    return startBefore;\n\n    /**\n     *\n     *\n     * @type {State}\n     */\n    function startBefore(code) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return start;\n    }\n\n    /**\n     * Before closing fence, at optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function start(code) {\n      // Always populated by defaults.\n\n      // To do: `enter` here or in next state?\n      effects.enter(\"codeFencedFence\");\n      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);\n    }\n\n    /**\n     * In closing fence, after optional whitespace, at sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function beforeSequenceClose(code) {\n      if (code === marker) {\n        effects.enter(\"codeFencedFenceSequence\");\n        return sequenceClose(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * In closing fence sequence.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *     ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceClose(code) {\n      if (code === marker) {\n        size++;\n        effects.consume(code);\n        return sequenceClose;\n      }\n      if (size >= sizeOpen) {\n        effects.exit(\"codeFencedFenceSequence\");\n        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, \"whitespace\")(code) : sequenceCloseAfter(code);\n      }\n      return nok(code);\n    }\n\n    /**\n     * After closing fence sequence, after optional whitespace.\n     *\n     * ```markdown\n     *   | ~~~js\n     *   | alert(1)\n     * > | ~~~\n     *        ^\n     * ```\n     *\n     * @type {State}\n     */\n    function sequenceCloseAfter(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit(\"codeFencedFence\");\n        return ok(code);\n      }\n      return nok(code);\n    }\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuation(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineStart;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function lineStart(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n\n/** @type {Construct} */\nconst furtherStart = {\n  partial: true,\n  tokenize: tokenizeFurtherStart\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of code (indented).\n   *\n   * > **Parsing note**: it is not needed to check if this first line is a\n   * > filled line (that it has a non-whitespace character), because blank lines\n   * > are parsed already, so we never run into that.\n   *\n   * ```markdown\n   * > |     aaa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: manually check if interrupting like `markdown-rs`.\n\n    effects.enter(\"codeIndented\");\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code);\n  }\n\n  /**\n   * At a break.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === null) {\n      return after(code);\n    }\n    if (markdownLineEnding(code)) {\n      return effects.attempt(furtherStart, atBreak, after)(code);\n    }\n    effects.enter(\"codeFlowValue\");\n    return inside(code);\n  }\n\n  /**\n   * In code content.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"codeFlowValue\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return inside;\n  }\n\n  /** @type {State} */\n  function after(code) {\n    effects.exit(\"codeIndented\");\n    // To do: allow interrupting like `markdown-rs`.\n    // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeFurtherStart(effects, ok, nok) {\n  const self = this;\n  return furtherStart;\n\n  /**\n   * At eol, trying to parse another indent.\n   *\n   * ```markdown\n   * > |     aaa\n   *            ^\n   *   |     bbb\n   * ```\n   *\n   * @type {State}\n   */\n  function furtherStart(code) {\n    // To do: improve `lazy` / `pierce` handling.\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return furtherStart;\n    }\n\n    // To do: the code here in `micromark-js` is a bit different from\n    // `markdown-rs` because there it can attempt spaces.\n    // We can’t yet.\n    //\n    // To do: use an improved `space_or_tab` function like `markdown-rs`,\n    // so that we can drop the next state.\n    return factorySpace(effects, afterPrefix, \"linePrefix\", 4 + 1)(code);\n  }\n\n  /**\n   * At start, after 1 or 4 spaces.\n   *\n   * ```markdown\n   * > |     aaa\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Previous,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const codeText = {\n  name: 'codeText',\n  previous,\n  resolve: resolveCodeText,\n  tokenize: tokenizeCodeText\n};\n\n// To do: next major: don’t resolve, like `markdown-rs`.\n/** @type {Resolver} */\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n  let index;\n  /** @type {number | undefined} */\n  let enter;\n\n  // If we start and end with an EOL or a space.\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;\n\n    // And we have data.\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === \"codeTextData\") {\n        // Then we have padding.\n        events[headEnterIndex][1].type = \"codeTextPadding\";\n        events[tailExitIndex][1].type = \"codeTextPadding\";\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  }\n\n  // Merge adjacent spaces and data.\n  index = headEnterIndex - 1;\n  tailExitIndex++;\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      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      enter = undefined;\n    }\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Previous}\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\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n  let size;\n  /** @type {Token} */\n  let token;\n  return start;\n\n  /**\n   * Start of code (text).\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * > | \\`a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"codeText\");\n    effects.enter(\"codeTextSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n    effects.exit(\"codeTextSequence\");\n    return between(code);\n  }\n\n  /**\n   * Between something and something else.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function between(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    }\n\n    // To do: next major: don’t do spaces in resolve, but when compiling,\n    // like `markdown-rs`.\n    // Tabs don’t work, and virtual spaces don’t make sense.\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return between;\n    }\n\n    // Closing fence? Could also be data.\n    if (code === 96) {\n      token = effects.enter(\"codeTextSequence\");\n      size = 0;\n      return sequenceClose(code);\n    }\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return between;\n    }\n\n    // Data.\n    effects.enter(\"codeTextData\");\n    return data(code);\n  }\n\n  /**\n   * In data.\n   *\n   * ```markdown\n   * > | `a`\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit(\"codeTextData\");\n      return between(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n\n  /**\n   * In closing sequence.\n   *\n   * ```markdown\n   * > | `a`\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceClose(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return sequenceClose;\n    }\n\n    // Done!\n    if (size === sizeOpen) {\n      effects.exit(\"codeTextSequence\");\n      effects.exit(\"codeText\");\n      return ok(code);\n    }\n\n    // More or less accents: mark as data.\n    token.type = \"codeTextData\";\n    return data(code);\n  }\n}","/**\n * Some of the internal operations of micromark do lots of editing\n * operations on very large arrays. This runs into problems with two\n * properties of most circa-2020 JavaScript interpreters:\n *\n *  - Array-length modifications at the high end of an array (push/pop) are\n *    expected to be common and are implemented in (amortized) time\n *    proportional to the number of elements added or removed, whereas\n *    other operations (shift/unshift and splice) are much less efficient.\n *  - Function arguments are passed on the stack, so adding tens of thousands\n *    of elements to an array with `arr.push(...newElements)` will frequently\n *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)\n *\n * SpliceBuffers are an implementation of gap buffers, which are a\n * generalization of the \"queue made of two stacks\" idea. The splice buffer\n * maintains a cursor, and moving the cursor has cost proportional to the\n * distance the cursor moves, but inserting, deleting, or splicing in\n * new information at the cursor is as efficient as the push/pop operation.\n * This allows for an efficient sequence of splices (or pushes, pops, shifts,\n * or unshifts) as long such edits happen at the same part of the array or\n * generally sweep through the array from the beginning to the end.\n *\n * The interface for splice buffers also supports large numbers of inputs by\n * passing a single array argument rather passing multiple arguments on the\n * function call stack.\n *\n * @template T\n *   Item type.\n */\nexport class SpliceBuffer {\n  /**\n   * @param {ReadonlyArray<T> | null | undefined} [initial]\n   *   Initial items (optional).\n   * @returns\n   *   Splice buffer.\n   */\n  constructor(initial) {\n    /** @type {Array<T>} */\n    this.left = initial ? [...initial] : [];\n    /** @type {Array<T>} */\n    this.right = [];\n  }\n\n  /**\n   * Array access;\n   * does not move the cursor.\n   *\n   * @param {number} index\n   *   Index.\n   * @return {T}\n   *   Item.\n   */\n  get(index) {\n    if (index < 0 || index >= this.left.length + this.right.length) {\n      throw new RangeError('Cannot access index `' + index + '` in a splice buffer of size `' + (this.left.length + this.right.length) + '`');\n    }\n    if (index < this.left.length) return this.left[index];\n    return this.right[this.right.length - index + this.left.length - 1];\n  }\n\n  /**\n   * The length of the splice buffer, one greater than the largest index in the\n   * array.\n   */\n  get length() {\n    return this.left.length + this.right.length;\n  }\n\n  /**\n   * Remove and return `list[0]`;\n   * moves the cursor to `0`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  shift() {\n    this.setCursor(0);\n    return this.right.pop();\n  }\n\n  /**\n   * Slice the buffer to get an array;\n   * does not move the cursor.\n   *\n   * @param {number} start\n   *   Start.\n   * @param {number | null | undefined} [end]\n   *   End (optional).\n   * @returns {Array<T>}\n   *   Array of items.\n   */\n  slice(start, end) {\n    /** @type {number} */\n    const stop = end === null || end === undefined ? Number.POSITIVE_INFINITY : end;\n    if (stop < this.left.length) {\n      return this.left.slice(start, stop);\n    }\n    if (start > this.left.length) {\n      return this.right.slice(this.right.length - stop + this.left.length, this.right.length - start + this.left.length).reverse();\n    }\n    return this.left.slice(start).concat(this.right.slice(this.right.length - stop + this.left.length).reverse());\n  }\n\n  /**\n   * Mimics the behavior of Array.prototype.splice() except for the change of\n   * interface necessary to avoid segfaults when patching in very large arrays.\n   *\n   * This operation moves cursor is moved to `start` and results in the cursor\n   * placed after any inserted items.\n   *\n   * @param {number} start\n   *   Start;\n   *   zero-based index at which to start changing the array;\n   *   negative numbers count backwards from the end of the array and values\n   *   that are out-of bounds are clamped to the appropriate end of the array.\n   * @param {number | null | undefined} [deleteCount=0]\n   *   Delete count (default: `0`);\n   *   maximum number of elements to delete, starting from start.\n   * @param {Array<T> | null | undefined} [items=[]]\n   *   Items to include in place of the deleted items (default: `[]`).\n   * @return {Array<T>}\n   *   Any removed items.\n   */\n  splice(start, deleteCount, items) {\n    /** @type {number} */\n    const count = deleteCount || 0;\n    this.setCursor(Math.trunc(start));\n    const removed = this.right.splice(this.right.length - count, Number.POSITIVE_INFINITY);\n    if (items) chunkedPush(this.left, items);\n    return removed.reverse();\n  }\n\n  /**\n   * Remove and return the highest-numbered item in the array, so\n   * `list[list.length - 1]`;\n   * Moves the cursor to `length`.\n   *\n   * @returns {T | undefined}\n   *   Item, optional.\n   */\n  pop() {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    return this.left.pop();\n  }\n\n  /**\n   * Inserts a single item to the high-numbered side of the array;\n   * moves the cursor to `length`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  push(item) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    this.left.push(item);\n  }\n\n  /**\n   * Inserts many items to the high-numbered side of the array.\n   * Moves the cursor to `length`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  pushMany(items) {\n    this.setCursor(Number.POSITIVE_INFINITY);\n    chunkedPush(this.left, items);\n  }\n\n  /**\n   * Inserts a single item to the low-numbered side of the array;\n   * Moves the cursor to `0`.\n   *\n   * @param {T} item\n   *   Item.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshift(item) {\n    this.setCursor(0);\n    this.right.push(item);\n  }\n\n  /**\n   * Inserts many items to the low-numbered side of the array;\n   * moves the cursor to `0`.\n   *\n   * @param {Array<T>} items\n   *   Items.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  unshiftMany(items) {\n    this.setCursor(0);\n    chunkedPush(this.right, items.reverse());\n  }\n\n  /**\n   * Move the cursor to a specific position in the array. Requires\n   * time proportional to the distance moved.\n   *\n   * If `n < 0`, the cursor will end up at the beginning.\n   * If `n > length`, the cursor will end up at the end.\n   *\n   * @param {number} n\n   *   Position.\n   * @return {undefined}\n   *   Nothing.\n   */\n  setCursor(n) {\n    if (n === this.left.length || n > this.left.length && this.right.length === 0 || n < 0 && this.left.length === 0) return;\n    if (n < this.left.length) {\n      // Move cursor to the this.left\n      const removed = this.left.splice(n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.right, removed.reverse());\n    } else {\n      // Move cursor to the this.right\n      const removed = this.right.splice(this.left.length + this.right.length - n, Number.POSITIVE_INFINITY);\n      chunkedPush(this.left, removed.reverse());\n    }\n  }\n}\n\n/**\n * Avoid stack overflow by pushing items onto the stack in segments\n *\n * @template T\n *   Item type.\n * @param {Array<T>} list\n *   List to inject into.\n * @param {ReadonlyArray<T>} right\n *   Items to inject.\n * @return {undefined}\n *   Nothing.\n */\nfunction chunkedPush(list, right) {\n  /** @type {number} */\n  let chunkStart = 0;\n  if (right.length < 10000) {\n    list.push(...right);\n  } else {\n    while (chunkStart < right.length) {\n      list.push(...right.slice(chunkStart, chunkStart + 10000));\n      chunkStart += 10000;\n    }\n  }\n}","/**\n * @import {Chunk, Event, Token} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { SpliceBuffer } from './lib/splice-buffer.js';\n\n// Hidden API exposed for testing.\nexport { SpliceBuffer } from './lib/splice-buffer.js';\n\n/**\n * Tokenize subcontent.\n *\n * @param {Array<Event>} eventsArray\n *   List of events.\n * @returns {boolean}\n *   Whether subtokens were found.\n */\n// eslint-disable-next-line complexity\nexport function subtokenize(eventsArray) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n  let event;\n  /** @type {number | undefined} */\n  let lineIndex;\n  /** @type {number} */\n  let otherIndex;\n  /** @type {Event} */\n  let otherEvent;\n  /** @type {Array<Event>} */\n  let parameters;\n  /** @type {Array<Event>} */\n  let subevents;\n  /** @type {boolean | undefined} */\n  let more;\n  const events = new SpliceBuffer(eventsArray);\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n    event = events.get(index);\n\n    // 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    if (index && event[1].type === \"chunkFlow\" && events.get(index - 1)[1].type === \"listItemPrefix\") {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === \"lineEndingBlank\") {\n        otherIndex += 2;\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          if (subevents[otherIndex][1].type === \"chunkText\") {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    }\n\n    // Enter.\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    }\n    // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n      while (otherIndex--) {\n        otherEvent = events.get(otherIndex);\n        if (otherEvent[1].type === \"lineEnding\" || otherEvent[1].type === \"lineEndingBlank\") {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events.get(lineIndex)[1].type = \"lineEndingBlank\";\n            }\n            otherEvent[1].type = \"lineEnding\";\n            lineIndex = otherIndex;\n          }\n        } else if (otherEvent[1].type === \"linePrefix\" || otherEvent[1].type === \"listItemIndent\") {\n          // Move past.\n        } else {\n          break;\n        }\n      }\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = {\n          ...events.get(lineIndex)[1].start\n        };\n\n        // Switch container exit w/ line endings.\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        events.splice(lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  // The changes to the `events` buffer must be copied back into the eventsArray\n  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0));\n  return !more;\n}\n\n/**\n * Tokenize embedded tokens.\n *\n * @param {SpliceBuffer<Event>} events\n *   Events.\n * @param {number} eventIndex\n *   Index.\n * @returns {Record<string, number>}\n *   Gaps.\n */\nfunction subcontent(events, eventIndex) {\n  const token = events.get(eventIndex)[1];\n  const context = events.get(eventIndex)[2];\n  let startPosition = eventIndex - 1;\n  /** @type {Array<number>} */\n  const startPositions = [];\n  let tokenizer = token._tokenizer;\n  if (!tokenizer) {\n    tokenizer = context.parser[token.contentType](token.start);\n    if (token._contentTypeTextTrailing) {\n      tokenizer._contentTypeTextTrailing = true;\n    }\n  }\n  const childEvents = tokenizer.events;\n  /** @type {Array<[number, number]>} */\n  const jumps = [];\n  /** @type {Record<string, number>} */\n  const gaps = {};\n  /** @type {Array<Chunk>} */\n  let stream;\n  /** @type {Token | undefined} */\n  let previous;\n  let index = -1;\n  /** @type {Token | undefined} */\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start];\n\n  // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n  while (current) {\n    // Find the position of the event for this token.\n    while (events.get(++startPosition)[1] !== current) {\n      // Empty.\n    }\n    startPositions.push(startPosition);\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n      if (!current.next) {\n        stream.push(null);\n      }\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n      tokenizer.write(stream);\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    }\n\n    // Unravel the next token.\n    previous = current;\n    current = current.next;\n  }\n\n  // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n  current = token;\n  while (++index < childEvents.length) {\n    if (\n    // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start);\n      // Help GC.\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  }\n\n  // Help GC.\n  tokenizer.events = [];\n\n  // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  }\n\n  // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n  index = breaks.length;\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.push([start, start + slice.length - 1]);\n    events.splice(start, 2, slice);\n  }\n  jumps.reverse();\n  index = -1;\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  return gaps;\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\nexport const content = {\n  resolve: resolveContent,\n  tokenize: tokenizeContent\n};\n\n/** @type {Construct} */\nconst continuationConstruct = {\n  partial: true,\n  tokenize: tokenizeContinuation\n};\n\n/**\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 *\n * @type {Resolver}\n */\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token | undefined} */\n  let previous;\n  return chunkStart;\n\n  /**\n   * Before a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkStart(code) {\n    effects.enter(\"content\");\n    previous = effects.enter(\"chunkContent\", {\n      contentType: \"content\"\n    });\n    return chunkInside(code);\n  }\n\n  /**\n   * In a content chunk.\n   *\n   * ```markdown\n   * > | abc\n   *     ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function chunkInside(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    // To do: in `markdown-rs`, each line is parsed on its own, and everything\n    // is stitched together resolving.\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    }\n\n    // Data.\n    effects.consume(code);\n    return chunkInside;\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentEnd(code) {\n    effects.exit(\"chunkContent\");\n    effects.exit(\"content\");\n    return ok(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit(\"chunkContent\");\n    previous.next = effects.enter(\"chunkContent\", {\n      contentType: \"content\",\n      previous\n    });\n    previous = previous.next;\n    return chunkInside;\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function startLookahead(code) {\n    effects.exit(\"chunkContent\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return factorySpace(effects, prefixed, \"linePrefix\");\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    // Always populated by defaults.\n\n    const tail = self.events[self.events.length - 1];\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === \"linePrefix\" && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @import {Effects, State, TokenType} from 'micromark-util-types'\n */\n\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse destinations.\n *\n * ###### Examples\n *\n * ```markdown\n * <a>\n * <a\\>b>\n * <a b>\n * <a)>\n * a\n * a\\)b\n * a(b)c\n * a(b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type for whole (`<a>` or `b`).\n * @param {TokenType} literalType\n *   Type when enclosed (`<a>`).\n * @param {TokenType} literalMarkerType\n *   Type for enclosing (`<` and `>`).\n * @param {TokenType} rawType\n *   Type when not enclosed (`b`).\n * @param {TokenType} stringType\n *   Type for the value (`a` or `b`).\n * @param {number | undefined} [max=Infinity]\n *   Depth of nested parens (inclusive).\n * @returns {State}\n *   Start state.\n */\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  const limit = max || Number.POSITIVE_INFINITY;\n  let balance = 0;\n  return start;\n\n  /**\n   * Start of destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *     ^\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\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 enclosedBefore;\n    }\n\n    // ASCII control, space, closing paren.\n    if (code === null || code === 32 || code === 41 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return raw(code);\n  }\n\n  /**\n   * After `<`, at an enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedBefore(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    effects.enter(stringType);\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return enclosed(code);\n  }\n\n  /**\n   * In enclosed destination.\n   *\n   * ```markdown\n   * > | <aa>\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosed(code) {\n    if (code === 62) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      return enclosedBefore(code);\n    }\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? enclosedEscape : enclosed;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | <a\\*a>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function enclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return enclosed;\n    }\n    return enclosed(code);\n  }\n\n  /**\n   * In raw destination.\n   *\n   * ```markdown\n   * > | aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function raw(code) {\n    if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) {\n      effects.exit(\"chunkString\");\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n    if (balance < limit && code === 40) {\n      effects.consume(code);\n      balance++;\n      return raw;\n    }\n    if (code === 41) {\n      effects.consume(code);\n      balance--;\n      return raw;\n    }\n\n    // ASCII control (but *not* `\\0`) and space and `(`.\n    // Note: in `markdown-rs`, `\\0` exists in codes, in `micromark-js` it\n    // doesn’t.\n    if (code === null || code === 32 || code === 40 || asciiControl(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return code === 92 ? rawEscape : raw;\n  }\n\n  /**\n   * After `\\`, at special character.\n   *\n   * ```markdown\n   * > | a\\*a\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function rawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return raw;\n    }\n    return raw(code);\n  }\n}","/**\n * @import {\n *   Effects,\n *   State,\n *   TokenizeContext,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse labels.\n *\n * > 👉 **Note**: labels in markdown are capped at 999 characters in the string.\n *\n * ###### Examples\n *\n * ```markdown\n * [a]\n * [a\n * b]\n * [a\\]b]\n * ```\n *\n * @this {TokenizeContext}\n *   Tokenize context.\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole label (`[a]`).\n * @param {TokenType} markerType\n *   Type for the markers (`[` and `]`).\n * @param {TokenType} stringType\n *   Type for the identifier (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /**\n   * Start of label.\n   *\n   * ```markdown\n   * > | [a]\n   *     ^\n   * ```\n   *\n   * @type {State}\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  /**\n   * In label, at something, before something else.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (size > 999 || code === null || code === 91 || code === 93 && !seen ||\n    // To do: remove in the future once we’ve switched from\n    // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n    // which doesn’t need this.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs) {\n      return nok(code);\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    // To do: indent? Link chunks and EOLs together?\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return atBreak;\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return labelInside(code);\n  }\n\n  /**\n   * In label, in text.\n   *\n   * ```markdown\n   * > | [a]\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    if (!seen) seen = !markdownSpace(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | [a\\*a]\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Effects,\n *   State,\n *   TokenType\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * Parse titles.\n *\n * ###### Examples\n *\n * ```markdown\n * \"a\"\n * 'b'\n * (c)\n * \"a\n * b\"\n * 'a\n *     b'\n * (a\\)b)\n * ```\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @param {State} nok\n *   State switched to when unsuccessful.\n * @param {TokenType} type\n *   Type of the whole title (`\"a\"`, `'b'`, `(c)`).\n * @param {TokenType} markerType\n *   Type for the markers (`\"`, `'`, `(`, and `)`).\n * @param {TokenType} stringType\n *   Type for the value (`a`).\n * @returns {State}\n *   Start state.\n */\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of title.\n   *\n   * ```markdown\n   * > | \"a\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      effects.enter(type);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      marker = code === 40 ? 41 : code;\n      return begin;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After opening marker.\n   *\n   * This is also used at the closing marker.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function begin(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    effects.enter(stringType);\n    return atBreak(code);\n  }\n\n  /**\n   * At something, before something else.\n   *\n   * ```markdown\n   * > | \"a\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return begin(marker);\n    }\n    if (code === null) {\n      return nok(code);\n    }\n\n    // Note: blank lines can’t exist in content.\n    if (markdownLineEnding(code)) {\n      // To do: use `space_or_tab_eol_with_options`, connect.\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return factorySpace(effects, atBreak, \"linePrefix\");\n    }\n    effects.enter(\"chunkString\", {\n      contentType: \"string\"\n    });\n    return inside(code);\n  }\n\n  /**\n   *\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit(\"chunkString\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? escape : inside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * ```markdown\n   * > | \"a\\*b\"\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function escape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return inside;\n    }\n    return inside(code);\n  }\n}","/**\n * @import {Effects, State} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * Parse spaces and tabs.\n *\n * There is no `nok` parameter:\n *\n * *   line endings or spaces in markdown are often optional, in which case this\n *     factory can be used and `ok` will be switched to whether spaces were found\n *     or not\n * *   one line ending or space can be detected with\n *     `markdownLineEndingOrSpace(code)` right before using `factoryWhitespace`\n *\n * @param {Effects} effects\n *   Context.\n * @param {State} ok\n *   State switched to when successful.\n * @returns {State}\n *   Start state.\n */\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n\n  /** @type {State} */\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    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? \"linePrefix\" : \"lineSuffix\")(code);\n    }\n    return ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\n/** @type {Construct} */\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n\n/** @type {Construct} */\nconst titleBefore = {\n  partial: true,\n  tokenize: tokenizeTitleBefore\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n  let identifier;\n  return start;\n\n  /**\n   * At start of a definition.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Do not interrupt paragraphs (but do follow definitions).\n    // To do: do `interrupt` the way `markdown-rs` does.\n    // To do: parse whitespace the way `markdown-rs` does.\n    effects.enter(\"definition\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `[`.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    // To do: parse whitespace the way `markdown-rs` does.\n\n    return factoryLabel.call(self, effects, labelAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionLabel\", \"definitionLabelMarker\", \"definitionLabelString\")(code);\n  }\n\n  /**\n   * After label.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n    if (code === 58) {\n      effects.enter(\"definitionMarker\");\n      effects.consume(code);\n      effects.exit(\"definitionMarker\");\n      return markerAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After marker.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function markerAfter(code) {\n    // Note: whitespace is optional.\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code);\n  }\n\n  /**\n   * Before destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationBefore(code) {\n    return factoryDestination(effects, destinationAfter,\n    // Note: we don’t need to reset the way `markdown-rs` does.\n    nok, \"definitionDestination\", \"definitionDestinationLiteral\", \"definitionDestinationLiteralMarker\", \"definitionDestinationRaw\", \"definitionDestinationString\")(code);\n  }\n\n  /**\n   * After destination.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function destinationAfter(code) {\n    return effects.attempt(titleBefore, after, after)(code);\n  }\n\n  /**\n   * After definition.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return markdownSpace(code) ? factorySpace(effects, afterWhitespace, \"whitespace\")(code) : afterWhitespace(code);\n  }\n\n  /**\n   * After definition, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterWhitespace(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"definition\");\n\n      // Note: we don’t care about uniqueness.\n      // It’s likely that that doesn’t happen very frequently.\n      // It is more likely that it wastes precious time.\n      self.parser.defined.push(identifier);\n\n      // To do: `markdown-rs` interrupt.\n      // // You’d be interrupting.\n      // tokenizer.interrupt = true\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeTitleBefore(effects, ok, nok) {\n  return titleBefore;\n\n  /**\n   * After destination, at whitespace.\n   *\n   * ```markdown\n   * > | [a]: b\n   *           ^\n   * > | [a]: b \"c\"\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code);\n  }\n\n  /**\n   * At title.\n   *\n   * ```markdown\n   *   | [a]: b\n   * > | \"c\"\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function beforeMarker(code) {\n    return factoryTitle(effects, titleAfter, nok, \"definitionTitle\", \"definitionTitleMarker\", \"definitionTitleString\")(code);\n  }\n\n  /**\n   * After title.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfter(code) {\n    return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, \"whitespace\")(code) : titleAfterOptionalWhitespace(code);\n  }\n\n  /**\n   * After title, after optional whitespace.\n   *\n   * ```markdown\n   * > | [a]: b \"c\"\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function titleAfterOptionalWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n\n  /**\n   * Start of a hard break (escape).\n   *\n   * ```markdown\n   * > | a\\\n   *      ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"hardBreakEscape\");\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After `\\`, at eol.\n   *\n   * ```markdown\n   * > | a\\\n   *       ^\n   *   | b\n   * ```\n   *\n   *  @type {State}\n   */\n  function after(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit(\"hardBreakEscape\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\nexport const headingAtx = {\n  name: 'headingAtx',\n  resolve: resolveHeadingAtx,\n  tokenize: tokenizeHeadingAtx\n};\n\n/** @type {Resolver} */\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n  let content;\n  /** @type {Token} */\n  let text;\n\n  // Prefix whitespace, part of the opening.\n  if (events[contentStart][1].type === \"whitespace\") {\n    contentStart += 2;\n  }\n\n  // Suffix whitespace, part of the closing.\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === \"whitespace\") {\n    contentEnd -= 2;\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  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    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  let size = 0;\n  return start;\n\n  /**\n   * Start of a heading (atx).\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    effects.enter(\"atxHeading\");\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at `#`.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"atxHeadingSequence\");\n    return sequenceOpen(code);\n  }\n\n  /**\n   * In opening sequence.\n   *\n   * ```markdown\n   * > | ## aa\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceOpen(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return sequenceOpen;\n    }\n\n    // Always at least one `#`.\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingSequence\");\n      return atBreak(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ## aa\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === 35) {\n      effects.enter(\"atxHeadingSequence\");\n      return sequenceFurther(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"atxHeading\");\n      // To do: interrupt like `markdown-rs`.\n      // // Feel free to interrupt.\n      // tokenizer.interrupt = false\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, \"whitespace\")(code);\n    }\n\n    // To do: generate `data` tokens, add the `text` token later.\n    // Needs edit map, see: `markdown.rs`.\n    effects.enter(\"atxHeadingText\");\n    return data(code);\n  }\n\n  /**\n   * In further sequence (after whitespace).\n   *\n   * Could be normal “visible” hashes in the heading or a final sequence.\n   *\n   * ```markdown\n   * > | ## aa ##\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequenceFurther(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequenceFurther;\n    }\n    effects.exit(\"atxHeadingSequence\");\n    return atBreak(code);\n  }\n\n  /**\n   * In text.\n   *\n   * ```markdown\n   * > | ## aa\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"atxHeadingText\");\n      return atBreak(code);\n    }\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * List of lowercase HTML “block” tag names.\n *\n * The list, when parsing HTML (flow), results in more relaxed rules (condition\n * 6).\n * Because they are known blocks, the HTML-like syntax doesn’t have to be\n * strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `search` was added in `CommonMark@0.31`.\n */\nexport const htmlBlockNames = [\n  'address',\n  'article',\n  'aside',\n  'base',\n  'basefont',\n  'blockquote',\n  'body',\n  'caption',\n  'center',\n  'col',\n  'colgroup',\n  'dd',\n  'details',\n  'dialog',\n  'dir',\n  'div',\n  'dl',\n  'dt',\n  'fieldset',\n  'figcaption',\n  'figure',\n  'footer',\n  'form',\n  'frame',\n  'frameset',\n  'h1',\n  'h2',\n  'h3',\n  'h4',\n  'h5',\n  'h6',\n  'head',\n  'header',\n  'hr',\n  'html',\n  'iframe',\n  'legend',\n  'li',\n  'link',\n  'main',\n  'menu',\n  'menuitem',\n  'nav',\n  'noframes',\n  'ol',\n  'optgroup',\n  'option',\n  'p',\n  'param',\n  'search',\n  'section',\n  'summary',\n  'table',\n  'tbody',\n  'td',\n  'tfoot',\n  'th',\n  'thead',\n  'title',\n  'tr',\n  'track',\n  'ul'\n]\n\n/**\n * List of lowercase HTML “raw” tag names.\n *\n * The list, when parsing HTML (flow), results in HTML that can include lines\n * without exiting, until a closing tag also in this list is found (condition\n * 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * > 👉 **Note**: `textarea` was added in `CommonMark@0.30`.\n */\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea']\n","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n\n/** @type {Construct} */\nexport const htmlFlow = {\n  concrete: true,\n  name: 'htmlFlow',\n  resolveTo: resolveToHtmlFlow,\n  tokenize: tokenizeHtmlFlow\n};\n\n/** @type {Construct} */\nconst blankLineBefore = {\n  partial: true,\n  tokenize: tokenizeBlankLineBefore\n};\nconst nonLazyContinuationStart = {\n  partial: true,\n  tokenize: tokenizeNonLazyContinuationStart\n};\n\n/** @type {Resolver} */\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === \"htmlFlow\") {\n      break;\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;\n    // Add the prefix start to the HTML line token.\n    events[index + 1][1].start = events[index - 2][1].start;\n    // Remove the line prefix.\n    events.splice(index - 2, 2);\n  }\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n  let marker;\n  /** @type {boolean} */\n  let closingTag;\n  /** @type {string} */\n  let buffer;\n  /** @type {number} */\n  let index;\n  /** @type {Code} */\n  let markerB;\n  return start;\n\n  /**\n   * Start of HTML (flow).\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * At `<`, after optional whitespace.\n   *\n   * ```markdown\n   * > | <x />\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"htmlFlow\");\n    effects.enter(\"htmlFlowData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | <x />\n   *      ^\n   * > | <!doctype>\n   *      ^\n   * > | <!--xxx-->\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      closingTag = true;\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      marker = 3;\n      // To do:\n      // tokenizer.concrete = true\n      // To do: use `markdown-rs` style interrupt.\n      // 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      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *       ^\n   * > | <!--xxx-->\n   *       ^\n   * > | <![CDATA[>&<]]>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      marker = 2;\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      marker = 5;\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      marker = 4;\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!-`, inside a comment, at another `-`.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<![`, inside CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *        ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      if (index === value.length) {\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok : continuation;\n      }\n      return cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | </x>\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      // Always the case.\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In tag name.\n   *\n   * ```markdown\n   * > | <ab>\n   *      ^^\n   * > | </ab>\n   *       ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      const slash = code === 47;\n      const name = buffer.toLowerCase();\n      if (!slash && !closingTag && htmlRawNames.includes(name)) {\n        marker = 1;\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        marker = 6;\n        if (slash) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        // // Do not form containers.\n        // tokenizer.concrete = true\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n      marker = 7;\n      // Do not support complete HTML when interrupting.\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code);\n    }\n\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a basic tag name.\n   *\n   * ```markdown\n   * > | <div/>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return self.interrupt ? ok : continuation;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After closing slash of a complete tag name.\n   *\n   * ```markdown\n   * > | <x/>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * At an attribute name.\n   *\n   * At first, this state is used after a complete tag name, after whitespace,\n   * where it expects optional attributes or the end of the tag.\n   * It is also reused after attributes, when expecting more optional\n   * attributes.\n   *\n   * ```markdown\n   * > | <a />\n   *        ^\n   * > | <a :b>\n   *        ^\n   * > | <a _b>\n   *        ^\n   * > | <a b>\n   *        ^\n   * > | <a >\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    // ASCII alphanumerical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n    return completeEnd(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | <a :b>\n   *         ^\n   * > | <a _b>\n   *         ^\n   * > | <a b>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeName(code) {\n    // ASCII alphanumerical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n    return completeAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, at an optional initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b>\n   *         ^\n   * > | <a b=c>\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n    return completeAttributeNameBefore(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * > | <a b=\"c\">\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      markerB = code;\n      return completeAttributeValueQuoted;\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n    return completeAttributeValueUnquoted(code);\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *           ^\n   * > | <a b='c'>\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuoted(code) {\n    if (code === markerB) {\n      effects.consume(code);\n      markerB = null;\n      return completeAttributeValueQuotedAfter;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | <a b=c>\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the\n   * end of the tag.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a complete tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | <a b=\"c\">\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `>` in a complete tag.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function completeAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      // // Do not form containers.\n      // tokenizer.concrete = true\n      return continuation(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In continuation of any HTML kind.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuation(code) {\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n    if (code === 60 && marker === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n    if (code === 62 && marker === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n    if (code === 63 && marker === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    if (code === 93 && marker === 5) {\n      effects.consume(code);\n      return continuationCdataInside;\n    }\n    if (markdownLineEnding(code) && (marker === 6 || marker === 7)) {\n      effects.exit(\"htmlFlowData\");\n      return effects.check(blankLineBefore, continuationAfter, continuationStart)(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationStart(code);\n    }\n    effects.consume(code);\n    return continuation;\n  }\n\n  /**\n   * In continuation, at eol.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStart(code) {\n    return effects.check(nonLazyContinuationStart, continuationStartNonLazy, continuationAfter)(code);\n  }\n\n  /**\n   * In continuation, at eol, before non-lazy content.\n   *\n   * ```markdown\n   * > | <x>\n   *        ^\n   *   | asd\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationStartNonLazy(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return continuationBefore;\n  }\n\n  /**\n   * In continuation, before non-lazy content.\n   *\n   * ```markdown\n   *   | <x>\n   * > | asd\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationBefore(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return continuationStart(code);\n    }\n    effects.enter(\"htmlFlowData\");\n    return continuation(code);\n  }\n\n  /**\n   * In comment continuation, after one `-`, expecting another.\n   *\n   * ```markdown\n   * > | <!--xxx-->\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `<`, at `/`.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In raw continuation, after `</`, in a raw tag name.\n   *\n   * ```markdown\n   * > | <script>console.log(1)</script>\n   *                             ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationRawEndTag(code) {\n    if (code === 62) {\n      const name = buffer.toLowerCase();\n      if (htmlRawNames.includes(name)) {\n        effects.consume(code);\n        return continuationClose;\n      }\n      return continuation(code);\n    }\n    if (asciiAlpha(code) && buffer.length < 8) {\n      // Always the case.\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In cdata continuation, after `]`, expecting `]>`.\n   *\n   * ```markdown\n   * > | <![CDATA[>&<]]>\n   *                  ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationCdataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In declaration or instruction continuation, at `>`.\n   *\n   * ```markdown\n   * > | <!-->\n   *         ^\n   * > | <?>\n   *       ^\n   * > | <!q>\n   *        ^\n   * > | <!--ab-->\n   *             ^\n   * > | <![CDATA[>&<]]>\n   *                   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    // More dashes.\n    if (code === 45 && marker === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n    return continuation(code);\n  }\n\n  /**\n   * In closed continuation: everything we get until the eol/eof is part of it.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"htmlFlowData\");\n      return continuationAfter(code);\n    }\n    effects.consume(code);\n    return continuationClose;\n  }\n\n  /**\n   * Done.\n   *\n   * ```markdown\n   * > | <!doctype>\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function continuationAfter(code) {\n    effects.exit(\"htmlFlow\");\n    // // Feel free to interrupt.\n    // tokenizer.interrupt = false\n    // // No longer concrete.\n    // tokenizer.concrete = false\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeNonLazyContinuationStart(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * At eol, before continuation.\n   *\n   * ```markdown\n   * > | * ```js\n   *            ^\n   *   | b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter(\"lineEnding\");\n      effects.consume(code);\n      effects.exit(\"lineEnding\");\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * A continuation.\n   *\n   * ```markdown\n   *   | * ```js\n   * > | b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeBlankLineBefore(effects, ok, nok) {\n  return start;\n\n  /**\n   * Before eol, expecting blank line.\n   *\n   * ```markdown\n   * > | <div>\n   *          ^\n   *   |\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlphanumeric, asciiAlpha, markdownLineEndingOrSpace, markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code> | undefined} */\n  let marker;\n  /** @type {number} */\n  let index;\n  /** @type {State} */\n  let returnState;\n  return start;\n\n  /**\n   * Start of HTML (text).\n   *\n   * ```markdown\n   * > | a <b> c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"htmlText\");\n    effects.enter(\"htmlTextData\");\n    effects.consume(code);\n    return open;\n  }\n\n  /**\n   * After `<`, at tag name or other stuff.\n   *\n   * ```markdown\n   * > | a <b> c\n   *        ^\n   * > | a <!doctype> c\n   *        ^\n   * > | a <!--b--> c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `<!`, at declaration, comment, or CDATA.\n   *\n   * ```markdown\n   * > | a <!doctype> c\n   *         ^\n   * > | a <!--b--> c\n   *         ^\n   * > | a <![CDATA[>&<]]> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpenInside;\n    }\n    if (code === 91) {\n      effects.consume(code);\n      index = 0;\n      return cdataOpenInside;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In a comment, after `<!-`, at another `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In comment.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return comment;\n  }\n\n  /**\n   * In comment, after `-`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentEnd;\n    }\n    return comment(code);\n  }\n\n  /**\n   * In comment, after `--`.\n   *\n   * ```markdown\n   * > | a <!--b--> c\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function commentEnd(code) {\n    return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code);\n  }\n\n  /**\n   * After `<![`, in CDATA, expecting `CDATA[`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *          ^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataOpenInside(code) {\n    const value = \"CDATA[\";\n    if (code === value.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === value.length ? cdata : cdataOpenInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In CDATA.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                ^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return cdata;\n  }\n\n  /**\n   * In CDATA, after `]`, at another `]`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In CDATA, after `]]`, at `>`.\n   *\n   * ```markdown\n   * > | a <![CDATA[>&<]]> b\n   *                     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n    return cdata(code);\n  }\n\n  /**\n   * In declaration.\n   *\n   * ```markdown\n   * > | a <!b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return declaration;\n  }\n\n  /**\n   * In instruction.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return instruction;\n  }\n\n  /**\n   * In instruction, after `?`, at `>`.\n   *\n   * ```markdown\n   * > | a <?b?> c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n\n  /**\n   * After `</`, in closing tag, at tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseStart(code) {\n    // ASCII alphabetical.\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After `</x`, in a tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagClose(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n    return tagCloseBetween(code);\n  }\n\n  /**\n   * In closing tag, after tag name.\n   *\n   * ```markdown\n   * > | a </b> c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * After `<x`, in opening tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpen(code) {\n    // ASCII alphanumerical and `-`.\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In opening tag, after tag name.\n   *\n   * ```markdown\n   * > | a <b> c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    // ASCII alphabetical and `:` and `_`.\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n    return end(code);\n  }\n\n  /**\n   * In attribute name.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeName(code) {\n    // ASCII alphabetical and `-`, `.`, `:`, and `_`.\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n    return tagOpenAttributeNameAfter(code);\n  }\n\n  /**\n   * After attribute name, before initializer, the end of the tag, or\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c> d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n    return tagOpenBetween(code);\n  }\n\n  /**\n   * Before unquoted, double quoted, or single quoted attribute value, allowing\n   * whitespace.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return lineEndingBefore(code);\n    }\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * In double or single quoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      marker = undefined;\n      return tagOpenAttributeValueQuotedAfter;\n    }\n    if (code === null) {\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return lineEndingBefore(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n\n  /**\n   * In unquoted attribute value.\n   *\n   * ```markdown\n   * > | a <b c=d> e\n   *            ^\n   * ```\n   *\n   * @type {State}\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    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  }\n\n  /**\n   * After double or single quoted attribute value, before whitespace or the end\n   * of the tag.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In certain circumstances of a tag where only an `>` is allowed.\n   *\n   * ```markdown\n   * > | a <b c=\"d\"> e\n   *               ^\n   * ```\n   *\n   * @type {State}\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    return nok(code);\n  }\n\n  /**\n   * At eol.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   * > | a <!--a\n   *            ^\n   *   | b-->\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingBefore(code) {\n    effects.exit(\"htmlTextData\");\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    return lineEndingAfter;\n  }\n\n  /**\n   * After eol, at optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfter(code) {\n    // Always populated by defaults.\n\n    return markdownSpace(code) ? factorySpace(effects, lineEndingAfterPrefix, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : lineEndingAfterPrefix(code);\n  }\n\n  /**\n   * After eol, after optional whitespace.\n   *\n   * > 👉 **Note**: we can’t have blank lines in text, so no need to worry about\n   * > empty tokens.\n   *\n   * ```markdown\n   *   | a <!--a\n   * > | b-->\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function lineEndingAfterPrefix(code) {\n    effects.enter(\"htmlTextData\");\n    return returnState(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   Event,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer,\n *   Token\n * } from 'micromark-util-types'\n */\n\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\nexport const labelEnd = {\n  name: 'labelEnd',\n  resolveAll: resolveAllLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  tokenize: tokenizeLabelEnd\n};\n\n/** @type {Construct} */\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\nconst referenceFullConstruct = {\n  tokenize: tokenizeReferenceFull\n};\n/** @type {Construct} */\nconst referenceCollapsedConstruct = {\n  tokenize: tokenizeReferenceCollapsed\n};\n\n/** @type {Resolver} */\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Array<Event>} */\n  const newEvents = [];\n  while (++index < events.length) {\n    const token = events[index][1];\n    newEvents.push(events[index]);\n    if (token.type === \"labelImage\" || token.type === \"labelLink\" || token.type === \"labelEnd\") {\n      // Remove the marker.\n      const offset = token.type === \"labelImage\" ? 4 : 2;\n      token.type = \"data\";\n      index += offset;\n    }\n  }\n\n  // If the events are equal, we don't have to copy newEvents to events\n  if (events.length !== newEvents.length) {\n    splice(events, 0, events.length, newEvents);\n  }\n  return events;\n}\n\n/** @type {Resolver} */\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n  let token;\n  /** @type {number | undefined} */\n  let open;\n  /** @type {number | undefined} */\n  let close;\n  /** @type {Array<Event>} */\n  let media;\n\n  // Find an opening.\n  while (index--) {\n    token = events[index][1];\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      }\n\n      // Mark other link openings as inactive, as we can’t have links in\n      // links.\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        if (token.type !== \"labelLink\") {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === \"labelEnd\") {\n      close = index;\n    }\n  }\n  const group = {\n    type: events[open][1].type === \"labelLink\" ? \"link\" : \"image\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n  const label = {\n    type: \"label\",\n    start: {\n      ...events[open][1].start\n    },\n    end: {\n      ...events[close][1].end\n    }\n  };\n  const text = {\n    type: \"labelText\",\n    start: {\n      ...events[open + offset + 2][1].end\n    },\n    end: {\n      ...events[close - 2][1].start\n    }\n  };\n  media = [['enter', group, context], ['enter', label, context]];\n\n  // Opening marker.\n  media = push(media, events.slice(open + 1, open + offset + 3));\n\n  // Text open.\n  media = push(media, [['enter', text, context]]);\n\n  // Always populated by defaults.\n\n  // Between.\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context));\n\n  // Text close, marker close, label close.\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]);\n\n  // Reference, resource, or so.\n  media = push(media, events.slice(close + 1));\n\n  // Media close.\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n  let labelStart;\n  /** @type {boolean} */\n  let defined;\n\n  // Find an opening.\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  return start;\n\n  /**\n   * Start of label end.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // If there is not an okay opening.\n    if (!labelStart) {\n      return nok(code);\n    }\n\n    // If the corresponding label (link) start is marked as inactive,\n    // it means we’d be wrapping a link, like this:\n    //\n    // ```markdown\n    // > | a [b [c](d) e](f) g.\n    //                  ^\n    // ```\n    //\n    // We can’t have that, so it’s just balanced brackets.\n    if (labelStart._inactive) {\n      return labelEndNok(code);\n    }\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter(\"labelEnd\");\n    effects.enter(\"labelMarker\");\n    effects.consume(code);\n    effects.exit(\"labelMarker\");\n    effects.exit(\"labelEnd\");\n    return after;\n  }\n\n  /**\n   * After `]`.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *       ^\n   * > | [a][b] c\n   *       ^\n   * > | [a][] b\n   *       ^\n   * > | [a] b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in\n    // an extension.\n\n    // Resource (`[asd](fgh)`)?\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, labelEndOk, defined ? labelEndOk : labelEndNok)(code);\n    }\n\n    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?\n    if (code === 91) {\n      return effects.attempt(referenceFullConstruct, labelEndOk, defined ? referenceNotFull : labelEndNok)(code);\n    }\n\n    // Shortcut (`[asd]`) reference?\n    return defined ? labelEndOk(code) : labelEndNok(code);\n  }\n\n  /**\n   * After `]`, at `[`, but not at a full reference.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] b\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceNotFull(code) {\n    return effects.attempt(referenceCollapsedConstruct, labelEndOk, labelEndNok)(code);\n  }\n\n  /**\n   * Done, we found something.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *           ^\n   * > | [a][b] c\n   *           ^\n   * > | [a][] b\n   *          ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndOk(code) {\n    // Note: `markdown-rs` does a bunch of stuff here.\n    return ok(code);\n  }\n\n  /**\n   * Done, it’s nothing.\n   *\n   * There was an okay opening, but we didn’t match anything.\n   *\n   * ```markdown\n   * > | [a](b c\n   *        ^\n   * > | [a][b c\n   *        ^\n   * > | [a] b\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEndNok(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeResource(effects, ok, nok) {\n  return resourceStart;\n\n  /**\n   * At a resource.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceStart(code) {\n    effects.enter(\"resource\");\n    effects.enter(\"resourceMarker\");\n    effects.consume(code);\n    effects.exit(\"resourceMarker\");\n    return resourceBefore;\n  }\n\n  /**\n   * In resource, after `(`, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBefore(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code);\n  }\n\n  /**\n   * In resource, after optional whitespace, at `)` or a destination.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceOpen(code) {\n    if (code === 41) {\n      return resourceEnd(code);\n    }\n    return factoryDestination(effects, resourceDestinationAfter, resourceDestinationMissing, \"resourceDestination\", \"resourceDestinationLiteral\", \"resourceDestinationLiteralMarker\", \"resourceDestinationRaw\", \"resourceDestinationString\", 32)(code);\n  }\n\n  /**\n   * In resource, after destination, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b) c\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code);\n  }\n\n  /**\n   * At invalid destination.\n   *\n   * ```markdown\n   * > | [a](<<) b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceDestinationMissing(code) {\n    return nok(code);\n  }\n\n  /**\n   * In resource, after destination and whitespace, at `(` or title.\n   *\n   * ```markdown\n   * > | [a](b ) c\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceBetween(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, resourceTitleAfter, nok, \"resourceTitle\", \"resourceTitleMarker\", \"resourceTitleString\")(code);\n    }\n    return resourceEnd(code);\n  }\n\n  /**\n   * In resource, after title, at optional whitespace.\n   *\n   * ```markdown\n   * > | [a](b \"c\") d\n   *              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceTitleAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code);\n  }\n\n  /**\n   * In resource, at `)`.\n   *\n   * ```markdown\n   * > | [a](b) d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function resourceEnd(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    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceFull(effects, ok, nok) {\n  const self = this;\n  return referenceFull;\n\n  /**\n   * In a reference (full), at the `[`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFull(code) {\n    return factoryLabel.call(self, effects, referenceFullAfter, referenceFullMissing, \"reference\", \"referenceMarker\", \"referenceString\")(code);\n  }\n\n  /**\n   * In a reference (full), after `]`.\n   *\n   * ```markdown\n   * > | [a][b] d\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullAfter(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n\n  /**\n   * In reference (full) that was missing.\n   *\n   * ```markdown\n   * > | [a][b d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceFullMissing(code) {\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeReferenceCollapsed(effects, ok, nok) {\n  return referenceCollapsedStart;\n\n  /**\n   * In reference (collapsed), at `[`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function referenceCollapsedStart(code) {\n    // We only attempt a collapsed label if there’s a `[`.\n\n    effects.enter(\"reference\");\n    effects.enter(\"referenceMarker\");\n    effects.consume(code);\n    effects.exit(\"referenceMarker\");\n    return referenceCollapsedOpen;\n  }\n\n  /**\n   * In reference (collapsed), at `]`.\n   *\n   * > 👉 **Note**: we only get here if the label is defined.\n   *\n   * ```markdown\n   * > | [a][] d\n   *         ^\n   * ```\n   *\n   *  @type {State}\n   */\n  function referenceCollapsedOpen(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    return nok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartImage\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (image) start.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\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  /**\n   * After `!`, at `[`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\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    return nok(code);\n  }\n\n  /**\n   * After `![`.\n   *\n   * ```markdown\n   * > | a ![b] c\n   *         ^\n   * ```\n   *\n   * This is needed in because, when GFM footnotes are enabled, images never\n   * form when started with a `^`.\n   * Instead, links form:\n   *\n   * ```markdown\n   * ![^a](b)\n   *\n   * ![^a][b]\n   *\n   * [b]: c\n   * ```\n   *\n   * ```html\n   * <p>!<a href=\\\"b\\\">^a</a></p>\n   * <p>!<a href=\\\"c\\\">^a</a></p>\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // To do: use a new field to do this, this is still needed for\n    // `micromark-extension-gfm-footnote`, but the `label-start-link`\n    // behavior isn’t.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { labelEnd } from './label-end.js';\n\n/** @type {Construct} */\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  resolveAll: labelEnd.resolveAll,\n  tokenize: tokenizeLabelStartLink\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n\n  /**\n   * Start of label (link) start.\n   *\n   * ```markdown\n   * > | a [b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\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  /** @type {State} */\n  function after(code) {\n    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,\n    // remove.\n    // Hidden footnotes hook.\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @import {\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n\n  /** @type {State} */\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 * @import {\n *   Code,\n *   Construct,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * Start of thematic break.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter(\"thematicBreak\");\n    // To do: parse indent like `markdown-rs`.\n    return before(code);\n  }\n\n  /**\n   * After optional whitespace, at marker.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    marker = code;\n    return atBreak(code);\n  }\n\n  /**\n   * After something, before something else.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter(\"thematicBreakSequence\");\n      return sequence(code);\n    }\n    if (size >= 3 && (code === null || markdownLineEnding(code))) {\n      effects.exit(\"thematicBreak\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   * > | ***\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n    effects.exit(\"thematicBreakSequence\");\n    return markdownSpace(code) ? factorySpace(effects, atBreak, \"whitespace\")(code) : atBreak(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Exiter,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n\n/** @type {Construct} */\nexport const list = {\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd,\n  name: 'list',\n  tokenize: tokenizeListStart\n};\n\n/** @type {Construct} */\nconst listItemPrefixWhitespaceConstruct = {\n  partial: true,\n  tokenize: tokenizeListItemPrefixWhitespace\n};\n\n/** @type {Construct} */\nconst indentConstruct = {\n  partial: true,\n  tokenize: tokenizeIndent\n};\n\n// To do: `markdown-rs` parses list items on their own and later stitches them\n// together.\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === \"linePrefix\" ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n\n  /** @type {State} */\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? \"listUnordered\" : \"listOrdered\");\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      if (kind === \"listUnordered\") {\n        effects.enter(\"listItemPrefix\");\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n      if (!self.interrupt || code === 49) {\n        effects.enter(\"listItemPrefix\");\n        effects.enter(\"listItemValue\");\n        return inside(code);\n      }\n    }\n    return nok(code);\n  }\n\n  /** @type {State} */\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\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    return nok(code);\n  }\n\n  /**\n   * @type {State}\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(blankLine,\n    // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n\n  /** @type {State} */\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    return nok(code);\n  }\n\n  /** @type {State} */\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit(\"listItemPrefix\"), true).length;\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n\n  /** @type {State} */\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine;\n\n    // We have a blank line.\n    // Still, try to consume at most the items size.\n    return factorySpace(effects, ok, \"listItemIndent\", self.containerState.size + 1)(code);\n  }\n\n  /** @type {State} */\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n\n  /** @type {State} */\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true;\n    // As we’re closing flow, we’re no longer interrupting.\n    self.interrupt = undefined;\n    // Always populated by defaults.\n\n    return factorySpace(effects, effects.attempt(list, ok, nok), \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, \"listItemIndent\", self.containerState.size + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === \"listItemIndent\" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Exiter}\n */\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n\n  // Always populated by defaults.\n\n  return factorySpace(effects, afterPrefix, \"listItemPrefixWhitespace\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n\n  /** @type {State} */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === \"listItemPrefixWhitespace\" ? ok(code) : nok(code);\n  }\n}","/**\n * @import {\n *   Code,\n *   Construct,\n *   Resolver,\n *   State,\n *   TokenizeContext,\n *   Tokenizer\n * } from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  resolveTo: resolveToSetextUnderline,\n  tokenize: tokenizeSetextUnderline\n};\n\n/** @type {Resolver} */\nfunction resolveToSetextUnderline(events, context) {\n  // To do: resolve like `markdown-rs`.\n  let index = events.length;\n  /** @type {number | undefined} */\n  let content;\n  /** @type {number | undefined} */\n  let text;\n  /** @type {number | undefined} */\n  let definition;\n\n  // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === \"content\") {\n        content = index;\n        break;\n      }\n      if (events[index][1].type === \"paragraph\") {\n        text = index;\n      }\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      if (!definition && events[index][1].type === \"definition\") {\n        definition = index;\n      }\n    }\n  }\n  const heading = {\n    type: \"setextHeading\",\n    start: {\n      ...events[content][1].start\n    },\n    end: {\n      ...events[events.length - 1][1].end\n    }\n  };\n\n  // Change the paragraph to setext heading text.\n  events[text][1].type = \"setextHeadingText\";\n\n  // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\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 = {\n      ...events[definition][1].end\n    };\n  } else {\n    events[content][1] = heading;\n  }\n\n  // Add the heading exit at the end.\n  events.push(['exit', heading, context]);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n *   Context.\n * @type {Tokenizer}\n */\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n\n  /**\n   * At start of heading (setext) underline.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length;\n    /** @type {boolean | undefined} */\n    let paragraph;\n    // Find an opening.\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    // To do: handle lazy/pierce like `markdown-rs`.\n    // To do: parse indent like `markdown-rs`.\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter(\"setextHeadingLine\");\n      marker = code;\n      return before(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * After optional whitespace, at `-` or `=`.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function before(code) {\n    effects.enter(\"setextHeadingLineSequence\");\n    return inside(code);\n  }\n\n  /**\n   * In sequence.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return inside;\n    }\n    effects.exit(\"setextHeadingLineSequence\");\n    return markdownSpace(code) ? factorySpace(effects, after, \"lineSuffix\")(code) : after(code);\n  }\n\n  /**\n   * After sequence, after optional whitespace.\n   *\n   * ```markdown\n   *   | aa\n   * > | ==\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit(\"setextHeadingLine\");\n      return ok(code);\n    }\n    return nok(code);\n  }\n}","/**\n * @import {\n *   InitialConstruct,\n *   Initializer,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\nexport const flow = {\n  tokenize: initializeFlow\n};\n\n/**\n * @this {TokenizeContext}\n *   Self.\n * @type {Initializer}\n *   Initializer.\n */\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt(\n  // Try to parse a blank line.\n  blankLine, atBlankEnding,\n  // 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  /** @type {State} */\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEndingBlank\");\n    effects.consume(code);\n    effects.exit(\"lineEndingBlank\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n\n  /** @type {State} */\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n    effects.enter(\"lineEnding\");\n    effects.consume(code);\n    effects.exit(\"lineEnding\");\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}","/**\n * @import {\n *   Code,\n *   InitialConstruct,\n *   Initializer,\n *   Resolver,\n *   State,\n *   TokenizeContext\n * } from 'micromark-util-types'\n */\n\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n\n/**\n * @param {'string' | 'text'} field\n *   Field.\n * @returns {InitialConstruct}\n *   Construct.\n */\nfunction initializeFactory(field) {\n  return {\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),\n    tokenize: initializeText\n  };\n\n  /**\n   * @this {TokenizeContext}\n   *   Context.\n   * @type {Initializer}\n   */\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n\n    /** @type {State} */\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n      effects.enter(\"data\");\n      effects.consume(code);\n      return data;\n    }\n\n    /** @type {State} */\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit(\"data\");\n        return text(code);\n      }\n\n      // Data.\n      effects.consume(code);\n      return data;\n    }\n\n    /**\n     * @param {Code} code\n     *   Code.\n     * @returns {boolean}\n     *   Whether the code is a break.\n     */\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n      const list = constructs[code];\n      let index = -1;\n      if (list) {\n        // Always populated by defaults.\n\n        while (++index < list.length) {\n          const item = list[index];\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n      return false;\n    }\n  }\n}\n\n/**\n * @param {Resolver | undefined} [extraResolver]\n *   Resolver.\n * @returns {Resolver}\n *   Resolver.\n */\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n\n  /** @type {Resolver} */\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number | undefined} */\n    let enter;\n\n    // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\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        enter = undefined;\n      }\n    }\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n\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 * @type {Resolver}\n */\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === \"lineEnding\") && events[eventIndex - 1][1].type === \"data\") {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean | undefined} */\n      let tabs;\n      while (index--) {\n        const chunk = chunks[index];\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        }\n        // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {\n          // Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      // Allow final trailing whitespace.\n      if (context._contentTypeTextTrailing && eventIndex === events.length) {\n        size = 0;\n      }\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? \"lineSuffix\" : \"hardBreakTrailing\",\n          start: {\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,\n            _index: data.start._index + index,\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size\n          },\n          end: {\n            ...data.end\n          }\n        };\n        data.end = {\n          ...token.start\n        };\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n      eventIndex++;\n    }\n  }\n  return events;\n}","/**\n * @import {Extension} from 'micromark-util-types'\n */\n\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n\n/** @satisfies {Extension['document']} */\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n\n/** @satisfies {Extension['contentInitial']} */\nexport const contentInitial = {\n  [91]: definition\n};\n\n/** @satisfies {Extension['flowInitial']} */\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n\n/** @satisfies {Extension['flow']} */\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n\n/** @satisfies {Extension['string']} */\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n\n/** @satisfies {Extension['text']} */\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n\n/** @satisfies {Extension['insideSpan']} */\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n\n/** @satisfies {Extension['attentionMarkers']} */\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n\n/** @satisfies {Extension['disable']} */\nexport const disable = {\n  null: []\n};","/**\n * @import {\n *   Chunk,\n *   Code,\n *   ConstructRecord,\n *   Construct,\n *   Effects,\n *   InitialConstruct,\n *   ParseContext,\n *   Point,\n *   State,\n *   TokenizeContext,\n *   Token\n * } from 'micromark-util-types'\n */\n\n/**\n * @callback Restore\n *   Restore the state.\n * @returns {undefined}\n *   Nothing.\n *\n * @typedef Info\n *   Info.\n * @property {Restore} restore\n *   Restore.\n * @property {number} from\n *   From.\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n *   Construct.\n * @param {Info} info\n *   Info.\n * @returns {undefined}\n *   Nothing.\n */\n\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n *   Parser.\n * @param {InitialConstruct} initialize\n *   Construct.\n * @param {Omit<Point, '_bufferIndex' | '_index'> | undefined} [from]\n *   Point (optional).\n * @returns {TokenizeContext}\n *   Context.\n */\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = {\n    _bufferIndex: -1,\n    _index: 0,\n    line: from && from.line || 1,\n    column: from && from.column || 1,\n    offset: from && from.offset || 0\n  };\n  /** @type {Record<string, number>} */\n  const columnStart = {};\n  /** @type {Array<Construct>} */\n  const resolveAllConstructs = [];\n  /** @type {Array<Chunk>} */\n  let chunks = [];\n  /** @type {Array<Token>} */\n  let stack = [];\n  /** @type {boolean | undefined} */\n  let consumed = true;\n\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n  const effects = {\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    consume,\n    enter,\n    exit,\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n  const context = {\n    code: null,\n    containerState: {},\n    defineSkip,\n    events: [],\n    now,\n    parser,\n    previous: null,\n    sliceSerialize,\n    sliceStream,\n    write\n  };\n\n  /**\n   * The state function.\n   *\n   * @type {State | undefined}\n   */\n  let state = initialize.tokenize.call(context, effects);\n\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n  let expectedCode;\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n  return context;\n\n  /** @type {TokenizeContext['write']} */\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main();\n\n    // Exit if we’re not done, resolve might change stuff.\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n    addResult(initialize, 0);\n\n    // Otherwise, resolve, and exit.\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  }\n\n  //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n\n  /** @type {TokenizeContext['sliceStream']} */\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n\n  /** @type {TokenizeContext['now']} */\n  function now() {\n    // This is a hot path, so we clone manually instead of `Object.assign({}, point)`\n    const {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    } = point;\n    return {\n      _bufferIndex,\n      _index,\n      line,\n      column,\n      offset\n    };\n  }\n\n  /** @type {TokenizeContext['defineSkip']} */\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  }\n\n  //\n  // State management.\n  //\n\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   * @returns {undefined}\n   *   Nothing.\n   */\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index];\n\n      // If we’re in a buffer chunk, loop through it.\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\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  }\n\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   *   Code.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n\n  /** @type {Effects['consume']} */\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    }\n\n    // Not in a string chunk.\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++;\n\n      // At end of string chunk.\n      if (point._bufferIndex ===\n      // Points w/ non-negative `_bufferIndex` reference\n      // strings.\n      /** @type {string} */\n      chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    }\n\n    // Expose the previous character.\n    context.previous = code;\n\n    // Mark as consumed.\n    consumed = true;\n  }\n\n  /** @type {Effects['enter']} */\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const 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  }\n\n  /** @type {Effects['exit']} */\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   *   Callback.\n   * @param {{interrupt?: boolean | undefined} | undefined} [fields]\n   *   Fields.\n   */\n  function constructFactory(onreturn, fields) {\n    return hook;\n\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Array<Construct> | ConstructRecord | Construct} constructs\n     *   Constructs.\n     * @param {State} returnState\n     *   State.\n     * @param {State | undefined} [bogusState]\n     *   State.\n     * @returns {State}\n     *   State.\n     */\n    function hook(constructs, returnState, bogusState) {\n      /** @type {ReadonlyArray<Construct>} */\n      let listOfConstructs;\n      /** @type {number} */\n      let constructIndex;\n      /** @type {Construct} */\n      let currentConstruct;\n      /** @type {Info} */\n      let info;\n      return Array.isArray(constructs) ? /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs ?\n      // Looks like a construct.\n      handleListOfConstructs([(/** @type {Construct} */constructs)]) : handleMapOfConstructs(constructs);\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleMapOfConstructs(map) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          const left = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [\n          // To do: add more extension tests.\n          /* c8 ignore next 2 */\n          ...(Array.isArray(left) ? left : left ? [left] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ReadonlyArray<Construct>} list\n       *   Constructs.\n       * @returns {State}\n       *   State.\n       */\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n        if (list.length === 0) {\n          return bogusState;\n        }\n        return handleConstruct(list[constructIndex]);\n      }\n\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       *   Construct.\n       * @returns {State}\n       *   State.\n       */\n      function handleConstruct(construct) {\n        return start;\n\n        /** @type {State} */\n        function start(code) {\n          // To do: not needed 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          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          // Always populated by defaults.\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n          return construct.tokenize.call(\n          // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n\n      /** @type {State} */\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n\n      /** @type {State} */\n      function nok(code) {\n        consumed = true;\n        info.restore();\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n        return bogusState;\n      }\n    }\n  }\n\n  /**\n   * @param {Construct} construct\n   *   Construct.\n   * @param {number} from\n   *   From.\n   * @returns {undefined}\n   *   Nothing.\n   */\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   *   Info.\n   */\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      from: startEventsIndex,\n      restore\n    };\n\n    /**\n     * Restore state.\n     *\n     * @returns {undefined}\n     *   Nothing.\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  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {undefined}\n   *   Nothing.\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\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {Pick<Token, 'end' | 'start'>} token\n *   Token.\n * @returns {Array<Chunk>}\n *   Chunks.\n */\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Array<Chunk>} */\n  let view;\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n    if (startBufferIndex > -1) {\n      const head = view[0];\n      if (typeof head === 'string') {\n        view[0] = head.slice(startBufferIndex);\n        /* c8 ignore next 4 -- used to be used, no longer */\n      } else {\n        view.shift();\n      }\n    }\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n  return view;\n}\n\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {ReadonlyArray<Chunk>} chunks\n *   Chunks.\n * @param {boolean | undefined} [expandTabs=false]\n *   Whether to expand tabs (default: `false`).\n * @returns {string}\n *   Result.\n */\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {Array<string>} */\n  const result = [];\n  /** @type {boolean | undefined} */\n  let atTab;\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n    let value;\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = \"\\r\";\n          break;\n        }\n      case -4:\n        {\n          value = \"\\n\";\n          break;\n        }\n      case -3:\n        {\n          value = \"\\r\" + \"\\n\";\n          break;\n        }\n      case -2:\n        {\n          value = expandTabs ? \" \" : \"\\t\";\n          break;\n        }\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = \" \";\n          break;\n        }\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n    atTab = chunk === -2;\n    result.push(value);\n  }\n  return result.join('');\n}","/**\n * @import {\n *   Create,\n *   FullNormalizedExtension,\n *   InitialConstruct,\n *   ParseContext,\n *   ParseOptions\n * } from 'micromark-util-types'\n */\n\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { string, text } from './initialize/text.js';\nimport * as defaultConstructs from './constructs.js';\nimport { createTokenizer } from './create-tokenizer.js';\n\n/**\n * @param {ParseOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ParseContext}\n *   Parser.\n */\nexport function parse(options) {\n  const settings = options || {};\n  const constructs = /** @type {FullNormalizedExtension} */\n  combineExtensions([defaultConstructs, ...(settings.extensions || [])]);\n\n  /** @type {ParseContext} */\n  const parser = {\n    constructs,\n    content: create(content),\n    defined: [],\n    document: create(document),\n    flow: create(flow),\n    lazy: {},\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n\n  /**\n   * @param {InitialConstruct} initial\n   *   Construct to start with.\n   * @returns {Create}\n   *   Create a tokenizer.\n   */\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}","/**\n * @import {Event} from 'micromark-util-types'\n */\n\nimport { subtokenize } from 'micromark-util-subtokenize';\n\n/**\n * @param {Array<Event>} events\n *   Events.\n * @returns {Array<Event>}\n *   Events.\n */\nexport function postprocess(events) {\n  while (!subtokenize(events)) {\n    // Empty\n  }\n  return events;\n}","/**\n * @import {Chunk, Code, Encoding, Value} from 'micromark-util-types'\n */\n\n/**\n * @callback Preprocessor\n *   Preprocess a value.\n * @param {Value} value\n *   Value.\n * @param {Encoding | null | undefined} [encoding]\n *   Encoding when `value` is a typed array (optional).\n * @param {boolean | null | undefined} [end=false]\n *   Whether this is the last chunk (default: `false`).\n * @returns {Array<Chunk>}\n *   Chunks.\n */\n\nconst search = /[\\0\\t\\n\\r]/g;\n\n/**\n * @returns {Preprocessor}\n *   Preprocess a value.\n */\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean | undefined} */\n  let start = true;\n  /** @type {boolean | undefined} */\n  let atCarriageReturn;\n  return preprocessor;\n\n  /** @type {Preprocessor} */\n  // eslint-disable-next-line complexity\n  function preprocessor(value, encoding, end) {\n    /** @type {Array<Chunk>} */\n    const chunks = [];\n    /** @type {RegExpMatchArray | null} */\n    let match;\n    /** @type {number} */\n    let next;\n    /** @type {number} */\n    let startPosition;\n    /** @type {number} */\n    let endPosition;\n    /** @type {Code} */\n    let code;\n    value = buffer + (typeof value === 'string' ? value.toString() : new TextDecoder(encoding || undefined).decode(value));\n    startPosition = 0;\n    buffer = '';\n    if (start) {\n      // To do: `markdown-rs` actually parses BOMs (byte order mark).\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n      start = undefined;\n    }\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\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        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n              while (column++ < next) chunks.push(-1);\n              break;\n            }\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n      startPosition = endPosition + 1;\n    }\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n    return chunks;\n  }\n}","import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n\n/**\n * Decode markdown strings (which occur in places such as fenced code info\n * strings, destinations, labels, and titles).\n *\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n *   Value to decode.\n * @returns {string}\n *   Decoded value.\n */\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n\n/**\n * @param {string} $0\n *   Match.\n * @param {string} $1\n *   Character escape.\n * @param {string} $2\n *   Character reference.\n * @returns {string}\n *   Decoded value\n */\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  }\n\n  // Reference.\n  const head = $2.charCodeAt(0);\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n  return decodeNamedCharacterReference($2) || $0;\n}","/**\n * @import {\n *   Break,\n *   Blockquote,\n *   Code,\n *   Definition,\n *   Emphasis,\n *   Heading,\n *   Html,\n *   Image,\n *   InlineCode,\n *   Link,\n *   ListItem,\n *   List,\n *   Nodes,\n *   Paragraph,\n *   PhrasingContent,\n *   ReferenceType,\n *   Root,\n *   Strong,\n *   Text,\n *   ThematicBreak\n * } from 'mdast'\n * @import {\n *   Encoding,\n *   Event,\n *   Token,\n *   Value\n * } from 'micromark-util-types'\n * @import {Point} from 'unist'\n * @import {\n *   CompileContext,\n *   CompileData,\n *   Config,\n *   Extension,\n *   Handle,\n *   OnEnterError,\n *   Options\n * } from './types.js'\n */\n\nimport { toString } from 'mdast-util-to-string';\nimport { parse, postprocess, preprocess } from 'micromark';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n\n/**\n * Turn markdown into a syntax tree.\n *\n * @overload\n * @param {Value} value\n * @param {Encoding | null | undefined} [encoding]\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @overload\n * @param {Value} value\n * @param {Options | null | undefined} [options]\n * @returns {Root}\n *\n * @param {Value} value\n *   Markdown to parse.\n * @param {Encoding | Options | null | undefined} [encoding]\n *   Character encoding for when `value` is `Buffer`.\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {Root}\n *   mdast tree.\n */\nexport function fromMarkdown(value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n}\n\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options | null | undefined} [options]\n */\nfunction compiler(options) {\n  /** @type {Config} */\n  const config = {\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      characterReference: onexitcharacterreference,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  };\n  configure(config, (options || {}).mdastExtensions || []);\n\n  /** @type {CompileData} */\n  const data = {};\n  return compile;\n\n  /**\n   * Turn micromark events into an mdast tree.\n   *\n   * @param {Array<Event>} events\n   *   Events.\n   * @returns {Root}\n   *   mdast tree.\n   */\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n    const context = {\n      stack: [tree],\n      tokenStack: [],\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      data\n    };\n    /** @type {Array<number>} */\n    const listStack = [];\n    let index = -1;\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          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    // Handle tokens still being open.\n    if (context.tokenStack.length > 0) {\n      const tail = context.tokenStack[context.tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    }\n\n    // Figure out `root` position.\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n\n    // Call transforms.\n    index = -1;\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n    return tree;\n  }\n\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token | undefined} */\n    let listItem;\n    /** @type {number | undefined} */\n    let lineIndex;\n    /** @type {number | undefined} */\n    let firstBlankLineIndex;\n    /** @type {boolean | undefined} */\n    let atMarker;\n    while (++index <= length) {\n      const event = events[index];\n      switch (event[1].type) {\n        case \"listUnordered\":\n        case \"listOrdered\":\n        case \"blockQuote\":\n          {\n            if (event[0] === 'enter') {\n              containerBalance++;\n            } else {\n              containerBalance--;\n            }\n            atMarker = undefined;\n            break;\n          }\n        case \"lineEndingBlank\":\n          {\n            if (event[0] === 'enter') {\n              if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n                firstBlankLineIndex = index;\n              }\n              atMarker = undefined;\n            }\n            break;\n          }\n        case \"linePrefix\":\n        case \"listItemValue\":\n        case \"listItemMarker\":\n        case \"listItemPrefix\":\n        case \"listItemPrefixWhitespace\":\n          {\n            // Empty.\n\n            break;\n          }\n        default:\n          {\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          let tailIndex = index;\n          lineIndex = undefined;\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n            if (tailEvent[1].type === \"lineEnding\" || tailEvent[1].type === \"lineEndingBlank\") {\n              if (tailEvent[0] === 'exit') continue;\n              if (lineIndex) {\n                events[lineIndex][1].type = \"lineEndingBlank\";\n                listSpread = true;\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\") {\n              // Empty\n            } else {\n              break;\n            }\n          }\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            listItem._spread = true;\n          }\n\n          // Fix position.\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        }\n\n        // Create a new list item.\n        if (event[1].type === \"listItemPrefix\") {\n          /** @type {Token} */\n          const item = {\n            type: 'listItem',\n            _spread: false,\n            start: Object.assign({}, event[1].start),\n            // @ts-expect-error: we’ll add `end` in a second.\n            end: undefined\n          };\n          listItem = item;\n          events.splice(index, 0, ['enter', item, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    }\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n\n  /**\n   * Create an opener handle.\n   *\n   * @param {(token: Token) => Nodes} create\n   *   Create a node.\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function opener(create, and) {\n    return open;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['buffer']}\n   */\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n\n  /**\n   * @type {CompileContext['enter']}\n   */\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children;\n    siblings.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler || undefined]);\n    node.position = {\n      start: point(token.start),\n      // @ts-expect-error: `end` will be patched later.\n      end: undefined\n    };\n  }\n\n  /**\n   * Create a closer handle.\n   *\n   * @param {Handle | undefined} [and]\n   *   Optional function to also run.\n   * @returns {Handle}\n   *   Handle.\n   */\n  function closer(and) {\n    return close;\n\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {undefined}\n     */\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n\n  /**\n   * @type {CompileContext['exit']}\n   */\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\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[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n    node.position.end = point(token.end);\n  }\n\n  /**\n   * @type {CompileContext['resume']}\n   */\n  function resume() {\n    return toString(this.stack.pop());\n  }\n\n  //\n  // Handlers.\n  //\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistordered() {\n    this.data.expectingFirstListItemValue = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onenterlistitemvalue(token) {\n    if (this.data.expectingFirstListItemValue) {\n      const ancestor = this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      this.data.expectingFirstListItemValue = undefined;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (this.data.flowCodeInside) return;\n    this.buffer();\n    this.data.flowCodeInside = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    this.data.flowCodeInside = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitionlabelstring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitatxheadingsequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadingtext() {\n    this.data.setextHeadingSlurpLineEnding = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheadinglinesequence(token) {\n    const node = this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).codePointAt(0) === 61 ? 1 : 2;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitsetextheading() {\n    this.data.setextHeadingSlurpLineEnding = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterdata(token) {\n    const node = this.stack[this.stack.length - 1];\n    /** @type {Array<Nodes>} */\n    const siblings = node.children;\n    let tail = siblings[siblings.length - 1];\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text();\n      tail.position = {\n        start: point(token.start),\n        // @ts-expect-error: we’ll add `end` later.\n        end: undefined\n      };\n      siblings.push(tail);\n    }\n    this.stack.push(tail);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1];\n    // If we’re at a hard break, include the line ending in there.\n    if (this.data.atHardBreak) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      this.data.atHardBreak = undefined;\n      return;\n    }\n    if (!this.data.setextHeadingSlurpLineEnding && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithardbreak() {\n    this.data.atHardBreak = true;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlink() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitimage() {\n    const node = this.stack[this.stack.length - 1];\n    // Note: there are also `identifier` and `label` fields on this link node!\n    // These are used / cleaned here.\n\n    // To do: clean.\n    if (this.data.inReference) {\n      /** @type {ReferenceType} */\n      const referenceType = this.data.referenceType || 'shortcut';\n      node.type += 'Reference';\n      // @ts-expect-error: mutate.\n      node.referenceType = referenceType;\n      // @ts-expect-error: mutate.\n      delete node.url;\n      delete node.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete node.identifier;\n      // @ts-expect-error: mutate.\n      delete node.label;\n    }\n    this.data.referenceType = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabeltext(token) {\n    const string = this.sliceSerialize(token);\n    const ancestor = this.stack[this.stack.length - 2];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    ancestor.label = decodeString(string);\n    // @ts-expect-error: same as above.\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitlabel() {\n    const fragment = this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // Assume a reference.\n    this.data.inReference = true;\n    if (node.type === 'link') {\n      /** @type {Array<PhrasingContent>} */\n      const children = fragment.children;\n      node.children = children;\n    } else {\n      node.alt = value;\n    }\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitresource() {\n    this.data.inReference = undefined;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onenterreference() {\n    this.data.referenceType = 'collapsed';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node = this.stack[this.stack.length - 1];\n    // @ts-expect-error: stash this on the node, as it might become a reference\n    // later.\n    node.label = label;\n    // @ts-expect-error: same as above.\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    this.data.referenceType = 'full';\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n\n  function onexitcharacterreferencemarker(token) {\n    this.data.characterReferenceType = token.type;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = this.data.characterReferenceType;\n    /** @type {string} */\n    let value;\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === \"characterReferenceMarkerNumeric\" ? 10 : 16);\n      this.data.characterReferenceType = undefined;\n    } else {\n      const result = decodeNamedCharacterReference(data);\n      value = result;\n    }\n    const tail = this.stack[this.stack.length - 1];\n    tail.value += value;\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitcharacterreference(token) {\n    const tail = this.stack.pop();\n    tail.position.end = point(token.end);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n\n  /**\n   * @this {CompileContext}\n   * @type {Handle}\n   */\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node = this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  }\n\n  //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n\n  /** @returns {Code} */\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n\n  /** @returns {InlineCode} */\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n\n  /** @returns {Definition} */\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n\n  /** @returns {Emphasis} */\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n\n  /** @returns {Heading} */\n  function heading() {\n    return {\n      type: 'heading',\n      // @ts-expect-error `depth` will be set later.\n      depth: 0,\n      children: []\n    };\n  }\n\n  /** @returns {Break} */\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n\n  /** @returns {Html} */\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n\n  /** @returns {Image} */\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n\n  /** @returns {Link} */\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n\n  /**\n   * @param {Token} token\n   * @returns {List}\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  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n\n  /** @returns {Paragraph} */\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n\n  /** @returns {Strong} */\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n\n  /** @returns {Text} */\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n\n  /** @returns {ThematicBreak} */\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n\n/**\n * Copy a point-like value.\n *\n * @param {Point} d\n *   Point-like value.\n * @returns {Point}\n *   unist point.\n */\nfunction point(d) {\n  return {\n    line: d.line,\n    column: d.column,\n    offset: d.offset\n  };\n}\n\n/**\n * @param {Config} combined\n * @param {Array<Array<Extension> | Extension>} extensions\n * @returns {undefined}\n */\nfunction configure(combined, extensions) {\n  let index = -1;\n  while (++index < extensions.length) {\n    const value = extensions[index];\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n}\n\n/**\n * @param {Config} combined\n * @param {Extension} extension\n * @returns {undefined}\n */\nfunction extension(combined, extension) {\n  /** @type {keyof Extension} */\n  let key;\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      switch (key) {\n        case 'canContainEols':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'transforms':\n          {\n            const right = extension[key];\n            if (right) {\n              combined[key].push(...right);\n            }\n            break;\n          }\n        case 'enter':\n        case 'exit':\n          {\n            const right = extension[key];\n            if (right) {\n              Object.assign(combined[key], right);\n            }\n            break;\n          }\n        // No default\n      }\n    }\n  }\n}\n\n/** @type {OnEnterError} */\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} FromMarkdownOptions\n * @typedef {import('unified').Parser<Root>} Parser\n * @typedef {import('unified').Processor<Root>} Processor\n */\n\n/**\n * @typedef {Omit<FromMarkdownOptions, 'extensions' | 'mdastExtensions'>} Options\n */\n\nimport {fromMarkdown} from 'mdast-util-from-markdown'\n\n/**\n * Aadd support for parsing from markdown.\n *\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkParse(options) {\n  /** @type {Processor} */\n  // @ts-expect-error: TS in JSDoc generates wrong types if `this` is typed regularly.\n  const self = this\n\n  self.parser = parser\n\n  /**\n   * @type {Parser}\n   */\n  function parser(doc) {\n    return fromMarkdown(doc, {\n      ...self.data('settings'),\n      ...options,\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: self.data('micromarkExtensions') || [],\n      mdastExtensions: self.data('fromMarkdownExtensions') || []\n    })\n  }\n}\n","export default function escapeStringRegexp(string) {\n\tif (typeof string !== 'string') {\n\t\tthrow new TypeError('Expected a string');\n\t}\n\n\t// Escape characters with special meaning either inside or outside character sets.\n\t// Use a simple backslash escape when it’s always valid, and a `\\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.\n\treturn string\n\t\t.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\t\t.replace(/-/g, '\\\\x2d');\n}\n","/**\n * @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'\n * @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'\n */\n\n/**\n * @typedef RegExpMatchObject\n *   Info on the match.\n * @property {number} index\n *   The index of the search at which the result was found.\n * @property {string} input\n *   A copy of the search string in the text node.\n * @property {[...Array<Parents>, Text]} stack\n *   All ancestors of the text node, where the last node is the text itself.\n *\n * @typedef {RegExp | string} Find\n *   Pattern to find.\n *\n *   Strings are escaped and then turned into global expressions.\n *\n * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList\n *   Several find and replaces, in array form.\n *\n * @typedef {[Find, Replace?]} FindAndReplaceTuple\n *   Find and replace in tuple form.\n *\n * @typedef {ReplaceFunction | string | null | undefined} Replace\n *   Thing to replace with.\n *\n * @callback ReplaceFunction\n *   Callback called when a search matches.\n * @param {...any} parameters\n *   The parameters are the result of corresponding search expression:\n *\n *   * `value` (`string`) — whole match\n *   * `...capture` (`Array<string>`) — matches from regex capture groups\n *   * `match` (`RegExpMatchObject`) — info on the match\n * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}\n *   Thing to replace with.\n *\n *   * when `null`, `undefined`, `''`, remove the match\n *   * …or when `false`, do not replace at all\n *   * …or when `string`, replace with a text node of that value\n *   * …or when `Node` or `Array<Node>`, replace with those nodes\n *\n * @typedef {[RegExp, ReplaceFunction]} Pair\n *   Normalized find and replace.\n *\n * @typedef {Array<Pair>} Pairs\n *   All find and replaced.\n *\n * @typedef Options\n *   Configuration.\n * @property {Test | null | undefined} [ignore]\n *   Test for which nodes to ignore (optional).\n */\n\nimport escape from 'escape-string-regexp'\nimport {visitParents} from 'unist-util-visit-parents'\nimport {convert} from 'unist-util-is'\n\n/**\n * Find patterns in a tree and replace them.\n *\n * The algorithm searches the tree in *preorder* for complete values in `Text`\n * nodes.\n * Partial matches are not supported.\n *\n * @param {Nodes} tree\n *   Tree to change.\n * @param {FindAndReplaceList | FindAndReplaceTuple} list\n *   Patterns to find.\n * @param {Options | null | undefined} [options]\n *   Configuration (when `find` is not `Find`).\n * @returns {undefined}\n *   Nothing.\n */\nexport function findAndReplace(tree, list, options) {\n  const settings = options || {}\n  const ignored = convert(settings.ignore || [])\n  const pairs = toPairs(list)\n  let pairIndex = -1\n\n  while (++pairIndex < pairs.length) {\n    visitParents(tree, 'text', visitor)\n  }\n\n  /** @type {BuildVisitor<Root, 'text'>} */\n  function visitor(node, parents) {\n    let index = -1\n    /** @type {Parents | undefined} */\n    let grandparent\n\n    while (++index < parents.length) {\n      const parent = parents[index]\n      /** @type {Array<Nodes> | undefined} */\n      const siblings = grandparent ? grandparent.children : undefined\n\n      if (\n        ignored(\n          parent,\n          siblings ? siblings.indexOf(parent) : undefined,\n          grandparent\n        )\n      ) {\n        return\n      }\n\n      grandparent = parent\n    }\n\n    if (grandparent) {\n      return handler(node, parents)\n    }\n  }\n\n  /**\n   * Handle a text node which is not in an ignored parent.\n   *\n   * @param {Text} node\n   *   Text node.\n   * @param {Array<Parents>} parents\n   *   Parents.\n   * @returns {VisitorResult}\n   *   Result.\n   */\n  function handler(node, parents) {\n    const parent = parents[parents.length - 1]\n    const find = pairs[pairIndex][0]\n    const replace = pairs[pairIndex][1]\n    let start = 0\n    /** @type {Array<Nodes>} */\n    const siblings = parent.children\n    const index = siblings.indexOf(node)\n    let change = false\n    /** @type {Array<PhrasingContent>} */\n    let nodes = []\n\n    find.lastIndex = 0\n\n    let match = find.exec(node.value)\n\n    while (match) {\n      const position = match.index\n      /** @type {RegExpMatchObject} */\n      const matchObject = {\n        index: match.index,\n        input: match.input,\n        stack: [...parents, node]\n      }\n      let value = replace(...match, matchObject)\n\n      if (typeof value === 'string') {\n        value = value.length > 0 ? {type: 'text', value} : undefined\n      }\n\n      // It wasn’t a match after all.\n      if (value === false) {\n        // False acts as if there was no match.\n        // So we need to reset `lastIndex`, which currently being at the end of\n        // the current match, to the beginning.\n        find.lastIndex = position + 1\n      } else {\n        if (start !== position) {\n          nodes.push({\n            type: 'text',\n            value: node.value.slice(start, position)\n          })\n        }\n\n        if (Array.isArray(value)) {\n          nodes.push(...value)\n        } else if (value) {\n          nodes.push(value)\n        }\n\n        start = position + match[0].length\n        change = true\n      }\n\n      if (!find.global) {\n        break\n      }\n\n      match = find.exec(node.value)\n    }\n\n    if (change) {\n      if (start < node.value.length) {\n        nodes.push({type: 'text', value: node.value.slice(start)})\n      }\n\n      parent.children.splice(index, 1, ...nodes)\n    } else {\n      nodes = [node]\n    }\n\n    return index + nodes.length\n  }\n}\n\n/**\n * Turn a tuple or a list of tuples into pairs.\n *\n * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList\n *   Schema.\n * @returns {Pairs}\n *   Clean pairs.\n */\nfunction toPairs(tupleOrList) {\n  /** @type {Pairs} */\n  const result = []\n\n  if (!Array.isArray(tupleOrList)) {\n    throw new TypeError('Expected find and replace tuple or list of tuples')\n  }\n\n  /** @type {FindAndReplaceList} */\n  // @ts-expect-error: correct.\n  const list =\n    !tupleOrList[0] || Array.isArray(tupleOrList[0])\n      ? tupleOrList\n      : [tupleOrList]\n\n  let index = -1\n\n  while (++index < list.length) {\n    const tuple = list[index]\n    result.push([toExpression(tuple[0]), toFunction(tuple[1])])\n  }\n\n  return result\n}\n\n/**\n * Turn a find into an expression.\n *\n * @param {Find} find\n *   Find.\n * @returns {RegExp}\n *   Expression.\n */\nfunction toExpression(find) {\n  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find\n}\n\n/**\n * Turn a replace into a function.\n *\n * @param {Replace} replace\n *   Replace.\n * @returns {ReplaceFunction}\n *   Function.\n */\nfunction toFunction(replace) {\n  return typeof replace === 'function'\n    ? replace\n    : function () {\n        return replace\n      }\n}\n","/**\n * @import {RegExpMatchObject, ReplaceFunction} from 'mdast-util-find-and-replace'\n * @import {CompileContext, Extension as FromMarkdownExtension, Handle as FromMarkdownHandle, Transform as FromMarkdownTransform} from 'mdast-util-from-markdown'\n * @import {ConstructName, Options as ToMarkdownExtension} from 'mdast-util-to-markdown'\n * @import {Link, PhrasingContent} from 'mdast'\n */\n\nimport {ccount} from 'ccount'\nimport {ok as assert} from 'devlop'\nimport {unicodePunctuation, unicodeWhitespace} from 'micromark-util-character'\nimport {findAndReplace} from 'mdast-util-find-and-replace'\n\n/** @type {ConstructName} */\nconst inConstruct = 'phrasing'\n/** @type {Array<ConstructName>} */\nconst notInConstruct = ['autolink', 'link', 'image', 'label']\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralFromMarkdown() {\n  return {\n    transforms: [transformGfmAutolinkLiterals],\n    enter: {\n      literalAutolink: enterLiteralAutolink,\n      literalAutolinkEmail: enterLiteralAutolinkValue,\n      literalAutolinkHttp: enterLiteralAutolinkValue,\n      literalAutolinkWww: enterLiteralAutolinkValue\n    },\n    exit: {\n      literalAutolink: exitLiteralAutolink,\n      literalAutolinkEmail: exitLiteralAutolinkEmail,\n      literalAutolinkHttp: exitLiteralAutolinkHttp,\n      literalAutolinkWww: exitLiteralAutolinkWww\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM autolink\n * literals in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM autolink literals.\n */\nexport function gfmAutolinkLiteralToMarkdown() {\n  return {\n    unsafe: [\n      {\n        character: '@',\n        before: '[+\\\\-.\\\\w]',\n        after: '[\\\\-.\\\\w]',\n        inConstruct,\n        notInConstruct\n      },\n      {\n        character: '.',\n        before: '[Ww]',\n        after: '[\\\\-.\\\\w]',\n        inConstruct,\n        notInConstruct\n      },\n      {\n        character: ':',\n        before: '[ps]',\n        after: '\\\\/',\n        inConstruct,\n        notInConstruct\n      }\n    ]\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolink(token) {\n  this.enter({type: 'link', title: null, url: '', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterLiteralAutolinkValue(token) {\n  this.config.enter.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkHttp(token) {\n  this.config.exit.autolinkProtocol.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkWww(token) {\n  this.config.exit.data.call(this, token)\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'link')\n  node.url = 'http://' + this.sliceSerialize(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolinkEmail(token) {\n  this.config.exit.autolinkEmail.call(this, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitLiteralAutolink(token) {\n  this.exit(token)\n}\n\n/** @type {FromMarkdownTransform} */\nfunction transformGfmAutolinkLiterals(tree) {\n  findAndReplace(\n    tree,\n    [\n      [/(https?:\\/\\/|www(?=\\.))([-.\\w]+)([^ \\t\\r\\n]*)/gi, findUrl],\n      [/(?<=^|\\s|\\p{P}|\\p{S})([-.\\w+]+)@([-\\w]+(?:\\.[-\\w]+)+)/gu, findEmail]\n    ],\n    {ignore: ['link', 'linkReference']}\n  )\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} protocol\n * @param {string} domain\n * @param {string} path\n * @param {RegExpMatchObject} match\n * @returns {Array<PhrasingContent> | Link | false}\n */\n// eslint-disable-next-line max-params\nfunction findUrl(_, protocol, domain, path, match) {\n  let prefix = ''\n\n  // Not an expected previous character.\n  if (!previous(match)) {\n    return false\n  }\n\n  // Treat `www` as part of the domain.\n  if (/^w/i.test(protocol)) {\n    domain = protocol + domain\n    protocol = ''\n    prefix = 'http://'\n  }\n\n  if (!isCorrectDomain(domain)) {\n    return false\n  }\n\n  const parts = splitUrl(domain + path)\n\n  if (!parts[0]) return false\n\n  /** @type {Link} */\n  const result = {\n    type: 'link',\n    title: null,\n    url: prefix + protocol + parts[0],\n    children: [{type: 'text', value: protocol + parts[0]}]\n  }\n\n  if (parts[1]) {\n    return [result, {type: 'text', value: parts[1]}]\n  }\n\n  return result\n}\n\n/**\n * @type {ReplaceFunction}\n * @param {string} _\n * @param {string} atext\n * @param {string} label\n * @param {RegExpMatchObject} match\n * @returns {Link | false}\n */\nfunction findEmail(_, atext, label, match) {\n  if (\n    // Not an expected previous character.\n    !previous(match, true) ||\n    // Label ends in not allowed character.\n    /[-\\d_]$/.test(label)\n  ) {\n    return false\n  }\n\n  return {\n    type: 'link',\n    title: null,\n    url: 'mailto:' + atext + '@' + label,\n    children: [{type: 'text', value: atext + '@' + label}]\n  }\n}\n\n/**\n * @param {string} domain\n * @returns {boolean}\n */\nfunction isCorrectDomain(domain) {\n  const parts = domain.split('.')\n\n  if (\n    parts.length < 2 ||\n    (parts[parts.length - 1] &&\n      (/_/.test(parts[parts.length - 1]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 1]))) ||\n    (parts[parts.length - 2] &&\n      (/_/.test(parts[parts.length - 2]) ||\n        !/[a-zA-Z\\d]/.test(parts[parts.length - 2])))\n  ) {\n    return false\n  }\n\n  return true\n}\n\n/**\n * @param {string} url\n * @returns {[string, string | undefined]}\n */\nfunction splitUrl(url) {\n  const trailExec = /[!\"&'),.:;<>?\\]}]+$/.exec(url)\n\n  if (!trailExec) {\n    return [url, undefined]\n  }\n\n  url = url.slice(0, trailExec.index)\n\n  let trail = trailExec[0]\n  let closingParenIndex = trail.indexOf(')')\n  const openingParens = ccount(url, '(')\n  let closingParens = ccount(url, ')')\n\n  while (closingParenIndex !== -1 && openingParens > closingParens) {\n    url += trail.slice(0, closingParenIndex + 1)\n    trail = trail.slice(closingParenIndex + 1)\n    closingParenIndex = trail.indexOf(')')\n    closingParens++\n  }\n\n  return [url, trail]\n}\n\n/**\n * @param {RegExpMatchObject} match\n * @param {boolean | null | undefined} [email=false]\n * @returns {boolean}\n */\nfunction previous(match, email) {\n  const code = match.input.charCodeAt(match.index - 1)\n\n  return (\n    (match.index === 0 ||\n      unicodeWhitespace(code) ||\n      unicodePunctuation(code)) &&\n    // If it’s an email, the previous character should not be a slash.\n    (!email || code !== 47)\n  )\n}\n","/**\n * @import {\n *   CompileContext,\n *   Extension as FromMarkdownExtension,\n *   Handle as FromMarkdownHandle\n * } from 'mdast-util-from-markdown'\n * @import {ToMarkdownOptions} from 'mdast-util-gfm-footnote'\n * @import {\n *   Handle as ToMarkdownHandle,\n *   Map,\n *   Options as ToMarkdownExtension\n * } from 'mdast-util-to-markdown'\n * @import {FootnoteDefinition, FootnoteReference} from 'mdast'\n */\n\nimport {ok as assert} from 'devlop'\nimport {normalizeIdentifier} from 'micromark-util-normalize-identifier'\n\nfootnoteReference.peek = footnoteReferencePeek\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCallString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteCall(token) {\n  this.enter({type: 'footnoteReference', identifier: '', label: ''}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinitionLabelString() {\n  this.buffer()\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterFootnoteDefinition(token) {\n  this.enter(\n    {type: 'footnoteDefinition', identifier: '', label: '', children: []},\n    token\n  )\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCallString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteReference')\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n  node.label = label\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteCall(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinitionLabelString(token) {\n  const label = this.resume()\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'footnoteDefinition')\n  node.identifier = normalizeIdentifier(\n    this.sliceSerialize(token)\n  ).toLowerCase()\n  node.label = label\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitFootnoteDefinition(token) {\n  this.exit(token)\n}\n\n/** @type {ToMarkdownHandle} */\nfunction footnoteReferencePeek() {\n  return '['\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {FootnoteReference} node\n */\nfunction footnoteReference(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[^')\n  const exit = state.enter('footnoteReference')\n  const subexit = state.enter('reference')\n  value += tracker.move(\n    state.safe(state.associationId(node), {after: ']', before: value})\n  )\n  subexit()\n  exit()\n  value += tracker.move(']')\n  return value\n}\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown`.\n */\nexport function gfmFootnoteFromMarkdown() {\n  return {\n    enter: {\n      gfmFootnoteCallString: enterFootnoteCallString,\n      gfmFootnoteCall: enterFootnoteCall,\n      gfmFootnoteDefinitionLabelString: enterFootnoteDefinitionLabelString,\n      gfmFootnoteDefinition: enterFootnoteDefinition\n    },\n    exit: {\n      gfmFootnoteCallString: exitFootnoteCallString,\n      gfmFootnoteCall: exitFootnoteCall,\n      gfmFootnoteDefinitionLabelString: exitFootnoteDefinitionLabelString,\n      gfmFootnoteDefinition: exitFootnoteDefinition\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM footnotes\n * in markdown.\n *\n * @param {ToMarkdownOptions | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown`.\n */\nexport function gfmFootnoteToMarkdown(options) {\n  // To do: next major: change default.\n  let firstLineBlank = false\n\n  if (options && options.firstLineBlank) {\n    firstLineBlank = true\n  }\n\n  return {\n    handlers: {footnoteDefinition, footnoteReference},\n    // This is on by default already.\n    unsafe: [{character: '[', inConstruct: ['label', 'phrasing', 'reference']}]\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {FootnoteDefinition} node\n   */\n  function footnoteDefinition(node, _, state, info) {\n    const tracker = state.createTracker(info)\n    let value = tracker.move('[^')\n    const exit = state.enter('footnoteDefinition')\n    const subexit = state.enter('label')\n    value += tracker.move(\n      state.safe(state.associationId(node), {before: value, after: ']'})\n    )\n    subexit()\n\n    value += tracker.move(']:')\n\n    if (node.children && node.children.length > 0) {\n      tracker.shift(4)\n\n      value += tracker.move(\n        (firstLineBlank ? '\\n' : ' ') +\n          state.indentLines(\n            state.containerFlow(node, tracker.current()),\n            firstLineBlank ? mapAll : mapExceptFirst\n          )\n      )\n    }\n\n    exit()\n\n    return value\n  }\n}\n\n/** @type {Map} */\nfunction mapExceptFirst(line, index, blank) {\n  return index === 0 ? line : mapAll(line, index, blank)\n}\n\n/** @type {Map} */\nfunction mapAll(line, index, blank) {\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @typedef {import('mdast').Delete} Delete\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').ConstructName} ConstructName\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n */\n\n/**\n * List of constructs that occur in phrasing (paragraphs, headings), but cannot\n * contain strikethrough.\n * So they sort of cancel each other out.\n * Note: could use a better name.\n *\n * Note: keep in sync with: <https://github.com/syntax-tree/mdast-util-to-markdown/blob/8ce8dbf/lib/unsafe.js#L14>\n *\n * @type {Array<ConstructName>}\n */\nconst constructsWithoutStrikethrough = [\n  'autolink',\n  'destinationLiteral',\n  'destinationRaw',\n  'reference',\n  'titleQuote',\n  'titleApostrophe'\n]\n\nhandleDelete.peek = peekDelete\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughFromMarkdown() {\n  return {\n    canContainEols: ['delete'],\n    enter: {strikethrough: enterStrikethrough},\n    exit: {strikethrough: exitStrikethrough}\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM\n * strikethrough in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM strikethrough.\n */\nexport function gfmStrikethroughToMarkdown() {\n  return {\n    unsafe: [\n      {\n        character: '~',\n        inConstruct: 'phrasing',\n        notInConstruct: constructsWithoutStrikethrough\n      }\n    ],\n    handlers: {delete: handleDelete}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterStrikethrough(token) {\n  this.enter({type: 'delete', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitStrikethrough(token) {\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {Delete} node\n */\nfunction handleDelete(node, _, state, info) {\n  const tracker = state.createTracker(info)\n  const exit = state.enter('strikethrough')\n  let value = tracker.move('~~')\n  value += state.containerPhrasing(node, {\n    ...tracker.current(),\n    before: value,\n    after: '~'\n  })\n  value += tracker.move('~~')\n  exit()\n  return value\n}\n\n/** @type {ToMarkdownHandle} */\nfunction peekDelete() {\n  return '~'\n}\n","// To do: next major: remove.\n/**\n * @typedef {Options} MarkdownTableOptions\n *   Configuration.\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [alignDelimiters=true]\n *   Whether to align the delimiters (default: `true`);\n *   they are aligned by default:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   Pass `false` to make them staggered:\n *\n *   ```markdown\n *   | Alpha | B |\n *   | - | - |\n *   | C | Delta |\n *   ```\n * @property {ReadonlyArray<string | null | undefined> | string | null | undefined} [align]\n *   How to align columns (default: `''`);\n *   one style for all columns or styles for their respective columns;\n *   each style is either `'l'` (left), `'r'` (right), or `'c'` (center);\n *   other values are treated as `''`, which doesn’t place the colon in the\n *   alignment row but does align left;\n *   *only the lowercased first character is used, so `Right` is fine.*\n * @property {boolean | null | undefined} [delimiterEnd=true]\n *   Whether to end each row with the delimiter (default: `true`).\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no ending delimiters:\n *\n *   ```markdown\n *   | Alpha | B\n *   | ----- | -----\n *   | C     | Delta\n *   ```\n * @property {boolean | null | undefined} [delimiterStart=true]\n *   Whether to begin each row with the delimiter (default: `true`).\n *\n *   > 👉 **Note**: please don’t use this: it could create fragile structures\n *   > that aren’t understandable to some markdown parsers.\n *\n *   When `true`, there are starting delimiters:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there are no starting delimiters:\n *\n *   ```markdown\n *   Alpha | B     |\n *   ----- | ----- |\n *   C     | Delta |\n *   ```\n * @property {boolean | null | undefined} [padding=true]\n *   Whether to add a space of padding between delimiters and cells\n *   (default: `true`).\n *\n *   When `true`, there is padding:\n *\n *   ```markdown\n *   | Alpha | B     |\n *   | ----- | ----- |\n *   | C     | Delta |\n *   ```\n *\n *   When `false`, there is no padding:\n *\n *   ```markdown\n *   |Alpha|B    |\n *   |-----|-----|\n *   |C    |Delta|\n *   ```\n * @property {((value: string) => number) | null | undefined} [stringLength]\n *   Function to detect the length of table cell content (optional);\n *   this is used when aligning the delimiters (`|`) between table cells;\n *   full-width characters and emoji mess up delimiter alignment when viewing\n *   the markdown source;\n *   to fix this, you can pass this function,\n *   which receives the cell content and returns its “visible” size;\n *   note that what is and isn’t visible depends on where the text is displayed.\n *\n *   Without such a function, the following:\n *\n *   ```js\n *   markdownTable([\n *     ['Alpha', 'Bravo'],\n *     ['中文', 'Charlie'],\n *     ['👩‍❤️‍👩', 'Delta']\n *   ])\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo |\n *   | - | - |\n *   | 中文 | Charlie |\n *   | 👩‍❤️‍👩 | Delta |\n *   ```\n *\n *   With [`string-width`](https://github.com/sindresorhus/string-width):\n *\n *   ```js\n *   import stringWidth from 'string-width'\n *\n *   markdownTable(\n *     [\n *       ['Alpha', 'Bravo'],\n *       ['中文', 'Charlie'],\n *       ['👩‍❤️‍👩', 'Delta']\n *     ],\n *     {stringLength: stringWidth}\n *   )\n *   ```\n *\n *   Yields:\n *\n *   ```markdown\n *   | Alpha | Bravo   |\n *   | ----- | ------- |\n *   | 中文  | Charlie |\n *   | 👩‍❤️‍👩    | Delta   |\n *   ```\n */\n\n/**\n * @param {string} value\n *   Cell value.\n * @returns {number}\n *   Cell size.\n */\nfunction defaultStringLength(value) {\n  return value.length\n}\n\n/**\n * Generate a markdown\n * ([GFM](https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables))\n * table.\n *\n * @param {ReadonlyArray<ReadonlyArray<string | null | undefined>>} table\n *   Table data (matrix of strings).\n * @param {Readonly<Options> | null | undefined} [options]\n *   Configuration (optional).\n * @returns {string}\n *   Result.\n */\nexport function markdownTable(table, options) {\n  const settings = options || {}\n  // To do: next major: change to spread.\n  const align = (settings.align || []).concat()\n  const stringLength = settings.stringLength || defaultStringLength\n  /** @type {Array<number>} Character codes as symbols for alignment per column. */\n  const alignments = []\n  /** @type {Array<Array<string>>} Cells per row. */\n  const cellMatrix = []\n  /** @type {Array<Array<number>>} Sizes of each cell per row. */\n  const sizeMatrix = []\n  /** @type {Array<number>} */\n  const longestCellByColumn = []\n  let mostCellsPerRow = 0\n  let rowIndex = -1\n\n  // This is a superfluous loop if we don’t align delimiters, but otherwise we’d\n  // do superfluous work when aligning, so optimize for aligning.\n  while (++rowIndex < table.length) {\n    /** @type {Array<string>} */\n    const row = []\n    /** @type {Array<number>} */\n    const sizes = []\n    let columnIndex = -1\n\n    if (table[rowIndex].length > mostCellsPerRow) {\n      mostCellsPerRow = table[rowIndex].length\n    }\n\n    while (++columnIndex < table[rowIndex].length) {\n      const cell = serialize(table[rowIndex][columnIndex])\n\n      if (settings.alignDelimiters !== false) {\n        const size = stringLength(cell)\n        sizes[columnIndex] = size\n\n        if (\n          longestCellByColumn[columnIndex] === undefined ||\n          size > longestCellByColumn[columnIndex]\n        ) {\n          longestCellByColumn[columnIndex] = size\n        }\n      }\n\n      row.push(cell)\n    }\n\n    cellMatrix[rowIndex] = row\n    sizeMatrix[rowIndex] = sizes\n  }\n\n  // Figure out which alignments to use.\n  let columnIndex = -1\n\n  if (typeof align === 'object' && 'length' in align) {\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = toAlignment(align[columnIndex])\n    }\n  } else {\n    const code = toAlignment(align)\n\n    while (++columnIndex < mostCellsPerRow) {\n      alignments[columnIndex] = code\n    }\n  }\n\n  // Inject the alignment row.\n  columnIndex = -1\n  /** @type {Array<string>} */\n  const row = []\n  /** @type {Array<number>} */\n  const sizes = []\n\n  while (++columnIndex < mostCellsPerRow) {\n    const code = alignments[columnIndex]\n    let before = ''\n    let after = ''\n\n    if (code === 99 /* `c` */) {\n      before = ':'\n      after = ':'\n    } else if (code === 108 /* `l` */) {\n      before = ':'\n    } else if (code === 114 /* `r` */) {\n      after = ':'\n    }\n\n    // There *must* be at least one hyphen-minus in each alignment cell.\n    let size =\n      settings.alignDelimiters === false\n        ? 1\n        : Math.max(\n            1,\n            longestCellByColumn[columnIndex] - before.length - after.length\n          )\n\n    const cell = before + '-'.repeat(size) + after\n\n    if (settings.alignDelimiters !== false) {\n      size = before.length + size + after.length\n\n      if (size > longestCellByColumn[columnIndex]) {\n        longestCellByColumn[columnIndex] = size\n      }\n\n      sizes[columnIndex] = size\n    }\n\n    row[columnIndex] = cell\n  }\n\n  // Inject the alignment row.\n  cellMatrix.splice(1, 0, row)\n  sizeMatrix.splice(1, 0, sizes)\n\n  rowIndex = -1\n  /** @type {Array<string>} */\n  const lines = []\n\n  while (++rowIndex < cellMatrix.length) {\n    const row = cellMatrix[rowIndex]\n    const sizes = sizeMatrix[rowIndex]\n    columnIndex = -1\n    /** @type {Array<string>} */\n    const line = []\n\n    while (++columnIndex < mostCellsPerRow) {\n      const cell = row[columnIndex] || ''\n      let before = ''\n      let after = ''\n\n      if (settings.alignDelimiters !== false) {\n        const size =\n          longestCellByColumn[columnIndex] - (sizes[columnIndex] || 0)\n        const code = alignments[columnIndex]\n\n        if (code === 114 /* `r` */) {\n          before = ' '.repeat(size)\n        } else if (code === 99 /* `c` */) {\n          if (size % 2) {\n            before = ' '.repeat(size / 2 + 0.5)\n            after = ' '.repeat(size / 2 - 0.5)\n          } else {\n            before = ' '.repeat(size / 2)\n            after = before\n          }\n        } else {\n          after = ' '.repeat(size)\n        }\n      }\n\n      if (settings.delimiterStart !== false && !columnIndex) {\n        line.push('|')\n      }\n\n      if (\n        settings.padding !== false &&\n        // Don’t add the opening space if we’re not aligning and the cell is\n        // empty: there will be a closing space.\n        !(settings.alignDelimiters === false && cell === '') &&\n        (settings.delimiterStart !== false || columnIndex)\n      ) {\n        line.push(' ')\n      }\n\n      if (settings.alignDelimiters !== false) {\n        line.push(before)\n      }\n\n      line.push(cell)\n\n      if (settings.alignDelimiters !== false) {\n        line.push(after)\n      }\n\n      if (settings.padding !== false) {\n        line.push(' ')\n      }\n\n      if (\n        settings.delimiterEnd !== false ||\n        columnIndex !== mostCellsPerRow - 1\n      ) {\n        line.push('|')\n      }\n    }\n\n    lines.push(\n      settings.delimiterEnd === false\n        ? line.join('').replace(/ +$/, '')\n        : line.join('')\n    )\n  }\n\n  return lines.join('\\n')\n}\n\n/**\n * @param {string | null | undefined} [value]\n *   Value to serialize.\n * @returns {string}\n *   Result.\n */\nfunction serialize(value) {\n  return value === null || value === undefined ? '' : String(value)\n}\n\n/**\n * @param {string | null | undefined} value\n *   Value.\n * @returns {number}\n *   Alignment.\n */\nfunction toAlignment(value) {\n  const code = typeof value === 'string' ? value.codePointAt(0) : 0\n\n  return code === 67 /* `C` */ || code === 99 /* `c` */\n    ? 99 /* `c` */\n    : code === 76 /* `L` */ || code === 108 /* `l` */\n      ? 108 /* `l` */\n      : code === 82 /* `R` */ || code === 114 /* `r` */\n        ? 114 /* `r` */\n        : 0\n}\n","/**\n * @import {Blockquote, Parents} from 'mdast'\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {Blockquote} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function blockquote(node, _, state, info) {\n  const exit = state.enter('blockquote')\n  const tracker = state.createTracker(info)\n  tracker.move('> ')\n  tracker.shift(2)\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return '>' + (blank ? '' : ' ') + line\n}\n","/**\n * @import {ConstructName, Unsafe} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe} pattern\n * @returns {boolean}\n */\nexport function patternInScope(stack, pattern) {\n  return (\n    listInScope(stack, pattern.inConstruct, true) &&\n    !listInScope(stack, pattern.notInConstruct, false)\n  )\n}\n\n/**\n * @param {Array<ConstructName>} stack\n * @param {Unsafe['inConstruct']} list\n * @param {boolean} none\n * @returns {boolean}\n */\nfunction listInScope(stack, list, none) {\n  if (typeof list === 'string') {\n    list = [list]\n  }\n\n  if (!list || list.length === 0) {\n    return none\n  }\n\n  let index = -1\n\n  while (++index < list.length) {\n    if (stack.includes(list[index])) {\n      return true\n    }\n  }\n\n  return false\n}\n","/**\n * @import {Break, Parents} from 'mdast'\n * @import {Info, State} from 'mdast-util-to-markdown'\n */\n\nimport {patternInScope} from '../util/pattern-in-scope.js'\n\n/**\n * @param {Break} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function hardBreak(_, _1, state, info) {\n  let index = -1\n\n  while (++index < state.unsafe.length) {\n    // If we can’t put eols in this construct (setext headings, tables), use a\n    // space instead.\n    if (\n      state.unsafe[index].character === '\\n' &&\n      patternInScope(state.stack, state.unsafe[index])\n    ) {\n      return /[ \\t]/.test(info.before) ? '' : ' '\n    }\n  }\n\n  return '\\\\\\n'\n}\n","/**\n * Get the count of the longest repeating streak of `substring` in `value`.\n *\n * @param {string} value\n *   Content to search in.\n * @param {string} substring\n *   Substring to look for, typically one character.\n * @returns {number}\n *   Count of most frequent adjacent `substring`s in `value`.\n */\nexport function longestStreak(value, substring) {\n  const source = String(value)\n  let index = source.indexOf(substring)\n  let expected = index\n  let count = 0\n  let max = 0\n\n  if (typeof substring !== 'string') {\n    throw new TypeError('Expected substring')\n  }\n\n  while (index !== -1) {\n    if (index === expected) {\n      if (++count > max) {\n        max = count\n      }\n    } else {\n      count = 1\n    }\n\n    expected = index + substring.length\n    index = source.indexOf(substring, expected)\n  }\n\n  return max\n}\n","/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Code} from 'mdast'\n */\n\n/**\n * @param {Code} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatCodeAsIndented(node, state) {\n  return Boolean(\n    state.options.fences === false &&\n      node.value &&\n      // If there’s no info…\n      !node.lang &&\n      // And there’s a non-whitespace character…\n      /[^ \\r\\n]/.test(node.value) &&\n      // And the value doesn’t start or end in a blank…\n      !/^[\\t ]*(?:[\\r\\n]|$)|(?:^|[\\r\\n])[\\t ]*$/.test(node.value)\n  )\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['fence'], null | undefined>}\n */\nexport function checkFence(state) {\n  const marker = state.options.fence || '`'\n\n  if (marker !== '`' && marker !== '~') {\n    throw new Error(\n      'Cannot serialize code with `' +\n        marker +\n        '` for `options.fence`, expected `` ` `` or `~`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n * @import {Code, Parents} from 'mdast'\n */\n\nimport {longestStreak} from 'longest-streak'\nimport {formatCodeAsIndented} from '../util/format-code-as-indented.js'\nimport {checkFence} from '../util/check-fence.js'\n\n/**\n * @param {Code} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function code(node, _, state, info) {\n  const marker = checkFence(state)\n  const raw = node.value || ''\n  const suffix = marker === '`' ? 'GraveAccent' : 'Tilde'\n\n  if (formatCodeAsIndented(node, state)) {\n    const exit = state.enter('codeIndented')\n    const value = state.indentLines(raw, map)\n    exit()\n    return value\n  }\n\n  const tracker = state.createTracker(info)\n  const sequence = marker.repeat(Math.max(longestStreak(raw, marker) + 1, 3))\n  const exit = state.enter('codeFenced')\n  let value = tracker.move(sequence)\n\n  if (node.lang) {\n    const subexit = state.enter(`codeFencedLang${suffix}`)\n    value += tracker.move(\n      state.safe(node.lang, {\n        before: value,\n        after: ' ',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  if (node.lang && node.meta) {\n    const subexit = state.enter(`codeFencedMeta${suffix}`)\n    value += tracker.move(' ')\n    value += tracker.move(\n      state.safe(node.meta, {\n        before: value,\n        after: '\\n',\n        encode: ['`'],\n        ...tracker.current()\n      })\n    )\n    subexit()\n  }\n\n  value += tracker.move('\\n')\n\n  if (raw) {\n    value += tracker.move(raw + '\\n')\n  }\n\n  value += tracker.move(sequence)\n  exit()\n  return value\n}\n\n/** @type {Map} */\nfunction map(line, _, blank) {\n  return (blank ? '' : '    ') + line\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['quote'], null | undefined>}\n */\nexport function checkQuote(state) {\n  const marker = state.options.quote || '\"'\n\n  if (marker !== '\"' && marker !== \"'\") {\n    throw new Error(\n      'Cannot serialize title with `' +\n        marker +\n        '` for `options.quote`, expected `\"`, or `\\'`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Definition, Parents} from 'mdast'\n */\n\nimport {checkQuote} from '../util/check-quote.js'\n\n/**\n * @param {Definition} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function definition(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const exit = state.enter('definition')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[')\n  value += tracker.move(\n    state.safe(state.associationId(node), {\n      before: value,\n      after: ']',\n      ...tracker.current()\n    })\n  )\n  value += tracker.move(']: ')\n\n  subexit()\n\n  if (\n    // If there’s no url, or…\n    !node.url ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : '\\n',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  exit()\n\n  return value\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['emphasis'], null | undefined>}\n */\nexport function checkEmphasis(state) {\n  const marker = state.options.emphasis || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize emphasis with `' +\n        marker +\n        '` for `options.emphasis`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * Encode a code point as a character reference.\n *\n * @param {number} code\n *   Code point to encode.\n * @returns {string}\n *   Encoded character reference.\n */\nexport function encodeCharacterReference(code) {\n  return '&#x' + code.toString(16).toUpperCase() + ';'\n}\n","/**\n * @import {EncodeSides} from '../types.js'\n */\n\nimport {classifyCharacter} from 'micromark-util-classify-character'\n\n/**\n * Check whether to encode (as a character reference) the characters\n * surrounding an attention run.\n *\n * Which characters are around an attention run influence whether it works or\n * not.\n *\n * See <https://github.com/orgs/syntax-tree/discussions/60> for more info.\n * See this markdown in a particular renderer to see what works:\n *\n * ```markdown\n * |                         | A (letter inside) | B (punctuation inside) | C (whitespace inside) | D (nothing inside) |\n * | ----------------------- | ----------------- | ---------------------- | --------------------- | ------------------ |\n * | 1 (letter outside)      | x*y*z             | x*.*z                  | x* *z                 | x**z               |\n * | 2 (punctuation outside) | .*y*.             | .*.*.                  | .* *.                 | .**.               |\n * | 3 (whitespace outside)  | x *y* z           | x *.* z                | x * * z               | x ** z             |\n * | 4 (nothing outside)     | *x*               | *.*                    | * *                   | **                 |\n * ```\n *\n * @param {number} outside\n *   Code point on the outer side of the run.\n * @param {number} inside\n *   Code point on the inner side of the run.\n * @param {'*' | '_'} marker\n *   Marker of the run.\n *   Underscores are handled more strictly (they form less often) than\n *   asterisks.\n * @returns {EncodeSides}\n *   Whether to encode characters.\n */\n// Important: punctuation must never be encoded.\n// Punctuation is solely used by markdown constructs.\n// And by encoding itself.\n// Encoding them will break constructs or double encode things.\nexport function encodeInfo(outside, inside, marker) {\n  const outsideKind = classifyCharacter(outside)\n  const insideKind = classifyCharacter(inside)\n\n  // Letter outside:\n  if (outsideKind === undefined) {\n    return insideKind === undefined\n      ? // Letter inside:\n        // we have to encode *both* letters for `_` as it is looser.\n        // it already forms for `*` (and GFMs `~`).\n        marker === '_'\n        ? {inside: true, outside: true}\n        : {inside: false, outside: false}\n      : insideKind === 1\n        ? // Whitespace inside: encode both (letter, whitespace).\n          {inside: true, outside: true}\n        : // Punctuation inside: encode outer (letter)\n          {inside: false, outside: true}\n  }\n\n  // Whitespace outside:\n  if (outsideKind === 1) {\n    return insideKind === undefined\n      ? // Letter inside: already forms.\n        {inside: false, outside: false}\n      : insideKind === 1\n        ? // Whitespace inside: encode both (whitespace).\n          {inside: true, outside: true}\n        : // Punctuation inside: already forms.\n          {inside: false, outside: false}\n  }\n\n  // Punctuation outside:\n  return insideKind === undefined\n    ? // Letter inside: already forms.\n      {inside: false, outside: false}\n    : insideKind === 1\n      ? // Whitespace inside: encode inner (whitespace).\n        {inside: true, outside: false}\n      : // Punctuation inside: already forms.\n        {inside: false, outside: false}\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Emphasis, Parents} from 'mdast'\n */\n\nimport {checkEmphasis} from '../util/check-emphasis.js'\nimport {encodeCharacterReference} from '../util/encode-character-reference.js'\nimport {encodeInfo} from '../util/encode-info.js'\n\nemphasis.peek = emphasisPeek\n\n/**\n * @param {Emphasis} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function emphasis(node, _, state, info) {\n  const marker = checkEmphasis(state)\n  const exit = state.enter('emphasis')\n  const tracker = state.createTracker(info)\n  const before = tracker.move(marker)\n\n  let between = tracker.move(\n    state.containerPhrasing(node, {\n      after: marker,\n      before,\n      ...tracker.current()\n    })\n  )\n  const betweenHead = between.charCodeAt(0)\n  const open = encodeInfo(\n    info.before.charCodeAt(info.before.length - 1),\n    betweenHead,\n    marker\n  )\n\n  if (open.inside) {\n    between = encodeCharacterReference(betweenHead) + between.slice(1)\n  }\n\n  const betweenTail = between.charCodeAt(between.length - 1)\n  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker)\n\n  if (close.inside) {\n    between = between.slice(0, -1) + encodeCharacterReference(betweenTail)\n  }\n\n  const after = tracker.move(marker)\n\n  exit()\n\n  state.attentionEncodeSurroundingInfo = {\n    after: close.outside,\n    before: open.outside\n  }\n  return before + between + after\n}\n\n/**\n * @param {Emphasis} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nfunction emphasisPeek(_, _1, state) {\n  return state.options.emphasis || '*'\n}\n","/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Heading} from 'mdast'\n */\n\nimport {EXIT, visit} from 'unist-util-visit'\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Heading} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatHeadingAsSetext(node, state) {\n  let literalWithBreak = false\n\n  // Look for literals with a line break.\n  // Note that this also\n  visit(node, function (node) {\n    if (\n      ('value' in node && /\\r?\\n|\\r/.test(node.value)) ||\n      node.type === 'break'\n    ) {\n      literalWithBreak = true\n      return EXIT\n    }\n  })\n\n  return Boolean(\n    (!node.depth || node.depth < 3) &&\n      toString(node) &&\n      (state.options.setext || literalWithBreak)\n  )\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Heading, Parents} from 'mdast'\n */\n\nimport {encodeCharacterReference} from '../util/encode-character-reference.js'\nimport {formatHeadingAsSetext} from '../util/format-heading-as-setext.js'\n\n/**\n * @param {Heading} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function heading(node, _, state, info) {\n  const rank = Math.max(Math.min(6, node.depth || 1), 1)\n  const tracker = state.createTracker(info)\n\n  if (formatHeadingAsSetext(node, state)) {\n    const exit = state.enter('headingSetext')\n    const subexit = state.enter('phrasing')\n    const value = state.containerPhrasing(node, {\n      ...tracker.current(),\n      before: '\\n',\n      after: '\\n'\n    })\n    subexit()\n    exit()\n\n    return (\n      value +\n      '\\n' +\n      (rank === 1 ? '=' : '-').repeat(\n        // The whole size…\n        value.length -\n          // Minus the position of the character after the last EOL (or\n          // 0 if there is none)…\n          (Math.max(value.lastIndexOf('\\r'), value.lastIndexOf('\\n')) + 1)\n      )\n    )\n  }\n\n  const sequence = '#'.repeat(rank)\n  const exit = state.enter('headingAtx')\n  const subexit = state.enter('phrasing')\n\n  // Note: for proper tracking, we should reset the output positions when there\n  // is no content returned, because then the space is not output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  tracker.move(sequence + ' ')\n\n  let value = state.containerPhrasing(node, {\n    before: '# ',\n    after: '\\n',\n    ...tracker.current()\n  })\n\n  if (/^[\\t ]/.test(value)) {\n    // To do: what effect has the character reference on tracking?\n    value = encodeCharacterReference(value.charCodeAt(0)) + value.slice(1)\n  }\n\n  value = value ? sequence + ' ' + value : sequence\n\n  if (state.options.closeAtx) {\n    value += ' ' + sequence\n  }\n\n  subexit()\n  exit()\n\n  return value\n}\n","/**\n * @import {Html} from 'mdast'\n */\n\nhtml.peek = htmlPeek\n\n/**\n * @param {Html} node\n * @returns {string}\n */\nexport function html(node) {\n  return node.value || ''\n}\n\n/**\n * @returns {string}\n */\nfunction htmlPeek() {\n  return '<'\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Image, Parents} from 'mdast'\n */\n\nimport {checkQuote} from '../util/check-quote.js'\n\nimage.peek = imagePeek\n\n/**\n * @param {Image} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function image(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const exit = state.enter('image')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('![')\n  value += tracker.move(\n    state.safe(node.alt, {before: value, after: ']', ...tracker.current()})\n  )\n  value += tracker.move('](')\n\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : ')',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  value += tracker.move(')')\n  exit()\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction imagePeek() {\n  return '!'\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {ImageReference, Parents} from 'mdast'\n */\n\nimageReference.peek = imageReferencePeek\n\n/**\n * @param {ImageReference} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function imageReference(node, _, state, info) {\n  const type = node.referenceType\n  const exit = state.enter('imageReference')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('![')\n  const alt = state.safe(node.alt, {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  value += tracker.move(alt + '][')\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  const stack = state.stack\n  state.stack = []\n  subexit = state.enter('reference')\n  // Note: for proper tracking, we should reset the output positions when we end\n  // up making a `shortcut` reference, because then there is no brace output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  const reference = state.safe(state.associationId(node), {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  subexit()\n  state.stack = stack\n  exit()\n\n  if (type === 'full' || !alt || alt !== reference) {\n    value += tracker.move(reference + ']')\n  } else if (type === 'shortcut') {\n    // Remove the unwanted `[`.\n    value = value.slice(0, -1)\n  } else {\n    value += tracker.move(']')\n  }\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction imageReferencePeek() {\n  return '!'\n}\n","/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {InlineCode, Parents} from 'mdast'\n */\n\ninlineCode.peek = inlineCodePeek\n\n/**\n * @param {InlineCode} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @returns {string}\n */\nexport function inlineCode(node, _, state) {\n  let value = node.value || ''\n  let sequence = '`'\n  let index = -1\n\n  // If there is a single grave accent on its own in the code, use a fence of\n  // two.\n  // If there are two in a row, use one.\n  while (new RegExp('(^|[^`])' + sequence + '([^`]|$)').test(value)) {\n    sequence += '`'\n  }\n\n  // If this is not just spaces or eols (tabs don’t count), and either the\n  // first or last character are a space, eol, or tick, then pad with spaces.\n  if (\n    /[^ \\r\\n]/.test(value) &&\n    ((/^[ \\r\\n]/.test(value) && /[ \\r\\n]$/.test(value)) || /^`|`$/.test(value))\n  ) {\n    value = ' ' + value + ' '\n  }\n\n  // We have a potential problem: certain characters after eols could result in\n  // blocks being seen.\n  // For example, if someone injected the string `'\\n# b'`, then that would\n  // result in an ATX heading.\n  // We can’t escape characters in `inlineCode`, but because eols are\n  // transformed to spaces when going from markdown to HTML anyway, we can swap\n  // them out.\n  while (++index < state.unsafe.length) {\n    const pattern = state.unsafe[index]\n    const expression = state.compilePattern(pattern)\n    /** @type {RegExpExecArray | null} */\n    let match\n\n    // Only look for `atBreak`s.\n    // Btw: note that `atBreak` patterns will always start the regex at LF or\n    // CR.\n    if (!pattern.atBreak) continue\n\n    while ((match = expression.exec(value))) {\n      let position = match.index\n\n      // Support CRLF (patterns only look for one of the characters).\n      if (\n        value.charCodeAt(position) === 10 /* `\\n` */ &&\n        value.charCodeAt(position - 1) === 13 /* `\\r` */\n      ) {\n        position--\n      }\n\n      value = value.slice(0, position) + ' ' + value.slice(match.index + 1)\n    }\n  }\n\n  return sequence + value + sequence\n}\n\n/**\n * @returns {string}\n */\nfunction inlineCodePeek() {\n  return '`'\n}\n","/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Link} from 'mdast'\n */\n\nimport {toString} from 'mdast-util-to-string'\n\n/**\n * @param {Link} node\n * @param {State} state\n * @returns {boolean}\n */\nexport function formatLinkAsAutolink(node, state) {\n  const raw = toString(node)\n\n  return Boolean(\n    !state.options.resourceLink &&\n      // If there’s a url…\n      node.url &&\n      // And there’s a no title…\n      !node.title &&\n      // And the content of `node` is a single text node…\n      node.children &&\n      node.children.length === 1 &&\n      node.children[0].type === 'text' &&\n      // And if the url is the same as the content…\n      (raw === node.url || 'mailto:' + raw === node.url) &&\n      // And that starts w/ a protocol…\n      /^[a-z][a-z+.-]+:/i.test(node.url) &&\n      // And that doesn’t contain ASCII control codes (character escapes and\n      // references don’t work), space, or angle brackets…\n      !/[\\0- <>\\u007F]/.test(node.url)\n  )\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Link, Parents} from 'mdast'\n * @import {Exit} from '../types.js'\n */\n\nimport {checkQuote} from '../util/check-quote.js'\nimport {formatLinkAsAutolink} from '../util/format-link-as-autolink.js'\n\nlink.peek = linkPeek\n\n/**\n * @param {Link} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function link(node, _, state, info) {\n  const quote = checkQuote(state)\n  const suffix = quote === '\"' ? 'Quote' : 'Apostrophe'\n  const tracker = state.createTracker(info)\n  /** @type {Exit} */\n  let exit\n  /** @type {Exit} */\n  let subexit\n\n  if (formatLinkAsAutolink(node, state)) {\n    // Hide the fact that we’re in phrasing, because escapes don’t work.\n    const stack = state.stack\n    state.stack = []\n    exit = state.enter('autolink')\n    let value = tracker.move('<')\n    value += tracker.move(\n      state.containerPhrasing(node, {\n        before: value,\n        after: '>',\n        ...tracker.current()\n      })\n    )\n    value += tracker.move('>')\n    exit()\n    state.stack = stack\n    return value\n  }\n\n  exit = state.enter('link')\n  subexit = state.enter('label')\n  let value = tracker.move('[')\n  value += tracker.move(\n    state.containerPhrasing(node, {\n      before: value,\n      after: '](',\n      ...tracker.current()\n    })\n  )\n  value += tracker.move('](')\n  subexit()\n\n  if (\n    // If there’s no url but there is a title…\n    (!node.url && node.title) ||\n    // If there are control characters or whitespace.\n    /[\\0- \\u007F]/.test(node.url)\n  ) {\n    subexit = state.enter('destinationLiteral')\n    value += tracker.move('<')\n    value += tracker.move(\n      state.safe(node.url, {before: value, after: '>', ...tracker.current()})\n    )\n    value += tracker.move('>')\n  } else {\n    // No whitespace, raw is prettier.\n    subexit = state.enter('destinationRaw')\n    value += tracker.move(\n      state.safe(node.url, {\n        before: value,\n        after: node.title ? ' ' : ')',\n        ...tracker.current()\n      })\n    )\n  }\n\n  subexit()\n\n  if (node.title) {\n    subexit = state.enter(`title${suffix}`)\n    value += tracker.move(' ' + quote)\n    value += tracker.move(\n      state.safe(node.title, {\n        before: value,\n        after: quote,\n        ...tracker.current()\n      })\n    )\n    value += tracker.move(quote)\n    subexit()\n  }\n\n  value += tracker.move(')')\n\n  exit()\n  return value\n}\n\n/**\n * @param {Link} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @returns {string}\n */\nfunction linkPeek(node, _, state) {\n  return formatLinkAsAutolink(node, state) ? '<' : '['\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {LinkReference, Parents} from 'mdast'\n */\n\nlinkReference.peek = linkReferencePeek\n\n/**\n * @param {LinkReference} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function linkReference(node, _, state, info) {\n  const type = node.referenceType\n  const exit = state.enter('linkReference')\n  let subexit = state.enter('label')\n  const tracker = state.createTracker(info)\n  let value = tracker.move('[')\n  const text = state.containerPhrasing(node, {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  value += tracker.move(text + '][')\n\n  subexit()\n  // Hide the fact that we’re in phrasing, because escapes don’t work.\n  const stack = state.stack\n  state.stack = []\n  subexit = state.enter('reference')\n  // Note: for proper tracking, we should reset the output positions when we end\n  // up making a `shortcut` reference, because then there is no brace output.\n  // Practically, in that case, there is no content, so it doesn’t matter that\n  // we’ve tracked one too many characters.\n  const reference = state.safe(state.associationId(node), {\n    before: value,\n    after: ']',\n    ...tracker.current()\n  })\n  subexit()\n  state.stack = stack\n  exit()\n\n  if (type === 'full' || !text || text !== reference) {\n    value += tracker.move(reference + ']')\n  } else if (type === 'shortcut') {\n    // Remove the unwanted `[`.\n    value = value.slice(0, -1)\n  } else {\n    value += tracker.move(']')\n  }\n\n  return value\n}\n\n/**\n * @returns {string}\n */\nfunction linkReferencePeek() {\n  return '['\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBullet(state) {\n  const marker = state.options.bullet || '*'\n\n  if (marker !== '*' && marker !== '+' && marker !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bullet`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\nimport {checkBullet} from './check-bullet.js'\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bullet'], null | undefined>}\n */\nexport function checkBulletOther(state) {\n  const bullet = checkBullet(state)\n  const bulletOther = state.options.bulletOther\n\n  if (!bulletOther) {\n    return bullet === '*' ? '-' : '*'\n  }\n\n  if (bulletOther !== '*' && bulletOther !== '+' && bulletOther !== '-') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        bulletOther +\n        '` for `options.bulletOther`, expected `*`, `+`, or `-`'\n    )\n  }\n\n  if (bulletOther === bullet) {\n    throw new Error(\n      'Expected `bullet` (`' +\n        bullet +\n        '`) and `bulletOther` (`' +\n        bulletOther +\n        '`) to be different'\n    )\n  }\n\n  return bulletOther\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['bulletOrdered'], null | undefined>}\n */\nexport function checkBulletOrdered(state) {\n  const marker = state.options.bulletOrdered || '.'\n\n  if (marker !== '.' && marker !== ')') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        marker +\n        '` for `options.bulletOrdered`, expected `.` or `)`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['rule'], null | undefined>}\n */\nexport function checkRule(state) {\n  const marker = state.options.rule || '*'\n\n  if (marker !== '*' && marker !== '-' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize rules with `' +\n        marker +\n        '` for `options.rule`, expected `*`, `-`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {List, Parents} from 'mdast'\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkBulletOther} from '../util/check-bullet-other.js'\nimport {checkBulletOrdered} from '../util/check-bullet-ordered.js'\nimport {checkRule} from '../util/check-rule.js'\n\n/**\n * @param {List} node\n * @param {Parents | undefined} parent\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function list(node, parent, state, info) {\n  const exit = state.enter('list')\n  const bulletCurrent = state.bulletCurrent\n  /** @type {string} */\n  let bullet = node.ordered ? checkBulletOrdered(state) : checkBullet(state)\n  /** @type {string} */\n  const bulletOther = node.ordered\n    ? bullet === '.'\n      ? ')'\n      : '.'\n    : checkBulletOther(state)\n  let useDifferentMarker =\n    parent && state.bulletLastUsed ? bullet === state.bulletLastUsed : false\n\n  if (!node.ordered) {\n    const firstListItem = node.children ? node.children[0] : undefined\n\n    // If there’s an empty first list item directly in two list items,\n    // we have to use a different bullet:\n    //\n    // ```markdown\n    // * - *\n    // ```\n    //\n    // …because otherwise it would become one big thematic break.\n    if (\n      // Bullet could be used as a thematic break marker:\n      (bullet === '*' || bullet === '-') &&\n      // Empty first list item:\n      firstListItem &&\n      (!firstListItem.children || !firstListItem.children[0]) &&\n      // Directly in two other list items:\n      state.stack[state.stack.length - 1] === 'list' &&\n      state.stack[state.stack.length - 2] === 'listItem' &&\n      state.stack[state.stack.length - 3] === 'list' &&\n      state.stack[state.stack.length - 4] === 'listItem' &&\n      // That are each the first child.\n      state.indexStack[state.indexStack.length - 1] === 0 &&\n      state.indexStack[state.indexStack.length - 2] === 0 &&\n      state.indexStack[state.indexStack.length - 3] === 0\n    ) {\n      useDifferentMarker = true\n    }\n\n    // If there’s a thematic break at the start of the first list item,\n    // we have to use a different bullet:\n    //\n    // ```markdown\n    // * ---\n    // ```\n    //\n    // …because otherwise it would become one big thematic break.\n    if (checkRule(state) === bullet && firstListItem) {\n      let index = -1\n\n      while (++index < node.children.length) {\n        const item = node.children[index]\n\n        if (\n          item &&\n          item.type === 'listItem' &&\n          item.children &&\n          item.children[0] &&\n          item.children[0].type === 'thematicBreak'\n        ) {\n          useDifferentMarker = true\n          break\n        }\n      }\n    }\n  }\n\n  if (useDifferentMarker) {\n    bullet = bulletOther\n  }\n\n  state.bulletCurrent = bullet\n  const value = state.containerFlow(node, info)\n  state.bulletLastUsed = bullet\n  state.bulletCurrent = bulletCurrent\n  exit()\n  return value\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['listItemIndent'], null | undefined>}\n */\nexport function checkListItemIndent(state) {\n  const style = state.options.listItemIndent || 'one'\n\n  if (style !== 'tab' && style !== 'one' && style !== 'mixed') {\n    throw new Error(\n      'Cannot serialize items with `' +\n        style +\n        '` for `options.listItemIndent`, expected `tab`, `one`, or `mixed`'\n    )\n  }\n\n  return style\n}\n","/**\n * @import {Info, Map, State} from 'mdast-util-to-markdown'\n * @import {ListItem, Parents} from 'mdast'\n */\n\nimport {checkBullet} from '../util/check-bullet.js'\nimport {checkListItemIndent} from '../util/check-list-item-indent.js'\n\n/**\n * @param {ListItem} node\n * @param {Parents | undefined} parent\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function listItem(node, parent, state, info) {\n  const listItemIndent = checkListItemIndent(state)\n  let bullet = state.bulletCurrent || checkBullet(state)\n\n  // Add the marker value for ordered lists.\n  if (parent && parent.type === 'list' && parent.ordered) {\n    bullet =\n      (typeof parent.start === 'number' && parent.start > -1\n        ? parent.start\n        : 1) +\n      (state.options.incrementListMarker === false\n        ? 0\n        : parent.children.indexOf(node)) +\n      bullet\n  }\n\n  let size = bullet.length + 1\n\n  if (\n    listItemIndent === 'tab' ||\n    (listItemIndent === 'mixed' &&\n      ((parent && parent.type === 'list' && parent.spread) || node.spread))\n  ) {\n    size = Math.ceil(size / 4) * 4\n  }\n\n  const tracker = state.createTracker(info)\n  tracker.move(bullet + ' '.repeat(size - bullet.length))\n  tracker.shift(size)\n  const exit = state.enter('listItem')\n  const value = state.indentLines(\n    state.containerFlow(node, tracker.current()),\n    map\n  )\n  exit()\n\n  return value\n\n  /** @type {Map} */\n  function map(line, index, blank) {\n    if (index) {\n      return (blank ? '' : ' '.repeat(size)) + line\n    }\n\n    return (blank ? bullet : bullet + ' '.repeat(size - bullet.length)) + line\n  }\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Paragraph, Parents} from 'mdast'\n */\n\n/**\n * @param {Paragraph} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function paragraph(node, _, state, info) {\n  const exit = state.enter('paragraph')\n  const subexit = state.enter('phrasing')\n  const value = state.containerPhrasing(node, info)\n  subexit()\n  exit()\n  return value\n}\n","/**\n * @typedef {import('mdast').Html} Html\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n */\n\nimport {convert} from 'unist-util-is'\n\n/**\n * Check if the given value is *phrasing content*.\n *\n * > 👉 **Note**: Excludes `html`, which can be both phrasing or flow.\n *\n * @param node\n *   Thing to check, typically `Node`.\n * @returns\n *   Whether `value` is phrasing content.\n */\n\nexport const phrasing =\n  /** @type {(node?: unknown) => node is Exclude<PhrasingContent, Html>} */\n  (\n    convert([\n      'break',\n      'delete',\n      'emphasis',\n      // To do: next major: removed since footnotes were added to GFM.\n      'footnote',\n      'footnoteReference',\n      'image',\n      'imageReference',\n      'inlineCode',\n      // Enabled by `mdast-util-math`:\n      'inlineMath',\n      'link',\n      'linkReference',\n      // Enabled by `mdast-util-mdx`:\n      'mdxJsxTextElement',\n      // Enabled by `mdast-util-mdx`:\n      'mdxTextExpression',\n      'strong',\n      'text',\n      // Enabled by `mdast-util-directive`:\n      'textDirective'\n    ])\n  )\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Parents, Root} from 'mdast'\n */\n\nimport {phrasing} from 'mdast-util-phrasing'\n\n/**\n * @param {Root} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function root(node, _, state, info) {\n  // Note: `html` nodes are ambiguous.\n  const hasPhrasing = node.children.some(function (d) {\n    return phrasing(d)\n  })\n\n  const container = hasPhrasing ? state.containerPhrasing : state.containerFlow\n  return container.call(state, node, info)\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['strong'], null | undefined>}\n */\nexport function checkStrong(state) {\n  const marker = state.options.strong || '*'\n\n  if (marker !== '*' && marker !== '_') {\n    throw new Error(\n      'Cannot serialize strong with `' +\n        marker +\n        '` for `options.strong`, expected `*`, or `_`'\n    )\n  }\n\n  return marker\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Parents, Strong} from 'mdast'\n */\n\nimport {checkStrong} from '../util/check-strong.js'\nimport {encodeCharacterReference} from '../util/encode-character-reference.js'\nimport {encodeInfo} from '../util/encode-info.js'\n\nstrong.peek = strongPeek\n\n/**\n * @param {Strong} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function strong(node, _, state, info) {\n  const marker = checkStrong(state)\n  const exit = state.enter('strong')\n  const tracker = state.createTracker(info)\n  const before = tracker.move(marker + marker)\n\n  let between = tracker.move(\n    state.containerPhrasing(node, {\n      after: marker,\n      before,\n      ...tracker.current()\n    })\n  )\n  const betweenHead = between.charCodeAt(0)\n  const open = encodeInfo(\n    info.before.charCodeAt(info.before.length - 1),\n    betweenHead,\n    marker\n  )\n\n  if (open.inside) {\n    between = encodeCharacterReference(betweenHead) + between.slice(1)\n  }\n\n  const betweenTail = between.charCodeAt(between.length - 1)\n  const close = encodeInfo(info.after.charCodeAt(0), betweenTail, marker)\n\n  if (close.inside) {\n    between = between.slice(0, -1) + encodeCharacterReference(betweenTail)\n  }\n\n  const after = tracker.move(marker + marker)\n\n  exit()\n\n  state.attentionEncodeSurroundingInfo = {\n    after: close.outside,\n    before: open.outside\n  }\n  return before + between + after\n}\n\n/**\n * @param {Strong} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nfunction strongPeek(_, _1, state) {\n  return state.options.strong || '*'\n}\n","/**\n * @import {Info, State} from 'mdast-util-to-markdown'\n * @import {Parents, Text} from 'mdast'\n */\n\n/**\n * @param {Text} node\n * @param {Parents | undefined} _\n * @param {State} state\n * @param {Info} info\n * @returns {string}\n */\nexport function text(node, _, state, info) {\n  return state.safe(node.value, info)\n}\n","/**\n * @import {Options, State} from 'mdast-util-to-markdown'\n */\n\n/**\n * @param {State} state\n * @returns {Exclude<Options['ruleRepetition'], null | undefined>}\n */\nexport function checkRuleRepetition(state) {\n  const repetition = state.options.ruleRepetition || 3\n\n  if (repetition < 3) {\n    throw new Error(\n      'Cannot serialize rules with repetition `' +\n        repetition +\n        '` for `options.ruleRepetition`, expected `3` or more'\n    )\n  }\n\n  return repetition\n}\n","/**\n * @import {State} from 'mdast-util-to-markdown'\n * @import {Parents, ThematicBreak} from 'mdast'\n */\n\nimport {checkRuleRepetition} from '../util/check-rule-repetition.js'\nimport {checkRule} from '../util/check-rule.js'\n\n/**\n * @param {ThematicBreak} _\n * @param {Parents | undefined} _1\n * @param {State} state\n * @returns {string}\n */\nexport function thematicBreak(_, _1, state) {\n  const value = (\n    checkRule(state) + (state.options.ruleSpaces ? ' ' : '')\n  ).repeat(checkRuleRepetition(state))\n\n  return state.options.ruleSpaces ? value.slice(0, -1) : value\n}\n","import {blockquote} from './blockquote.js'\nimport {hardBreak} from './break.js'\nimport {code} from './code.js'\nimport {definition} from './definition.js'\nimport {emphasis} from './emphasis.js'\nimport {heading} from './heading.js'\nimport {html} from './html.js'\nimport {image} from './image.js'\nimport {imageReference} from './image-reference.js'\nimport {inlineCode} from './inline-code.js'\nimport {link} from './link.js'\nimport {linkReference} from './link-reference.js'\nimport {list} from './list.js'\nimport {listItem} from './list-item.js'\nimport {paragraph} from './paragraph.js'\nimport {root} from './root.js'\nimport {strong} from './strong.js'\nimport {text} from './text.js'\nimport {thematicBreak} from './thematic-break.js'\n\n/**\n * Default (CommonMark) handlers.\n */\nexport const handle = {\n  blockquote,\n  break: hardBreak,\n  code,\n  definition,\n  emphasis,\n  hardBreak,\n  heading,\n  html,\n  image,\n  imageReference,\n  inlineCode,\n  link,\n  linkReference,\n  list,\n  listItem,\n  paragraph,\n  root,\n  strong,\n  text,\n  thematicBreak\n}\n","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('mdast').TableRow} TableRow\n *\n * @typedef {import('markdown-table').Options} MarkdownTableOptions\n *\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n *\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').State} State\n * @typedef {import('mdast-util-to-markdown').Info} Info\n */\n\n/**\n * @typedef Options\n *   Configuration.\n * @property {boolean | null | undefined} [tableCellPadding=true]\n *   Whether to add a space of padding between delimiters and cells (default:\n *   `true`).\n * @property {boolean | null | undefined} [tablePipeAlign=true]\n *   Whether to align the delimiters (default: `true`).\n * @property {MarkdownTableOptions['stringLength'] | null | undefined} [stringLength]\n *   Function to detect the length of table cell content, used when aligning\n *   the delimiters between cells (optional).\n */\n\nimport {ok as assert} from 'devlop'\nimport {markdownTable} from 'markdown-table'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM tables in\n * markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM tables.\n */\nexport function gfmTableFromMarkdown() {\n  return {\n    enter: {\n      table: enterTable,\n      tableData: enterCell,\n      tableHeader: enterCell,\n      tableRow: enterRow\n    },\n    exit: {\n      codeText: exitCodeText,\n      table: exitTable,\n      tableData: exit,\n      tableHeader: exit,\n      tableRow: exit\n    }\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterTable(token) {\n  const align = token._align\n  assert(align, 'expected `_align` on table')\n  this.enter(\n    {\n      type: 'table',\n      align: align.map(function (d) {\n        return d === 'none' ? null : d\n      }),\n      children: []\n    },\n    token\n  )\n  this.data.inTable = true\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitTable(token) {\n  this.exit(token)\n  this.data.inTable = undefined\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterRow(token) {\n  this.enter({type: 'tableRow', children: []}, token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exit(token) {\n  this.exit(token)\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction enterCell(token) {\n  this.enter({type: 'tableCell', children: []}, token)\n}\n\n// Overwrite the default code text data handler to unescape escaped pipes when\n// they are in tables.\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCodeText(token) {\n  let value = this.resume()\n\n  if (this.data.inTable) {\n    value = value.replace(/\\\\([\\\\|])/g, replace)\n  }\n\n  const node = this.stack[this.stack.length - 1]\n  assert(node.type === 'inlineCode')\n  node.value = value\n  this.exit(token)\n}\n\n/**\n * @param {string} $0\n * @param {string} $1\n * @returns {string}\n */\nfunction replace($0, $1) {\n  // Pipes work, backslashes don’t (but can’t escape pipes).\n  return $1 === '|' ? $1 : $0\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM tables in\n * markdown.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration.\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM tables.\n */\nexport function gfmTableToMarkdown(options) {\n  const settings = options || {}\n  const padding = settings.tableCellPadding\n  const alignDelimiters = settings.tablePipeAlign\n  const stringLength = settings.stringLength\n  const around = padding ? ' ' : '|'\n\n  return {\n    unsafe: [\n      {character: '\\r', inConstruct: 'tableCell'},\n      {character: '\\n', inConstruct: 'tableCell'},\n      // A pipe, when followed by a tab or space (padding), or a dash or colon\n      // (unpadded delimiter row), could result in a table.\n      {atBreak: true, character: '|', after: '[\\t :-]'},\n      // A pipe in a cell must be encoded.\n      {character: '|', inConstruct: 'tableCell'},\n      // A colon must be followed by a dash, in which case it could start a\n      // delimiter row.\n      {atBreak: true, character: ':', after: '-'},\n      // A delimiter row can also start with a dash, when followed by more\n      // dashes, a colon, or a pipe.\n      // This is a stricter version than the built in check for lists, thematic\n      // breaks, and setex heading underlines though:\n      // <https://github.com/syntax-tree/mdast-util-to-markdown/blob/51a2038/lib/unsafe.js#L57>\n      {atBreak: true, character: '-', after: '[:|-]'}\n    ],\n    handlers: {\n      inlineCode: inlineCodeWithTable,\n      table: handleTable,\n      tableCell: handleTableCell,\n      tableRow: handleTableRow\n    }\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {Table} node\n   */\n  function handleTable(node, _, state, info) {\n    return serializeData(handleTableAsData(node, state, info), node.align)\n  }\n\n  /**\n   * This function isn’t really used normally, because we handle rows at the\n   * table level.\n   * But, if someone passes in a table row, this ensures we make somewhat sense.\n   *\n   * @type {ToMarkdownHandle}\n   * @param {TableRow} node\n   */\n  function handleTableRow(node, _, state, info) {\n    const row = handleTableRowAsData(node, state, info)\n    const value = serializeData([row])\n    // `markdown-table` will always add an align row\n    return value.slice(0, value.indexOf('\\n'))\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {TableCell} node\n   */\n  function handleTableCell(node, _, state, info) {\n    const exit = state.enter('tableCell')\n    const subexit = state.enter('phrasing')\n    const value = state.containerPhrasing(node, {\n      ...info,\n      before: around,\n      after: around\n    })\n    subexit()\n    exit()\n    return value\n  }\n\n  /**\n   * @param {Array<Array<string>>} matrix\n   * @param {Array<string | null | undefined> | null | undefined} [align]\n   */\n  function serializeData(matrix, align) {\n    return markdownTable(matrix, {\n      align,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      alignDelimiters,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      padding,\n      // @ts-expect-error: `markdown-table` types should support `null`.\n      stringLength\n    })\n  }\n\n  /**\n   * @param {Table} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<Array<string>>} */\n    const result = []\n    const subexit = state.enter('table')\n\n    while (++index < children.length) {\n      result[index] = handleTableRowAsData(children[index], state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @param {TableRow} node\n   * @param {State} state\n   * @param {Info} info\n   */\n  function handleTableRowAsData(node, state, info) {\n    const children = node.children\n    let index = -1\n    /** @type {Array<string>} */\n    const result = []\n    const subexit = state.enter('tableRow')\n\n    while (++index < children.length) {\n      // Note: the positional info as used here is incorrect.\n      // Making it correct would be impossible due to aligning cells?\n      // And it would need copy/pasting `markdown-table` into this project.\n      result[index] = handleTableCell(children[index], node, state, info)\n    }\n\n    subexit()\n\n    return result\n  }\n\n  /**\n   * @type {ToMarkdownHandle}\n   * @param {InlineCode} node\n   */\n  function inlineCodeWithTable(node, parent, state) {\n    let value = defaultHandlers.inlineCode(node, parent, state)\n\n    if (state.stack.includes('tableCell')) {\n      value = value.replace(/\\|/g, '\\\\$&')\n    }\n\n    return value\n  }\n}\n","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast-util-from-markdown').CompileContext} CompileContext\n * @typedef {import('mdast-util-from-markdown').Extension} FromMarkdownExtension\n * @typedef {import('mdast-util-from-markdown').Handle} FromMarkdownHandle\n * @typedef {import('mdast-util-to-markdown').Options} ToMarkdownExtension\n * @typedef {import('mdast-util-to-markdown').Handle} ToMarkdownHandle\n */\n\nimport {ok as assert} from 'devlop'\nimport {defaultHandlers} from 'mdast-util-to-markdown'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM task\n * list items in markdown.\n *\n * @returns {FromMarkdownExtension}\n *   Extension for `mdast-util-from-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemFromMarkdown() {\n  return {\n    exit: {\n      taskListCheckValueChecked: exitCheck,\n      taskListCheckValueUnchecked: exitCheck,\n      paragraph: exitParagraphWithTaskListItem\n    }\n  }\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM task list\n * items in markdown.\n *\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM task list items.\n */\nexport function gfmTaskListItemToMarkdown() {\n  return {\n    unsafe: [{atBreak: true, character: '-', after: '[:|-]'}],\n    handlers: {listItem: listItemWithTaskListItem}\n  }\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitCheck(token) {\n  // We’re always in a paragraph, in a list item.\n  const node = this.stack[this.stack.length - 2]\n  assert(node.type === 'listItem')\n  node.checked = token.type === 'taskListCheckValueChecked'\n}\n\n/**\n * @this {CompileContext}\n * @type {FromMarkdownHandle}\n */\nfunction exitParagraphWithTaskListItem(token) {\n  const parent = this.stack[this.stack.length - 2]\n\n  if (\n    parent &&\n    parent.type === 'listItem' &&\n    typeof parent.checked === 'boolean'\n  ) {\n    const node = this.stack[this.stack.length - 1]\n    assert(node.type === 'paragraph')\n    const head = node.children[0]\n\n    if (head && head.type === 'text') {\n      const siblings = parent.children\n      let index = -1\n      /** @type {Paragraph | undefined} */\n      let firstParaghraph\n\n      while (++index < siblings.length) {\n        const sibling = siblings[index]\n        if (sibling.type === 'paragraph') {\n          firstParaghraph = sibling\n          break\n        }\n      }\n\n      if (firstParaghraph === node) {\n        // Must start with a space or a tab.\n        head.value = head.value.slice(1)\n\n        if (head.value.length === 0) {\n          node.children.shift()\n        } else if (\n          node.position &&\n          head.position &&\n          typeof head.position.start.offset === 'number'\n        ) {\n          head.position.start.column++\n          head.position.start.offset++\n          node.position.start = Object.assign({}, head.position.start)\n        }\n      }\n    }\n  }\n\n  this.exit(token)\n}\n\n/**\n * @type {ToMarkdownHandle}\n * @param {ListItem} node\n */\nfunction listItemWithTaskListItem(node, parent, state, info) {\n  const head = node.children[0]\n  const checkable =\n    typeof node.checked === 'boolean' && head && head.type === 'paragraph'\n  const checkbox = '[' + (node.checked ? 'x' : ' ') + '] '\n  const tracker = state.createTracker(info)\n\n  if (checkable) {\n    tracker.move(checkbox)\n  }\n\n  let value = defaultHandlers.listItem(node, parent, state, {\n    ...info,\n    ...tracker.current()\n  })\n\n  if (checkable) {\n    value = value.replace(/^(?:[*+-]|\\d+\\.)([\\r\\n]| {1,3})/, check)\n  }\n\n  return value\n\n  /**\n   * @param {string} $0\n   * @returns {string}\n   */\n  function check($0) {\n    return $0 + checkbox\n  }\n}\n","/**\n * @import {Extension as FromMarkdownExtension} from 'mdast-util-from-markdown'\n * @import {Options} from 'mdast-util-gfm'\n * @import {Options as ToMarkdownExtension} from 'mdast-util-to-markdown'\n */\n\nimport {\n  gfmAutolinkLiteralFromMarkdown,\n  gfmAutolinkLiteralToMarkdown\n} from 'mdast-util-gfm-autolink-literal'\nimport {\n  gfmFootnoteFromMarkdown,\n  gfmFootnoteToMarkdown\n} from 'mdast-util-gfm-footnote'\nimport {\n  gfmStrikethroughFromMarkdown,\n  gfmStrikethroughToMarkdown\n} from 'mdast-util-gfm-strikethrough'\nimport {gfmTableFromMarkdown, gfmTableToMarkdown} from 'mdast-util-gfm-table'\nimport {\n  gfmTaskListItemFromMarkdown,\n  gfmTaskListItemToMarkdown\n} from 'mdast-util-gfm-task-list-item'\n\n/**\n * Create an extension for `mdast-util-from-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @returns {Array<FromMarkdownExtension>}\n *   Extension for `mdast-util-from-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmFromMarkdown() {\n  return [\n    gfmAutolinkLiteralFromMarkdown(),\n    gfmFootnoteFromMarkdown(),\n    gfmStrikethroughFromMarkdown(),\n    gfmTableFromMarkdown(),\n    gfmTaskListItemFromMarkdown()\n  ]\n}\n\n/**\n * Create an extension for `mdast-util-to-markdown` to enable GFM (autolink\n * literals, footnotes, strikethrough, tables, tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {ToMarkdownExtension}\n *   Extension for `mdast-util-to-markdown` to enable GFM (autolink literals,\n *   footnotes, strikethrough, tables, tasklists).\n */\nexport function gfmToMarkdown(options) {\n  return {\n    extensions: [\n      gfmAutolinkLiteralToMarkdown(),\n      gfmFootnoteToMarkdown(options),\n      gfmStrikethroughToMarkdown(),\n      gfmTableToMarkdown(options),\n      gfmTaskListItemToMarkdown()\n    ]\n  }\n}\n","/**\n * @import {Code, ConstructRecord, Event, Extension, Previous, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { asciiAlpha, asciiAlphanumeric, asciiControl, markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\nconst wwwPrefix = {\n  tokenize: tokenizeWwwPrefix,\n  partial: true\n};\nconst domain = {\n  tokenize: tokenizeDomain,\n  partial: true\n};\nconst path = {\n  tokenize: tokenizePath,\n  partial: true\n};\nconst trail = {\n  tokenize: tokenizeTrail,\n  partial: true\n};\nconst emailDomainDotTrail = {\n  tokenize: tokenizeEmailDomainDotTrail,\n  partial: true\n};\nconst wwwAutolink = {\n  name: 'wwwAutolink',\n  tokenize: tokenizeWwwAutolink,\n  previous: previousWww\n};\nconst protocolAutolink = {\n  name: 'protocolAutolink',\n  tokenize: tokenizeProtocolAutolink,\n  previous: previousProtocol\n};\nconst emailAutolink = {\n  name: 'emailAutolink',\n  tokenize: tokenizeEmailAutolink,\n  previous: previousEmail\n};\n\n/** @type {ConstructRecord} */\nconst text = {};\n\n/**\n * Create an extension for `micromark` to support GitHub autolink literal\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   autolink literal syntax.\n */\nexport function gfmAutolinkLiteral() {\n  return {\n    text\n  };\n}\n\n/** @type {Code} */\nlet code = 48;\n\n// Add alphanumerics.\nwhile (code < 123) {\n  text[code] = emailAutolink;\n  code++;\n  if (code === 58) code = 65;else if (code === 91) code = 97;\n}\ntext[43] = emailAutolink;\ntext[45] = emailAutolink;\ntext[46] = emailAutolink;\ntext[95] = emailAutolink;\ntext[72] = [emailAutolink, protocolAutolink];\ntext[104] = [emailAutolink, protocolAutolink];\ntext[87] = [emailAutolink, wwwAutolink];\ntext[119] = [emailAutolink, wwwAutolink];\n\n// To do: perform email autolink literals on events, afterwards.\n// That’s where `markdown-rs` and `cmark-gfm` perform it.\n// It should look for `@`, then for atext backwards, and then for a label\n// forwards.\n// To do: `mailto:`, `xmpp:` protocol as prefix.\n\n/**\n * Email autolink literal.\n *\n * ```markdown\n * > | a contact@example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailAutolink(effects, ok, nok) {\n  const self = this;\n  /** @type {boolean | undefined} */\n  let dot;\n  /** @type {boolean} */\n  let data;\n  return start;\n\n  /**\n   * Start of email autolink literal.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    if (!gfmAtext(code) || !previousEmail.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkEmail');\n    return atext(code);\n  }\n\n  /**\n   * In email atext.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function atext(code) {\n    if (gfmAtext(code)) {\n      effects.consume(code);\n      return atext;\n    }\n    if (code === 64) {\n      effects.consume(code);\n      return emailDomain;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In email domain.\n   *\n   * The reference code is a bit overly complex as it handles the `@`, of which\n   * there may be just one.\n   * Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L318>\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *               ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomain(code) {\n    // Dot followed by alphanumerical (not `-` or `_`).\n    if (code === 46) {\n      return effects.check(emailDomainDotTrail, emailDomainAfter, emailDomainDot)(code);\n    }\n\n    // Alphanumerical, `-`, and `_`.\n    if (code === 45 || code === 95 || asciiAlphanumeric(code)) {\n      data = true;\n      effects.consume(code);\n      return emailDomain;\n    }\n\n    // To do: `/` if xmpp.\n\n    // Note: normally we’d truncate trailing punctuation from the link.\n    // However, email autolink literals cannot contain any of those markers,\n    // except for `.`, but that can only occur if it isn’t trailing.\n    // So we can ignore truncating!\n    return emailDomainAfter(code);\n  }\n\n  /**\n   * In email domain, on dot that is not a trail.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainDot(code) {\n    effects.consume(code);\n    dot = true;\n    return emailDomain;\n  }\n\n  /**\n   * After email domain.\n   *\n   * ```markdown\n   * > | a contact@example.org b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function emailDomainAfter(code) {\n    // Domain must not be empty, must include a dot, and must end in alphabetical.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L332>.\n    if (data && dot && asciiAlpha(self.previous)) {\n      effects.exit('literalAutolinkEmail');\n      effects.exit('literalAutolink');\n      return ok(code);\n    }\n    return nok(code);\n  }\n}\n\n/**\n * `www` autolink literal.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwAutolink(effects, ok, nok) {\n  const self = this;\n  return wwwStart;\n\n  /**\n   * Start of www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwStart(code) {\n    if (code !== 87 && code !== 119 || !previousWww.call(self, self.previous) || previousUnbalanced(self.events)) {\n      return nok(code);\n    }\n    effects.enter('literalAutolink');\n    effects.enter('literalAutolinkWww');\n    // Note: we *check*, so we can discard the `www.` we parsed.\n    // If it worked, we consider it as a part of the domain.\n    return effects.check(wwwPrefix, effects.attempt(domain, effects.attempt(path, wwwAfter), nok), nok)(code);\n  }\n\n  /**\n   * After a www autolink literal.\n   *\n   * ```markdown\n   * > | www.example.com/a?b#c\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwAfter(code) {\n    effects.exit('literalAutolinkWww');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * Protocol autolink literal.\n *\n * ```markdown\n * > | a https://example.org b\n *       ^^^^^^^^^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeProtocolAutolink(effects, ok, nok) {\n  const self = this;\n  let buffer = '';\n  let seen = false;\n  return protocolStart;\n\n  /**\n   * Start of protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolStart(code) {\n    if ((code === 72 || code === 104) && previousProtocol.call(self, self.previous) && !previousUnbalanced(self.events)) {\n      effects.enter('literalAutolink');\n      effects.enter('literalAutolinkHttp');\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In protocol.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *     ^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolPrefixInside(code) {\n    // `5` is size of `https`\n    if (asciiAlpha(code) && buffer.length < 5) {\n      // @ts-expect-error: definitely number.\n      buffer += String.fromCodePoint(code);\n      effects.consume(code);\n      return protocolPrefixInside;\n    }\n    if (code === 58) {\n      const protocol = buffer.toLowerCase();\n      if (protocol === 'http' || protocol === 'https') {\n        effects.consume(code);\n        return protocolSlashesInside;\n      }\n    }\n    return nok(code);\n  }\n\n  /**\n   * In slashes.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *           ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolSlashesInside(code) {\n    if (code === 47) {\n      effects.consume(code);\n      if (seen) {\n        return afterProtocol;\n      }\n      seen = true;\n      return protocolSlashesInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After protocol, before domain.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *             ^\n   * ```\n   *\n   * @type {State}\n   */\n  function afterProtocol(code) {\n    // To do: this is different from `markdown-rs`:\n    // https://github.com/wooorm/markdown-rs/blob/b3a921c761309ae00a51fe348d8a43adbc54b518/src/construct/gfm_autolink_literal.rs#L172-L182\n    return code === null || asciiControl(code) || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || unicodePunctuation(code) ? nok(code) : effects.attempt(domain, effects.attempt(path, protocolAfter), nok)(code);\n  }\n\n  /**\n   * After a protocol autolink literal.\n   *\n   * ```markdown\n   * > | https://example.com/a?b#c\n   *                              ^\n   * ```\n   *\n   * @type {State}\n   */\n  function protocolAfter(code) {\n    effects.exit('literalAutolinkHttp');\n    effects.exit('literalAutolink');\n    return ok(code);\n  }\n}\n\n/**\n * `www` prefix.\n *\n * ```markdown\n * > | a www.example.org b\n *       ^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeWwwPrefix(effects, ok, nok) {\n  let size = 0;\n  return wwwPrefixInside;\n\n  /**\n   * In www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *     ^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixInside(code) {\n    if ((code === 87 || code === 119) && size < 3) {\n      size++;\n      effects.consume(code);\n      return wwwPrefixInside;\n    }\n    if (code === 46 && size === 3) {\n      effects.consume(code);\n      return wwwPrefixAfter;\n    }\n    return nok(code);\n  }\n\n  /**\n   * After www prefix.\n   *\n   * ```markdown\n   * > | www.example.com\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function wwwPrefixAfter(code) {\n    // If there is *anything*, we can link.\n    return code === null ? nok(code) : ok(code);\n  }\n}\n\n/**\n * Domain.\n *\n * ```markdown\n * > | a https://example.org b\n *               ^^^^^^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDomain(effects, ok, nok) {\n  /** @type {boolean | undefined} */\n  let underscoreInLastSegment;\n  /** @type {boolean | undefined} */\n  let underscoreInLastLastSegment;\n  /** @type {boolean | undefined} */\n  let seen;\n  return domainInside;\n\n  /**\n   * In domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *             ^^^^^^^^^^^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainInside(code) {\n    // Check whether this marker, which is a trailing punctuation\n    // marker, optionally followed by more trailing markers, and then\n    // followed by an end.\n    if (code === 46 || code === 95) {\n      return effects.check(trail, domainAfter, domainAtPunctuation)(code);\n    }\n\n    // GH documents that only alphanumerics (other than `-`, `.`, and `_`) can\n    // occur, which sounds like ASCII only, but they also support `www.點看.com`,\n    // so that’s Unicode.\n    // Instead of some new production for Unicode alphanumerics, markdown\n    // already has that for Unicode punctuation and whitespace, so use those.\n    // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L12>.\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code) || code !== 45 && unicodePunctuation(code)) {\n      return domainAfter(code);\n    }\n    seen = true;\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * In domain, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com\n   *                    ^\n   * ```\n   *\n   * @type {State}\n   */\n  function domainAtPunctuation(code) {\n    // There is an underscore in the last segment of the domain\n    if (code === 95) {\n      underscoreInLastSegment = true;\n    }\n    // Otherwise, it’s a `.`: save the last segment underscore in the\n    // penultimate segment slot.\n    else {\n      underscoreInLastLastSegment = underscoreInLastSegment;\n      underscoreInLastSegment = undefined;\n    }\n    effects.consume(code);\n    return domainInside;\n  }\n\n  /**\n   * After domain.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^\n   * ```\n   *\n   * @type {State} */\n  function domainAfter(code) {\n    // Note: that’s GH says a dot is needed, but it’s not true:\n    // <https://github.com/github/cmark-gfm/issues/279>\n    if (underscoreInLastLastSegment || underscoreInLastSegment || !seen) {\n      return nok(code);\n    }\n    return ok(code);\n  }\n}\n\n/**\n * Path.\n *\n * ```markdown\n * > | a https://example.org/stuff b\n *                          ^^^^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePath(effects, ok) {\n  let sizeOpen = 0;\n  let sizeClose = 0;\n  return pathInside;\n\n  /**\n   * In path.\n   *\n   * ```markdown\n   * > | https://example.com/a\n   *                        ^^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathInside(code) {\n    if (code === 40) {\n      sizeOpen++;\n      effects.consume(code);\n      return pathInside;\n    }\n\n    // To do: `markdown-rs` also needs this.\n    // If this is a paren, and there are less closings than openings,\n    // we don’t check for a trail.\n    if (code === 41 && sizeClose < sizeOpen) {\n      return pathAtPunctuation(code);\n    }\n\n    // Check whether this trailing punctuation marker is optionally\n    // followed by more trailing markers, and then followed\n    // by an end.\n    if (code === 33 || code === 34 || code === 38 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 60 || code === 63 || code === 93 || code === 95 || code === 126) {\n      return effects.check(trail, ok, pathAtPunctuation)(code);\n    }\n    if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n\n  /**\n   * In path, at potential trailing punctuation, that was not trailing.\n   *\n   * ```markdown\n   * > | https://example.com/a\"b\n   *                          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function pathAtPunctuation(code) {\n    // Count closing parens.\n    if (code === 41) {\n      sizeClose++;\n    }\n    effects.consume(code);\n    return pathInside;\n  }\n}\n\n/**\n * Trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the entire trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | https://example.com\").\n *                        ^^^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTrail(effects, ok, nok) {\n  return trail;\n\n  /**\n   * In trail of domain or path.\n   *\n   * ```markdown\n   * > | https://example.com\").\n   *                        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trail(code) {\n    // Regular trailing punctuation.\n    if (code === 33 || code === 34 || code === 39 || code === 41 || code === 42 || code === 44 || code === 46 || code === 58 || code === 59 || code === 63 || code === 95 || code === 126) {\n      effects.consume(code);\n      return trail;\n    }\n\n    // `&` followed by one or more alphabeticals and then a `;`, is\n    // as a whole considered as trailing punctuation.\n    // In all other cases, it is considered as continuation of the URL.\n    if (code === 38) {\n      effects.consume(code);\n      return trailCharacterReferenceStart;\n    }\n\n    // Needed because we allow literals after `[`, as we fix:\n    // <https://github.com/github/cmark-gfm/issues/278>.\n    // Check that it is not followed by `(` or `[`.\n    if (code === 93) {\n      effects.consume(code);\n      return trailBracketAfter;\n    }\n    if (\n    // `<` is an end.\n    code === 60 ||\n    // So is whitespace.\n    code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return nok(code);\n  }\n\n  /**\n   * In trail, after `]`.\n   *\n   * > 👉 **Note**: this deviates from `cmark-gfm` to fix a bug.\n   * > See end of <https://github.com/github/cmark-gfm/issues/278> for more.\n   *\n   * ```markdown\n   * > | https://example.com](\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailBracketAfter(code) {\n    // Whitespace or something that could start a resource or reference is the end.\n    // Switch back to trail otherwise.\n    if (code === null || code === 40 || code === 91 || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n      return ok(code);\n    }\n    return trail(code);\n  }\n\n  /**\n   * In character-reference like trail, after `&`.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceStart(code) {\n    // When non-alpha, it’s not a trail.\n    return asciiAlpha(code) ? trailCharacterReferenceInside(code) : nok(code);\n  }\n\n  /**\n   * In character-reference like trail.\n   *\n   * ```markdown\n   * > | https://example.com&amp;).\n   *                         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function trailCharacterReferenceInside(code) {\n    // Switch back to trail if this is well-formed.\n    if (code === 59) {\n      effects.consume(code);\n      return trail;\n    }\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return trailCharacterReferenceInside;\n    }\n\n    // It’s not a trail.\n    return nok(code);\n  }\n}\n\n/**\n * Dot in email domain trail.\n *\n * This calls `ok` if this *is* the trail, followed by an end, which means\n * the trail is not part of the link.\n * It calls `nok` if this *is* part of the link.\n *\n * ```markdown\n * > | contact@example.org.\n *                        ^\n * ```\n *\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeEmailDomainDotTrail(effects, ok, nok) {\n  return start;\n\n  /**\n   * Dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                    ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    // Must be dot.\n    effects.consume(code);\n    return after;\n  }\n\n  /**\n   * After dot.\n   *\n   * ```markdown\n   * > | contact@example.org.\n   *                     ^   ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // Not a trail if alphanumeric.\n    return asciiAlphanumeric(code) ? nok(code) : ok(code);\n  }\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L156>.\n *\n * @type {Previous}\n */\nfunction previousWww(code) {\n  return code === null || code === 40 || code === 42 || code === 95 || code === 91 || code === 93 || code === 126 || markdownLineEndingOrSpace(code);\n}\n\n/**\n * See:\n * <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L214>.\n *\n * @type {Previous}\n */\nfunction previousProtocol(code) {\n  return !asciiAlpha(code);\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Previous}\n */\nfunction previousEmail(code) {\n  // Do not allow a slash “inside” atext.\n  // The reference code is a bit weird, but that’s what it results in.\n  // Source: <https://github.com/github/cmark-gfm/blob/ef1cfcb/extensions/autolink.c#L307>.\n  // Other than slash, every preceding character is allowed.\n  return !(code === 47 || gfmAtext(code));\n}\n\n/**\n * @param {Code} code\n * @returns {boolean}\n */\nfunction gfmAtext(code) {\n  return code === 43 || code === 45 || code === 46 || code === 95 || asciiAlphanumeric(code);\n}\n\n/**\n * @param {Array<Event>} events\n * @returns {boolean}\n */\nfunction previousUnbalanced(events) {\n  let index = events.length;\n  let result = false;\n  while (index--) {\n    const token = events[index][1];\n    if ((token.type === 'labelLink' || token.type === 'labelImage') && !token._balanced) {\n      result = true;\n      break;\n    }\n\n    // If we’ve seen this token, and it was marked as not having any unbalanced\n    // bracket before it, we can exit.\n    if (token._gfmAutolinkLiteralWalkedInto) {\n      result = false;\n      break;\n    }\n  }\n  if (events.length > 0 && !result) {\n    // Mark the last token as “walked into” w/o finding\n    // anything.\n    events[events.length - 1][1]._gfmAutolinkLiteralWalkedInto = true;\n  }\n  return result;\n}","/**\n * @import {Event, Exiter, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { blankLine } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nconst indent = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n\n// To do: micromark should support a `_hiddenGfmFootnoteSupport`, which only\n// affects label start (image).\n// That will let us drop `tokenizePotentialGfmFootnote*`.\n// It currently has a `_hiddenFootnoteSupport`, which affects that and more.\n// That can be removed when `micromark-extension-footnote` is archived.\n\n/**\n * Create an extension for `micromark` to enable GFM footnote syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to\n *   enable GFM footnote syntax.\n */\nexport function gfmFootnote() {\n  /** @type {Extension} */\n  return {\n    document: {\n      [91]: {\n        name: 'gfmFootnoteDefinition',\n        tokenize: tokenizeDefinitionStart,\n        continuation: {\n          tokenize: tokenizeDefinitionContinuation\n        },\n        exit: gfmFootnoteDefinitionEnd\n      }\n    },\n    text: {\n      [91]: {\n        name: 'gfmFootnoteCall',\n        tokenize: tokenizeGfmFootnoteCall\n      },\n      [93]: {\n        name: 'gfmPotentialFootnoteCall',\n        add: 'after',\n        tokenize: tokenizePotentialGfmFootnoteCall,\n        resolveTo: resolveToPotentialGfmFootnoteCall\n      }\n    }\n  };\n}\n\n// To do: remove after micromark update.\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizePotentialGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {Token} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    const token = self.events[index][1];\n    if (token.type === \"labelImage\") {\n      labelStart = token;\n      break;\n    }\n\n    // Exit if we’ve walked far enough.\n    if (token.type === 'gfmFootnoteCall' || token.type === \"labelLink\" || token.type === \"label\" || token.type === \"image\" || token.type === \"link\") {\n      break;\n    }\n  }\n  return start;\n\n  /**\n   * @type {State}\n   */\n  function start(code) {\n    if (!labelStart || !labelStart._balanced) {\n      return nok(code);\n    }\n    const id = normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    }));\n    if (id.codePointAt(0) !== 94 || !defined.includes(id.slice(1))) {\n      return nok(code);\n    }\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return ok(code);\n  }\n}\n\n// To do: remove after micromark update.\n/** @type {Resolver} */\nfunction resolveToPotentialGfmFootnoteCall(events, context) {\n  let index = events.length;\n  /** @type {Token | undefined} */\n  let labelStart;\n\n  // Find an opening.\n  while (index--) {\n    if (events[index][1].type === \"labelImage\" && events[index][0] === 'enter') {\n      labelStart = events[index][1];\n      break;\n    }\n  }\n  // Change the `labelImageMarker` to a `data`.\n  events[index + 1][1].type = \"data\";\n  events[index + 3][1].type = 'gfmFootnoteCallLabelMarker';\n\n  // The whole (without `!`):\n  /** @type {Token} */\n  const call = {\n    type: 'gfmFootnoteCall',\n    start: Object.assign({}, events[index + 3][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  // The `^` marker\n  /** @type {Token} */\n  const marker = {\n    type: 'gfmFootnoteCallMarker',\n    start: Object.assign({}, events[index + 3][1].end),\n    end: Object.assign({}, events[index + 3][1].end)\n  };\n  // Increment the end 1 character.\n  marker.end.column++;\n  marker.end.offset++;\n  marker.end._bufferIndex++;\n  /** @type {Token} */\n  const string = {\n    type: 'gfmFootnoteCallString',\n    start: Object.assign({}, marker.end),\n    end: Object.assign({}, events[events.length - 1][1].start)\n  };\n  /** @type {Token} */\n  const chunk = {\n    type: \"chunkString\",\n    contentType: 'string',\n    start: Object.assign({}, string.start),\n    end: Object.assign({}, string.end)\n  };\n\n  /** @type {Array<Event>} */\n  const replacement = [\n  // Take the `labelImageMarker` (now `data`, the `!`)\n  events[index + 1], events[index + 2], ['enter', call, context],\n  // The `[`\n  events[index + 3], events[index + 4],\n  // The `^`.\n  ['enter', marker, context], ['exit', marker, context],\n  // Everything in between.\n  ['enter', string, context], ['enter', chunk, context], ['exit', chunk, context], ['exit', string, context],\n  // The ending (`]`, properly parsed and labelled).\n  events[events.length - 2], events[events.length - 1], ['exit', call, context]];\n  events.splice(index, events.length - index + 1, ...replacement);\n  return events;\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeGfmFootnoteCall(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  let size = 0;\n  /** @type {boolean} */\n  let data;\n\n  // Note: the implementation of `markdown-rs` is different, because it houses\n  // core *and* extensions in one project.\n  // Therefore, it can include footnote logic inside `label-end`.\n  // We can’t do that, but luckily, we can parse footnotes in a simpler way than\n  // needed for labels.\n  return start;\n\n  /**\n   * Start of footnote label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteCall');\n    effects.enter('gfmFootnoteCallLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallLabelMarker');\n    return callStart;\n  }\n\n  /**\n   * After `[`, at `^`.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callStart(code) {\n    if (code !== 94) return nok(code);\n    effects.enter('gfmFootnoteCallMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteCallMarker');\n    effects.enter('gfmFootnoteCallString');\n    effects.enter('chunkString').contentType = 'string';\n    return callData;\n  }\n\n  /**\n   * In label.\n   *\n   * ```markdown\n   * > | a [^b] c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callData(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteCallString');\n      if (!defined.includes(normalizeIdentifier(self.sliceSerialize(token)))) {\n        return nok(code);\n      }\n      effects.enter('gfmFootnoteCallLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteCallLabelMarker');\n      effects.exit('gfmFootnoteCall');\n      return ok;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? callEscape : callData;\n  }\n\n  /**\n   * On character after escape.\n   *\n   * ```markdown\n   * > | a [^b\\c] d\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function callEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return callData;\n    }\n    return callData(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionStart(effects, ok, nok) {\n  const self = this;\n  const defined = self.parser.gfmFootnotes || (self.parser.gfmFootnotes = []);\n  /** @type {string} */\n  let identifier;\n  let size = 0;\n  /** @type {boolean | undefined} */\n  let data;\n  return start;\n\n  /**\n   * Start of GFM footnote definition.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function start(code) {\n    effects.enter('gfmFootnoteDefinition')._container = true;\n    effects.enter('gfmFootnoteDefinitionLabel');\n    effects.enter('gfmFootnoteDefinitionLabelMarker');\n    effects.consume(code);\n    effects.exit('gfmFootnoteDefinitionLabelMarker');\n    return labelAtMarker;\n  }\n\n  /**\n   * In label, at caret.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAtMarker(code) {\n    if (code === 94) {\n      effects.enter('gfmFootnoteDefinitionMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionMarker');\n      effects.enter('gfmFootnoteDefinitionLabelString');\n      effects.enter('chunkString').contentType = 'string';\n      return labelInside;\n    }\n    return nok(code);\n  }\n\n  /**\n   * In label.\n   *\n   * > 👉 **Note**: `cmark-gfm` prevents whitespace from occurring in footnote\n   * > definition labels.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelInside(code) {\n    if (\n    // Too long.\n    size > 999 ||\n    // Closing brace with nothing.\n    code === 93 && !data ||\n    // Space or tab is not supported by GFM for some reason.\n    // `\\n` and `[` not being supported makes sense.\n    code === null || code === 91 || markdownLineEndingOrSpace(code)) {\n      return nok(code);\n    }\n    if (code === 93) {\n      effects.exit('chunkString');\n      const token = effects.exit('gfmFootnoteDefinitionLabelString');\n      identifier = normalizeIdentifier(self.sliceSerialize(token));\n      effects.enter('gfmFootnoteDefinitionLabelMarker');\n      effects.consume(code);\n      effects.exit('gfmFootnoteDefinitionLabelMarker');\n      effects.exit('gfmFootnoteDefinitionLabel');\n      return labelAfter;\n    }\n    if (!markdownLineEndingOrSpace(code)) {\n      data = true;\n    }\n    size++;\n    effects.consume(code);\n    return code === 92 ? labelEscape : labelInside;\n  }\n\n  /**\n   * After `\\`, at a special character.\n   *\n   * > 👉 **Note**: `cmark-gfm` currently does not support escaped brackets:\n   * > <https://github.com/github/cmark-gfm/issues/240>\n   *\n   * ```markdown\n   * > | [^a\\*b]: c\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return labelInside;\n    }\n    return labelInside(code);\n  }\n\n  /**\n   * After definition label.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function labelAfter(code) {\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker');\n      if (!defined.includes(identifier)) {\n        defined.push(identifier);\n      }\n\n      // Any whitespace after the marker is eaten, forming indented code\n      // is not possible.\n      // No space is also fine, just like a block quote marker.\n      return factorySpace(effects, whitespaceAfter, 'gfmFootnoteDefinitionWhitespace');\n    }\n    return nok(code);\n  }\n\n  /**\n   * After definition prefix.\n   *\n   * ```markdown\n   * > | [^a]: b\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function whitespaceAfter(code) {\n    // `markdown-rs` has a wrapping token for the prefix that is closed here.\n    return ok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeDefinitionContinuation(effects, ok, nok) {\n  /// Start of footnote definition continuation.\n  ///\n  /// ```markdown\n  ///   | [^a]: b\n  /// > |     c\n  ///     ^\n  /// ```\n  //\n  // Either a blank line, which is okay, or an indented thing.\n  return effects.check(blankLine, ok, effects.attempt(indent, ok, nok));\n}\n\n/** @type {Exiter} */\nfunction gfmFootnoteDefinitionEnd(effects) {\n  effects.exit('gfmFootnoteDefinition');\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'gfmFootnoteDefinitionIndent', 4 + 1);\n\n  /**\n   * @type {State}\n   */\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'gfmFootnoteDefinitionIndent' && tail[2].sliceSerialize(tail[1], true).length === 4 ? ok(code) : nok(code);\n  }\n}","/**\n * @import {Options} from 'micromark-extension-gfm-strikethrough'\n * @import {Event, Extension, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create an extension for `micromark` to enable GFM strikethrough syntax.\n *\n * @param {Options | null | undefined} [options={}]\n *   Configuration.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions`, to\n *   enable GFM strikethrough syntax.\n */\nexport function gfmStrikethrough(options) {\n  const options_ = options || {};\n  let single = options_.singleTilde;\n  const tokenizer = {\n    name: 'strikethrough',\n    tokenize: tokenizeStrikethrough,\n    resolveAll: resolveAllStrikethrough\n  };\n  if (single === null || single === undefined) {\n    single = true;\n  }\n  return {\n    text: {\n      [126]: tokenizer\n    },\n    insideSpan: {\n      null: [tokenizer]\n    },\n    attentionMarkers: {\n      null: [126]\n    }\n  };\n\n  /**\n   * Take events and resolve strikethrough.\n   *\n   * @type {Resolver}\n   */\n  function resolveAllStrikethrough(events, context) {\n    let index = -1;\n\n    // Walk through all events.\n    while (++index < events.length) {\n      // Find a token that can close.\n      if (events[index][0] === 'enter' && events[index][1].type === 'strikethroughSequenceTemporary' && events[index][1]._close) {\n        let open = index;\n\n        // Now walk back to find an opener.\n        while (open--) {\n          // Find a token that can open the closer.\n          if (events[open][0] === 'exit' && events[open][1].type === 'strikethroughSequenceTemporary' && events[open][1]._open &&\n          // If the sizes are the same:\n          events[index][1].end.offset - events[index][1].start.offset === events[open][1].end.offset - events[open][1].start.offset) {\n            events[index][1].type = 'strikethroughSequence';\n            events[open][1].type = 'strikethroughSequence';\n\n            /** @type {Token} */\n            const strikethrough = {\n              type: 'strikethrough',\n              start: Object.assign({}, events[open][1].start),\n              end: Object.assign({}, events[index][1].end)\n            };\n\n            /** @type {Token} */\n            const text = {\n              type: 'strikethroughText',\n              start: Object.assign({}, events[open][1].end),\n              end: Object.assign({}, events[index][1].start)\n            };\n\n            // Opening.\n            /** @type {Array<Event>} */\n            const nextEvents = [['enter', strikethrough, context], ['enter', events[open][1], context], ['exit', events[open][1], context], ['enter', text, context]];\n            const insideSpan = context.parser.constructs.insideSpan.null;\n            if (insideSpan) {\n              // Between.\n              splice(nextEvents, nextEvents.length, 0, resolveAll(insideSpan, events.slice(open + 1, index), context));\n            }\n\n            // Closing.\n            splice(nextEvents, nextEvents.length, 0, [['exit', text, context], ['enter', events[index][1], context], ['exit', events[index][1], context], ['exit', strikethrough, context]]);\n            splice(events, open - 1, index - open + 3, nextEvents);\n            index = open + nextEvents.length - 2;\n            break;\n          }\n        }\n      }\n    }\n    index = -1;\n    while (++index < events.length) {\n      if (events[index][1].type === 'strikethroughSequenceTemporary') {\n        events[index][1].type = \"data\";\n      }\n    }\n    return events;\n  }\n\n  /**\n   * @this {TokenizeContext}\n   * @type {Tokenizer}\n   */\n  function tokenizeStrikethrough(effects, ok, nok) {\n    const previous = this.previous;\n    const events = this.events;\n    let size = 0;\n    return start;\n\n    /** @type {State} */\n    function start(code) {\n      if (previous === 126 && events[events.length - 1][1].type !== \"characterEscape\") {\n        return nok(code);\n      }\n      effects.enter('strikethroughSequenceTemporary');\n      return more(code);\n    }\n\n    /** @type {State} */\n    function more(code) {\n      const before = classifyCharacter(previous);\n      if (code === 126) {\n        // If this is the third marker, exit.\n        if (size > 1) return nok(code);\n        effects.consume(code);\n        size++;\n        return more;\n      }\n      if (size < 2 && !single) return nok(code);\n      const token = effects.exit('strikethroughSequenceTemporary');\n      const after = classifyCharacter(code);\n      token._open = !after || after === 2 && Boolean(before);\n      token._close = !before || before === 2 && Boolean(after);\n      return ok(code);\n    }\n  }\n}","/**\n * @import {Event} from 'micromark-util-types'\n */\n\n// Port of `edit_map.rs` from `markdown-rs`.\n// This should move to `markdown-js` later.\n\n// Deal with several changes in events, batching them together.\n//\n// Preferably, changes should be kept to a minimum.\n// Sometimes, it’s needed to change the list of events, because parsing can be\n// messy, and it helps to expose a cleaner interface of events to the compiler\n// and other users.\n// It can also help to merge many adjacent similar events.\n// And, in other cases, it’s needed to parse subcontent: pass some events\n// through another tokenizer and inject the result.\n\n/**\n * @typedef {[number, number, Array<Event>]} Change\n * @typedef {[number, number, number]} Jump\n */\n\n/**\n * Tracks a bunch of edits.\n */\nexport class EditMap {\n  /**\n   * Create a new edit map.\n   */\n  constructor() {\n    /**\n     * Record of changes.\n     *\n     * @type {Array<Change>}\n     */\n    this.map = [];\n  }\n\n  /**\n   * Create an edit: a remove and/or add at a certain place.\n   *\n   * @param {number} index\n   * @param {number} remove\n   * @param {Array<Event>} add\n   * @returns {undefined}\n   */\n  add(index, remove, add) {\n    addImplementation(this, index, remove, add);\n  }\n\n  // To do: add this when moving to `micromark`.\n  // /**\n  //  * Create an edit: but insert `add` before existing additions.\n  //  *\n  //  * @param {number} index\n  //  * @param {number} remove\n  //  * @param {Array<Event>} add\n  //  * @returns {undefined}\n  //  */\n  // addBefore(index, remove, add) {\n  //   addImplementation(this, index, remove, add, true)\n  // }\n\n  /**\n   * Done, change the events.\n   *\n   * @param {Array<Event>} events\n   * @returns {undefined}\n   */\n  consume(events) {\n    this.map.sort(function (a, b) {\n      return a[0] - b[0];\n    });\n\n    /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n    if (this.map.length === 0) {\n      return;\n    }\n\n    // To do: if links are added in events, like they are in `markdown-rs`,\n    // this is needed.\n    // // Calculate jumps: where items in the current list move to.\n    // /** @type {Array<Jump>} */\n    // const jumps = []\n    // let index = 0\n    // let addAcc = 0\n    // let removeAcc = 0\n    // while (index < this.map.length) {\n    //   const [at, remove, add] = this.map[index]\n    //   removeAcc += remove\n    //   addAcc += add.length\n    //   jumps.push([at, removeAcc, addAcc])\n    //   index += 1\n    // }\n    //\n    // . shiftLinks(events, jumps)\n\n    let index = this.map.length;\n    /** @type {Array<Array<Event>>} */\n    const vecs = [];\n    while (index > 0) {\n      index -= 1;\n      vecs.push(events.slice(this.map[index][0] + this.map[index][1]), this.map[index][2]);\n\n      // Truncate rest.\n      events.length = this.map[index][0];\n    }\n    vecs.push(events.slice());\n    events.length = 0;\n    let slice = vecs.pop();\n    while (slice) {\n      for (const element of slice) {\n        events.push(element);\n      }\n      slice = vecs.pop();\n    }\n\n    // Truncate everything.\n    this.map.length = 0;\n  }\n}\n\n/**\n * Create an edit.\n *\n * @param {EditMap} editMap\n * @param {number} at\n * @param {number} remove\n * @param {Array<Event>} add\n * @returns {undefined}\n */\nfunction addImplementation(editMap, at, remove, add) {\n  let index = 0;\n\n  /* c8 ignore next 3 -- `resolve` is never called without tables, so without edits. */\n  if (remove === 0 && add.length === 0) {\n    return;\n  }\n  while (index < editMap.map.length) {\n    if (editMap.map[index][0] === at) {\n      editMap.map[index][1] += remove;\n\n      // To do: before not used by tables, use when moving to micromark.\n      // if (before) {\n      //   add.push(...editMap.map[index][2])\n      //   editMap.map[index][2] = add\n      // } else {\n      editMap.map[index][2].push(...add);\n      // }\n\n      return;\n    }\n    index += 1;\n  }\n  editMap.map.push([at, remove, add]);\n}\n\n// /**\n//  * Shift `previous` and `next` links according to `jumps`.\n//  *\n//  * This fixes links in case there are events removed or added between them.\n//  *\n//  * @param {Array<Event>} events\n//  * @param {Array<Jump>} jumps\n//  */\n// function shiftLinks(events, jumps) {\n//   let jumpIndex = 0\n//   let index = 0\n//   let add = 0\n//   let rm = 0\n\n//   while (index < events.length) {\n//     const rmCurr = rm\n\n//     while (jumpIndex < jumps.length && jumps[jumpIndex][0] <= index) {\n//       add = jumps[jumpIndex][2]\n//       rm = jumps[jumpIndex][1]\n//       jumpIndex += 1\n//     }\n\n//     // Ignore items that will be removed.\n//     if (rm > rmCurr) {\n//       index += rm - rmCurr\n//     } else {\n//       // ?\n//       // if let Some(link) = &events[index].link {\n//       //     if let Some(next) = link.next {\n//       //         events[next].link.as_mut().unwrap().previous = Some(index + add - rm);\n//       //         while jumpIndex < jumps.len() && jumps[jumpIndex].0 <= next {\n//       //             add = jumps[jumpIndex].2;\n//       //             rm = jumps[jumpIndex].1;\n//       //             jumpIndex += 1;\n//       //         }\n//       //         events[index].link.as_mut().unwrap().next = Some(next + add - rm);\n//       //         index = next;\n//       //         continue;\n//       //     }\n//       // }\n//       index += 1\n//     }\n//   }\n// }","/**\n * @import {Event} from 'micromark-util-types'\n */\n\n/**\n * @typedef {'center' | 'left' | 'none' | 'right'} Align\n */\n\n/**\n * Figure out the alignment of a GFM table.\n *\n * @param {Readonly<Array<Event>>} events\n *   List of events.\n * @param {number} index\n *   Table enter event.\n * @returns {Array<Align>}\n *   List of aligns.\n */\nexport function gfmTableAlign(events, index) {\n  let inDelimiterRow = false;\n  /** @type {Array<Align>} */\n  const align = [];\n  while (index < events.length) {\n    const event = events[index];\n    if (inDelimiterRow) {\n      if (event[0] === 'enter') {\n        // Start of alignment value: set a new column.\n        // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n        if (event[1].type === 'tableContent') {\n          align.push(events[index + 1][1].type === 'tableDelimiterMarker' ? 'left' : 'none');\n        }\n      }\n      // Exits:\n      // End of alignment value: change the column.\n      // To do: `markdown-rs` uses `tableDelimiterCellValue`.\n      else if (event[1].type === 'tableContent') {\n        if (events[index - 1][1].type === 'tableDelimiterMarker') {\n          const alignIndex = align.length - 1;\n          align[alignIndex] = align[alignIndex] === 'left' ? 'center' : 'right';\n        }\n      }\n      // Done!\n      else if (event[1].type === 'tableDelimiterRow') {\n        break;\n      }\n    } else if (event[0] === 'enter' && event[1].type === 'tableDelimiterRow') {\n      inDelimiterRow = true;\n    }\n    index += 1;\n  }\n  return align;\n}","/**\n * @import {Event, Extension, Point, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\n/**\n * @typedef {[number, number, number, number]} Range\n *   Cell info.\n *\n * @typedef {0 | 1 | 2 | 3} RowKind\n *   Where we are: `1` for head row, `2` for delimiter row, `3` for body row.\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { EditMap } from './edit-map.js';\nimport { gfmTableAlign } from './infer.js';\n\n/**\n * Create an HTML extension for `micromark` to support GitHub tables syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   table syntax.\n */\nexport function gfmTable() {\n  return {\n    flow: {\n      null: {\n        name: 'table',\n        tokenize: tokenizeTable,\n        resolveAll: resolveTable\n      }\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTable(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  let sizeB = 0;\n  /** @type {boolean | undefined} */\n  let seen;\n  return start;\n\n  /**\n   * Start of a GFM table.\n   *\n   * If there is a valid table row or table head before, then we try to parse\n   * another row.\n   * Otherwise, we try to parse a head.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   * @type {State}\n   */\n  function start(code) {\n    let index = self.events.length - 1;\n    while (index > -1) {\n      const type = self.events[index][1].type;\n      if (type === \"lineEnding\" ||\n      // Note: markdown-rs uses `whitespace` instead of `linePrefix`\n      type === \"linePrefix\") index--;else break;\n    }\n    const tail = index > -1 ? self.events[index][1].type : null;\n    const next = tail === 'tableHead' || tail === 'tableRow' ? bodyRowStart : headRowBefore;\n\n    // Don’t allow lazy body rows.\n    if (next === bodyRowStart && self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    return next(code);\n  }\n\n  /**\n   * Before table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBefore(code) {\n    effects.enter('tableHead');\n    effects.enter('tableRow');\n    return headRowStart(code);\n  }\n\n  /**\n   * Before table head row, after whitespace.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowStart(code) {\n    if (code === 124) {\n      return headRowBreak(code);\n    }\n\n    // To do: micromark-js should let us parse our own whitespace in extensions,\n    // like `markdown-rs`:\n    //\n    // ```js\n    // // 4+ spaces.\n    // if (markdownSpace(code)) {\n    //   return nok(code)\n    // }\n    // ```\n\n    seen = true;\n    // Count the first character, that isn’t a pipe, double.\n    sizeB += 1;\n    return headRowBreak(code);\n  }\n\n  /**\n   * At break in table head row.\n   *\n   * ```markdown\n   * > | | a |\n   *     ^\n   *       ^\n   *         ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowBreak(code) {\n    if (code === null) {\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownLineEnding(code)) {\n      // If anything other than one pipe (ignoring whitespace) was used, it’s fine.\n      if (sizeB > 1) {\n        sizeB = 0;\n        // To do: check if this works.\n        // Feel free to interrupt:\n        self.interrupt = true;\n        effects.exit('tableRow');\n        effects.enter(\"lineEnding\");\n        effects.consume(code);\n        effects.exit(\"lineEnding\");\n        return headDelimiterStart;\n      }\n\n      // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n      return nok(code);\n    }\n    if (markdownSpace(code)) {\n      // To do: check if this is fine.\n      // effects.attempt(State::Next(StateName::GfmTableHeadRowBreak), State::Nok)\n      // State::Retry(space_or_tab(tokenizer))\n      return factorySpace(effects, headRowBreak, \"whitespace\")(code);\n    }\n    sizeB += 1;\n    if (seen) {\n      seen = false;\n      // Header cell count.\n      size += 1;\n    }\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      // Whether a delimiter was seen.\n      seen = true;\n      return headRowBreak;\n    }\n\n    // Anything else is cell data.\n    effects.enter(\"data\");\n    return headRowData(code);\n  }\n\n  /**\n   * In table head row data.\n   *\n   * ```markdown\n   * > | | a |\n   *       ^\n   *   | | - |\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return headRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? headRowEscape : headRowData;\n  }\n\n  /**\n   * In table head row escape.\n   *\n   * ```markdown\n   * > | | a\\-b |\n   *         ^\n   *   | | ---- |\n   *   | | c    |\n   * ```\n   *\n   * @type {State}\n   */\n  function headRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return headRowData;\n    }\n    return headRowData(code);\n  }\n\n  /**\n   * Before delimiter row.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterStart(code) {\n    // Reset `interrupt`.\n    self.interrupt = false;\n\n    // Note: in `markdown-rs`, we need to handle piercing here too.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n    effects.enter('tableDelimiterRow');\n    // Track if we’ve seen a `:` or `|`.\n    seen = false;\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterBefore, \"linePrefix\", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n    }\n    return headDelimiterBefore(code);\n  }\n\n  /**\n   * Before delimiter row, after optional whitespace.\n   *\n   * Reused when a `|` is found later, to parse another cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *     ^\n   *   | | b |\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterBefore(code) {\n    if (code === 45 || code === 58) {\n      return headDelimiterValueBefore(code);\n    }\n    if (code === 124) {\n      seen = true;\n      // If we start with a pipe, we open a cell marker.\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return headDelimiterCellBefore;\n    }\n\n    // More whitespace / empty row not allowed at start.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After `|`, before delimiter cell.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *      ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellBefore(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterValueBefore, \"whitespace\")(code);\n    }\n    return headDelimiterValueBefore(code);\n  }\n\n  /**\n   * Before delimiter cell value.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterValueBefore(code) {\n    // Align: left.\n    if (code === 58) {\n      sizeB += 1;\n      seen = true;\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterLeftAlignmentAfter;\n    }\n\n    // Align: none.\n    if (code === 45) {\n      sizeB += 1;\n      // To do: seems weird that this *isn’t* left aligned, but that state is used?\n      return headDelimiterLeftAlignmentAfter(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      return headDelimiterCellAfter(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * After delimiter cell left alignment marker.\n   *\n   * ```markdown\n   *   | | a  |\n   * > | | :- |\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterLeftAlignmentAfter(code) {\n    if (code === 45) {\n      effects.enter('tableDelimiterFiller');\n      return headDelimiterFiller(code);\n    }\n\n    // Anything else is not ok after the left-align colon.\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter cell filler.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | - |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterFiller(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return headDelimiterFiller;\n    }\n\n    // Align is `center` if it was `left`, `right` otherwise.\n    if (code === 58) {\n      seen = true;\n      effects.exit('tableDelimiterFiller');\n      effects.enter('tableDelimiterMarker');\n      effects.consume(code);\n      effects.exit('tableDelimiterMarker');\n      return headDelimiterRightAlignmentAfter;\n    }\n    effects.exit('tableDelimiterFiller');\n    return headDelimiterRightAlignmentAfter(code);\n  }\n\n  /**\n   * After delimiter cell right alignment marker.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterRightAlignmentAfter(code) {\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headDelimiterCellAfter, \"whitespace\")(code);\n    }\n    return headDelimiterCellAfter(code);\n  }\n\n  /**\n   * After delimiter cell.\n   *\n   * ```markdown\n   *   | |  a |\n   * > | | -: |\n   *          ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterCellAfter(code) {\n    if (code === 124) {\n      return headDelimiterBefore(code);\n    }\n    if (code === null || markdownLineEnding(code)) {\n      // Exit when:\n      // * there was no `:` or `|` at all (it’s a thematic break or setext\n      //   underline instead)\n      // * the header cell count is not the delimiter cell count\n      if (!seen || size !== sizeB) {\n        return headDelimiterNok(code);\n      }\n\n      // Note: in markdown-rs`, a reset is needed here.\n      effects.exit('tableDelimiterRow');\n      effects.exit('tableHead');\n      // To do: in `markdown-rs`, resolvers need to be registered manually.\n      // effects.register_resolver(ResolveName::GfmTable)\n      return ok(code);\n    }\n    return headDelimiterNok(code);\n  }\n\n  /**\n   * In delimiter row, at a disallowed byte.\n   *\n   * ```markdown\n   *   | | a |\n   * > | | x |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function headDelimiterNok(code) {\n    // Note: in `markdown-rs`, we need to reset, in `micromark-js` we don‘t.\n    return nok(code);\n  }\n\n  /**\n   * Before table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowStart(code) {\n    // Note: in `markdown-rs` we need to manually take care of a prefix,\n    // but in `micromark-js` that is done for us, so if we’re here, we’re\n    // never at whitespace.\n    effects.enter('tableRow');\n    return bodyRowBreak(code);\n  }\n\n  /**\n   * At break in table body row.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *     ^\n   *       ^\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowBreak(code) {\n    if (code === 124) {\n      effects.enter('tableCellDivider');\n      effects.consume(code);\n      effects.exit('tableCellDivider');\n      return bodyRowBreak;\n    }\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('tableRow');\n      return ok(code);\n    }\n    if (markdownSpace(code)) {\n      return factorySpace(effects, bodyRowBreak, \"whitespace\")(code);\n    }\n\n    // Anything else is cell content.\n    effects.enter(\"data\");\n    return bodyRowData(code);\n  }\n\n  /**\n   * In table body row data.\n   *\n   * ```markdown\n   *   | | a |\n   *   | | - |\n   * > | | b |\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowData(code) {\n    if (code === null || code === 124 || markdownLineEndingOrSpace(code)) {\n      effects.exit(\"data\");\n      return bodyRowBreak(code);\n    }\n    effects.consume(code);\n    return code === 92 ? bodyRowEscape : bodyRowData;\n  }\n\n  /**\n   * In table body row escape.\n   *\n   * ```markdown\n   *   | | a    |\n   *   | | ---- |\n   * > | | b\\-c |\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function bodyRowEscape(code) {\n    if (code === 92 || code === 124) {\n      effects.consume(code);\n      return bodyRowData;\n    }\n    return bodyRowData(code);\n  }\n}\n\n/** @type {Resolver} */\n\nfunction resolveTable(events, context) {\n  let index = -1;\n  let inFirstCellAwaitingPipe = true;\n  /** @type {RowKind} */\n  let rowKind = 0;\n  /** @type {Range} */\n  let lastCell = [0, 0, 0, 0];\n  /** @type {Range} */\n  let cell = [0, 0, 0, 0];\n  let afterHeadAwaitingFirstBodyRow = false;\n  let lastTableEnd = 0;\n  /** @type {Token | undefined} */\n  let currentTable;\n  /** @type {Token | undefined} */\n  let currentBody;\n  /** @type {Token | undefined} */\n  let currentCell;\n  const map = new EditMap();\n  while (++index < events.length) {\n    const event = events[index];\n    const token = event[1];\n    if (event[0] === 'enter') {\n      // Start of head.\n      if (token.type === 'tableHead') {\n        afterHeadAwaitingFirstBodyRow = false;\n\n        // Inject previous (body end and) table end.\n        if (lastTableEnd !== 0) {\n          flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n          currentBody = undefined;\n          lastTableEnd = 0;\n        }\n\n        // Inject table start.\n        currentTable = {\n          type: 'table',\n          start: Object.assign({}, token.start),\n          // Note: correct end is set later.\n          end: Object.assign({}, token.end)\n        };\n        map.add(index, 0, [['enter', currentTable, context]]);\n      } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n        inFirstCellAwaitingPipe = true;\n        currentCell = undefined;\n        lastCell = [0, 0, 0, 0];\n        cell = [0, index + 1, 0, 0];\n\n        // Inject table body start.\n        if (afterHeadAwaitingFirstBodyRow) {\n          afterHeadAwaitingFirstBodyRow = false;\n          currentBody = {\n            type: 'tableBody',\n            start: Object.assign({}, token.start),\n            // Note: correct end is set later.\n            end: Object.assign({}, token.end)\n          };\n          map.add(index, 0, [['enter', currentBody, context]]);\n        }\n        rowKind = token.type === 'tableDelimiterRow' ? 2 : currentBody ? 3 : 1;\n      }\n      // Cell data.\n      else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n        inFirstCellAwaitingPipe = false;\n\n        // First value in cell.\n        if (cell[2] === 0) {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n            lastCell = [0, 0, 0, 0];\n          }\n          cell[2] = index;\n        }\n      } else if (token.type === 'tableCellDivider') {\n        if (inFirstCellAwaitingPipe) {\n          inFirstCellAwaitingPipe = false;\n        } else {\n          if (lastCell[1] !== 0) {\n            cell[0] = cell[1];\n            currentCell = flushCell(map, context, lastCell, rowKind, undefined, currentCell);\n          }\n          lastCell = cell;\n          cell = [lastCell[1], index, 0, 0];\n        }\n      }\n    }\n    // Exit events.\n    else if (token.type === 'tableHead') {\n      afterHeadAwaitingFirstBodyRow = true;\n      lastTableEnd = index;\n    } else if (token.type === 'tableRow' || token.type === 'tableDelimiterRow') {\n      lastTableEnd = index;\n      if (lastCell[1] !== 0) {\n        cell[0] = cell[1];\n        currentCell = flushCell(map, context, lastCell, rowKind, index, currentCell);\n      } else if (cell[1] !== 0) {\n        currentCell = flushCell(map, context, cell, rowKind, index, currentCell);\n      }\n      rowKind = 0;\n    } else if (rowKind && (token.type === \"data\" || token.type === 'tableDelimiterMarker' || token.type === 'tableDelimiterFiller')) {\n      cell[3] = index;\n    }\n  }\n  if (lastTableEnd !== 0) {\n    flushTableEnd(map, context, lastTableEnd, currentTable, currentBody);\n  }\n  map.consume(context.events);\n\n  // To do: move this into `html`, when events are exposed there.\n  // That’s what `markdown-rs` does.\n  // That needs updates to `mdast-util-gfm-table`.\n  index = -1;\n  while (++index < context.events.length) {\n    const event = context.events[index];\n    if (event[0] === 'enter' && event[1].type === 'table') {\n      event[1]._align = gfmTableAlign(context.events, index);\n    }\n  }\n  return events;\n}\n\n/**\n * Generate a cell.\n *\n * @param {EditMap} map\n * @param {Readonly<TokenizeContext>} context\n * @param {Readonly<Range>} range\n * @param {RowKind} rowKind\n * @param {number | undefined} rowEnd\n * @param {Token | undefined} previousCell\n * @returns {Token | undefined}\n */\n// eslint-disable-next-line max-params\nfunction flushCell(map, context, range, rowKind, rowEnd, previousCell) {\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCell' : 'tableCell'\n  const groupName = rowKind === 1 ? 'tableHeader' : rowKind === 2 ? 'tableDelimiter' : 'tableData';\n  // `markdown-rs` uses:\n  // rowKind === 2 ? 'tableDelimiterCellValue' : 'tableCellText'\n  const valueName = 'tableContent';\n\n  // Insert an exit for the previous cell, if there is one.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //          ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[0] !== 0) {\n    previousCell.end = Object.assign({}, getPoint(context.events, range[0]));\n    map.add(range[0], 0, [['exit', previousCell, context]]);\n  }\n\n  // Insert enter of this cell.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //           ^-- enter\n  //           ^^^^-- this cell\n  // ```\n  const now = getPoint(context.events, range[1]);\n  previousCell = {\n    type: groupName,\n    start: Object.assign({}, now),\n    // Note: correct end is set later.\n    end: Object.assign({}, now)\n  };\n  map.add(range[1], 0, [['enter', previousCell, context]]);\n\n  // Insert text start at first data start and end at last data end, and\n  // remove events between.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //            ^-- enter\n  //             ^-- exit\n  //           ^^^^-- this cell\n  // ```\n  if (range[2] !== 0) {\n    const relatedStart = getPoint(context.events, range[2]);\n    const relatedEnd = getPoint(context.events, range[3]);\n    /** @type {Token} */\n    const valueToken = {\n      type: valueName,\n      start: Object.assign({}, relatedStart),\n      end: Object.assign({}, relatedEnd)\n    };\n    map.add(range[2], 0, [['enter', valueToken, context]]);\n    if (rowKind !== 2) {\n      // Fix positional info on remaining events\n      const start = context.events[range[2]];\n      const end = context.events[range[3]];\n      start[1].end = Object.assign({}, end[1].end);\n      start[1].type = \"chunkText\";\n      start[1].contentType = \"text\";\n\n      // Remove if needed.\n      if (range[3] > range[2] + 1) {\n        const a = range[2] + 1;\n        const b = range[3] - range[2] - 1;\n        map.add(a, b, []);\n      }\n    }\n    map.add(range[3] + 1, 0, [['exit', valueToken, context]]);\n  }\n\n  // Insert an exit for the last cell, if at the row end.\n  //\n  // ```markdown\n  // > | | aa | bb | cc |\n  //                    ^-- exit\n  //               ^^^^^^-- this cell (the last one contains two “between” parts)\n  // ```\n  if (rowEnd !== undefined) {\n    previousCell.end = Object.assign({}, getPoint(context.events, rowEnd));\n    map.add(rowEnd, 0, [['exit', previousCell, context]]);\n    previousCell = undefined;\n  }\n  return previousCell;\n}\n\n/**\n * Generate table end (and table body end).\n *\n * @param {Readonly<EditMap>} map\n * @param {Readonly<TokenizeContext>} context\n * @param {number} index\n * @param {Token} table\n * @param {Token | undefined} tableBody\n */\n// eslint-disable-next-line max-params\nfunction flushTableEnd(map, context, index, table, tableBody) {\n  /** @type {Array<Event>} */\n  const exits = [];\n  const related = getPoint(context.events, index);\n  if (tableBody) {\n    tableBody.end = Object.assign({}, related);\n    exits.push(['exit', tableBody, context]);\n  }\n  table.end = Object.assign({}, related);\n  exits.push(['exit', table, context]);\n  map.add(index + 1, 0, exits);\n}\n\n/**\n * @param {Readonly<Array<Event>>} events\n * @param {number} index\n * @returns {Readonly<Point>}\n */\nfunction getPoint(events, index) {\n  const event = events[index];\n  const side = event[0] === 'enter' ? 'start' : 'end';\n  return event[1][side];\n}","/**\n * @import {Extension, State, TokenizeContext, Tokenizer} from 'micromark-util-types'\n */\n\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nconst tasklistCheck = {\n  name: 'tasklistCheck',\n  tokenize: tokenizeTasklistCheck\n};\n\n/**\n * Create an HTML extension for `micromark` to support GFM task list items\n * syntax.\n *\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM task list items when serializing to HTML.\n */\nexport function gfmTaskListItem() {\n  return {\n    text: {\n      [91]: tasklistCheck\n    }\n  };\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction tokenizeTasklistCheck(effects, ok, nok) {\n  const self = this;\n  return open;\n\n  /**\n   * At start of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *       ^\n   * ```\n   *\n   * @type {State}\n   */\n  function open(code) {\n    if (\n    // Exit if there’s stuff before.\n    self.previous !== null ||\n    // Exit if not in the first content that is the first child of a list\n    // item.\n    !self._gfmTasklistFirstContentOfListItem) {\n      return nok(code);\n    }\n    effects.enter('taskListCheck');\n    effects.enter('taskListCheckMarker');\n    effects.consume(code);\n    effects.exit('taskListCheckMarker');\n    return inside;\n  }\n\n  /**\n   * In task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *        ^\n   * ```\n   *\n   * @type {State}\n   */\n  function inside(code) {\n    // Currently we match how GH works in files.\n    // To match how GH works in comments, use `markdownSpace` (`[\\t ]`) instead\n    // of `markdownLineEndingOrSpace` (`[\\t\\n\\r ]`).\n    if (markdownLineEndingOrSpace(code)) {\n      effects.enter('taskListCheckValueUnchecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueUnchecked');\n      return close;\n    }\n    if (code === 88 || code === 120) {\n      effects.enter('taskListCheckValueChecked');\n      effects.consume(code);\n      effects.exit('taskListCheckValueChecked');\n      return close;\n    }\n    return nok(code);\n  }\n\n  /**\n   * At close of task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *         ^\n   * ```\n   *\n   * @type {State}\n   */\n  function close(code) {\n    if (code === 93) {\n      effects.enter('taskListCheckMarker');\n      effects.consume(code);\n      effects.exit('taskListCheckMarker');\n      effects.exit('taskListCheck');\n      return after;\n    }\n    return nok(code);\n  }\n\n  /**\n   * @type {State}\n   */\n  function after(code) {\n    // EOL in paragraph means there must be something else after it.\n    if (markdownLineEnding(code)) {\n      return ok(code);\n    }\n\n    // Space or tab?\n    // Check what comes after.\n    if (markdownSpace(code)) {\n      return effects.check({\n        tokenize: spaceThenNonSpace\n      }, ok, nok)(code);\n    }\n\n    // EOF, or non-whitespace, both wrong.\n    return nok(code);\n  }\n}\n\n/**\n * @this {TokenizeContext}\n * @type {Tokenizer}\n */\nfunction spaceThenNonSpace(effects, ok, nok) {\n  return factorySpace(effects, after, \"whitespace\");\n\n  /**\n   * After whitespace, after task list item check.\n   *\n   * ```markdown\n   * > | * [x] y.\n   *           ^\n   * ```\n   *\n   * @type {State}\n   */\n  function after(code) {\n    // EOF means there was nothing, so bad.\n    // EOL means there’s content after it, so good.\n    // Impossible to have more spaces.\n    // Anything else is good.\n    return code === null ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-extension-gfm-footnote').HtmlOptions} HtmlOptions\n * @typedef {import('micromark-extension-gfm-strikethrough').Options} Options\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\n\nimport {\n  combineExtensions,\n  combineHtmlExtensions\n} from 'micromark-util-combine-extensions'\nimport {\n  gfmAutolinkLiteral,\n  gfmAutolinkLiteralHtml\n} from 'micromark-extension-gfm-autolink-literal'\nimport {gfmFootnote, gfmFootnoteHtml} from 'micromark-extension-gfm-footnote'\nimport {\n  gfmStrikethrough,\n  gfmStrikethroughHtml\n} from 'micromark-extension-gfm-strikethrough'\nimport {gfmTable, gfmTableHtml} from 'micromark-extension-gfm-table'\nimport {gfmTagfilterHtml} from 'micromark-extension-gfm-tagfilter'\nimport {\n  gfmTaskListItem,\n  gfmTaskListItemHtml\n} from 'micromark-extension-gfm-task-list-item'\n\n/**\n * Create an extension for `micromark` to enable GFM syntax.\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-strikethrough`.\n * @returns {Extension}\n *   Extension for `micromark` that can be passed in `extensions` to enable GFM\n *   syntax.\n */\nexport function gfm(options) {\n  return combineExtensions([\n    gfmAutolinkLiteral(),\n    gfmFootnote(),\n    gfmStrikethrough(options),\n    gfmTable(),\n    gfmTaskListItem()\n  ])\n}\n\n/**\n * Create an extension for `micromark` to support GFM when serializing to HTML.\n *\n * @param {HtmlOptions | null | undefined} [options]\n *   Configuration (optional).\n *\n *   Passed to `micromark-extens-gfm-footnote`.\n * @returns {HtmlExtension}\n *   Extension for `micromark` that can be passed in `htmlExtensions` to\n *   support GFM when serializing to HTML.\n */\nexport function gfmHtml(options) {\n  return combineHtmlExtensions([\n    gfmAutolinkLiteralHtml(),\n    gfmFootnoteHtml(options),\n    gfmStrikethroughHtml(),\n    gfmTableHtml(),\n    gfmTagfilterHtml(),\n    gfmTaskListItemHtml()\n  ])\n}\n","/**\n * @import {Root} from 'mdast'\n * @import {Options} from 'remark-gfm'\n * @import {} from 'remark-parse'\n * @import {} from 'remark-stringify'\n * @import {Processor} from 'unified'\n */\n\nimport {gfmFromMarkdown, gfmToMarkdown} from 'mdast-util-gfm'\nimport {gfm} from 'micromark-extension-gfm'\n\n/** @type {Options} */\nconst emptyOptions = {}\n\n/**\n * Add support GFM (autolink literals, footnotes, strikethrough, tables,\n * tasklists).\n *\n * @param {Options | null | undefined} [options]\n *   Configuration (optional).\n * @returns {undefined}\n *   Nothing.\n */\nexport default function remarkGfm(options) {\n  // @ts-expect-error: TS is wrong about `this`.\n  // eslint-disable-next-line unicorn/no-this-assignment\n  const self = /** @type {Processor<Root>} */ (this)\n  const settings = options || emptyOptions\n  const data = self.data()\n\n  const micromarkExtensions =\n    data.micromarkExtensions || (data.micromarkExtensions = [])\n  const fromMarkdownExtensions =\n    data.fromMarkdownExtensions || (data.fromMarkdownExtensions = [])\n  const toMarkdownExtensions =\n    data.toMarkdownExtensions || (data.toMarkdownExtensions = [])\n\n  micromarkExtensions.push(gfm(settings))\n  fromMarkdownExtensions.push(gfmFromMarkdown())\n  toMarkdownExtensions.push(gfmToMarkdown(settings))\n}\n","<script context=\"module\">\n  import \"../../md.css\";\n\n  import remarkGfm from \"remark-gfm\";\n  import remarkParse from \"remark-parse\";\n  import { unified } from \"unified\";\n\n  const processor = unified().use(remarkParse).use(remarkGfm);\n  const parse = processor.parse.bind(processor);\n</script>\n\n<article class=\"max-w-full text-sm text-neutral-2 font-sans prose [&>*:first-child]:mt-0 [&>*:last-child]:mb-0\">\n  <slot {parse} />\n</article>\n","<script lang=\"ts\">\n  import WithMarkdown from \"../reusable/WithMarkdown.svelte\";\n  import Router from \"./Router.svelte\";\n\n  export let text: string;\n</script>\n\n<WithMarkdown let:parse>\n  <Router node={parse(text)} />\n</WithMarkdown>\n","import BaseMarkdown from \"$lib/components/markdown/BaseMarkdown.svelte\";\nimport { tick } from \"svelte\";\nimport { toast } from \"svelte-sonner\";\n\nexport function withToast(data: { loading: string; success?: string; duration?: number }) {\n  return <T extends (...args: any[]) => any>(anyFunction: T) => {\n    data.success = data.success ?? data.loading;\n    return (async (...args) => {\n      const promise: Promise<ReturnType<T>> = Promise.resolve(anyFunction(...args));\n      toast.promise(promise, { ...data, error: data.loading });\n      const result = await promise;\n      await tick();\n      return result;\n    }) as T;\n  };\n}\n\nlet index = 0;\n\nexport function toastMarkdown(markdown: string, type: \"message\" | \"success\" | \"info\" | \"warning\" | \"error\" | \"loading\" = \"success\", id = index++) {\n  // @ts-expect-error promise option is not in the type definition\n  toast[type](BaseMarkdown, { componentProps: { text: markdown }, id, promise: true });\n  return id;\n}\n","<script lang=\"ts\">\n  import { toastMarkdown } from \"$lib/utils/toast\";\n\n  export let text: string;\n\n  async function handleClick() {\n    text = text.trimEnd();\n    navigator.clipboard.writeText(text);\n    const n = text.split(\"\\n\").length;\n    toastMarkdown(`successfully copied \\`${n}\\` ${n === 1 ? \"line\" : \"lines\"} to clipboard`);\n  }\n</script>\n\n<slot {handleClick} />\n","<script lang=\"ts\">\n  import type { Code, Node } from \"mdast\";\n\n  import { currentConsolePush } from \"../console/store\";\n  import UseCopy from \"../console/UseCopy.svelte\";\n  import WithTooltip from \"../reusable/WithTooltip.svelte\";\n\n  export let node: Node;\n  export let run: ((source: string) => any) | null = null;\n  export let fadeIn = false;\n  export let runnable: boolean | null = null;\n\n  $: code = node as Code;\n\n  $: runnable = runnable || Boolean(code.lang && run && \"python\".startsWith(code.lang));\n</script>\n\n{#if code.value}\n  <div class=\"group relative flex flex-col animate-(duration-150 ease-out)\" class:animate-fade-in={fadeIn}>\n\n    <slot {code} />\n\n    <div class=\"absolute right-0.9em top-0.9em flex flex-row-reverse gap-0.3em transition group-not-hover:(pointer-events-none op-0) [&>button]:(rounded bg-white/5 p-0.6em text-0.725em transition) [&>button:hover]:(bg-white/10)\">\n      <UseCopy text={code.value} let:handleClick>\n        <WithTooltip let:builder tips=\"复制\">\n          <button on:click={handleClick} {...builder} use:builder.action><div class=\"i-icon-park-twotone-copy\" /></button>\n        </WithTooltip>\n      </UseCopy>\n      {#if runnable && run}\n        <WithTooltip let:builder tips=\"运行\">\n          <button on:click={() => run(code.value)} {...builder} use:builder.action><div class=\"i-mingcute-play-fill\" /></button>\n        </WithTooltip>\n      {/if}\n      {#if runnable && $currentConsolePush}\n        <WithTooltip let:builder tips=\"在终端中运行\">\n          <button on:click={() => {\n            const source = code.value.trimEnd();\n            if (source.split(\"\\n\").at(-1)?.startsWith(\" \"))\n              $currentConsolePush(`${source}\\n\\n`);\n            else\n              $currentConsolePush(`${source}\\n`);\n          }} {...builder} use:builder.action><div class=\"i-mdi-console\" /></button>\n        </WithTooltip>\n      {/if}\n    </div>\n  </div>\n{/if}\n\n<style>\n  div:not(:has(>div>button:active)) :global(pre > *)  {\n    --uno: transition-font-weight duration-400 ease-out;\n  }\n\n  div:has(>div>button:active) :global(pre *) {\n    --uno: font-black;\n  }\n</style>\n","const globalCache = new Map<string, any>();\n\nexport function cacheGlobally<T extends () => R, R>(key: string, target: T): T {\n  return (() => {\n    const cache = globalCache as Map<string, R>;\n\n    if (cache.has(key))\n      return cache.get(key);\n\n    const result = target();\n    cache.set(key, result);\n    return result;\n  }) as T;\n}\n\nexport function cacheSingleton<T extends () => any>(target: T): T {\n  const UNSET = {};\n  let result: any = UNSET;\n\n  return (() => {\n    if (result !== UNSET)\n      return result;\n\n    result = target();\n    return result;\n  }) as T;\n}\n","class ShikiError extends Error {\n  constructor(message) {\n    super(message);\n    this.name = \"ShikiError\";\n  }\n}\n\nexport { ShikiError };\n","// src/utils.ts\nfunction clone(something) {\n  return doClone(something);\n}\nfunction doClone(something) {\n  if (Array.isArray(something)) {\n    return cloneArray(something);\n  }\n  if (something instanceof RegExp) {\n    return something;\n  }\n  if (typeof something === \"object\") {\n    return cloneObj(something);\n  }\n  return something;\n}\nfunction cloneArray(arr) {\n  let r = [];\n  for (let i = 0, len = arr.length; i < len; i++) {\n    r[i] = doClone(arr[i]);\n  }\n  return r;\n}\nfunction cloneObj(obj) {\n  let r = {};\n  for (let key in obj) {\n    r[key] = doClone(obj[key]);\n  }\n  return r;\n}\nfunction mergeObjects(target, ...sources) {\n  sources.forEach((source) => {\n    for (let key in source) {\n      target[key] = source[key];\n    }\n  });\n  return target;\n}\nfunction basename(path) {\n  const idx = ~path.lastIndexOf(\"/\") || ~path.lastIndexOf(\"\\\\\");\n  if (idx === 0) {\n    return path;\n  } else if (~idx === path.length - 1) {\n    return basename(path.substring(0, path.length - 1));\n  } else {\n    return path.substr(~idx + 1);\n  }\n}\nvar CAPTURING_REGEX_SOURCE = /\\$(\\d+)|\\${(\\d+):\\/(downcase|upcase)}/g;\nvar RegexSource = class {\n  static hasCaptures(regexSource) {\n    if (regexSource === null) {\n      return false;\n    }\n    CAPTURING_REGEX_SOURCE.lastIndex = 0;\n    return CAPTURING_REGEX_SOURCE.test(regexSource);\n  }\n  static replaceCaptures(regexSource, captureSource, captureIndices) {\n    return regexSource.replace(CAPTURING_REGEX_SOURCE, (match, index, commandIndex, command) => {\n      let capture = captureIndices[parseInt(index || commandIndex, 10)];\n      if (capture) {\n        let result = captureSource.substring(capture.start, capture.end);\n        while (result[0] === \".\") {\n          result = result.substring(1);\n        }\n        switch (command) {\n          case \"downcase\":\n            return result.toLowerCase();\n          case \"upcase\":\n            return result.toUpperCase();\n          default:\n            return result;\n        }\n      } else {\n        return match;\n      }\n    });\n  }\n};\nfunction strcmp(a, b) {\n  if (a < b) {\n    return -1;\n  }\n  if (a > b) {\n    return 1;\n  }\n  return 0;\n}\nfunction strArrCmp(a, b) {\n  if (a === null && b === null) {\n    return 0;\n  }\n  if (!a) {\n    return -1;\n  }\n  if (!b) {\n    return 1;\n  }\n  let len1 = a.length;\n  let len2 = b.length;\n  if (len1 === len2) {\n    for (let i = 0; i < len1; i++) {\n      let res = strcmp(a[i], b[i]);\n      if (res !== 0) {\n        return res;\n      }\n    }\n    return 0;\n  }\n  return len1 - len2;\n}\nfunction isValidHexColor(hex) {\n  if (/^#[0-9a-f]{6}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{8}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{3}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{4}$/i.test(hex)) {\n    return true;\n  }\n  return false;\n}\nfunction escapeRegExpCharacters(value) {\n  return value.replace(/[\\-\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, \"\\\\$&\");\n}\nvar CachedFn = class {\n  constructor(fn) {\n    this.fn = fn;\n  }\n  cache = /* @__PURE__ */ new Map();\n  get(key) {\n    if (this.cache.has(key)) {\n      return this.cache.get(key);\n    }\n    const value = this.fn(key);\n    this.cache.set(key, value);\n    return value;\n  }\n};\n\n// src/theme.ts\nvar Theme = class {\n  constructor(_colorMap, _defaults, _root) {\n    this._colorMap = _colorMap;\n    this._defaults = _defaults;\n    this._root = _root;\n  }\n  static createFromRawTheme(source, colorMap) {\n    return this.createFromParsedTheme(parseTheme(source), colorMap);\n  }\n  static createFromParsedTheme(source, colorMap) {\n    return resolveParsedThemeRules(source, colorMap);\n  }\n  _cachedMatchRoot = new CachedFn(\n    (scopeName) => this._root.match(scopeName)\n  );\n  getColorMap() {\n    return this._colorMap.getColorMap();\n  }\n  getDefaults() {\n    return this._defaults;\n  }\n  match(scopePath) {\n    if (scopePath === null) {\n      return this._defaults;\n    }\n    const scopeName = scopePath.scopeName;\n    const matchingTrieElements = this._cachedMatchRoot.get(scopeName);\n    const effectiveRule = matchingTrieElements.find(\n      (v) => _scopePathMatchesParentScopes(scopePath.parent, v.parentScopes)\n    );\n    if (!effectiveRule) {\n      return null;\n    }\n    return new StyleAttributes(\n      effectiveRule.fontStyle,\n      effectiveRule.foreground,\n      effectiveRule.background\n    );\n  }\n};\nvar ScopeStack = class _ScopeStack {\n  constructor(parent, scopeName) {\n    this.parent = parent;\n    this.scopeName = scopeName;\n  }\n  static push(path, scopeNames) {\n    for (const name of scopeNames) {\n      path = new _ScopeStack(path, name);\n    }\n    return path;\n  }\n  static from(...segments) {\n    let result = null;\n    for (let i = 0; i < segments.length; i++) {\n      result = new _ScopeStack(result, segments[i]);\n    }\n    return result;\n  }\n  push(scopeName) {\n    return new _ScopeStack(this, scopeName);\n  }\n  getSegments() {\n    let item = this;\n    const result = [];\n    while (item) {\n      result.push(item.scopeName);\n      item = item.parent;\n    }\n    result.reverse();\n    return result;\n  }\n  toString() {\n    return this.getSegments().join(\" \");\n  }\n  extends(other) {\n    if (this === other) {\n      return true;\n    }\n    if (this.parent === null) {\n      return false;\n    }\n    return this.parent.extends(other);\n  }\n  getExtensionIfDefined(base) {\n    const result = [];\n    let item = this;\n    while (item && item !== base) {\n      result.push(item.scopeName);\n      item = item.parent;\n    }\n    return item === base ? result.reverse() : void 0;\n  }\n};\nfunction _scopePathMatchesParentScopes(scopePath, parentScopes) {\n  if (parentScopes.length === 0) {\n    return true;\n  }\n  for (let index = 0; index < parentScopes.length; index++) {\n    let scopePattern = parentScopes[index];\n    let scopeMustMatch = false;\n    if (scopePattern === \">\") {\n      if (index === parentScopes.length - 1) {\n        return false;\n      }\n      scopePattern = parentScopes[++index];\n      scopeMustMatch = true;\n    }\n    while (scopePath) {\n      if (_matchesScope(scopePath.scopeName, scopePattern)) {\n        break;\n      }\n      if (scopeMustMatch) {\n        return false;\n      }\n      scopePath = scopePath.parent;\n    }\n    if (!scopePath) {\n      return false;\n    }\n    scopePath = scopePath.parent;\n  }\n  return true;\n}\nfunction _matchesScope(scopeName, scopePattern) {\n  return scopePattern === scopeName || scopeName.startsWith(scopePattern) && scopeName[scopePattern.length] === \".\";\n}\nvar StyleAttributes = class {\n  constructor(fontStyle, foregroundId, backgroundId) {\n    this.fontStyle = fontStyle;\n    this.foregroundId = foregroundId;\n    this.backgroundId = backgroundId;\n  }\n};\nfunction parseTheme(source) {\n  if (!source) {\n    return [];\n  }\n  if (!source.settings || !Array.isArray(source.settings)) {\n    return [];\n  }\n  let settings = source.settings;\n  let result = [], resultLen = 0;\n  for (let i = 0, len = settings.length; i < len; i++) {\n    let entry = settings[i];\n    if (!entry.settings) {\n      continue;\n    }\n    let scopes;\n    if (typeof entry.scope === \"string\") {\n      let _scope = entry.scope;\n      _scope = _scope.replace(/^[,]+/, \"\");\n      _scope = _scope.replace(/[,]+$/, \"\");\n      scopes = _scope.split(\",\");\n    } else if (Array.isArray(entry.scope)) {\n      scopes = entry.scope;\n    } else {\n      scopes = [\"\"];\n    }\n    let fontStyle = -1 /* NotSet */;\n    if (typeof entry.settings.fontStyle === \"string\") {\n      fontStyle = 0 /* None */;\n      let segments = entry.settings.fontStyle.split(\" \");\n      for (let j = 0, lenJ = segments.length; j < lenJ; j++) {\n        let segment = segments[j];\n        switch (segment) {\n          case \"italic\":\n            fontStyle = fontStyle | 1 /* Italic */;\n            break;\n          case \"bold\":\n            fontStyle = fontStyle | 2 /* Bold */;\n            break;\n          case \"underline\":\n            fontStyle = fontStyle | 4 /* Underline */;\n            break;\n          case \"strikethrough\":\n            fontStyle = fontStyle | 8 /* Strikethrough */;\n            break;\n        }\n      }\n    }\n    let foreground = null;\n    if (typeof entry.settings.foreground === \"string\" && isValidHexColor(entry.settings.foreground)) {\n      foreground = entry.settings.foreground;\n    }\n    let background = null;\n    if (typeof entry.settings.background === \"string\" && isValidHexColor(entry.settings.background)) {\n      background = entry.settings.background;\n    }\n    for (let j = 0, lenJ = scopes.length; j < lenJ; j++) {\n      let _scope = scopes[j].trim();\n      let segments = _scope.split(\" \");\n      let scope = segments[segments.length - 1];\n      let parentScopes = null;\n      if (segments.length > 1) {\n        parentScopes = segments.slice(0, segments.length - 1);\n        parentScopes.reverse();\n      }\n      result[resultLen++] = new ParsedThemeRule(\n        scope,\n        parentScopes,\n        i,\n        fontStyle,\n        foreground,\n        background\n      );\n    }\n  }\n  return result;\n}\nvar ParsedThemeRule = class {\n  constructor(scope, parentScopes, index, fontStyle, foreground, background) {\n    this.scope = scope;\n    this.parentScopes = parentScopes;\n    this.index = index;\n    this.fontStyle = fontStyle;\n    this.foreground = foreground;\n    this.background = background;\n  }\n};\nvar FontStyle = /* @__PURE__ */ ((FontStyle2) => {\n  FontStyle2[FontStyle2[\"NotSet\"] = -1] = \"NotSet\";\n  FontStyle2[FontStyle2[\"None\"] = 0] = \"None\";\n  FontStyle2[FontStyle2[\"Italic\"] = 1] = \"Italic\";\n  FontStyle2[FontStyle2[\"Bold\"] = 2] = \"Bold\";\n  FontStyle2[FontStyle2[\"Underline\"] = 4] = \"Underline\";\n  FontStyle2[FontStyle2[\"Strikethrough\"] = 8] = \"Strikethrough\";\n  return FontStyle2;\n})(FontStyle || {});\nfunction resolveParsedThemeRules(parsedThemeRules, _colorMap) {\n  parsedThemeRules.sort((a, b) => {\n    let r = strcmp(a.scope, b.scope);\n    if (r !== 0) {\n      return r;\n    }\n    r = strArrCmp(a.parentScopes, b.parentScopes);\n    if (r !== 0) {\n      return r;\n    }\n    return a.index - b.index;\n  });\n  let defaultFontStyle = 0 /* None */;\n  let defaultForeground = \"#000000\";\n  let defaultBackground = \"#ffffff\";\n  while (parsedThemeRules.length >= 1 && parsedThemeRules[0].scope === \"\") {\n    let incomingDefaults = parsedThemeRules.shift();\n    if (incomingDefaults.fontStyle !== -1 /* NotSet */) {\n      defaultFontStyle = incomingDefaults.fontStyle;\n    }\n    if (incomingDefaults.foreground !== null) {\n      defaultForeground = incomingDefaults.foreground;\n    }\n    if (incomingDefaults.background !== null) {\n      defaultBackground = incomingDefaults.background;\n    }\n  }\n  let colorMap = new ColorMap(_colorMap);\n  let defaults = new StyleAttributes(defaultFontStyle, colorMap.getId(defaultForeground), colorMap.getId(defaultBackground));\n  let root = new ThemeTrieElement(new ThemeTrieElementRule(0, null, -1 /* NotSet */, 0, 0), []);\n  for (let i = 0, len = parsedThemeRules.length; i < len; i++) {\n    let rule = parsedThemeRules[i];\n    root.insert(0, rule.scope, rule.parentScopes, rule.fontStyle, colorMap.getId(rule.foreground), colorMap.getId(rule.background));\n  }\n  return new Theme(colorMap, defaults, root);\n}\nvar ColorMap = class {\n  _isFrozen;\n  _lastColorId;\n  _id2color;\n  _color2id;\n  constructor(_colorMap) {\n    this._lastColorId = 0;\n    this._id2color = [];\n    this._color2id = /* @__PURE__ */ Object.create(null);\n    if (Array.isArray(_colorMap)) {\n      this._isFrozen = true;\n      for (let i = 0, len = _colorMap.length; i < len; i++) {\n        this._color2id[_colorMap[i]] = i;\n        this._id2color[i] = _colorMap[i];\n      }\n    } else {\n      this._isFrozen = false;\n    }\n  }\n  getId(color) {\n    if (color === null) {\n      return 0;\n    }\n    color = color.toUpperCase();\n    let value = this._color2id[color];\n    if (value) {\n      return value;\n    }\n    if (this._isFrozen) {\n      throw new Error(`Missing color in color map - ${color}`);\n    }\n    value = ++this._lastColorId;\n    this._color2id[color] = value;\n    this._id2color[value] = color;\n    return value;\n  }\n  getColorMap() {\n    return this._id2color.slice(0);\n  }\n};\nvar emptyParentScopes = Object.freeze([]);\nvar ThemeTrieElementRule = class _ThemeTrieElementRule {\n  scopeDepth;\n  parentScopes;\n  fontStyle;\n  foreground;\n  background;\n  constructor(scopeDepth, parentScopes, fontStyle, foreground, background) {\n    this.scopeDepth = scopeDepth;\n    this.parentScopes = parentScopes || emptyParentScopes;\n    this.fontStyle = fontStyle;\n    this.foreground = foreground;\n    this.background = background;\n  }\n  clone() {\n    return new _ThemeTrieElementRule(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);\n  }\n  static cloneArr(arr) {\n    let r = [];\n    for (let i = 0, len = arr.length; i < len; i++) {\n      r[i] = arr[i].clone();\n    }\n    return r;\n  }\n  acceptOverwrite(scopeDepth, fontStyle, foreground, background) {\n    if (this.scopeDepth > scopeDepth) {\n      console.log(\"how did this happen?\");\n    } else {\n      this.scopeDepth = scopeDepth;\n    }\n    if (fontStyle !== -1 /* NotSet */) {\n      this.fontStyle = fontStyle;\n    }\n    if (foreground !== 0) {\n      this.foreground = foreground;\n    }\n    if (background !== 0) {\n      this.background = background;\n    }\n  }\n};\nvar ThemeTrieElement = class _ThemeTrieElement {\n  constructor(_mainRule, rulesWithParentScopes = [], _children = {}) {\n    this._mainRule = _mainRule;\n    this._children = _children;\n    this._rulesWithParentScopes = rulesWithParentScopes;\n  }\n  _rulesWithParentScopes;\n  static _cmpBySpecificity(a, b) {\n    if (a.scopeDepth !== b.scopeDepth) {\n      return b.scopeDepth - a.scopeDepth;\n    }\n    let aParentIndex = 0;\n    let bParentIndex = 0;\n    while (true) {\n      if (a.parentScopes[aParentIndex] === \">\") {\n        aParentIndex++;\n      }\n      if (b.parentScopes[bParentIndex] === \">\") {\n        bParentIndex++;\n      }\n      if (aParentIndex >= a.parentScopes.length || bParentIndex >= b.parentScopes.length) {\n        break;\n      }\n      const parentScopeLengthDiff = b.parentScopes[bParentIndex].length - a.parentScopes[aParentIndex].length;\n      if (parentScopeLengthDiff !== 0) {\n        return parentScopeLengthDiff;\n      }\n      aParentIndex++;\n      bParentIndex++;\n    }\n    return b.parentScopes.length - a.parentScopes.length;\n  }\n  match(scope) {\n    if (scope !== \"\") {\n      let dotIndex = scope.indexOf(\".\");\n      let head;\n      let tail;\n      if (dotIndex === -1) {\n        head = scope;\n        tail = \"\";\n      } else {\n        head = scope.substring(0, dotIndex);\n        tail = scope.substring(dotIndex + 1);\n      }\n      if (this._children.hasOwnProperty(head)) {\n        return this._children[head].match(tail);\n      }\n    }\n    const rules = this._rulesWithParentScopes.concat(this._mainRule);\n    rules.sort(_ThemeTrieElement._cmpBySpecificity);\n    return rules;\n  }\n  insert(scopeDepth, scope, parentScopes, fontStyle, foreground, background) {\n    if (scope === \"\") {\n      this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);\n      return;\n    }\n    let dotIndex = scope.indexOf(\".\");\n    let head;\n    let tail;\n    if (dotIndex === -1) {\n      head = scope;\n      tail = \"\";\n    } else {\n      head = scope.substring(0, dotIndex);\n      tail = scope.substring(dotIndex + 1);\n    }\n    let child;\n    if (this._children.hasOwnProperty(head)) {\n      child = this._children[head];\n    } else {\n      child = new _ThemeTrieElement(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));\n      this._children[head] = child;\n    }\n    child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);\n  }\n  _doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background) {\n    if (parentScopes === null) {\n      this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);\n      return;\n    }\n    for (let i = 0, len = this._rulesWithParentScopes.length; i < len; i++) {\n      let rule = this._rulesWithParentScopes[i];\n      if (strArrCmp(rule.parentScopes, parentScopes) === 0) {\n        rule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);\n        return;\n      }\n    }\n    if (fontStyle === -1 /* NotSet */) {\n      fontStyle = this._mainRule.fontStyle;\n    }\n    if (foreground === 0) {\n      foreground = this._mainRule.foreground;\n    }\n    if (background === 0) {\n      background = this._mainRule.background;\n    }\n    this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle, foreground, background));\n  }\n};\n\n// src/encodedTokenAttributes.ts\nvar EncodedTokenMetadata = class _EncodedTokenMetadata {\n  static toBinaryStr(encodedTokenAttributes) {\n    return encodedTokenAttributes.toString(2).padStart(32, \"0\");\n  }\n  static print(encodedTokenAttributes) {\n    const languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);\n    const tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);\n    const fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);\n    const foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);\n    const background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);\n    console.log({\n      languageId,\n      tokenType,\n      fontStyle,\n      foreground,\n      background\n    });\n  }\n  static getLanguageId(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 255 /* LANGUAGEID_MASK */) >>> 0 /* LANGUAGEID_OFFSET */;\n  }\n  static getTokenType(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 768 /* TOKEN_TYPE_MASK */) >>> 8 /* TOKEN_TYPE_OFFSET */;\n  }\n  static containsBalancedBrackets(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 1024 /* BALANCED_BRACKETS_MASK */) !== 0;\n  }\n  static getFontStyle(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 30720 /* FONT_STYLE_MASK */) >>> 11 /* FONT_STYLE_OFFSET */;\n  }\n  static getForeground(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 16744448 /* FOREGROUND_MASK */) >>> 15 /* FOREGROUND_OFFSET */;\n  }\n  static getBackground(encodedTokenAttributes) {\n    return (encodedTokenAttributes & 4278190080 /* BACKGROUND_MASK */) >>> 24 /* BACKGROUND_OFFSET */;\n  }\n  /**\n   * Updates the fields in `metadata`.\n   * A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.\n   */\n  static set(encodedTokenAttributes, languageId, tokenType, containsBalancedBrackets, fontStyle, foreground, background) {\n    let _languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);\n    let _tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);\n    let _containsBalancedBracketsBit = _EncodedTokenMetadata.containsBalancedBrackets(encodedTokenAttributes) ? 1 : 0;\n    let _fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);\n    let _foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);\n    let _background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);\n    if (languageId !== 0) {\n      _languageId = languageId;\n    }\n    if (tokenType !== 8 /* NotSet */) {\n      _tokenType = fromOptionalTokenType(tokenType);\n    }\n    if (containsBalancedBrackets !== null) {\n      _containsBalancedBracketsBit = containsBalancedBrackets ? 1 : 0;\n    }\n    if (fontStyle !== -1 /* NotSet */) {\n      _fontStyle = fontStyle;\n    }\n    if (foreground !== 0) {\n      _foreground = foreground;\n    }\n    if (background !== 0) {\n      _background = background;\n    }\n    return (_languageId << 0 /* LANGUAGEID_OFFSET */ | _tokenType << 8 /* TOKEN_TYPE_OFFSET */ | _containsBalancedBracketsBit << 10 /* BALANCED_BRACKETS_OFFSET */ | _fontStyle << 11 /* FONT_STYLE_OFFSET */ | _foreground << 15 /* FOREGROUND_OFFSET */ | _background << 24 /* BACKGROUND_OFFSET */) >>> 0;\n  }\n};\nfunction toOptionalTokenType(standardType) {\n  return standardType;\n}\nfunction fromOptionalTokenType(standardType) {\n  return standardType;\n}\n\n// src/matcher.ts\nfunction createMatchers(selector, matchesName) {\n  const results = [];\n  const tokenizer = newTokenizer(selector);\n  let token = tokenizer.next();\n  while (token !== null) {\n    let priority = 0;\n    if (token.length === 2 && token.charAt(1) === \":\") {\n      switch (token.charAt(0)) {\n        case \"R\":\n          priority = 1;\n          break;\n        case \"L\":\n          priority = -1;\n          break;\n        default:\n          console.log(`Unknown priority ${token} in scope selector`);\n      }\n      token = tokenizer.next();\n    }\n    let matcher = parseConjunction();\n    results.push({ matcher, priority });\n    if (token !== \",\") {\n      break;\n    }\n    token = tokenizer.next();\n  }\n  return results;\n  function parseOperand() {\n    if (token === \"-\") {\n      token = tokenizer.next();\n      const expressionToNegate = parseOperand();\n      return (matcherInput) => !!expressionToNegate && !expressionToNegate(matcherInput);\n    }\n    if (token === \"(\") {\n      token = tokenizer.next();\n      const expressionInParents = parseInnerExpression();\n      if (token === \")\") {\n        token = tokenizer.next();\n      }\n      return expressionInParents;\n    }\n    if (isIdentifier(token)) {\n      const identifiers = [];\n      do {\n        identifiers.push(token);\n        token = tokenizer.next();\n      } while (isIdentifier(token));\n      return (matcherInput) => matchesName(identifiers, matcherInput);\n    }\n    return null;\n  }\n  function parseConjunction() {\n    const matchers = [];\n    let matcher = parseOperand();\n    while (matcher) {\n      matchers.push(matcher);\n      matcher = parseOperand();\n    }\n    return (matcherInput) => matchers.every((matcher2) => matcher2(matcherInput));\n  }\n  function parseInnerExpression() {\n    const matchers = [];\n    let matcher = parseConjunction();\n    while (matcher) {\n      matchers.push(matcher);\n      if (token === \"|\" || token === \",\") {\n        do {\n          token = tokenizer.next();\n        } while (token === \"|\" || token === \",\");\n      } else {\n        break;\n      }\n      matcher = parseConjunction();\n    }\n    return (matcherInput) => matchers.some((matcher2) => matcher2(matcherInput));\n  }\n}\nfunction isIdentifier(token) {\n  return !!token && !!token.match(/[\\w\\.:]+/);\n}\nfunction newTokenizer(input) {\n  let regex = /([LR]:|[\\w\\.:][\\w\\.:\\-]*|[\\,\\|\\-\\(\\)])/g;\n  let match = regex.exec(input);\n  return {\n    next: () => {\n      if (!match) {\n        return null;\n      }\n      const res = match[0];\n      match = regex.exec(input);\n      return res;\n    }\n  };\n}\n\n// src/onigLib.ts\nvar FindOption = /* @__PURE__ */ ((FindOption2) => {\n  FindOption2[FindOption2[\"None\"] = 0] = \"None\";\n  FindOption2[FindOption2[\"NotBeginString\"] = 1] = \"NotBeginString\";\n  FindOption2[FindOption2[\"NotEndString\"] = 2] = \"NotEndString\";\n  FindOption2[FindOption2[\"NotBeginPosition\"] = 4] = \"NotBeginPosition\";\n  FindOption2[FindOption2[\"DebugCall\"] = 8] = \"DebugCall\";\n  return FindOption2;\n})(FindOption || {});\nfunction disposeOnigString(str) {\n  if (typeof str.dispose === \"function\") {\n    str.dispose();\n  }\n}\n\n// src/grammar/grammarDependencies.ts\nvar TopLevelRuleReference = class {\n  constructor(scopeName) {\n    this.scopeName = scopeName;\n  }\n  toKey() {\n    return this.scopeName;\n  }\n};\nvar TopLevelRepositoryRuleReference = class {\n  constructor(scopeName, ruleName) {\n    this.scopeName = scopeName;\n    this.ruleName = ruleName;\n  }\n  toKey() {\n    return `${this.scopeName}#${this.ruleName}`;\n  }\n};\nvar ExternalReferenceCollector = class {\n  _references = [];\n  _seenReferenceKeys = /* @__PURE__ */ new Set();\n  get references() {\n    return this._references;\n  }\n  visitedRule = /* @__PURE__ */ new Set();\n  add(reference) {\n    const key = reference.toKey();\n    if (this._seenReferenceKeys.has(key)) {\n      return;\n    }\n    this._seenReferenceKeys.add(key);\n    this._references.push(reference);\n  }\n};\nvar ScopeDependencyProcessor = class {\n  constructor(repo, initialScopeName) {\n    this.repo = repo;\n    this.initialScopeName = initialScopeName;\n    this.seenFullScopeRequests.add(this.initialScopeName);\n    this.Q = [new TopLevelRuleReference(this.initialScopeName)];\n  }\n  seenFullScopeRequests = /* @__PURE__ */ new Set();\n  seenPartialScopeRequests = /* @__PURE__ */ new Set();\n  Q;\n  processQueue() {\n    const q = this.Q;\n    this.Q = [];\n    const deps = new ExternalReferenceCollector();\n    for (const dep of q) {\n      collectReferencesOfReference(dep, this.initialScopeName, this.repo, deps);\n    }\n    for (const dep of deps.references) {\n      if (dep instanceof TopLevelRuleReference) {\n        if (this.seenFullScopeRequests.has(dep.scopeName)) {\n          continue;\n        }\n        this.seenFullScopeRequests.add(dep.scopeName);\n        this.Q.push(dep);\n      } else {\n        if (this.seenFullScopeRequests.has(dep.scopeName)) {\n          continue;\n        }\n        if (this.seenPartialScopeRequests.has(dep.toKey())) {\n          continue;\n        }\n        this.seenPartialScopeRequests.add(dep.toKey());\n        this.Q.push(dep);\n      }\n    }\n  }\n};\nfunction collectReferencesOfReference(reference, baseGrammarScopeName, repo, result) {\n  const selfGrammar = repo.lookup(reference.scopeName);\n  if (!selfGrammar) {\n    if (reference.scopeName === baseGrammarScopeName) {\n      throw new Error(`No grammar provided for <${baseGrammarScopeName}>`);\n    }\n    return;\n  }\n  const baseGrammar = repo.lookup(baseGrammarScopeName);\n  if (reference instanceof TopLevelRuleReference) {\n    collectExternalReferencesInTopLevelRule({ baseGrammar, selfGrammar }, result);\n  } else {\n    collectExternalReferencesInTopLevelRepositoryRule(\n      reference.ruleName,\n      { baseGrammar, selfGrammar, repository: selfGrammar.repository },\n      result\n    );\n  }\n  const injections = repo.injections(reference.scopeName);\n  if (injections) {\n    for (const injection of injections) {\n      result.add(new TopLevelRuleReference(injection));\n    }\n  }\n}\nfunction collectExternalReferencesInTopLevelRepositoryRule(ruleName, context, result) {\n  if (context.repository && context.repository[ruleName]) {\n    const rule = context.repository[ruleName];\n    collectExternalReferencesInRules([rule], context, result);\n  }\n}\nfunction collectExternalReferencesInTopLevelRule(context, result) {\n  if (context.selfGrammar.patterns && Array.isArray(context.selfGrammar.patterns)) {\n    collectExternalReferencesInRules(\n      context.selfGrammar.patterns,\n      { ...context, repository: context.selfGrammar.repository },\n      result\n    );\n  }\n  if (context.selfGrammar.injections) {\n    collectExternalReferencesInRules(\n      Object.values(context.selfGrammar.injections),\n      { ...context, repository: context.selfGrammar.repository },\n      result\n    );\n  }\n}\nfunction collectExternalReferencesInRules(rules, context, result) {\n  for (const rule of rules) {\n    if (result.visitedRule.has(rule)) {\n      continue;\n    }\n    result.visitedRule.add(rule);\n    const patternRepository = rule.repository ? mergeObjects({}, context.repository, rule.repository) : context.repository;\n    if (Array.isArray(rule.patterns)) {\n      collectExternalReferencesInRules(rule.patterns, { ...context, repository: patternRepository }, result);\n    }\n    const include = rule.include;\n    if (!include) {\n      continue;\n    }\n    const reference = parseInclude(include);\n    switch (reference.kind) {\n      case 0 /* Base */:\n        collectExternalReferencesInTopLevelRule({ ...context, selfGrammar: context.baseGrammar }, result);\n        break;\n      case 1 /* Self */:\n        collectExternalReferencesInTopLevelRule(context, result);\n        break;\n      case 2 /* RelativeReference */:\n        collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, { ...context, repository: patternRepository }, result);\n        break;\n      case 3 /* TopLevelReference */:\n      case 4 /* TopLevelRepositoryReference */:\n        const selfGrammar = reference.scopeName === context.selfGrammar.scopeName ? context.selfGrammar : reference.scopeName === context.baseGrammar.scopeName ? context.baseGrammar : void 0;\n        if (selfGrammar) {\n          const newContext = { baseGrammar: context.baseGrammar, selfGrammar, repository: patternRepository };\n          if (reference.kind === 4 /* TopLevelRepositoryReference */) {\n            collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, newContext, result);\n          } else {\n            collectExternalReferencesInTopLevelRule(newContext, result);\n          }\n        } else {\n          if (reference.kind === 4 /* TopLevelRepositoryReference */) {\n            result.add(new TopLevelRepositoryRuleReference(reference.scopeName, reference.ruleName));\n          } else {\n            result.add(new TopLevelRuleReference(reference.scopeName));\n          }\n        }\n        break;\n    }\n  }\n}\nvar BaseReference = class {\n  kind = 0 /* Base */;\n};\nvar SelfReference = class {\n  kind = 1 /* Self */;\n};\nvar RelativeReference = class {\n  constructor(ruleName) {\n    this.ruleName = ruleName;\n  }\n  kind = 2 /* RelativeReference */;\n};\nvar TopLevelReference = class {\n  constructor(scopeName) {\n    this.scopeName = scopeName;\n  }\n  kind = 3 /* TopLevelReference */;\n};\nvar TopLevelRepositoryReference = class {\n  constructor(scopeName, ruleName) {\n    this.scopeName = scopeName;\n    this.ruleName = ruleName;\n  }\n  kind = 4 /* TopLevelRepositoryReference */;\n};\nfunction parseInclude(include) {\n  if (include === \"$base\") {\n    return new BaseReference();\n  } else if (include === \"$self\") {\n    return new SelfReference();\n  }\n  const indexOfSharp = include.indexOf(\"#\");\n  if (indexOfSharp === -1) {\n    return new TopLevelReference(include);\n  } else if (indexOfSharp === 0) {\n    return new RelativeReference(include.substring(1));\n  } else {\n    const scopeName = include.substring(0, indexOfSharp);\n    const ruleName = include.substring(indexOfSharp + 1);\n    return new TopLevelRepositoryReference(scopeName, ruleName);\n  }\n}\n\n// src/rule.ts\nvar HAS_BACK_REFERENCES = /\\\\(\\d+)/;\nvar BACK_REFERENCING_END = /\\\\(\\d+)/g;\nvar ruleIdSymbol = Symbol(\"RuleId\");\nvar endRuleId = -1;\nvar whileRuleId = -2;\nfunction ruleIdFromNumber(id) {\n  return id;\n}\nfunction ruleIdToNumber(id) {\n  return id;\n}\nvar Rule = class {\n  $location;\n  id;\n  _nameIsCapturing;\n  _name;\n  _contentNameIsCapturing;\n  _contentName;\n  constructor($location, id, name, contentName) {\n    this.$location = $location;\n    this.id = id;\n    this._name = name || null;\n    this._nameIsCapturing = RegexSource.hasCaptures(this._name);\n    this._contentName = contentName || null;\n    this._contentNameIsCapturing = RegexSource.hasCaptures(this._contentName);\n  }\n  get debugName() {\n    const location = this.$location ? `${basename(this.$location.filename)}:${this.$location.line}` : \"unknown\";\n    return `${this.constructor.name}#${this.id} @ ${location}`;\n  }\n  getName(lineText, captureIndices) {\n    if (!this._nameIsCapturing || this._name === null || lineText === null || captureIndices === null) {\n      return this._name;\n    }\n    return RegexSource.replaceCaptures(this._name, lineText, captureIndices);\n  }\n  getContentName(lineText, captureIndices) {\n    if (!this._contentNameIsCapturing || this._contentName === null) {\n      return this._contentName;\n    }\n    return RegexSource.replaceCaptures(this._contentName, lineText, captureIndices);\n  }\n};\nvar CaptureRule = class extends Rule {\n  retokenizeCapturedWithRuleId;\n  constructor($location, id, name, contentName, retokenizeCapturedWithRuleId) {\n    super($location, id, name, contentName);\n    this.retokenizeCapturedWithRuleId = retokenizeCapturedWithRuleId;\n  }\n  dispose() {\n  }\n  collectPatterns(grammar, out) {\n    throw new Error(\"Not supported!\");\n  }\n  compile(grammar, endRegexSource) {\n    throw new Error(\"Not supported!\");\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    throw new Error(\"Not supported!\");\n  }\n};\nvar MatchRule = class extends Rule {\n  _match;\n  captures;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, match, captures) {\n    super($location, id, name, null);\n    this._match = new RegExpSource(match, this.id);\n    this.captures = captures;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  get debugMatchRegExp() {\n    return `${this._match.source}`;\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._match);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      this.collectPatterns(grammar, this._cachedCompiledPatterns);\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar IncludeOnlyRule = class extends Rule {\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, contentName, patterns) {\n    super($location, id, name, contentName);\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  collectPatterns(grammar, out) {\n    for (const pattern of this.patterns) {\n      const rule = grammar.getRule(pattern);\n      rule.collectPatterns(grammar, out);\n    }\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      this.collectPatterns(grammar, this._cachedCompiledPatterns);\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar BeginEndRule = class extends Rule {\n  _begin;\n  beginCaptures;\n  _end;\n  endHasBackReferences;\n  endCaptures;\n  applyEndPatternLast;\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, contentName, begin, beginCaptures, end, endCaptures, applyEndPatternLast, patterns) {\n    super($location, id, name, contentName);\n    this._begin = new RegExpSource(begin, this.id);\n    this.beginCaptures = beginCaptures;\n    this._end = new RegExpSource(end ? end : \"\\uFFFF\", -1);\n    this.endHasBackReferences = this._end.hasBackReferences;\n    this.endCaptures = endCaptures;\n    this.applyEndPatternLast = applyEndPatternLast || false;\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  get debugBeginRegExp() {\n    return `${this._begin.source}`;\n  }\n  get debugEndRegExp() {\n    return `${this._end.source}`;\n  }\n  getEndWithResolvedBackReferences(lineText, captureIndices) {\n    return this._end.resolveBackReferences(lineText, captureIndices);\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._begin);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar, endRegexSource).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar, endRegexSource) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      for (const pattern of this.patterns) {\n        const rule = grammar.getRule(pattern);\n        rule.collectPatterns(grammar, this._cachedCompiledPatterns);\n      }\n      if (this.applyEndPatternLast) {\n        this._cachedCompiledPatterns.push(this._end.hasBackReferences ? this._end.clone() : this._end);\n      } else {\n        this._cachedCompiledPatterns.unshift(this._end.hasBackReferences ? this._end.clone() : this._end);\n      }\n    }\n    if (this._end.hasBackReferences) {\n      if (this.applyEndPatternLast) {\n        this._cachedCompiledPatterns.setSource(this._cachedCompiledPatterns.length() - 1, endRegexSource);\n      } else {\n        this._cachedCompiledPatterns.setSource(0, endRegexSource);\n      }\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar BeginWhileRule = class extends Rule {\n  _begin;\n  beginCaptures;\n  whileCaptures;\n  _while;\n  whileHasBackReferences;\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  _cachedCompiledWhilePatterns;\n  constructor($location, id, name, contentName, begin, beginCaptures, _while, whileCaptures, patterns) {\n    super($location, id, name, contentName);\n    this._begin = new RegExpSource(begin, this.id);\n    this.beginCaptures = beginCaptures;\n    this.whileCaptures = whileCaptures;\n    this._while = new RegExpSource(_while, whileRuleId);\n    this.whileHasBackReferences = this._while.hasBackReferences;\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n    this._cachedCompiledWhilePatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n    if (this._cachedCompiledWhilePatterns) {\n      this._cachedCompiledWhilePatterns.dispose();\n      this._cachedCompiledWhilePatterns = null;\n    }\n  }\n  get debugBeginRegExp() {\n    return `${this._begin.source}`;\n  }\n  get debugWhileRegExp() {\n    return `${this._while.source}`;\n  }\n  getWhileWithResolvedBackReferences(lineText, captureIndices) {\n    return this._while.resolveBackReferences(lineText, captureIndices);\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._begin);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      for (const pattern of this.patterns) {\n        const rule = grammar.getRule(pattern);\n        rule.collectPatterns(grammar, this._cachedCompiledPatterns);\n      }\n    }\n    return this._cachedCompiledPatterns;\n  }\n  compileWhile(grammar, endRegexSource) {\n    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compile(grammar);\n  }\n  compileWhileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledWhilePatterns(grammar, endRegexSource) {\n    if (!this._cachedCompiledWhilePatterns) {\n      this._cachedCompiledWhilePatterns = new RegExpSourceList();\n      this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while);\n    }\n    if (this._while.hasBackReferences) {\n      this._cachedCompiledWhilePatterns.setSource(0, endRegexSource ? endRegexSource : \"\\uFFFF\");\n    }\n    return this._cachedCompiledWhilePatterns;\n  }\n};\nvar RuleFactory = class _RuleFactory {\n  static createCaptureRule(helper, $location, name, contentName, retokenizeCapturedWithRuleId) {\n    return helper.registerRule((id) => {\n      return new CaptureRule($location, id, name, contentName, retokenizeCapturedWithRuleId);\n    });\n  }\n  static getCompiledRuleId(desc, helper, repository) {\n    if (!desc.id) {\n      helper.registerRule((id) => {\n        desc.id = id;\n        if (desc.match) {\n          return new MatchRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.match,\n            _RuleFactory._compileCaptures(desc.captures, helper, repository)\n          );\n        }\n        if (typeof desc.begin === \"undefined\") {\n          if (desc.repository) {\n            repository = mergeObjects({}, repository, desc.repository);\n          }\n          let patterns = desc.patterns;\n          if (typeof patterns === \"undefined\" && desc.include) {\n            patterns = [{ include: desc.include }];\n          }\n          return new IncludeOnlyRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.contentName,\n            _RuleFactory._compilePatterns(patterns, helper, repository)\n          );\n        }\n        if (desc.while) {\n          return new BeginWhileRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.contentName,\n            desc.begin,\n            _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),\n            desc.while,\n            _RuleFactory._compileCaptures(desc.whileCaptures || desc.captures, helper, repository),\n            _RuleFactory._compilePatterns(desc.patterns, helper, repository)\n          );\n        }\n        return new BeginEndRule(\n          desc.$vscodeTextmateLocation,\n          desc.id,\n          desc.name,\n          desc.contentName,\n          desc.begin,\n          _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),\n          desc.end,\n          _RuleFactory._compileCaptures(desc.endCaptures || desc.captures, helper, repository),\n          desc.applyEndPatternLast,\n          _RuleFactory._compilePatterns(desc.patterns, helper, repository)\n        );\n      });\n    }\n    return desc.id;\n  }\n  static _compileCaptures(captures, helper, repository) {\n    let r = [];\n    if (captures) {\n      let maximumCaptureId = 0;\n      for (const captureId in captures) {\n        if (captureId === \"$vscodeTextmateLocation\") {\n          continue;\n        }\n        const numericCaptureId = parseInt(captureId, 10);\n        if (numericCaptureId > maximumCaptureId) {\n          maximumCaptureId = numericCaptureId;\n        }\n      }\n      for (let i = 0; i <= maximumCaptureId; i++) {\n        r[i] = null;\n      }\n      for (const captureId in captures) {\n        if (captureId === \"$vscodeTextmateLocation\") {\n          continue;\n        }\n        const numericCaptureId = parseInt(captureId, 10);\n        let retokenizeCapturedWithRuleId = 0;\n        if (captures[captureId].patterns) {\n          retokenizeCapturedWithRuleId = _RuleFactory.getCompiledRuleId(captures[captureId], helper, repository);\n        }\n        r[numericCaptureId] = _RuleFactory.createCaptureRule(helper, captures[captureId].$vscodeTextmateLocation, captures[captureId].name, captures[captureId].contentName, retokenizeCapturedWithRuleId);\n      }\n    }\n    return r;\n  }\n  static _compilePatterns(patterns, helper, repository) {\n    let r = [];\n    if (patterns) {\n      for (let i = 0, len = patterns.length; i < len; i++) {\n        const pattern = patterns[i];\n        let ruleId = -1;\n        if (pattern.include) {\n          const reference = parseInclude(pattern.include);\n          switch (reference.kind) {\n            case 0 /* Base */:\n            case 1 /* Self */:\n              ruleId = _RuleFactory.getCompiledRuleId(repository[pattern.include], helper, repository);\n              break;\n            case 2 /* RelativeReference */:\n              let localIncludedRule = repository[reference.ruleName];\n              if (localIncludedRule) {\n                ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);\n              } else {\n              }\n              break;\n            case 3 /* TopLevelReference */:\n            case 4 /* TopLevelRepositoryReference */:\n              const externalGrammarName = reference.scopeName;\n              const externalGrammarInclude = reference.kind === 4 /* TopLevelRepositoryReference */ ? reference.ruleName : null;\n              const externalGrammar = helper.getExternalGrammar(externalGrammarName, repository);\n              if (externalGrammar) {\n                if (externalGrammarInclude) {\n                  let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];\n                  if (externalIncludedRule) {\n                    ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);\n                  } else {\n                  }\n                } else {\n                  ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);\n                }\n              } else {\n              }\n              break;\n          }\n        } else {\n          ruleId = _RuleFactory.getCompiledRuleId(pattern, helper, repository);\n        }\n        if (ruleId !== -1) {\n          const rule = helper.getRule(ruleId);\n          let skipRule = false;\n          if (rule instanceof IncludeOnlyRule || rule instanceof BeginEndRule || rule instanceof BeginWhileRule) {\n            if (rule.hasMissingPatterns && rule.patterns.length === 0) {\n              skipRule = true;\n            }\n          }\n          if (skipRule) {\n            continue;\n          }\n          r.push(ruleId);\n        }\n      }\n    }\n    return {\n      patterns: r,\n      hasMissingPatterns: (patterns ? patterns.length : 0) !== r.length\n    };\n  }\n};\nvar RegExpSource = class _RegExpSource {\n  source;\n  ruleId;\n  hasAnchor;\n  hasBackReferences;\n  _anchorCache;\n  constructor(regExpSource, ruleId) {\n    if (regExpSource && typeof regExpSource === \"string\") {\n      const len = regExpSource.length;\n      let lastPushedPos = 0;\n      let output = [];\n      let hasAnchor = false;\n      for (let pos = 0; pos < len; pos++) {\n        const ch = regExpSource.charAt(pos);\n        if (ch === \"\\\\\") {\n          if (pos + 1 < len) {\n            const nextCh = regExpSource.charAt(pos + 1);\n            if (nextCh === \"z\") {\n              output.push(regExpSource.substring(lastPushedPos, pos));\n              output.push(\"$(?!\\\\n)(?<!\\\\n)\");\n              lastPushedPos = pos + 2;\n            } else if (nextCh === \"A\" || nextCh === \"G\") {\n              hasAnchor = true;\n            }\n            pos++;\n          }\n        }\n      }\n      this.hasAnchor = hasAnchor;\n      if (lastPushedPos === 0) {\n        this.source = regExpSource;\n      } else {\n        output.push(regExpSource.substring(lastPushedPos, len));\n        this.source = output.join(\"\");\n      }\n    } else {\n      this.hasAnchor = false;\n      this.source = regExpSource;\n    }\n    if (this.hasAnchor) {\n      this._anchorCache = this._buildAnchorCache();\n    } else {\n      this._anchorCache = null;\n    }\n    this.ruleId = ruleId;\n    if (typeof this.source === \"string\") {\n      this.hasBackReferences = HAS_BACK_REFERENCES.test(this.source);\n    } else {\n      this.hasBackReferences = false;\n    }\n  }\n  clone() {\n    return new _RegExpSource(this.source, this.ruleId);\n  }\n  setSource(newSource) {\n    if (this.source === newSource) {\n      return;\n    }\n    this.source = newSource;\n    if (this.hasAnchor) {\n      this._anchorCache = this._buildAnchorCache();\n    }\n  }\n  resolveBackReferences(lineText, captureIndices) {\n    if (typeof this.source !== \"string\") {\n      throw new Error(\"This method should only be called if the source is a string\");\n    }\n    let capturedValues = captureIndices.map((capture) => {\n      return lineText.substring(capture.start, capture.end);\n    });\n    BACK_REFERENCING_END.lastIndex = 0;\n    return this.source.replace(BACK_REFERENCING_END, (match, g1) => {\n      return escapeRegExpCharacters(capturedValues[parseInt(g1, 10)] || \"\");\n    });\n  }\n  _buildAnchorCache() {\n    if (typeof this.source !== \"string\") {\n      throw new Error(\"This method should only be called if the source is a string\");\n    }\n    let A0_G0_result = [];\n    let A0_G1_result = [];\n    let A1_G0_result = [];\n    let A1_G1_result = [];\n    let pos, len, ch, nextCh;\n    for (pos = 0, len = this.source.length; pos < len; pos++) {\n      ch = this.source.charAt(pos);\n      A0_G0_result[pos] = ch;\n      A0_G1_result[pos] = ch;\n      A1_G0_result[pos] = ch;\n      A1_G1_result[pos] = ch;\n      if (ch === \"\\\\\") {\n        if (pos + 1 < len) {\n          nextCh = this.source.charAt(pos + 1);\n          if (nextCh === \"A\") {\n            A0_G0_result[pos + 1] = \"\\uFFFF\";\n            A0_G1_result[pos + 1] = \"\\uFFFF\";\n            A1_G0_result[pos + 1] = \"A\";\n            A1_G1_result[pos + 1] = \"A\";\n          } else if (nextCh === \"G\") {\n            A0_G0_result[pos + 1] = \"\\uFFFF\";\n            A0_G1_result[pos + 1] = \"G\";\n            A1_G0_result[pos + 1] = \"\\uFFFF\";\n            A1_G1_result[pos + 1] = \"G\";\n          } else {\n            A0_G0_result[pos + 1] = nextCh;\n            A0_G1_result[pos + 1] = nextCh;\n            A1_G0_result[pos + 1] = nextCh;\n            A1_G1_result[pos + 1] = nextCh;\n          }\n          pos++;\n        }\n      }\n    }\n    return {\n      A0_G0: A0_G0_result.join(\"\"),\n      A0_G1: A0_G1_result.join(\"\"),\n      A1_G0: A1_G0_result.join(\"\"),\n      A1_G1: A1_G1_result.join(\"\")\n    };\n  }\n  resolveAnchors(allowA, allowG) {\n    if (!this.hasAnchor || !this._anchorCache || typeof this.source !== \"string\") {\n      return this.source;\n    }\n    if (allowA) {\n      if (allowG) {\n        return this._anchorCache.A1_G1;\n      } else {\n        return this._anchorCache.A1_G0;\n      }\n    } else {\n      if (allowG) {\n        return this._anchorCache.A0_G1;\n      } else {\n        return this._anchorCache.A0_G0;\n      }\n    }\n  }\n};\nvar RegExpSourceList = class {\n  _items;\n  _hasAnchors;\n  _cached;\n  _anchorCache;\n  constructor() {\n    this._items = [];\n    this._hasAnchors = false;\n    this._cached = null;\n    this._anchorCache = {\n      A0_G0: null,\n      A0_G1: null,\n      A1_G0: null,\n      A1_G1: null\n    };\n  }\n  dispose() {\n    this._disposeCaches();\n  }\n  _disposeCaches() {\n    if (this._cached) {\n      this._cached.dispose();\n      this._cached = null;\n    }\n    if (this._anchorCache.A0_G0) {\n      this._anchorCache.A0_G0.dispose();\n      this._anchorCache.A0_G0 = null;\n    }\n    if (this._anchorCache.A0_G1) {\n      this._anchorCache.A0_G1.dispose();\n      this._anchorCache.A0_G1 = null;\n    }\n    if (this._anchorCache.A1_G0) {\n      this._anchorCache.A1_G0.dispose();\n      this._anchorCache.A1_G0 = null;\n    }\n    if (this._anchorCache.A1_G1) {\n      this._anchorCache.A1_G1.dispose();\n      this._anchorCache.A1_G1 = null;\n    }\n  }\n  push(item) {\n    this._items.push(item);\n    this._hasAnchors = this._hasAnchors || item.hasAnchor;\n  }\n  unshift(item) {\n    this._items.unshift(item);\n    this._hasAnchors = this._hasAnchors || item.hasAnchor;\n  }\n  length() {\n    return this._items.length;\n  }\n  setSource(index, newSource) {\n    if (this._items[index].source !== newSource) {\n      this._disposeCaches();\n      this._items[index].setSource(newSource);\n    }\n  }\n  compile(onigLib) {\n    if (!this._cached) {\n      let regExps = this._items.map((e) => e.source);\n      this._cached = new CompiledRule(onigLib, regExps, this._items.map((e) => e.ruleId));\n    }\n    return this._cached;\n  }\n  compileAG(onigLib, allowA, allowG) {\n    if (!this._hasAnchors) {\n      return this.compile(onigLib);\n    } else {\n      if (allowA) {\n        if (allowG) {\n          if (!this._anchorCache.A1_G1) {\n            this._anchorCache.A1_G1 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A1_G1;\n        } else {\n          if (!this._anchorCache.A1_G0) {\n            this._anchorCache.A1_G0 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A1_G0;\n        }\n      } else {\n        if (allowG) {\n          if (!this._anchorCache.A0_G1) {\n            this._anchorCache.A0_G1 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A0_G1;\n        } else {\n          if (!this._anchorCache.A0_G0) {\n            this._anchorCache.A0_G0 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A0_G0;\n        }\n      }\n    }\n  }\n  _resolveAnchors(onigLib, allowA, allowG) {\n    let regExps = this._items.map((e) => e.resolveAnchors(allowA, allowG));\n    return new CompiledRule(onigLib, regExps, this._items.map((e) => e.ruleId));\n  }\n};\nvar CompiledRule = class {\n  constructor(onigLib, regExps, rules) {\n    this.regExps = regExps;\n    this.rules = rules;\n    this.scanner = onigLib.createOnigScanner(regExps);\n  }\n  scanner;\n  dispose() {\n    if (typeof this.scanner.dispose === \"function\") {\n      this.scanner.dispose();\n    }\n  }\n  toString() {\n    const r = [];\n    for (let i = 0, len = this.rules.length; i < len; i++) {\n      r.push(\"   - \" + this.rules[i] + \": \" + this.regExps[i]);\n    }\n    return r.join(\"\\n\");\n  }\n  findNextMatchSync(string, startPosition, options) {\n    const result = this.scanner.findNextMatchSync(string, startPosition, options);\n    if (!result) {\n      return null;\n    }\n    return {\n      ruleId: this.rules[result.index],\n      captureIndices: result.captureIndices\n    };\n  }\n};\n\n// src/grammar/basicScopesAttributeProvider.ts\nvar BasicScopeAttributes = class {\n  constructor(languageId, tokenType) {\n    this.languageId = languageId;\n    this.tokenType = tokenType;\n  }\n};\nvar BasicScopeAttributesProvider = class _BasicScopeAttributesProvider {\n  _defaultAttributes;\n  _embeddedLanguagesMatcher;\n  constructor(initialLanguageId, embeddedLanguages) {\n    this._defaultAttributes = new BasicScopeAttributes(initialLanguageId, 8 /* NotSet */);\n    this._embeddedLanguagesMatcher = new ScopeMatcher(Object.entries(embeddedLanguages || {}));\n  }\n  getDefaultAttributes() {\n    return this._defaultAttributes;\n  }\n  getBasicScopeAttributes(scopeName) {\n    if (scopeName === null) {\n      return _BasicScopeAttributesProvider._NULL_SCOPE_METADATA;\n    }\n    return this._getBasicScopeAttributes.get(scopeName);\n  }\n  static _NULL_SCOPE_METADATA = new BasicScopeAttributes(0, 0);\n  _getBasicScopeAttributes = new CachedFn((scopeName) => {\n    const languageId = this._scopeToLanguage(scopeName);\n    const standardTokenType = this._toStandardTokenType(scopeName);\n    return new BasicScopeAttributes(languageId, standardTokenType);\n  });\n  /**\n   * Given a produced TM scope, return the language that token describes or null if unknown.\n   * e.g. source.html => html, source.css.embedded.html => css, punctuation.definition.tag.html => null\n   */\n  _scopeToLanguage(scope) {\n    return this._embeddedLanguagesMatcher.match(scope) || 0;\n  }\n  _toStandardTokenType(scopeName) {\n    const m = scopeName.match(_BasicScopeAttributesProvider.STANDARD_TOKEN_TYPE_REGEXP);\n    if (!m) {\n      return 8 /* NotSet */;\n    }\n    switch (m[1]) {\n      case \"comment\":\n        return 1 /* Comment */;\n      case \"string\":\n        return 2 /* String */;\n      case \"regex\":\n        return 3 /* RegEx */;\n      case \"meta.embedded\":\n        return 0 /* Other */;\n    }\n    throw new Error(\"Unexpected match for standard token type!\");\n  }\n  static STANDARD_TOKEN_TYPE_REGEXP = /\\b(comment|string|regex|meta\\.embedded)\\b/;\n};\nvar ScopeMatcher = class {\n  values;\n  scopesRegExp;\n  constructor(values) {\n    if (values.length === 0) {\n      this.values = null;\n      this.scopesRegExp = null;\n    } else {\n      this.values = new Map(values);\n      const escapedScopes = values.map(\n        ([scopeName, value]) => escapeRegExpCharacters(scopeName)\n      );\n      escapedScopes.sort();\n      escapedScopes.reverse();\n      this.scopesRegExp = new RegExp(\n        `^((${escapedScopes.join(\")|(\")}))($|\\\\.)`,\n        \"\"\n      );\n    }\n  }\n  match(scope) {\n    if (!this.scopesRegExp) {\n      return void 0;\n    }\n    const m = scope.match(this.scopesRegExp);\n    if (!m) {\n      return void 0;\n    }\n    return this.values.get(m[1]);\n  }\n};\n\n// src/debug.ts\nvar DebugFlags = {\n  InDebugMode: typeof process !== \"undefined\" && !!process.env[\"VSCODE_TEXTMATE_DEBUG\"]\n};\nvar UseOnigurumaFindOptions = false;\n\n// src/grammar/tokenizeString.ts\nvar TokenizeStringResult = class {\n  constructor(stack, stoppedEarly) {\n    this.stack = stack;\n    this.stoppedEarly = stoppedEarly;\n  }\n};\nfunction _tokenizeString(grammar, lineText, isFirstLine, linePos, stack, lineTokens, checkWhileConditions, timeLimit) {\n  const lineLength = lineText.content.length;\n  let STOP = false;\n  let anchorPosition = -1;\n  if (checkWhileConditions) {\n    const whileCheckResult = _checkWhileConditions(\n      grammar,\n      lineText,\n      isFirstLine,\n      linePos,\n      stack,\n      lineTokens\n    );\n    stack = whileCheckResult.stack;\n    linePos = whileCheckResult.linePos;\n    isFirstLine = whileCheckResult.isFirstLine;\n    anchorPosition = whileCheckResult.anchorPosition;\n  }\n  const startTime = Date.now();\n  while (!STOP) {\n    if (timeLimit !== 0) {\n      const elapsedTime = Date.now() - startTime;\n      if (elapsedTime > timeLimit) {\n        return new TokenizeStringResult(stack, true);\n      }\n    }\n    scanNext();\n  }\n  return new TokenizeStringResult(stack, false);\n  function scanNext() {\n    if (false) {\n      console.log(\"\");\n      console.log(\n        `@@scanNext ${linePos}: |${lineText.content.substr(linePos).replace(/\\n$/, \"\\\\n\")}|`\n      );\n    }\n    const r = matchRuleOrInjections(\n      grammar,\n      lineText,\n      isFirstLine,\n      linePos,\n      stack,\n      anchorPosition\n    );\n    if (!r) {\n      lineTokens.produce(stack, lineLength);\n      STOP = true;\n      return;\n    }\n    const captureIndices = r.captureIndices;\n    const matchedRuleId = r.matchedRuleId;\n    const hasAdvanced = captureIndices && captureIndices.length > 0 ? captureIndices[0].end > linePos : false;\n    if (matchedRuleId === endRuleId) {\n      const poppedRule = stack.getRule(grammar);\n      if (false) {\n        console.log(\n          \"  popping \" + poppedRule.debugName + \" - \" + poppedRule.debugEndRegExp\n        );\n      }\n      lineTokens.produce(stack, captureIndices[0].start);\n      stack = stack.withContentNameScopesList(stack.nameScopesList);\n      handleCaptures(\n        grammar,\n        lineText,\n        isFirstLine,\n        stack,\n        lineTokens,\n        poppedRule.endCaptures,\n        captureIndices\n      );\n      lineTokens.produce(stack, captureIndices[0].end);\n      const popped = stack;\n      stack = stack.parent;\n      anchorPosition = popped.getAnchorPos();\n      if (!hasAdvanced && popped.getEnterPos() === linePos) {\n        if (false) {\n          console.error(\n            \"[1] - Grammar is in an endless loop - Grammar pushed & popped a rule without advancing\"\n          );\n        }\n        stack = popped;\n        lineTokens.produce(stack, lineLength);\n        STOP = true;\n        return;\n      }\n    } else {\n      const _rule = grammar.getRule(matchedRuleId);\n      lineTokens.produce(stack, captureIndices[0].start);\n      const beforePush = stack;\n      const scopeName = _rule.getName(lineText.content, captureIndices);\n      const nameScopesList = stack.contentNameScopesList.pushAttributed(\n        scopeName,\n        grammar\n      );\n      stack = stack.push(\n        matchedRuleId,\n        linePos,\n        anchorPosition,\n        captureIndices[0].end === lineLength,\n        null,\n        nameScopesList,\n        nameScopesList\n      );\n      if (_rule instanceof BeginEndRule) {\n        const pushedRule = _rule;\n        if (false) {\n          console.log(\n            \"  pushing \" + pushedRule.debugName + \" - \" + pushedRule.debugBeginRegExp\n          );\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          pushedRule.beginCaptures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        anchorPosition = captureIndices[0].end;\n        const contentName = pushedRule.getContentName(\n          lineText.content,\n          captureIndices\n        );\n        const contentNameScopesList = nameScopesList.pushAttributed(\n          contentName,\n          grammar\n        );\n        stack = stack.withContentNameScopesList(contentNameScopesList);\n        if (pushedRule.endHasBackReferences) {\n          stack = stack.withEndRule(\n            pushedRule.getEndWithResolvedBackReferences(\n              lineText.content,\n              captureIndices\n            )\n          );\n        }\n        if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {\n          if (false) {\n            console.error(\n              \"[2] - Grammar is in an endless loop - Grammar pushed the same rule without advancing\"\n            );\n          }\n          stack = stack.pop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      } else if (_rule instanceof BeginWhileRule) {\n        const pushedRule = _rule;\n        if (false) {\n          console.log(\"  pushing \" + pushedRule.debugName);\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          pushedRule.beginCaptures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        anchorPosition = captureIndices[0].end;\n        const contentName = pushedRule.getContentName(\n          lineText.content,\n          captureIndices\n        );\n        const contentNameScopesList = nameScopesList.pushAttributed(\n          contentName,\n          grammar\n        );\n        stack = stack.withContentNameScopesList(contentNameScopesList);\n        if (pushedRule.whileHasBackReferences) {\n          stack = stack.withEndRule(\n            pushedRule.getWhileWithResolvedBackReferences(\n              lineText.content,\n              captureIndices\n            )\n          );\n        }\n        if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {\n          if (false) {\n            console.error(\n              \"[3] - Grammar is in an endless loop - Grammar pushed the same rule without advancing\"\n            );\n          }\n          stack = stack.pop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      } else {\n        const matchingRule = _rule;\n        if (false) {\n          console.log(\n            \"  matched \" + matchingRule.debugName + \" - \" + matchingRule.debugMatchRegExp\n          );\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          matchingRule.captures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        stack = stack.pop();\n        if (!hasAdvanced) {\n          if (false) {\n            console.error(\n              \"[4] - Grammar is in an endless loop - Grammar is not advancing, nor is it pushing/popping\"\n            );\n          }\n          stack = stack.safePop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      }\n    }\n    if (captureIndices[0].end > linePos) {\n      linePos = captureIndices[0].end;\n      isFirstLine = false;\n    }\n  }\n}\nfunction _checkWhileConditions(grammar, lineText, isFirstLine, linePos, stack, lineTokens) {\n  let anchorPosition = stack.beginRuleCapturedEOL ? 0 : -1;\n  const whileRules = [];\n  for (let node = stack; node; node = node.pop()) {\n    const nodeRule = node.getRule(grammar);\n    if (nodeRule instanceof BeginWhileRule) {\n      whileRules.push({\n        rule: nodeRule,\n        stack: node\n      });\n    }\n  }\n  for (let whileRule = whileRules.pop(); whileRule; whileRule = whileRules.pop()) {\n    const { ruleScanner, findOptions } = prepareRuleWhileSearch(whileRule.rule, grammar, whileRule.stack.endRule, isFirstLine, linePos === anchorPosition);\n    const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n    if (false) {\n      console.log(\"  scanning for while rule\");\n      console.log(ruleScanner.toString());\n    }\n    if (r) {\n      const matchedRuleId = r.ruleId;\n      if (matchedRuleId !== whileRuleId) {\n        stack = whileRule.stack.pop();\n        break;\n      }\n      if (r.captureIndices && r.captureIndices.length) {\n        lineTokens.produce(whileRule.stack, r.captureIndices[0].start);\n        handleCaptures(grammar, lineText, isFirstLine, whileRule.stack, lineTokens, whileRule.rule.whileCaptures, r.captureIndices);\n        lineTokens.produce(whileRule.stack, r.captureIndices[0].end);\n        anchorPosition = r.captureIndices[0].end;\n        if (r.captureIndices[0].end > linePos) {\n          linePos = r.captureIndices[0].end;\n          isFirstLine = false;\n        }\n      }\n    } else {\n      if (false) {\n        console.log(\"  popping \" + whileRule.rule.debugName + \" - \" + whileRule.rule.debugWhileRegExp);\n      }\n      stack = whileRule.stack.pop();\n      break;\n    }\n  }\n  return { stack, linePos, anchorPosition, isFirstLine };\n}\nfunction matchRuleOrInjections(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  const matchResult = matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition);\n  const injections = grammar.getInjections();\n  if (injections.length === 0) {\n    return matchResult;\n  }\n  const injectionResult = matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition);\n  if (!injectionResult) {\n    return matchResult;\n  }\n  if (!matchResult) {\n    return injectionResult;\n  }\n  const matchResultScore = matchResult.captureIndices[0].start;\n  const injectionResultScore = injectionResult.captureIndices[0].start;\n  if (injectionResultScore < matchResultScore || injectionResult.priorityMatch && injectionResultScore === matchResultScore) {\n    return injectionResult;\n  }\n  return matchResult;\n}\nfunction matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  const rule = stack.getRule(grammar);\n  const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, stack.endRule, isFirstLine, linePos === anchorPosition);\n  const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n  if (r) {\n    return {\n      captureIndices: r.captureIndices,\n      matchedRuleId: r.ruleId\n    };\n  }\n  return null;\n}\nfunction matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  let bestMatchRating = Number.MAX_VALUE;\n  let bestMatchCaptureIndices = null;\n  let bestMatchRuleId;\n  let bestMatchResultPriority = 0;\n  const scopes = stack.contentNameScopesList.getScopeNames();\n  for (let i = 0, len = injections.length; i < len; i++) {\n    const injection = injections[i];\n    if (!injection.matcher(scopes)) {\n      continue;\n    }\n    const rule = grammar.getRule(injection.ruleId);\n    const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, null, isFirstLine, linePos === anchorPosition);\n    const matchResult = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n    if (!matchResult) {\n      continue;\n    }\n    if (false) {\n      console.log(`  matched injection: ${injection.debugSelector}`);\n      console.log(ruleScanner.toString());\n    }\n    const matchRating = matchResult.captureIndices[0].start;\n    if (matchRating >= bestMatchRating) {\n      continue;\n    }\n    bestMatchRating = matchRating;\n    bestMatchCaptureIndices = matchResult.captureIndices;\n    bestMatchRuleId = matchResult.ruleId;\n    bestMatchResultPriority = injection.priority;\n    if (bestMatchRating === linePos) {\n      break;\n    }\n  }\n  if (bestMatchCaptureIndices) {\n    return {\n      priorityMatch: bestMatchResultPriority === -1,\n      captureIndices: bestMatchCaptureIndices,\n      matchedRuleId: bestMatchRuleId\n    };\n  }\n  return null;\n}\nfunction prepareRuleSearch(rule, grammar, endRegexSource, allowA, allowG) {\n  if (UseOnigurumaFindOptions) {\n    const ruleScanner2 = rule.compile(grammar, endRegexSource);\n    const findOptions = getFindOptions(allowA, allowG);\n    return { ruleScanner: ruleScanner2, findOptions };\n  }\n  const ruleScanner = rule.compileAG(grammar, endRegexSource, allowA, allowG);\n  return { ruleScanner, findOptions: 0 /* None */ };\n}\nfunction prepareRuleWhileSearch(rule, grammar, endRegexSource, allowA, allowG) {\n  if (UseOnigurumaFindOptions) {\n    const ruleScanner2 = rule.compileWhile(grammar, endRegexSource);\n    const findOptions = getFindOptions(allowA, allowG);\n    return { ruleScanner: ruleScanner2, findOptions };\n  }\n  const ruleScanner = rule.compileWhileAG(grammar, endRegexSource, allowA, allowG);\n  return { ruleScanner, findOptions: 0 /* None */ };\n}\nfunction getFindOptions(allowA, allowG) {\n  let options = 0 /* None */;\n  if (!allowA) {\n    options |= 1 /* NotBeginString */;\n  }\n  if (!allowG) {\n    options |= 4 /* NotBeginPosition */;\n  }\n  return options;\n}\nfunction handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, captures, captureIndices) {\n  if (captures.length === 0) {\n    return;\n  }\n  const lineTextContent = lineText.content;\n  const len = Math.min(captures.length, captureIndices.length);\n  const localStack = [];\n  const maxEnd = captureIndices[0].end;\n  for (let i = 0; i < len; i++) {\n    const captureRule = captures[i];\n    if (captureRule === null) {\n      continue;\n    }\n    const captureIndex = captureIndices[i];\n    if (captureIndex.length === 0) {\n      continue;\n    }\n    if (captureIndex.start > maxEnd) {\n      break;\n    }\n    while (localStack.length > 0 && localStack[localStack.length - 1].endPos <= captureIndex.start) {\n      lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);\n      localStack.pop();\n    }\n    if (localStack.length > 0) {\n      lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, captureIndex.start);\n    } else {\n      lineTokens.produce(stack, captureIndex.start);\n    }\n    if (captureRule.retokenizeCapturedWithRuleId) {\n      const scopeName = captureRule.getName(lineTextContent, captureIndices);\n      const nameScopesList = stack.contentNameScopesList.pushAttributed(scopeName, grammar);\n      const contentName = captureRule.getContentName(lineTextContent, captureIndices);\n      const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);\n      const stackClone = stack.push(captureRule.retokenizeCapturedWithRuleId, captureIndex.start, -1, false, null, nameScopesList, contentNameScopesList);\n      const onigSubStr = grammar.createOnigString(lineTextContent.substring(0, captureIndex.end));\n      _tokenizeString(\n        grammar,\n        onigSubStr,\n        isFirstLine && captureIndex.start === 0,\n        captureIndex.start,\n        stackClone,\n        lineTokens,\n        false,\n        /* no time limit */\n        0\n      );\n      disposeOnigString(onigSubStr);\n      continue;\n    }\n    const captureRuleScopeName = captureRule.getName(lineTextContent, captureIndices);\n    if (captureRuleScopeName !== null) {\n      const base = localStack.length > 0 ? localStack[localStack.length - 1].scopes : stack.contentNameScopesList;\n      const captureRuleScopesList = base.pushAttributed(captureRuleScopeName, grammar);\n      localStack.push(new LocalStackElement(captureRuleScopesList, captureIndex.end));\n    }\n  }\n  while (localStack.length > 0) {\n    lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);\n    localStack.pop();\n  }\n}\nvar LocalStackElement = class {\n  scopes;\n  endPos;\n  constructor(scopes, endPos) {\n    this.scopes = scopes;\n    this.endPos = endPos;\n  }\n};\n\n// src/grammar/grammar.ts\nfunction createGrammar(scopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, onigLib) {\n  return new Grammar(\n    scopeName,\n    grammar,\n    initialLanguage,\n    embeddedLanguages,\n    tokenTypes,\n    balancedBracketSelectors,\n    grammarRepository,\n    onigLib\n  );\n}\nfunction collectInjections(result, selector, rule, ruleFactoryHelper, grammar) {\n  const matchers = createMatchers(selector, nameMatcher);\n  const ruleId = RuleFactory.getCompiledRuleId(rule, ruleFactoryHelper, grammar.repository);\n  for (const matcher of matchers) {\n    result.push({\n      debugSelector: selector,\n      matcher: matcher.matcher,\n      ruleId,\n      grammar,\n      priority: matcher.priority\n    });\n  }\n}\nfunction nameMatcher(identifers, scopes) {\n  if (scopes.length < identifers.length) {\n    return false;\n  }\n  let lastIndex = 0;\n  return identifers.every((identifier) => {\n    for (let i = lastIndex; i < scopes.length; i++) {\n      if (scopesAreMatching(scopes[i], identifier)) {\n        lastIndex = i + 1;\n        return true;\n      }\n    }\n    return false;\n  });\n}\nfunction scopesAreMatching(thisScopeName, scopeName) {\n  if (!thisScopeName) {\n    return false;\n  }\n  if (thisScopeName === scopeName) {\n    return true;\n  }\n  const len = scopeName.length;\n  return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === \".\";\n}\nvar Grammar = class {\n  constructor(_rootScopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, _onigLib) {\n    this._rootScopeName = _rootScopeName;\n    this.balancedBracketSelectors = balancedBracketSelectors;\n    this._onigLib = _onigLib;\n    this._basicScopeAttributesProvider = new BasicScopeAttributesProvider(\n      initialLanguage,\n      embeddedLanguages\n    );\n    this._rootId = -1;\n    this._lastRuleId = 0;\n    this._ruleId2desc = [null];\n    this._includedGrammars = {};\n    this._grammarRepository = grammarRepository;\n    this._grammar = initGrammar(grammar, null);\n    this._injections = null;\n    this._tokenTypeMatchers = [];\n    if (tokenTypes) {\n      for (const selector of Object.keys(tokenTypes)) {\n        const matchers = createMatchers(selector, nameMatcher);\n        for (const matcher of matchers) {\n          this._tokenTypeMatchers.push({\n            matcher: matcher.matcher,\n            type: tokenTypes[selector]\n          });\n        }\n      }\n    }\n  }\n  _rootId;\n  _lastRuleId;\n  _ruleId2desc;\n  _includedGrammars;\n  _grammarRepository;\n  _grammar;\n  _injections;\n  _basicScopeAttributesProvider;\n  _tokenTypeMatchers;\n  get themeProvider() {\n    return this._grammarRepository;\n  }\n  dispose() {\n    for (const rule of this._ruleId2desc) {\n      if (rule) {\n        rule.dispose();\n      }\n    }\n  }\n  createOnigScanner(sources) {\n    return this._onigLib.createOnigScanner(sources);\n  }\n  createOnigString(sources) {\n    return this._onigLib.createOnigString(sources);\n  }\n  getMetadataForScope(scope) {\n    return this._basicScopeAttributesProvider.getBasicScopeAttributes(scope);\n  }\n  _collectInjections() {\n    const grammarRepository = {\n      lookup: (scopeName2) => {\n        if (scopeName2 === this._rootScopeName) {\n          return this._grammar;\n        }\n        return this.getExternalGrammar(scopeName2);\n      },\n      injections: (scopeName2) => {\n        return this._grammarRepository.injections(scopeName2);\n      }\n    };\n    const result = [];\n    const scopeName = this._rootScopeName;\n    const grammar = grammarRepository.lookup(scopeName);\n    if (grammar) {\n      const rawInjections = grammar.injections;\n      if (rawInjections) {\n        for (let expression in rawInjections) {\n          collectInjections(\n            result,\n            expression,\n            rawInjections[expression],\n            this,\n            grammar\n          );\n        }\n      }\n      const injectionScopeNames = this._grammarRepository.injections(scopeName);\n      if (injectionScopeNames) {\n        injectionScopeNames.forEach((injectionScopeName) => {\n          const injectionGrammar = this.getExternalGrammar(injectionScopeName);\n          if (injectionGrammar) {\n            const selector = injectionGrammar.injectionSelector;\n            if (selector) {\n              collectInjections(\n                result,\n                selector,\n                injectionGrammar,\n                this,\n                injectionGrammar\n              );\n            }\n          }\n        });\n      }\n    }\n    result.sort((i1, i2) => i1.priority - i2.priority);\n    return result;\n  }\n  getInjections() {\n    if (this._injections === null) {\n      this._injections = this._collectInjections();\n    }\n    return this._injections;\n  }\n  registerRule(factory) {\n    const id = ++this._lastRuleId;\n    const result = factory(ruleIdFromNumber(id));\n    this._ruleId2desc[id] = result;\n    return result;\n  }\n  getRule(ruleId) {\n    return this._ruleId2desc[ruleIdToNumber(ruleId)];\n  }\n  getExternalGrammar(scopeName, repository) {\n    if (this._includedGrammars[scopeName]) {\n      return this._includedGrammars[scopeName];\n    } else if (this._grammarRepository) {\n      const rawIncludedGrammar = this._grammarRepository.lookup(scopeName);\n      if (rawIncludedGrammar) {\n        this._includedGrammars[scopeName] = initGrammar(\n          rawIncludedGrammar,\n          repository && repository.$base\n        );\n        return this._includedGrammars[scopeName];\n      }\n    }\n    return void 0;\n  }\n  tokenizeLine(lineText, prevState, timeLimit = 0) {\n    const r = this._tokenize(lineText, prevState, false, timeLimit);\n    return {\n      tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),\n      ruleStack: r.ruleStack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n  tokenizeLine2(lineText, prevState, timeLimit = 0) {\n    const r = this._tokenize(lineText, prevState, true, timeLimit);\n    return {\n      tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),\n      ruleStack: r.ruleStack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n  _tokenize(lineText, prevState, emitBinaryTokens, timeLimit) {\n    if (this._rootId === -1) {\n      this._rootId = RuleFactory.getCompiledRuleId(\n        this._grammar.repository.$self,\n        this,\n        this._grammar.repository\n      );\n      this.getInjections();\n    }\n    let isFirstLine;\n    if (!prevState || prevState === StateStackImpl.NULL) {\n      isFirstLine = true;\n      const rawDefaultMetadata = this._basicScopeAttributesProvider.getDefaultAttributes();\n      const defaultStyle = this.themeProvider.getDefaults();\n      const defaultMetadata = EncodedTokenMetadata.set(\n        0,\n        rawDefaultMetadata.languageId,\n        rawDefaultMetadata.tokenType,\n        null,\n        defaultStyle.fontStyle,\n        defaultStyle.foregroundId,\n        defaultStyle.backgroundId\n      );\n      const rootScopeName = this.getRule(this._rootId).getName(\n        null,\n        null\n      );\n      let scopeList;\n      if (rootScopeName) {\n        scopeList = AttributedScopeStack.createRootAndLookUpScopeName(\n          rootScopeName,\n          defaultMetadata,\n          this\n        );\n      } else {\n        scopeList = AttributedScopeStack.createRoot(\n          \"unknown\",\n          defaultMetadata\n        );\n      }\n      prevState = new StateStackImpl(\n        null,\n        this._rootId,\n        -1,\n        -1,\n        false,\n        null,\n        scopeList,\n        scopeList\n      );\n    } else {\n      isFirstLine = false;\n      prevState.reset();\n    }\n    lineText = lineText + \"\\n\";\n    const onigLineText = this.createOnigString(lineText);\n    const lineLength = onigLineText.content.length;\n    const lineTokens = new LineTokens(\n      emitBinaryTokens,\n      lineText,\n      this._tokenTypeMatchers,\n      this.balancedBracketSelectors\n    );\n    const r = _tokenizeString(\n      this,\n      onigLineText,\n      isFirstLine,\n      0,\n      prevState,\n      lineTokens,\n      true,\n      timeLimit\n    );\n    disposeOnigString(onigLineText);\n    return {\n      lineLength,\n      lineTokens,\n      ruleStack: r.stack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n};\nfunction initGrammar(grammar, base) {\n  grammar = clone(grammar);\n  grammar.repository = grammar.repository || {};\n  grammar.repository.$self = {\n    $vscodeTextmateLocation: grammar.$vscodeTextmateLocation,\n    patterns: grammar.patterns,\n    name: grammar.scopeName\n  };\n  grammar.repository.$base = base || grammar.repository.$self;\n  return grammar;\n}\nvar AttributedScopeStack = class _AttributedScopeStack {\n  /**\n   * Invariant:\n   * ```\n   * if (parent && !scopePath.extends(parent.scopePath)) {\n   * \tthrow new Error();\n   * }\n   * ```\n   */\n  constructor(parent, scopePath, tokenAttributes) {\n    this.parent = parent;\n    this.scopePath = scopePath;\n    this.tokenAttributes = tokenAttributes;\n  }\n  static fromExtension(namesScopeList, contentNameScopesList) {\n    let current = namesScopeList;\n    let scopeNames = namesScopeList?.scopePath ?? null;\n    for (const frame of contentNameScopesList) {\n      scopeNames = ScopeStack.push(scopeNames, frame.scopeNames);\n      current = new _AttributedScopeStack(current, scopeNames, frame.encodedTokenAttributes);\n    }\n    return current;\n  }\n  static createRoot(scopeName, tokenAttributes) {\n    return new _AttributedScopeStack(null, new ScopeStack(null, scopeName), tokenAttributes);\n  }\n  static createRootAndLookUpScopeName(scopeName, tokenAttributes, grammar) {\n    const rawRootMetadata = grammar.getMetadataForScope(scopeName);\n    const scopePath = new ScopeStack(null, scopeName);\n    const rootStyle = grammar.themeProvider.themeMatch(scopePath);\n    const resolvedTokenAttributes = _AttributedScopeStack.mergeAttributes(\n      tokenAttributes,\n      rawRootMetadata,\n      rootStyle\n    );\n    return new _AttributedScopeStack(null, scopePath, resolvedTokenAttributes);\n  }\n  get scopeName() {\n    return this.scopePath.scopeName;\n  }\n  toString() {\n    return this.getScopeNames().join(\" \");\n  }\n  equals(other) {\n    return _AttributedScopeStack.equals(this, other);\n  }\n  static equals(a, b) {\n    do {\n      if (a === b) {\n        return true;\n      }\n      if (!a && !b) {\n        return true;\n      }\n      if (!a || !b) {\n        return false;\n      }\n      if (a.scopeName !== b.scopeName || a.tokenAttributes !== b.tokenAttributes) {\n        return false;\n      }\n      a = a.parent;\n      b = b.parent;\n    } while (true);\n  }\n  static mergeAttributes(existingTokenAttributes, basicScopeAttributes, styleAttributes) {\n    let fontStyle = -1 /* NotSet */;\n    let foreground = 0;\n    let background = 0;\n    if (styleAttributes !== null) {\n      fontStyle = styleAttributes.fontStyle;\n      foreground = styleAttributes.foregroundId;\n      background = styleAttributes.backgroundId;\n    }\n    return EncodedTokenMetadata.set(\n      existingTokenAttributes,\n      basicScopeAttributes.languageId,\n      basicScopeAttributes.tokenType,\n      null,\n      fontStyle,\n      foreground,\n      background\n    );\n  }\n  pushAttributed(scopePath, grammar) {\n    if (scopePath === null) {\n      return this;\n    }\n    if (scopePath.indexOf(\" \") === -1) {\n      return _AttributedScopeStack._pushAttributed(this, scopePath, grammar);\n    }\n    const scopes = scopePath.split(/ /g);\n    let result = this;\n    for (const scope of scopes) {\n      result = _AttributedScopeStack._pushAttributed(result, scope, grammar);\n    }\n    return result;\n  }\n  static _pushAttributed(target, scopeName, grammar) {\n    const rawMetadata = grammar.getMetadataForScope(scopeName);\n    const newPath = target.scopePath.push(scopeName);\n    const scopeThemeMatchResult = grammar.themeProvider.themeMatch(newPath);\n    const metadata = _AttributedScopeStack.mergeAttributes(\n      target.tokenAttributes,\n      rawMetadata,\n      scopeThemeMatchResult\n    );\n    return new _AttributedScopeStack(target, newPath, metadata);\n  }\n  getScopeNames() {\n    return this.scopePath.getSegments();\n  }\n  getExtensionIfDefined(base) {\n    const result = [];\n    let self = this;\n    while (self && self !== base) {\n      result.push({\n        encodedTokenAttributes: self.tokenAttributes,\n        scopeNames: self.scopePath.getExtensionIfDefined(self.parent?.scopePath ?? null)\n      });\n      self = self.parent;\n    }\n    return self === base ? result.reverse() : void 0;\n  }\n};\nvar StateStackImpl = class _StateStackImpl {\n  /**\n   * Invariant:\n   * ```\n   * if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {\n   * \tthrow new Error();\n   * }\n   * if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {\n   * \tthrow new Error();\n   * }\n   * ```\n   */\n  constructor(parent, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {\n    this.parent = parent;\n    this.ruleId = ruleId;\n    this.beginRuleCapturedEOL = beginRuleCapturedEOL;\n    this.endRule = endRule;\n    this.nameScopesList = nameScopesList;\n    this.contentNameScopesList = contentNameScopesList;\n    this.depth = this.parent ? this.parent.depth + 1 : 1;\n    this._enterPos = enterPos;\n    this._anchorPos = anchorPos;\n  }\n  _stackElementBrand = void 0;\n  // TODO remove me\n  static NULL = new _StateStackImpl(\n    null,\n    0,\n    0,\n    0,\n    false,\n    null,\n    null,\n    null\n  );\n  /**\n   * The position on the current line where this state was pushed.\n   * This is relevant only while tokenizing a line, to detect endless loops.\n   * Its value is meaningless across lines.\n   */\n  _enterPos;\n  /**\n   * The captured anchor position when this stack element was pushed.\n   * This is relevant only while tokenizing a line, to restore the anchor position when popping.\n   * Its value is meaningless across lines.\n   */\n  _anchorPos;\n  /**\n   * The depth of the stack.\n   */\n  depth;\n  equals(other) {\n    if (other === null) {\n      return false;\n    }\n    return _StateStackImpl._equals(this, other);\n  }\n  static _equals(a, b) {\n    if (a === b) {\n      return true;\n    }\n    if (!this._structuralEquals(a, b)) {\n      return false;\n    }\n    return AttributedScopeStack.equals(a.contentNameScopesList, b.contentNameScopesList);\n  }\n  /**\n   * A structural equals check. Does not take into account `scopes`.\n   */\n  static _structuralEquals(a, b) {\n    do {\n      if (a === b) {\n        return true;\n      }\n      if (!a && !b) {\n        return true;\n      }\n      if (!a || !b) {\n        return false;\n      }\n      if (a.depth !== b.depth || a.ruleId !== b.ruleId || a.endRule !== b.endRule) {\n        return false;\n      }\n      a = a.parent;\n      b = b.parent;\n    } while (true);\n  }\n  clone() {\n    return this;\n  }\n  static _reset(el) {\n    while (el) {\n      el._enterPos = -1;\n      el._anchorPos = -1;\n      el = el.parent;\n    }\n  }\n  reset() {\n    _StateStackImpl._reset(this);\n  }\n  pop() {\n    return this.parent;\n  }\n  safePop() {\n    if (this.parent) {\n      return this.parent;\n    }\n    return this;\n  }\n  push(ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {\n    return new _StateStackImpl(\n      this,\n      ruleId,\n      enterPos,\n      anchorPos,\n      beginRuleCapturedEOL,\n      endRule,\n      nameScopesList,\n      contentNameScopesList\n    );\n  }\n  getEnterPos() {\n    return this._enterPos;\n  }\n  getAnchorPos() {\n    return this._anchorPos;\n  }\n  getRule(grammar) {\n    return grammar.getRule(this.ruleId);\n  }\n  toString() {\n    const r = [];\n    this._writeString(r, 0);\n    return \"[\" + r.join(\",\") + \"]\";\n  }\n  _writeString(res, outIndex) {\n    if (this.parent) {\n      outIndex = this.parent._writeString(res, outIndex);\n    }\n    res[outIndex++] = `(${this.ruleId}, ${this.nameScopesList?.toString()}, ${this.contentNameScopesList?.toString()})`;\n    return outIndex;\n  }\n  withContentNameScopesList(contentNameScopeStack) {\n    if (this.contentNameScopesList === contentNameScopeStack) {\n      return this;\n    }\n    return this.parent.push(\n      this.ruleId,\n      this._enterPos,\n      this._anchorPos,\n      this.beginRuleCapturedEOL,\n      this.endRule,\n      this.nameScopesList,\n      contentNameScopeStack\n    );\n  }\n  withEndRule(endRule) {\n    if (this.endRule === endRule) {\n      return this;\n    }\n    return new _StateStackImpl(\n      this.parent,\n      this.ruleId,\n      this._enterPos,\n      this._anchorPos,\n      this.beginRuleCapturedEOL,\n      endRule,\n      this.nameScopesList,\n      this.contentNameScopesList\n    );\n  }\n  // Used to warn of endless loops\n  hasSameRuleAs(other) {\n    let el = this;\n    while (el && el._enterPos === other._enterPos) {\n      if (el.ruleId === other.ruleId) {\n        return true;\n      }\n      el = el.parent;\n    }\n    return false;\n  }\n  toStateStackFrame() {\n    return {\n      ruleId: ruleIdToNumber(this.ruleId),\n      beginRuleCapturedEOL: this.beginRuleCapturedEOL,\n      endRule: this.endRule,\n      nameScopesList: this.nameScopesList?.getExtensionIfDefined(this.parent?.nameScopesList ?? null) ?? [],\n      contentNameScopesList: this.contentNameScopesList?.getExtensionIfDefined(this.nameScopesList) ?? []\n    };\n  }\n  static pushFrame(self, frame) {\n    const namesScopeList = AttributedScopeStack.fromExtension(self?.nameScopesList ?? null, frame.nameScopesList);\n    return new _StateStackImpl(\n      self,\n      ruleIdFromNumber(frame.ruleId),\n      frame.enterPos ?? -1,\n      frame.anchorPos ?? -1,\n      frame.beginRuleCapturedEOL,\n      frame.endRule,\n      namesScopeList,\n      AttributedScopeStack.fromExtension(namesScopeList, frame.contentNameScopesList)\n    );\n  }\n};\nvar BalancedBracketSelectors = class {\n  balancedBracketScopes;\n  unbalancedBracketScopes;\n  allowAny = false;\n  constructor(balancedBracketScopes, unbalancedBracketScopes) {\n    this.balancedBracketScopes = balancedBracketScopes.flatMap(\n      (selector) => {\n        if (selector === \"*\") {\n          this.allowAny = true;\n          return [];\n        }\n        return createMatchers(selector, nameMatcher).map((m) => m.matcher);\n      }\n    );\n    this.unbalancedBracketScopes = unbalancedBracketScopes.flatMap(\n      (selector) => createMatchers(selector, nameMatcher).map((m) => m.matcher)\n    );\n  }\n  get matchesAlways() {\n    return this.allowAny && this.unbalancedBracketScopes.length === 0;\n  }\n  get matchesNever() {\n    return this.balancedBracketScopes.length === 0 && !this.allowAny;\n  }\n  match(scopes) {\n    for (const excluder of this.unbalancedBracketScopes) {\n      if (excluder(scopes)) {\n        return false;\n      }\n    }\n    for (const includer of this.balancedBracketScopes) {\n      if (includer(scopes)) {\n        return true;\n      }\n    }\n    return this.allowAny;\n  }\n};\nvar LineTokens = class {\n  constructor(emitBinaryTokens, lineText, tokenTypeOverrides, balancedBracketSelectors) {\n    this.balancedBracketSelectors = balancedBracketSelectors;\n    this._emitBinaryTokens = emitBinaryTokens;\n    this._tokenTypeOverrides = tokenTypeOverrides;\n    if (false) {\n      this._lineText = lineText;\n    } else {\n      this._lineText = null;\n    }\n    this._tokens = [];\n    this._binaryTokens = [];\n    this._lastTokenEndIndex = 0;\n  }\n  _emitBinaryTokens;\n  /**\n   * defined only if `false`.\n   */\n  _lineText;\n  /**\n   * used only if `_emitBinaryTokens` is false.\n   */\n  _tokens;\n  /**\n   * used only if `_emitBinaryTokens` is true.\n   */\n  _binaryTokens;\n  _lastTokenEndIndex;\n  _tokenTypeOverrides;\n  produce(stack, endIndex) {\n    this.produceFromScopes(stack.contentNameScopesList, endIndex);\n  }\n  produceFromScopes(scopesList, endIndex) {\n    if (this._lastTokenEndIndex >= endIndex) {\n      return;\n    }\n    if (this._emitBinaryTokens) {\n      let metadata = scopesList?.tokenAttributes ?? 0;\n      let containsBalancedBrackets = false;\n      if (this.balancedBracketSelectors?.matchesAlways) {\n        containsBalancedBrackets = true;\n      }\n      if (this._tokenTypeOverrides.length > 0 || this.balancedBracketSelectors && !this.balancedBracketSelectors.matchesAlways && !this.balancedBracketSelectors.matchesNever) {\n        const scopes2 = scopesList?.getScopeNames() ?? [];\n        for (const tokenType of this._tokenTypeOverrides) {\n          if (tokenType.matcher(scopes2)) {\n            metadata = EncodedTokenMetadata.set(\n              metadata,\n              0,\n              toOptionalTokenType(tokenType.type),\n              null,\n              -1 /* NotSet */,\n              0,\n              0\n            );\n          }\n        }\n        if (this.balancedBracketSelectors) {\n          containsBalancedBrackets = this.balancedBracketSelectors.match(scopes2);\n        }\n      }\n      if (containsBalancedBrackets) {\n        metadata = EncodedTokenMetadata.set(\n          metadata,\n          0,\n          8 /* NotSet */,\n          containsBalancedBrackets,\n          -1 /* NotSet */,\n          0,\n          0\n        );\n      }\n      if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 1] === metadata) {\n        this._lastTokenEndIndex = endIndex;\n        return;\n      }\n      this._binaryTokens.push(this._lastTokenEndIndex);\n      this._binaryTokens.push(metadata);\n      this._lastTokenEndIndex = endIndex;\n      return;\n    }\n    const scopes = scopesList?.getScopeNames() ?? [];\n    this._tokens.push({\n      startIndex: this._lastTokenEndIndex,\n      endIndex,\n      // value: lineText.substring(lastTokenEndIndex, endIndex),\n      scopes\n    });\n    this._lastTokenEndIndex = endIndex;\n  }\n  getResult(stack, lineLength) {\n    if (this._tokens.length > 0 && this._tokens[this._tokens.length - 1].startIndex === lineLength - 1) {\n      this._tokens.pop();\n    }\n    if (this._tokens.length === 0) {\n      this._lastTokenEndIndex = -1;\n      this.produce(stack, lineLength);\n      this._tokens[this._tokens.length - 1].startIndex = 0;\n    }\n    return this._tokens;\n  }\n  getBinaryResult(stack, lineLength) {\n    if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 2] === lineLength - 1) {\n      this._binaryTokens.pop();\n      this._binaryTokens.pop();\n    }\n    if (this._binaryTokens.length === 0) {\n      this._lastTokenEndIndex = -1;\n      this.produce(stack, lineLength);\n      this._binaryTokens[this._binaryTokens.length - 2] = 0;\n    }\n    const result = new Uint32Array(this._binaryTokens.length);\n    for (let i = 0, len = this._binaryTokens.length; i < len; i++) {\n      result[i] = this._binaryTokens[i];\n    }\n    return result;\n  }\n};\n\n// src/registry.ts\nvar SyncRegistry = class {\n  constructor(theme, _onigLib) {\n    this._onigLib = _onigLib;\n    this._theme = theme;\n  }\n  _grammars = /* @__PURE__ */ new Map();\n  _rawGrammars = /* @__PURE__ */ new Map();\n  _injectionGrammars = /* @__PURE__ */ new Map();\n  _theme;\n  dispose() {\n    for (const grammar of this._grammars.values()) {\n      grammar.dispose();\n    }\n  }\n  setTheme(theme) {\n    this._theme = theme;\n  }\n  getColorMap() {\n    return this._theme.getColorMap();\n  }\n  /**\n   * Add `grammar` to registry and return a list of referenced scope names\n   */\n  addGrammar(grammar, injectionScopeNames) {\n    this._rawGrammars.set(grammar.scopeName, grammar);\n    if (injectionScopeNames) {\n      this._injectionGrammars.set(grammar.scopeName, injectionScopeNames);\n    }\n  }\n  /**\n   * Lookup a raw grammar.\n   */\n  lookup(scopeName) {\n    return this._rawGrammars.get(scopeName);\n  }\n  /**\n   * Returns the injections for the given grammar\n   */\n  injections(targetScope) {\n    return this._injectionGrammars.get(targetScope);\n  }\n  /**\n   * Get the default theme settings\n   */\n  getDefaults() {\n    return this._theme.getDefaults();\n  }\n  /**\n   * Match a scope in the theme.\n   */\n  themeMatch(scopePath) {\n    return this._theme.match(scopePath);\n  }\n  /**\n   * Lookup a grammar.\n   */\n  grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {\n    if (!this._grammars.has(scopeName)) {\n      let rawGrammar = this._rawGrammars.get(scopeName);\n      if (!rawGrammar) {\n        return null;\n      }\n      this._grammars.set(scopeName, createGrammar(\n        scopeName,\n        rawGrammar,\n        initialLanguage,\n        embeddedLanguages,\n        tokenTypes,\n        balancedBracketSelectors,\n        this,\n        this._onigLib\n      ));\n    }\n    return this._grammars.get(scopeName);\n  }\n};\n\n// src/index.ts\nvar Registry = class {\n  _options;\n  _syncRegistry;\n  _ensureGrammarCache;\n  constructor(options) {\n    this._options = options;\n    this._syncRegistry = new SyncRegistry(\n      Theme.createFromRawTheme(options.theme, options.colorMap),\n      options.onigLib\n    );\n    this._ensureGrammarCache = /* @__PURE__ */ new Map();\n  }\n  dispose() {\n    this._syncRegistry.dispose();\n  }\n  /**\n   * Change the theme. Once called, no previous `ruleStack` should be used anymore.\n   */\n  setTheme(theme, colorMap) {\n    this._syncRegistry.setTheme(Theme.createFromRawTheme(theme, colorMap));\n  }\n  /**\n   * Returns a lookup array for color ids.\n   */\n  getColorMap() {\n    return this._syncRegistry.getColorMap();\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   * Please do not use language id 0.\n   */\n  loadGrammarWithEmbeddedLanguages(initialScopeName, initialLanguage, embeddedLanguages) {\n    return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   * Please do not use language id 0.\n   */\n  loadGrammarWithConfiguration(initialScopeName, initialLanguage, configuration) {\n    return this._loadGrammar(\n      initialScopeName,\n      initialLanguage,\n      configuration.embeddedLanguages,\n      configuration.tokenTypes,\n      new BalancedBracketSelectors(\n        configuration.balancedBracketSelectors || [],\n        configuration.unbalancedBracketSelectors || []\n      )\n    );\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   */\n  loadGrammar(initialScopeName) {\n    return this._loadGrammar(initialScopeName, 0, null, null, null);\n  }\n  _loadGrammar(initialScopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {\n    const dependencyProcessor = new ScopeDependencyProcessor(this._syncRegistry, initialScopeName);\n    while (dependencyProcessor.Q.length > 0) {\n      dependencyProcessor.Q.map((request) => this._loadSingleGrammar(request.scopeName));\n      dependencyProcessor.processQueue();\n    }\n    return this._grammarForScopeName(\n      initialScopeName,\n      initialLanguage,\n      embeddedLanguages,\n      tokenTypes,\n      balancedBracketSelectors\n    );\n  }\n  _loadSingleGrammar(scopeName) {\n    if (!this._ensureGrammarCache.has(scopeName)) {\n      this._doLoadSingleGrammar(scopeName);\n      this._ensureGrammarCache.set(scopeName, true);\n    }\n  }\n  _doLoadSingleGrammar(scopeName) {\n    const grammar = this._options.loadGrammar(scopeName);\n    if (grammar) {\n      const injections = typeof this._options.getInjections === \"function\" ? this._options.getInjections(scopeName) : void 0;\n      this._syncRegistry.addGrammar(grammar, injections);\n    }\n  }\n  /**\n   * Adds a rawGrammar.\n   */\n  addGrammar(rawGrammar, injections = [], initialLanguage = 0, embeddedLanguages = null) {\n    this._syncRegistry.addGrammar(rawGrammar, injections);\n    return this._grammarForScopeName(rawGrammar.scopeName, initialLanguage, embeddedLanguages);\n  }\n  /**\n   * Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.\n   */\n  _grammarForScopeName(scopeName, initialLanguage = 0, embeddedLanguages = null, tokenTypes = null, balancedBracketSelectors = null) {\n    return this._syncRegistry.grammarForScopeName(\n      scopeName,\n      initialLanguage,\n      embeddedLanguages,\n      tokenTypes,\n      balancedBracketSelectors\n    );\n  }\n};\nvar INITIAL = StateStackImpl.NULL;\nexport {\n  EncodedTokenMetadata,\n  FindOption,\n  FontStyle,\n  INITIAL,\n  Registry,\n  Theme,\n  disposeOnigString\n};\n","import { ShikiError as ShikiError$1 } from '@shikijs/types';\nexport * from '@shikijs/types';\nimport { FontStyle, INITIAL, EncodedTokenMetadata, Registry as Registry$1, Theme } from '@shikijs/vscode-textmate';\nimport { toHtml } from 'hast-util-to-html';\n\nfunction resolveColorReplacements(theme, options) {\n  const replacements = typeof theme === \"string\" ? {} : { ...theme.colorReplacements };\n  const themeName = typeof theme === \"string\" ? theme : theme.name;\n  for (const [key, value] of Object.entries(options?.colorReplacements || {})) {\n    if (typeof value === \"string\")\n      replacements[key] = value;\n    else if (key === themeName)\n      Object.assign(replacements, value);\n  }\n  return replacements;\n}\nfunction applyColorReplacements(color, replacements) {\n  if (!color)\n    return color;\n  return replacements?.[color?.toLowerCase()] || color;\n}\n\nfunction toArray(x) {\n  return Array.isArray(x) ? x : [x];\n}\nasync function normalizeGetter(p) {\n  return Promise.resolve(typeof p === \"function\" ? p() : p).then((r) => r.default || r);\n}\nfunction isPlainLang(lang) {\n  return !lang || [\"plaintext\", \"txt\", \"text\", \"plain\"].includes(lang);\n}\nfunction isSpecialLang(lang) {\n  return lang === \"ansi\" || isPlainLang(lang);\n}\nfunction isNoneTheme(theme) {\n  return theme === \"none\";\n}\nfunction isSpecialTheme(theme) {\n  return isNoneTheme(theme);\n}\n\nfunction addClassToHast(node, className) {\n  if (!className)\n    return node;\n  node.properties ||= {};\n  node.properties.class ||= [];\n  if (typeof node.properties.class === \"string\")\n    node.properties.class = node.properties.class.split(/\\s+/g);\n  if (!Array.isArray(node.properties.class))\n    node.properties.class = [];\n  const targets = Array.isArray(className) ? className : className.split(/\\s+/g);\n  for (const c of targets) {\n    if (c && !node.properties.class.includes(c))\n      node.properties.class.push(c);\n  }\n  return node;\n}\n\nfunction splitLines(code, preserveEnding = false) {\n  const parts = code.split(/(\\r?\\n)/g);\n  let index = 0;\n  const lines = [];\n  for (let i = 0; i < parts.length; i += 2) {\n    const line = preserveEnding ? parts[i] + (parts[i + 1] || \"\") : parts[i];\n    lines.push([line, index]);\n    index += parts[i].length;\n    index += parts[i + 1]?.length || 0;\n  }\n  return lines;\n}\nfunction createPositionConverter(code) {\n  const lines = splitLines(code, true).map(([line]) => line);\n  function indexToPos(index) {\n    if (index === code.length) {\n      return {\n        line: lines.length - 1,\n        character: lines[lines.length - 1].length\n      };\n    }\n    let character = index;\n    let line = 0;\n    for (const lineText of lines) {\n      if (character < lineText.length)\n        break;\n      character -= lineText.length;\n      line++;\n    }\n    return { line, character };\n  }\n  function posToIndex(line, character) {\n    let index = 0;\n    for (let i = 0; i < line; i++)\n      index += lines[i].length;\n    index += character;\n    return index;\n  }\n  return {\n    lines,\n    indexToPos,\n    posToIndex\n  };\n}\nfunction guessEmbeddedLanguages(code, _lang, highlighter) {\n  const langs = /* @__PURE__ */ new Set();\n  for (const match of code.matchAll(/lang=[\"']([\\w-]+)[\"']/g)) {\n    langs.add(match[1]);\n  }\n  for (const match of code.matchAll(/(?:```|~~~)([\\w-]+)/g)) {\n    langs.add(match[1]);\n  }\n  for (const match of code.matchAll(/\\\\begin\\{([\\w-]+)\\}/g)) {\n    langs.add(match[1]);\n  }\n  if (!highlighter)\n    return Array.from(langs);\n  const bundle = highlighter.getBundledLanguages();\n  return Array.from(langs).filter((l) => l && bundle[l]);\n}\n\nconst DEFAULT_COLOR_LIGHT_DARK = \"light-dark()\";\nconst COLOR_KEYS = [\"color\", \"background-color\"];\n\nfunction splitToken(token, offsets) {\n  let lastOffset = 0;\n  const tokens = [];\n  for (const offset of offsets) {\n    if (offset > lastOffset) {\n      tokens.push({\n        ...token,\n        content: token.content.slice(lastOffset, offset),\n        offset: token.offset + lastOffset\n      });\n    }\n    lastOffset = offset;\n  }\n  if (lastOffset < token.content.length) {\n    tokens.push({\n      ...token,\n      content: token.content.slice(lastOffset),\n      offset: token.offset + lastOffset\n    });\n  }\n  return tokens;\n}\nfunction splitTokens(tokens, breakpoints) {\n  const sorted = Array.from(breakpoints instanceof Set ? breakpoints : new Set(breakpoints)).sort((a, b) => a - b);\n  if (!sorted.length)\n    return tokens;\n  return tokens.map((line) => {\n    return line.flatMap((token) => {\n      const breakpointsInToken = sorted.filter((i) => token.offset < i && i < token.offset + token.content.length).map((i) => i - token.offset).sort((a, b) => a - b);\n      if (!breakpointsInToken.length)\n        return token;\n      return splitToken(token, breakpointsInToken);\n    });\n  });\n}\nfunction flatTokenVariants(merged, variantsOrder, cssVariablePrefix, defaultColor, colorsRendering = \"css-vars\") {\n  const token = {\n    content: merged.content,\n    explanation: merged.explanation,\n    offset: merged.offset\n  };\n  const styles = variantsOrder.map((t) => getTokenStyleObject(merged.variants[t]));\n  const styleKeys = new Set(styles.flatMap((t) => Object.keys(t)));\n  const mergedStyles = {};\n  const varKey = (idx, key) => {\n    const keyName = key === \"color\" ? \"\" : key === \"background-color\" ? \"-bg\" : `-${key}`;\n    return cssVariablePrefix + variantsOrder[idx] + (key === \"color\" ? \"\" : keyName);\n  };\n  styles.forEach((cur, idx) => {\n    for (const key of styleKeys) {\n      const value = cur[key] || \"inherit\";\n      if (idx === 0 && defaultColor && COLOR_KEYS.includes(key)) {\n        if (defaultColor === DEFAULT_COLOR_LIGHT_DARK && styles.length > 1) {\n          const lightIndex = variantsOrder.findIndex((t) => t === \"light\");\n          const darkIndex = variantsOrder.findIndex((t) => t === \"dark\");\n          if (lightIndex === -1 || darkIndex === -1)\n            throw new ShikiError$1('When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes');\n          const lightValue = styles[lightIndex][key] || \"inherit\";\n          const darkValue = styles[darkIndex][key] || \"inherit\";\n          mergedStyles[key] = `light-dark(${lightValue}, ${darkValue})`;\n          if (colorsRendering === \"css-vars\")\n            mergedStyles[varKey(idx, key)] = value;\n        } else {\n          mergedStyles[key] = value;\n        }\n      } else {\n        if (colorsRendering === \"css-vars\")\n          mergedStyles[varKey(idx, key)] = value;\n      }\n    }\n  });\n  token.htmlStyle = mergedStyles;\n  return token;\n}\nfunction getTokenStyleObject(token) {\n  const styles = {};\n  if (token.color)\n    styles.color = token.color;\n  if (token.bgColor)\n    styles[\"background-color\"] = token.bgColor;\n  if (token.fontStyle) {\n    if (token.fontStyle & FontStyle.Italic)\n      styles[\"font-style\"] = \"italic\";\n    if (token.fontStyle & FontStyle.Bold)\n      styles[\"font-weight\"] = \"bold\";\n    const decorations = [];\n    if (token.fontStyle & FontStyle.Underline)\n      decorations.push(\"underline\");\n    if (token.fontStyle & FontStyle.Strikethrough)\n      decorations.push(\"line-through\");\n    if (decorations.length)\n      styles[\"text-decoration\"] = decorations.join(\" \");\n  }\n  return styles;\n}\nfunction stringifyTokenStyle(token) {\n  if (typeof token === \"string\")\n    return token;\n  return Object.entries(token).map(([key, value]) => `${key}:${value}`).join(\";\");\n}\n\nconst _grammarStateMap = /* @__PURE__ */ new WeakMap();\nfunction setLastGrammarStateToMap(keys, state) {\n  _grammarStateMap.set(keys, state);\n}\nfunction getLastGrammarStateFromMap(keys) {\n  return _grammarStateMap.get(keys);\n}\nclass GrammarState {\n  /**\n   * Theme to Stack mapping\n   */\n  _stacks = {};\n  lang;\n  get themes() {\n    return Object.keys(this._stacks);\n  }\n  get theme() {\n    return this.themes[0];\n  }\n  get _stack() {\n    return this._stacks[this.theme];\n  }\n  /**\n   * Static method to create a initial grammar state.\n   */\n  static initial(lang, themes) {\n    return new GrammarState(\n      Object.fromEntries(toArray(themes).map((theme) => [theme, INITIAL])),\n      lang\n    );\n  }\n  constructor(...args) {\n    if (args.length === 2) {\n      const [stacksMap, lang] = args;\n      this.lang = lang;\n      this._stacks = stacksMap;\n    } else {\n      const [stack, lang, theme] = args;\n      this.lang = lang;\n      this._stacks = { [theme]: stack };\n    }\n  }\n  /**\n   * Get the internal stack object.\n   * @internal\n   */\n  getInternalStack(theme = this.theme) {\n    return this._stacks[theme];\n  }\n  getScopes(theme = this.theme) {\n    return getScopes(this._stacks[theme]);\n  }\n  toJSON() {\n    return {\n      lang: this.lang,\n      theme: this.theme,\n      themes: this.themes,\n      scopes: this.getScopes()\n    };\n  }\n}\nfunction getScopes(stack) {\n  const scopes = [];\n  const visited = /* @__PURE__ */ new Set();\n  function pushScope(stack2) {\n    if (visited.has(stack2))\n      return;\n    visited.add(stack2);\n    const name = stack2?.nameScopesList?.scopeName;\n    if (name)\n      scopes.push(name);\n    if (stack2.parent)\n      pushScope(stack2.parent);\n  }\n  pushScope(stack);\n  return scopes;\n}\nfunction getGrammarStack(state, theme) {\n  if (!(state instanceof GrammarState))\n    throw new ShikiError$1(\"Invalid grammar state\");\n  return state.getInternalStack(theme);\n}\n\nfunction transformerDecorations() {\n  const map = /* @__PURE__ */ new WeakMap();\n  function getContext(shiki) {\n    if (!map.has(shiki.meta)) {\n      let normalizePosition = function(p) {\n        if (typeof p === \"number\") {\n          if (p < 0 || p > shiki.source.length)\n            throw new ShikiError$1(`Invalid decoration offset: ${p}. Code length: ${shiki.source.length}`);\n          return {\n            ...converter.indexToPos(p),\n            offset: p\n          };\n        } else {\n          const line = converter.lines[p.line];\n          if (line === void 0)\n            throw new ShikiError$1(`Invalid decoration position ${JSON.stringify(p)}. Lines length: ${converter.lines.length}`);\n          let character = p.character;\n          if (character < 0)\n            character = line.length + character;\n          if (character < 0 || character > line.length)\n            throw new ShikiError$1(`Invalid decoration position ${JSON.stringify(p)}. Line ${p.line} length: ${line.length}`);\n          return {\n            ...p,\n            character,\n            offset: converter.posToIndex(p.line, character)\n          };\n        }\n      };\n      const converter = createPositionConverter(shiki.source);\n      const decorations = (shiki.options.decorations || []).map((d) => ({\n        ...d,\n        start: normalizePosition(d.start),\n        end: normalizePosition(d.end)\n      }));\n      verifyIntersections(decorations);\n      map.set(shiki.meta, {\n        decorations,\n        converter,\n        source: shiki.source\n      });\n    }\n    return map.get(shiki.meta);\n  }\n  return {\n    name: \"shiki:decorations\",\n    tokens(tokens) {\n      if (!this.options.decorations?.length)\n        return;\n      const ctx = getContext(this);\n      const breakpoints = ctx.decorations.flatMap((d) => [d.start.offset, d.end.offset]);\n      const splitted = splitTokens(tokens, breakpoints);\n      return splitted;\n    },\n    code(codeEl) {\n      if (!this.options.decorations?.length)\n        return;\n      const ctx = getContext(this);\n      const lines = Array.from(codeEl.children).filter((i) => i.type === \"element\" && i.tagName === \"span\");\n      if (lines.length !== ctx.converter.lines.length)\n        throw new ShikiError$1(`Number of lines in code element (${lines.length}) does not match the number of lines in the source (${ctx.converter.lines.length}). Failed to apply decorations.`);\n      function applyLineSection(line, start, end, decoration) {\n        const lineEl = lines[line];\n        let text = \"\";\n        let startIndex = -1;\n        let endIndex = -1;\n        if (start === 0)\n          startIndex = 0;\n        if (end === 0)\n          endIndex = 0;\n        if (end === Number.POSITIVE_INFINITY)\n          endIndex = lineEl.children.length;\n        if (startIndex === -1 || endIndex === -1) {\n          for (let i = 0; i < lineEl.children.length; i++) {\n            text += stringify(lineEl.children[i]);\n            if (startIndex === -1 && text.length === start)\n              startIndex = i + 1;\n            if (endIndex === -1 && text.length === end)\n              endIndex = i + 1;\n          }\n        }\n        if (startIndex === -1)\n          throw new ShikiError$1(`Failed to find start index for decoration ${JSON.stringify(decoration.start)}`);\n        if (endIndex === -1)\n          throw new ShikiError$1(`Failed to find end index for decoration ${JSON.stringify(decoration.end)}`);\n        const children = lineEl.children.slice(startIndex, endIndex);\n        if (!decoration.alwaysWrap && children.length === lineEl.children.length) {\n          applyDecoration(lineEl, decoration, \"line\");\n        } else if (!decoration.alwaysWrap && children.length === 1 && children[0].type === \"element\") {\n          applyDecoration(children[0], decoration, \"token\");\n        } else {\n          const wrapper = {\n            type: \"element\",\n            tagName: \"span\",\n            properties: {},\n            children\n          };\n          applyDecoration(wrapper, decoration, \"wrapper\");\n          lineEl.children.splice(startIndex, children.length, wrapper);\n        }\n      }\n      function applyLine(line, decoration) {\n        lines[line] = applyDecoration(lines[line], decoration, \"line\");\n      }\n      function applyDecoration(el, decoration, type) {\n        const properties = decoration.properties || {};\n        const transform = decoration.transform || ((i) => i);\n        el.tagName = decoration.tagName || \"span\";\n        el.properties = {\n          ...el.properties,\n          ...properties,\n          class: el.properties.class\n        };\n        if (decoration.properties?.class)\n          addClassToHast(el, decoration.properties.class);\n        el = transform(el, type) || el;\n        return el;\n      }\n      const lineApplies = [];\n      const sorted = ctx.decorations.sort((a, b) => b.start.offset - a.start.offset || a.end.offset - b.end.offset);\n      for (const decoration of sorted) {\n        const { start, end } = decoration;\n        if (start.line === end.line) {\n          applyLineSection(start.line, start.character, end.character, decoration);\n        } else if (start.line < end.line) {\n          applyLineSection(start.line, start.character, Number.POSITIVE_INFINITY, decoration);\n          for (let i = start.line + 1; i < end.line; i++)\n            lineApplies.unshift(() => applyLine(i, decoration));\n          applyLineSection(end.line, 0, end.character, decoration);\n        }\n      }\n      lineApplies.forEach((i) => i());\n    }\n  };\n}\nfunction verifyIntersections(items) {\n  for (let i = 0; i < items.length; i++) {\n    const foo = items[i];\n    if (foo.start.offset > foo.end.offset)\n      throw new ShikiError$1(`Invalid decoration range: ${JSON.stringify(foo.start)} - ${JSON.stringify(foo.end)}`);\n    for (let j = i + 1; j < items.length; j++) {\n      const bar = items[j];\n      const isFooHasBarStart = foo.start.offset <= bar.start.offset && bar.start.offset < foo.end.offset;\n      const isFooHasBarEnd = foo.start.offset < bar.end.offset && bar.end.offset <= foo.end.offset;\n      const isBarHasFooStart = bar.start.offset <= foo.start.offset && foo.start.offset < bar.end.offset;\n      const isBarHasFooEnd = bar.start.offset < foo.end.offset && foo.end.offset <= bar.end.offset;\n      if (isFooHasBarStart || isFooHasBarEnd || isBarHasFooStart || isBarHasFooEnd) {\n        if (isFooHasBarStart && isFooHasBarEnd)\n          continue;\n        if (isBarHasFooStart && isBarHasFooEnd)\n          continue;\n        if (isBarHasFooStart && foo.start.offset === foo.end.offset)\n          continue;\n        if (isFooHasBarEnd && bar.start.offset === bar.end.offset)\n          continue;\n        throw new ShikiError$1(`Decorations ${JSON.stringify(foo.start)} and ${JSON.stringify(bar.start)} intersect.`);\n      }\n    }\n  }\n}\nfunction stringify(el) {\n  if (el.type === \"text\")\n    return el.value;\n  if (el.type === \"element\")\n    return el.children.map(stringify).join(\"\");\n  return \"\";\n}\n\nconst builtInTransformers = [\n  /* @__PURE__ */ transformerDecorations()\n];\nfunction getTransformers(options) {\n  const transformers = sortTransformersByEnforcement(options.transformers || []);\n  return [\n    ...transformers.pre,\n    ...transformers.normal,\n    ...transformers.post,\n    ...builtInTransformers\n  ];\n}\nfunction sortTransformersByEnforcement(transformers) {\n  const pre = [];\n  const post = [];\n  const normal = [];\n  for (const transformer of transformers) {\n    switch (transformer.enforce) {\n      case \"pre\":\n        pre.push(transformer);\n        break;\n      case \"post\":\n        post.push(transformer);\n        break;\n      default:\n        normal.push(transformer);\n    }\n  }\n  return { pre, post, normal };\n}\n\n// src/colors.ts\nvar namedColors = [\n  \"black\",\n  \"red\",\n  \"green\",\n  \"yellow\",\n  \"blue\",\n  \"magenta\",\n  \"cyan\",\n  \"white\",\n  \"brightBlack\",\n  \"brightRed\",\n  \"brightGreen\",\n  \"brightYellow\",\n  \"brightBlue\",\n  \"brightMagenta\",\n  \"brightCyan\",\n  \"brightWhite\"\n];\n\n// src/decorations.ts\nvar decorations = {\n  1: \"bold\",\n  2: \"dim\",\n  3: \"italic\",\n  4: \"underline\",\n  7: \"reverse\",\n  8: \"hidden\",\n  9: \"strikethrough\"\n};\n\n// src/parser.ts\nfunction findSequence(value, position) {\n  const nextEscape = value.indexOf(\"\\x1B\", position);\n  if (nextEscape !== -1) {\n    if (value[nextEscape + 1] === \"[\") {\n      const nextClose = value.indexOf(\"m\", nextEscape);\n      if (nextClose !== -1) {\n        return {\n          sequence: value.substring(nextEscape + 2, nextClose).split(\";\"),\n          startPosition: nextEscape,\n          position: nextClose + 1\n        };\n      }\n    }\n  }\n  return {\n    position: value.length\n  };\n}\nfunction parseColor(sequence) {\n  const colorMode = sequence.shift();\n  if (colorMode === \"2\") {\n    const rgb = sequence.splice(0, 3).map((x) => Number.parseInt(x));\n    if (rgb.length !== 3 || rgb.some((x) => Number.isNaN(x)))\n      return;\n    return {\n      type: \"rgb\",\n      rgb\n    };\n  } else if (colorMode === \"5\") {\n    const index = sequence.shift();\n    if (index) {\n      return { type: \"table\", index: Number(index) };\n    }\n  }\n}\nfunction parseSequence(sequence) {\n  const commands = [];\n  while (sequence.length > 0) {\n    const code = sequence.shift();\n    if (!code)\n      continue;\n    const codeInt = Number.parseInt(code);\n    if (Number.isNaN(codeInt))\n      continue;\n    if (codeInt === 0) {\n      commands.push({ type: \"resetAll\" });\n    } else if (codeInt <= 9) {\n      const decoration = decorations[codeInt];\n      if (decoration) {\n        commands.push({\n          type: \"setDecoration\",\n          value: decorations[codeInt]\n        });\n      }\n    } else if (codeInt <= 29) {\n      const decoration = decorations[codeInt - 20];\n      if (decoration) {\n        commands.push({\n          type: \"resetDecoration\",\n          value: decoration\n        });\n        if (decoration === \"dim\") {\n          commands.push({\n            type: \"resetDecoration\",\n            value: \"bold\"\n          });\n        }\n      }\n    } else if (codeInt <= 37) {\n      commands.push({\n        type: \"setForegroundColor\",\n        value: { type: \"named\", name: namedColors[codeInt - 30] }\n      });\n    } else if (codeInt === 38) {\n      const color = parseColor(sequence);\n      if (color) {\n        commands.push({\n          type: \"setForegroundColor\",\n          value: color\n        });\n      }\n    } else if (codeInt === 39) {\n      commands.push({\n        type: \"resetForegroundColor\"\n      });\n    } else if (codeInt <= 47) {\n      commands.push({\n        type: \"setBackgroundColor\",\n        value: { type: \"named\", name: namedColors[codeInt - 40] }\n      });\n    } else if (codeInt === 48) {\n      const color = parseColor(sequence);\n      if (color) {\n        commands.push({\n          type: \"setBackgroundColor\",\n          value: color\n        });\n      }\n    } else if (codeInt === 49) {\n      commands.push({\n        type: \"resetBackgroundColor\"\n      });\n    } else if (codeInt === 53) {\n      commands.push({\n        type: \"setDecoration\",\n        value: \"overline\"\n      });\n    } else if (codeInt === 55) {\n      commands.push({\n        type: \"resetDecoration\",\n        value: \"overline\"\n      });\n    } else if (codeInt >= 90 && codeInt <= 97) {\n      commands.push({\n        type: \"setForegroundColor\",\n        value: { type: \"named\", name: namedColors[codeInt - 90 + 8] }\n      });\n    } else if (codeInt >= 100 && codeInt <= 107) {\n      commands.push({\n        type: \"setBackgroundColor\",\n        value: { type: \"named\", name: namedColors[codeInt - 100 + 8] }\n      });\n    }\n  }\n  return commands;\n}\nfunction createAnsiSequenceParser() {\n  let foreground = null;\n  let background = null;\n  let decorations2 = /* @__PURE__ */ new Set();\n  return {\n    parse(value) {\n      const tokens = [];\n      let position = 0;\n      do {\n        const findResult = findSequence(value, position);\n        const text = findResult.sequence ? value.substring(position, findResult.startPosition) : value.substring(position);\n        if (text.length > 0) {\n          tokens.push({\n            value: text,\n            foreground,\n            background,\n            decorations: new Set(decorations2)\n          });\n        }\n        if (findResult.sequence) {\n          const commands = parseSequence(findResult.sequence);\n          for (const styleToken of commands) {\n            if (styleToken.type === \"resetAll\") {\n              foreground = null;\n              background = null;\n              decorations2.clear();\n            } else if (styleToken.type === \"resetForegroundColor\") {\n              foreground = null;\n            } else if (styleToken.type === \"resetBackgroundColor\") {\n              background = null;\n            } else if (styleToken.type === \"resetDecoration\") {\n              decorations2.delete(styleToken.value);\n            }\n          }\n          for (const styleToken of commands) {\n            if (styleToken.type === \"setForegroundColor\") {\n              foreground = styleToken.value;\n            } else if (styleToken.type === \"setBackgroundColor\") {\n              background = styleToken.value;\n            } else if (styleToken.type === \"setDecoration\") {\n              decorations2.add(styleToken.value);\n            }\n          }\n        }\n        position = findResult.position;\n      } while (position < value.length);\n      return tokens;\n    }\n  };\n}\n\n// src/palette.ts\nvar defaultNamedColorsMap = {\n  black: \"#000000\",\n  red: \"#bb0000\",\n  green: \"#00bb00\",\n  yellow: \"#bbbb00\",\n  blue: \"#0000bb\",\n  magenta: \"#ff00ff\",\n  cyan: \"#00bbbb\",\n  white: \"#eeeeee\",\n  brightBlack: \"#555555\",\n  brightRed: \"#ff5555\",\n  brightGreen: \"#00ff00\",\n  brightYellow: \"#ffff55\",\n  brightBlue: \"#5555ff\",\n  brightMagenta: \"#ff55ff\",\n  brightCyan: \"#55ffff\",\n  brightWhite: \"#ffffff\"\n};\nfunction createColorPalette(namedColorsMap = defaultNamedColorsMap) {\n  function namedColor(name) {\n    return namedColorsMap[name];\n  }\n  function rgbColor(rgb) {\n    return `#${rgb.map((x) => Math.max(0, Math.min(x, 255)).toString(16).padStart(2, \"0\")).join(\"\")}`;\n  }\n  let colorTable;\n  function getColorTable() {\n    if (colorTable) {\n      return colorTable;\n    }\n    colorTable = [];\n    for (let i = 0; i < namedColors.length; i++) {\n      colorTable.push(namedColor(namedColors[i]));\n    }\n    let levels = [0, 95, 135, 175, 215, 255];\n    for (let r = 0; r < 6; r++) {\n      for (let g = 0; g < 6; g++) {\n        for (let b = 0; b < 6; b++) {\n          colorTable.push(rgbColor([levels[r], levels[g], levels[b]]));\n        }\n      }\n    }\n    let level = 8;\n    for (let i = 0; i < 24; i++, level += 10) {\n      colorTable.push(rgbColor([level, level, level]));\n    }\n    return colorTable;\n  }\n  function tableColor(index) {\n    return getColorTable()[index];\n  }\n  function value(color) {\n    switch (color.type) {\n      case \"named\":\n        return namedColor(color.name);\n      case \"rgb\":\n        return rgbColor(color.rgb);\n      case \"table\":\n        return tableColor(color.index);\n    }\n  }\n  return {\n    value\n  };\n}\n\nconst defaultAnsiColors = {\n  black: \"#000000\",\n  red: \"#cd3131\",\n  green: \"#0DBC79\",\n  yellow: \"#E5E510\",\n  blue: \"#2472C8\",\n  magenta: \"#BC3FBC\",\n  cyan: \"#11A8CD\",\n  white: \"#E5E5E5\",\n  brightBlack: \"#666666\",\n  brightRed: \"#F14C4C\",\n  brightGreen: \"#23D18B\",\n  brightYellow: \"#F5F543\",\n  brightBlue: \"#3B8EEA\",\n  brightMagenta: \"#D670D6\",\n  brightCyan: \"#29B8DB\",\n  brightWhite: \"#FFFFFF\"\n};\nfunction tokenizeAnsiWithTheme(theme, fileContents, options) {\n  const colorReplacements = resolveColorReplacements(theme, options);\n  const lines = splitLines(fileContents);\n  const ansiPalette = Object.fromEntries(\n    namedColors.map((name) => {\n      const key = `terminal.ansi${name[0].toUpperCase()}${name.substring(1)}`;\n      const themeColor = theme.colors?.[key];\n      return [name, themeColor || defaultAnsiColors[name]];\n    })\n  );\n  const colorPalette = createColorPalette(ansiPalette);\n  const parser = createAnsiSequenceParser();\n  return lines.map(\n    (line) => parser.parse(line[0]).map((token) => {\n      let color;\n      let bgColor;\n      if (token.decorations.has(\"reverse\")) {\n        color = token.background ? colorPalette.value(token.background) : theme.bg;\n        bgColor = token.foreground ? colorPalette.value(token.foreground) : theme.fg;\n      } else {\n        color = token.foreground ? colorPalette.value(token.foreground) : theme.fg;\n        bgColor = token.background ? colorPalette.value(token.background) : void 0;\n      }\n      color = applyColorReplacements(color, colorReplacements);\n      bgColor = applyColorReplacements(bgColor, colorReplacements);\n      if (token.decorations.has(\"dim\"))\n        color = dimColor(color);\n      let fontStyle = FontStyle.None;\n      if (token.decorations.has(\"bold\"))\n        fontStyle |= FontStyle.Bold;\n      if (token.decorations.has(\"italic\"))\n        fontStyle |= FontStyle.Italic;\n      if (token.decorations.has(\"underline\"))\n        fontStyle |= FontStyle.Underline;\n      if (token.decorations.has(\"strikethrough\"))\n        fontStyle |= FontStyle.Strikethrough;\n      return {\n        content: token.value,\n        offset: line[1],\n        // TODO: more accurate offset? might need to fork ansi-sequence-parser\n        color,\n        bgColor,\n        fontStyle\n      };\n    })\n  );\n}\nfunction dimColor(color) {\n  const hexMatch = color.match(/#([0-9a-f]{3})([0-9a-f]{3})?([0-9a-f]{2})?/i);\n  if (hexMatch) {\n    if (hexMatch[3]) {\n      const alpha = Math.round(Number.parseInt(hexMatch[3], 16) / 2).toString(16).padStart(2, \"0\");\n      return `#${hexMatch[1]}${hexMatch[2]}${alpha}`;\n    } else if (hexMatch[2]) {\n      return `#${hexMatch[1]}${hexMatch[2]}80`;\n    } else {\n      return `#${Array.from(hexMatch[1]).map((x) => `${x}${x}`).join(\"\")}80`;\n    }\n  }\n  const cssVarMatch = color.match(/var\\((--[\\w-]+-ansi-[\\w-]+)\\)/);\n  if (cssVarMatch)\n    return `var(${cssVarMatch[1]}-dim)`;\n  return color;\n}\n\nfunction codeToTokensBase(internal, code, options = {}) {\n  const {\n    lang = \"text\",\n    theme: themeName = internal.getLoadedThemes()[0]\n  } = options;\n  if (isPlainLang(lang) || isNoneTheme(themeName))\n    return splitLines(code).map((line) => [{ content: line[0], offset: line[1] }]);\n  const { theme, colorMap } = internal.setTheme(themeName);\n  if (lang === \"ansi\")\n    return tokenizeAnsiWithTheme(theme, code, options);\n  const _grammar = internal.getLanguage(lang);\n  if (options.grammarState) {\n    if (options.grammarState.lang !== _grammar.name) {\n      throw new ShikiError$1(`Grammar state language \"${options.grammarState.lang}\" does not match highlight language \"${_grammar.name}\"`);\n    }\n    if (!options.grammarState.themes.includes(theme.name)) {\n      throw new ShikiError$1(`Grammar state themes \"${options.grammarState.themes}\" do not contain highlight theme \"${theme.name}\"`);\n    }\n  }\n  return tokenizeWithTheme(code, _grammar, theme, colorMap, options);\n}\nfunction getLastGrammarState(...args) {\n  if (args.length === 2) {\n    return getLastGrammarStateFromMap(args[1]);\n  }\n  const [internal, code, options = {}] = args;\n  const {\n    lang = \"text\",\n    theme: themeName = internal.getLoadedThemes()[0]\n  } = options;\n  if (isPlainLang(lang) || isNoneTheme(themeName))\n    throw new ShikiError$1(\"Plain language does not have grammar state\");\n  if (lang === \"ansi\")\n    throw new ShikiError$1(\"ANSI language does not have grammar state\");\n  const { theme, colorMap } = internal.setTheme(themeName);\n  const _grammar = internal.getLanguage(lang);\n  return new GrammarState(\n    _tokenizeWithTheme(code, _grammar, theme, colorMap, options).stateStack,\n    _grammar.name,\n    theme.name\n  );\n}\nfunction tokenizeWithTheme(code, grammar, theme, colorMap, options) {\n  const result = _tokenizeWithTheme(code, grammar, theme, colorMap, options);\n  const grammarState = new GrammarState(\n    _tokenizeWithTheme(code, grammar, theme, colorMap, options).stateStack,\n    grammar.name,\n    theme.name\n  );\n  setLastGrammarStateToMap(result.tokens, grammarState);\n  return result.tokens;\n}\nfunction _tokenizeWithTheme(code, grammar, theme, colorMap, options) {\n  const colorReplacements = resolveColorReplacements(theme, options);\n  const {\n    tokenizeMaxLineLength = 0,\n    tokenizeTimeLimit = 500\n  } = options;\n  const lines = splitLines(code);\n  let stateStack = options.grammarState ? getGrammarStack(options.grammarState, theme.name) ?? INITIAL : options.grammarContextCode != null ? _tokenizeWithTheme(\n    options.grammarContextCode,\n    grammar,\n    theme,\n    colorMap,\n    {\n      ...options,\n      grammarState: void 0,\n      grammarContextCode: void 0\n    }\n  ).stateStack : INITIAL;\n  let actual = [];\n  const final = [];\n  for (let i = 0, len = lines.length; i < len; i++) {\n    const [line, lineOffset] = lines[i];\n    if (line === \"\") {\n      actual = [];\n      final.push([]);\n      continue;\n    }\n    if (tokenizeMaxLineLength > 0 && line.length >= tokenizeMaxLineLength) {\n      actual = [];\n      final.push([{\n        content: line,\n        offset: lineOffset,\n        color: \"\",\n        fontStyle: 0\n      }]);\n      continue;\n    }\n    let resultWithScopes;\n    let tokensWithScopes;\n    let tokensWithScopesIndex;\n    if (options.includeExplanation) {\n      resultWithScopes = grammar.tokenizeLine(line, stateStack, tokenizeTimeLimit);\n      tokensWithScopes = resultWithScopes.tokens;\n      tokensWithScopesIndex = 0;\n    }\n    const result = grammar.tokenizeLine2(line, stateStack, tokenizeTimeLimit);\n    const tokensLength = result.tokens.length / 2;\n    for (let j = 0; j < tokensLength; j++) {\n      const startIndex = result.tokens[2 * j];\n      const nextStartIndex = j + 1 < tokensLength ? result.tokens[2 * j + 2] : line.length;\n      if (startIndex === nextStartIndex)\n        continue;\n      const metadata = result.tokens[2 * j + 1];\n      const color = applyColorReplacements(\n        colorMap[EncodedTokenMetadata.getForeground(metadata)],\n        colorReplacements\n      );\n      const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);\n      const token = {\n        content: line.substring(startIndex, nextStartIndex),\n        offset: lineOffset + startIndex,\n        color,\n        fontStyle\n      };\n      if (options.includeExplanation) {\n        const themeSettingsSelectors = [];\n        if (options.includeExplanation !== \"scopeName\") {\n          for (const setting of theme.settings) {\n            let selectors;\n            switch (typeof setting.scope) {\n              case \"string\":\n                selectors = setting.scope.split(/,/).map((scope) => scope.trim());\n                break;\n              case \"object\":\n                selectors = setting.scope;\n                break;\n              default:\n                continue;\n            }\n            themeSettingsSelectors.push({\n              settings: setting,\n              selectors: selectors.map((selector) => selector.split(/ /))\n            });\n          }\n        }\n        token.explanation = [];\n        let offset = 0;\n        while (startIndex + offset < nextStartIndex) {\n          const tokenWithScopes = tokensWithScopes[tokensWithScopesIndex];\n          const tokenWithScopesText = line.substring(\n            tokenWithScopes.startIndex,\n            tokenWithScopes.endIndex\n          );\n          offset += tokenWithScopesText.length;\n          token.explanation.push({\n            content: tokenWithScopesText,\n            scopes: options.includeExplanation === \"scopeName\" ? explainThemeScopesNameOnly(\n              tokenWithScopes.scopes\n            ) : explainThemeScopesFull(\n              themeSettingsSelectors,\n              tokenWithScopes.scopes\n            )\n          });\n          tokensWithScopesIndex += 1;\n        }\n      }\n      actual.push(token);\n    }\n    final.push(actual);\n    actual = [];\n    stateStack = result.ruleStack;\n  }\n  return {\n    tokens: final,\n    stateStack\n  };\n}\nfunction explainThemeScopesNameOnly(scopes) {\n  return scopes.map((scope) => ({ scopeName: scope }));\n}\nfunction explainThemeScopesFull(themeSelectors, scopes) {\n  const result = [];\n  for (let i = 0, len = scopes.length; i < len; i++) {\n    const scope = scopes[i];\n    result[i] = {\n      scopeName: scope,\n      themeMatches: explainThemeScope(themeSelectors, scope, scopes.slice(0, i))\n    };\n  }\n  return result;\n}\nfunction matchesOne(selector, scope) {\n  return selector === scope || scope.substring(0, selector.length) === selector && scope[selector.length] === \".\";\n}\nfunction matches(selectors, scope, parentScopes) {\n  if (!matchesOne(selectors[selectors.length - 1], scope))\n    return false;\n  let selectorParentIndex = selectors.length - 2;\n  let parentIndex = parentScopes.length - 1;\n  while (selectorParentIndex >= 0 && parentIndex >= 0) {\n    if (matchesOne(selectors[selectorParentIndex], parentScopes[parentIndex]))\n      selectorParentIndex -= 1;\n    parentIndex -= 1;\n  }\n  if (selectorParentIndex === -1)\n    return true;\n  return false;\n}\nfunction explainThemeScope(themeSettingsSelectors, scope, parentScopes) {\n  const result = [];\n  for (const { selectors, settings } of themeSettingsSelectors) {\n    for (const selectorPieces of selectors) {\n      if (matches(selectorPieces, scope, parentScopes)) {\n        result.push(settings);\n        break;\n      }\n    }\n  }\n  return result;\n}\n\nfunction codeToTokensWithThemes(internal, code, options) {\n  const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({ color: i[0], theme: i[1] }));\n  const themedTokens = themes.map((t) => {\n    const tokens2 = codeToTokensBase(internal, code, {\n      ...options,\n      theme: t.theme\n    });\n    const state = getLastGrammarStateFromMap(tokens2);\n    const theme = typeof t.theme === \"string\" ? t.theme : t.theme.name;\n    return {\n      tokens: tokens2,\n      state,\n      theme\n    };\n  });\n  const tokens = syncThemesTokenization(\n    ...themedTokens.map((i) => i.tokens)\n  );\n  const mergedTokens = tokens[0].map(\n    (line, lineIdx) => line.map((_token, tokenIdx) => {\n      const mergedToken = {\n        content: _token.content,\n        variants: {},\n        offset: _token.offset\n      };\n      if (\"includeExplanation\" in options && options.includeExplanation) {\n        mergedToken.explanation = _token.explanation;\n      }\n      tokens.forEach((t, themeIdx) => {\n        const {\n          content: _,\n          explanation: __,\n          offset: ___,\n          ...styles\n        } = t[lineIdx][tokenIdx];\n        mergedToken.variants[themes[themeIdx].color] = styles;\n      });\n      return mergedToken;\n    })\n  );\n  const mergedGrammarState = themedTokens[0].state ? new GrammarState(\n    Object.fromEntries(themedTokens.map((s) => [s.theme, s.state?.getInternalStack(s.theme)])),\n    themedTokens[0].state.lang\n  ) : void 0;\n  if (mergedGrammarState)\n    setLastGrammarStateToMap(mergedTokens, mergedGrammarState);\n  return mergedTokens;\n}\nfunction syncThemesTokenization(...themes) {\n  const outThemes = themes.map(() => []);\n  const count = themes.length;\n  for (let i = 0; i < themes[0].length; i++) {\n    const lines = themes.map((t) => t[i]);\n    const outLines = outThemes.map(() => []);\n    outThemes.forEach((t, i2) => t.push(outLines[i2]));\n    const indexes = lines.map(() => 0);\n    const current = lines.map((l) => l[0]);\n    while (current.every((t) => t)) {\n      const minLength = Math.min(...current.map((t) => t.content.length));\n      for (let n = 0; n < count; n++) {\n        const token = current[n];\n        if (token.content.length === minLength) {\n          outLines[n].push(token);\n          indexes[n] += 1;\n          current[n] = lines[n][indexes[n]];\n        } else {\n          outLines[n].push({\n            ...token,\n            content: token.content.slice(0, minLength)\n          });\n          current[n] = {\n            ...token,\n            content: token.content.slice(minLength),\n            offset: token.offset + minLength\n          };\n        }\n      }\n    }\n  }\n  return outThemes;\n}\n\nfunction codeToTokens(internal, code, options) {\n  let bg;\n  let fg;\n  let tokens;\n  let themeName;\n  let rootStyle;\n  let grammarState;\n  if (\"themes\" in options) {\n    const {\n      defaultColor = \"light\",\n      cssVariablePrefix = \"--shiki-\",\n      colorsRendering = \"css-vars\"\n    } = options;\n    const themes = Object.entries(options.themes).filter((i) => i[1]).map((i) => ({ color: i[0], theme: i[1] })).sort((a, b) => a.color === defaultColor ? -1 : b.color === defaultColor ? 1 : 0);\n    if (themes.length === 0)\n      throw new ShikiError$1(\"`themes` option must not be empty\");\n    const themeTokens = codeToTokensWithThemes(\n      internal,\n      code,\n      options\n    );\n    grammarState = getLastGrammarStateFromMap(themeTokens);\n    if (defaultColor && DEFAULT_COLOR_LIGHT_DARK !== defaultColor && !themes.find((t) => t.color === defaultColor))\n      throw new ShikiError$1(`\\`themes\\` option must contain the defaultColor key \\`${defaultColor}\\``);\n    const themeRegs = themes.map((t) => internal.getTheme(t.theme));\n    const themesOrder = themes.map((t) => t.color);\n    tokens = themeTokens.map((line) => line.map((token) => flatTokenVariants(token, themesOrder, cssVariablePrefix, defaultColor, colorsRendering)));\n    if (grammarState)\n      setLastGrammarStateToMap(tokens, grammarState);\n    const themeColorReplacements = themes.map((t) => resolveColorReplacements(t.theme, options));\n    fg = mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, \"fg\", colorsRendering);\n    bg = mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, \"bg\", colorsRendering);\n    themeName = `shiki-themes ${themeRegs.map((t) => t.name).join(\" \")}`;\n    rootStyle = defaultColor ? void 0 : [fg, bg].join(\";\");\n  } else if (\"theme\" in options) {\n    const colorReplacements = resolveColorReplacements(options.theme, options);\n    tokens = codeToTokensBase(\n      internal,\n      code,\n      options\n    );\n    const _theme = internal.getTheme(options.theme);\n    bg = applyColorReplacements(_theme.bg, colorReplacements);\n    fg = applyColorReplacements(_theme.fg, colorReplacements);\n    themeName = _theme.name;\n    grammarState = getLastGrammarStateFromMap(tokens);\n  } else {\n    throw new ShikiError$1(\"Invalid options, either `theme` or `themes` must be provided\");\n  }\n  return {\n    tokens,\n    fg,\n    bg,\n    themeName,\n    rootStyle,\n    grammarState\n  };\n}\nfunction mapThemeColors(themes, themeRegs, themeColorReplacements, cssVariablePrefix, defaultColor, property, colorsRendering) {\n  return themes.map((t, idx) => {\n    const value = applyColorReplacements(themeRegs[idx][property], themeColorReplacements[idx]) || \"inherit\";\n    const cssVar = `${cssVariablePrefix + t.color}${property === \"bg\" ? \"-bg\" : \"\"}:${value}`;\n    if (idx === 0 && defaultColor) {\n      if (defaultColor === DEFAULT_COLOR_LIGHT_DARK && themes.length > 1) {\n        const lightIndex = themes.findIndex((t2) => t2.color === \"light\");\n        const darkIndex = themes.findIndex((t2) => t2.color === \"dark\");\n        if (lightIndex === -1 || darkIndex === -1)\n          throw new ShikiError$1('When using `defaultColor: \"light-dark()\"`, you must provide both `light` and `dark` themes');\n        const lightValue = applyColorReplacements(themeRegs[lightIndex][property], themeColorReplacements[lightIndex]) || \"inherit\";\n        const darkValue = applyColorReplacements(themeRegs[darkIndex][property], themeColorReplacements[darkIndex]) || \"inherit\";\n        return `light-dark(${lightValue}, ${darkValue});${cssVar}`;\n      }\n      return value;\n    }\n    if (colorsRendering === \"css-vars\") {\n      return cssVar;\n    }\n    return null;\n  }).filter((i) => !!i).join(\";\");\n}\n\nfunction codeToHast(internal, code, options, transformerContext = {\n  meta: {},\n  options,\n  codeToHast: (_code, _options) => codeToHast(internal, _code, _options),\n  codeToTokens: (_code, _options) => codeToTokens(internal, _code, _options)\n}) {\n  let input = code;\n  for (const transformer of getTransformers(options))\n    input = transformer.preprocess?.call(transformerContext, input, options) || input;\n  let {\n    tokens,\n    fg,\n    bg,\n    themeName,\n    rootStyle,\n    grammarState\n  } = codeToTokens(internal, input, options);\n  const {\n    mergeWhitespaces = true,\n    mergeSameStyleTokens = false\n  } = options;\n  if (mergeWhitespaces === true)\n    tokens = mergeWhitespaceTokens(tokens);\n  else if (mergeWhitespaces === \"never\")\n    tokens = splitWhitespaceTokens(tokens);\n  if (mergeSameStyleTokens) {\n    tokens = mergeAdjacentStyledTokens(tokens);\n  }\n  const contextSource = {\n    ...transformerContext,\n    get source() {\n      return input;\n    }\n  };\n  for (const transformer of getTransformers(options))\n    tokens = transformer.tokens?.call(contextSource, tokens) || tokens;\n  return tokensToHast(\n    tokens,\n    {\n      ...options,\n      fg,\n      bg,\n      themeName,\n      rootStyle\n    },\n    contextSource,\n    grammarState\n  );\n}\nfunction tokensToHast(tokens, options, transformerContext, grammarState = getLastGrammarStateFromMap(tokens)) {\n  const transformers = getTransformers(options);\n  const lines = [];\n  const root = {\n    type: \"root\",\n    children: []\n  };\n  const {\n    structure = \"classic\",\n    tabindex = \"0\"\n  } = options;\n  let preNode = {\n    type: \"element\",\n    tagName: \"pre\",\n    properties: {\n      class: `shiki ${options.themeName || \"\"}`,\n      style: options.rootStyle || `background-color:${options.bg};color:${options.fg}`,\n      ...tabindex !== false && tabindex != null ? {\n        tabindex: tabindex.toString()\n      } : {},\n      ...Object.fromEntries(\n        Array.from(\n          Object.entries(options.meta || {})\n        ).filter(([key]) => !key.startsWith(\"_\"))\n      )\n    },\n    children: []\n  };\n  let codeNode = {\n    type: \"element\",\n    tagName: \"code\",\n    properties: {},\n    children: lines\n  };\n  const lineNodes = [];\n  const context = {\n    ...transformerContext,\n    structure,\n    addClassToHast,\n    get source() {\n      return transformerContext.source;\n    },\n    get tokens() {\n      return tokens;\n    },\n    get options() {\n      return options;\n    },\n    get root() {\n      return root;\n    },\n    get pre() {\n      return preNode;\n    },\n    get code() {\n      return codeNode;\n    },\n    get lines() {\n      return lineNodes;\n    }\n  };\n  tokens.forEach((line, idx) => {\n    if (idx) {\n      if (structure === \"inline\")\n        root.children.push({ type: \"element\", tagName: \"br\", properties: {}, children: [] });\n      else if (structure === \"classic\")\n        lines.push({ type: \"text\", value: \"\\n\" });\n    }\n    let lineNode = {\n      type: \"element\",\n      tagName: \"span\",\n      properties: { class: \"line\" },\n      children: []\n    };\n    let col = 0;\n    for (const token of line) {\n      let tokenNode = {\n        type: \"element\",\n        tagName: \"span\",\n        properties: {\n          ...token.htmlAttrs\n        },\n        children: [{ type: \"text\", value: token.content }]\n      };\n      const style = stringifyTokenStyle(token.htmlStyle || getTokenStyleObject(token));\n      if (style)\n        tokenNode.properties.style = style;\n      for (const transformer of transformers)\n        tokenNode = transformer?.span?.call(context, tokenNode, idx + 1, col, lineNode, token) || tokenNode;\n      if (structure === \"inline\")\n        root.children.push(tokenNode);\n      else if (structure === \"classic\")\n        lineNode.children.push(tokenNode);\n      col += token.content.length;\n    }\n    if (structure === \"classic\") {\n      for (const transformer of transformers)\n        lineNode = transformer?.line?.call(context, lineNode, idx + 1) || lineNode;\n      lineNodes.push(lineNode);\n      lines.push(lineNode);\n    }\n  });\n  if (structure === \"classic\") {\n    for (const transformer of transformers)\n      codeNode = transformer?.code?.call(context, codeNode) || codeNode;\n    preNode.children.push(codeNode);\n    for (const transformer of transformers)\n      preNode = transformer?.pre?.call(context, preNode) || preNode;\n    root.children.push(preNode);\n  }\n  let result = root;\n  for (const transformer of transformers)\n    result = transformer?.root?.call(context, result) || result;\n  if (grammarState)\n    setLastGrammarStateToMap(result, grammarState);\n  return result;\n}\nfunction mergeWhitespaceTokens(tokens) {\n  return tokens.map((line) => {\n    const newLine = [];\n    let carryOnContent = \"\";\n    let firstOffset = 0;\n    line.forEach((token, idx) => {\n      const isDecorated = token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough);\n      const couldMerge = !isDecorated;\n      if (couldMerge && token.content.match(/^\\s+$/) && line[idx + 1]) {\n        if (!firstOffset)\n          firstOffset = token.offset;\n        carryOnContent += token.content;\n      } else {\n        if (carryOnContent) {\n          if (couldMerge) {\n            newLine.push({\n              ...token,\n              offset: firstOffset,\n              content: carryOnContent + token.content\n            });\n          } else {\n            newLine.push(\n              {\n                content: carryOnContent,\n                offset: firstOffset\n              },\n              token\n            );\n          }\n          firstOffset = 0;\n          carryOnContent = \"\";\n        } else {\n          newLine.push(token);\n        }\n      }\n    });\n    return newLine;\n  });\n}\nfunction splitWhitespaceTokens(tokens) {\n  return tokens.map((line) => {\n    return line.flatMap((token) => {\n      if (token.content.match(/^\\s+$/))\n        return token;\n      const match = token.content.match(/^(\\s*)(.*?)(\\s*)$/);\n      if (!match)\n        return token;\n      const [, leading, content, trailing] = match;\n      if (!leading && !trailing)\n        return token;\n      const expanded = [{\n        ...token,\n        offset: token.offset + leading.length,\n        content\n      }];\n      if (leading) {\n        expanded.unshift({\n          content: leading,\n          offset: token.offset\n        });\n      }\n      if (trailing) {\n        expanded.push({\n          content: trailing,\n          offset: token.offset + leading.length + content.length\n        });\n      }\n      return expanded;\n    });\n  });\n}\nfunction mergeAdjacentStyledTokens(tokens) {\n  return tokens.map((line) => {\n    const newLine = [];\n    for (const token of line) {\n      if (newLine.length === 0) {\n        newLine.push({ ...token });\n        continue;\n      }\n      const prevToken = newLine[newLine.length - 1];\n      const prevStyle = stringifyTokenStyle(prevToken.htmlStyle || getTokenStyleObject(prevToken));\n      const currentStyle = stringifyTokenStyle(token.htmlStyle || getTokenStyleObject(token));\n      const isPrevDecorated = prevToken.fontStyle && (prevToken.fontStyle & FontStyle.Underline || prevToken.fontStyle & FontStyle.Strikethrough);\n      const isDecorated = token.fontStyle && (token.fontStyle & FontStyle.Underline || token.fontStyle & FontStyle.Strikethrough);\n      if (!isPrevDecorated && !isDecorated && prevStyle === currentStyle) {\n        prevToken.content += token.content;\n      } else {\n        newLine.push({ ...token });\n      }\n    }\n    return newLine;\n  });\n}\n\nconst hastToHtml = toHtml;\nfunction codeToHtml(internal, code, options) {\n  const context = {\n    meta: {},\n    options,\n    codeToHast: (_code, _options) => codeToHast(internal, _code, _options),\n    codeToTokens: (_code, _options) => codeToTokens(internal, _code, _options)\n  };\n  let result = hastToHtml(codeToHast(internal, code, options, context));\n  for (const transformer of getTransformers(options))\n    result = transformer.postprocess?.call(context, result, options) || result;\n  return result;\n}\n\nconst VSCODE_FALLBACK_EDITOR_FG = { light: \"#333333\", dark: \"#bbbbbb\" };\nconst VSCODE_FALLBACK_EDITOR_BG = { light: \"#fffffe\", dark: \"#1e1e1e\" };\nconst RESOLVED_KEY = \"__shiki_resolved\";\nfunction normalizeTheme(rawTheme) {\n  if (rawTheme?.[RESOLVED_KEY])\n    return rawTheme;\n  const theme = {\n    ...rawTheme\n  };\n  if (theme.tokenColors && !theme.settings) {\n    theme.settings = theme.tokenColors;\n    delete theme.tokenColors;\n  }\n  theme.type ||= \"dark\";\n  theme.colorReplacements = { ...theme.colorReplacements };\n  theme.settings ||= [];\n  let { bg, fg } = theme;\n  if (!bg || !fg) {\n    const globalSetting = theme.settings ? theme.settings.find((s) => !s.name && !s.scope) : void 0;\n    if (globalSetting?.settings?.foreground)\n      fg = globalSetting.settings.foreground;\n    if (globalSetting?.settings?.background)\n      bg = globalSetting.settings.background;\n    if (!fg && theme?.colors?.[\"editor.foreground\"])\n      fg = theme.colors[\"editor.foreground\"];\n    if (!bg && theme?.colors?.[\"editor.background\"])\n      bg = theme.colors[\"editor.background\"];\n    if (!fg)\n      fg = theme.type === \"light\" ? VSCODE_FALLBACK_EDITOR_FG.light : VSCODE_FALLBACK_EDITOR_FG.dark;\n    if (!bg)\n      bg = theme.type === \"light\" ? VSCODE_FALLBACK_EDITOR_BG.light : VSCODE_FALLBACK_EDITOR_BG.dark;\n    theme.fg = fg;\n    theme.bg = bg;\n  }\n  if (!(theme.settings[0] && theme.settings[0].settings && !theme.settings[0].scope)) {\n    theme.settings.unshift({\n      settings: {\n        foreground: theme.fg,\n        background: theme.bg\n      }\n    });\n  }\n  let replacementCount = 0;\n  const replacementMap = /* @__PURE__ */ new Map();\n  function getReplacementColor(value) {\n    if (replacementMap.has(value))\n      return replacementMap.get(value);\n    replacementCount += 1;\n    const hex = `#${replacementCount.toString(16).padStart(8, \"0\").toLowerCase()}`;\n    if (theme.colorReplacements?.[`#${hex}`])\n      return getReplacementColor(value);\n    replacementMap.set(value, hex);\n    return hex;\n  }\n  theme.settings = theme.settings.map((setting) => {\n    const replaceFg = setting.settings?.foreground && !setting.settings.foreground.startsWith(\"#\");\n    const replaceBg = setting.settings?.background && !setting.settings.background.startsWith(\"#\");\n    if (!replaceFg && !replaceBg)\n      return setting;\n    const clone = {\n      ...setting,\n      settings: {\n        ...setting.settings\n      }\n    };\n    if (replaceFg) {\n      const replacement = getReplacementColor(setting.settings.foreground);\n      theme.colorReplacements[replacement] = setting.settings.foreground;\n      clone.settings.foreground = replacement;\n    }\n    if (replaceBg) {\n      const replacement = getReplacementColor(setting.settings.background);\n      theme.colorReplacements[replacement] = setting.settings.background;\n      clone.settings.background = replacement;\n    }\n    return clone;\n  });\n  for (const key of Object.keys(theme.colors || {})) {\n    if (key === \"editor.foreground\" || key === \"editor.background\" || key.startsWith(\"terminal.ansi\")) {\n      if (!theme.colors[key]?.startsWith(\"#\")) {\n        const replacement = getReplacementColor(theme.colors[key]);\n        theme.colorReplacements[replacement] = theme.colors[key];\n        theme.colors[key] = replacement;\n      }\n    }\n  }\n  Object.defineProperty(theme, RESOLVED_KEY, {\n    enumerable: false,\n    writable: false,\n    value: true\n  });\n  return theme;\n}\n\nasync function resolveLangs(langs) {\n  return Array.from(new Set((await Promise.all(\n    langs.filter((l) => !isSpecialLang(l)).map(async (lang) => await normalizeGetter(lang).then((r) => Array.isArray(r) ? r : [r]))\n  )).flat()));\n}\nasync function resolveThemes(themes) {\n  const resolved = await Promise.all(\n    themes.map(\n      async (theme) => isSpecialTheme(theme) ? null : normalizeTheme(await normalizeGetter(theme))\n    )\n  );\n  return resolved.filter((i) => !!i);\n}\n\nlet _emitDeprecation = 3;\nlet _emitError = false;\nfunction enableDeprecationWarnings(emitDeprecation = true, emitError = false) {\n  _emitDeprecation = emitDeprecation;\n  _emitError = emitError;\n}\nfunction warnDeprecated(message, version = 3) {\n  if (!_emitDeprecation)\n    return;\n  if (typeof _emitDeprecation === \"number\" && version > _emitDeprecation)\n    return;\n  if (_emitError) {\n    throw new Error(`[SHIKI DEPRECATE]: ${message}`);\n  } else {\n    console.trace(`[SHIKI DEPRECATE]: ${message}`);\n  }\n}\n\nclass ShikiError extends Error {\n  constructor(message) {\n    super(message);\n    this.name = \"ShikiError\";\n  }\n}\n\nclass Registry extends Registry$1 {\n  constructor(_resolver, _themes, _langs, _alias = {}) {\n    super(_resolver);\n    this._resolver = _resolver;\n    this._themes = _themes;\n    this._langs = _langs;\n    this._alias = _alias;\n    this._themes.map((t) => this.loadTheme(t));\n    this.loadLanguages(this._langs);\n  }\n  _resolvedThemes = /* @__PURE__ */ new Map();\n  _resolvedGrammars = /* @__PURE__ */ new Map();\n  _langMap = /* @__PURE__ */ new Map();\n  _langGraph = /* @__PURE__ */ new Map();\n  _textmateThemeCache = /* @__PURE__ */ new WeakMap();\n  _loadedThemesCache = null;\n  _loadedLanguagesCache = null;\n  getTheme(theme) {\n    if (typeof theme === \"string\")\n      return this._resolvedThemes.get(theme);\n    else\n      return this.loadTheme(theme);\n  }\n  loadTheme(theme) {\n    const _theme = normalizeTheme(theme);\n    if (_theme.name) {\n      this._resolvedThemes.set(_theme.name, _theme);\n      this._loadedThemesCache = null;\n    }\n    return _theme;\n  }\n  getLoadedThemes() {\n    if (!this._loadedThemesCache)\n      this._loadedThemesCache = [...this._resolvedThemes.keys()];\n    return this._loadedThemesCache;\n  }\n  // Override and re-implement this method to cache the textmate themes as `TextMateTheme.createFromRawTheme`\n  // is expensive. Themes can switch often especially for dual-theme support.\n  //\n  // The parent class also accepts `colorMap` as the second parameter, but since we don't use that,\n  // we omit here so it's easier to cache the themes.\n  setTheme(theme) {\n    let textmateTheme = this._textmateThemeCache.get(theme);\n    if (!textmateTheme) {\n      textmateTheme = Theme.createFromRawTheme(theme);\n      this._textmateThemeCache.set(theme, textmateTheme);\n    }\n    this._syncRegistry.setTheme(textmateTheme);\n  }\n  getGrammar(name) {\n    if (this._alias[name]) {\n      const resolved = /* @__PURE__ */ new Set([name]);\n      while (this._alias[name]) {\n        name = this._alias[name];\n        if (resolved.has(name))\n          throw new ShikiError(`Circular alias \\`${Array.from(resolved).join(\" -> \")} -> ${name}\\``);\n        resolved.add(name);\n      }\n    }\n    return this._resolvedGrammars.get(name);\n  }\n  loadLanguage(lang) {\n    if (this.getGrammar(lang.name))\n      return;\n    const embeddedLazilyBy = new Set(\n      [...this._langMap.values()].filter((i) => i.embeddedLangsLazy?.includes(lang.name))\n    );\n    this._resolver.addLanguage(lang);\n    const grammarConfig = {\n      balancedBracketSelectors: lang.balancedBracketSelectors || [\"*\"],\n      unbalancedBracketSelectors: lang.unbalancedBracketSelectors || []\n    };\n    this._syncRegistry._rawGrammars.set(lang.scopeName, lang);\n    const g = this.loadGrammarWithConfiguration(lang.scopeName, 1, grammarConfig);\n    g.name = lang.name;\n    this._resolvedGrammars.set(lang.name, g);\n    if (lang.aliases) {\n      lang.aliases.forEach((alias) => {\n        this._alias[alias] = lang.name;\n      });\n    }\n    this._loadedLanguagesCache = null;\n    if (embeddedLazilyBy.size) {\n      for (const e of embeddedLazilyBy) {\n        this._resolvedGrammars.delete(e.name);\n        this._loadedLanguagesCache = null;\n        this._syncRegistry?._injectionGrammars?.delete(e.scopeName);\n        this._syncRegistry?._grammars?.delete(e.scopeName);\n        this.loadLanguage(this._langMap.get(e.name));\n      }\n    }\n  }\n  dispose() {\n    super.dispose();\n    this._resolvedThemes.clear();\n    this._resolvedGrammars.clear();\n    this._langMap.clear();\n    this._langGraph.clear();\n    this._loadedThemesCache = null;\n  }\n  loadLanguages(langs) {\n    for (const lang of langs)\n      this.resolveEmbeddedLanguages(lang);\n    const langsGraphArray = Array.from(this._langGraph.entries());\n    const missingLangs = langsGraphArray.filter(([_, lang]) => !lang);\n    if (missingLangs.length) {\n      const dependents = langsGraphArray.filter(([_, lang]) => lang && lang.embeddedLangs?.some((l) => missingLangs.map(([name]) => name).includes(l))).filter((lang) => !missingLangs.includes(lang));\n      throw new ShikiError(`Missing languages ${missingLangs.map(([name]) => `\\`${name}\\``).join(\", \")}, required by ${dependents.map(([name]) => `\\`${name}\\``).join(\", \")}`);\n    }\n    for (const [_, lang] of langsGraphArray)\n      this._resolver.addLanguage(lang);\n    for (const [_, lang] of langsGraphArray)\n      this.loadLanguage(lang);\n  }\n  getLoadedLanguages() {\n    if (!this._loadedLanguagesCache) {\n      this._loadedLanguagesCache = [\n        .../* @__PURE__ */ new Set([...this._resolvedGrammars.keys(), ...Object.keys(this._alias)])\n      ];\n    }\n    return this._loadedLanguagesCache;\n  }\n  resolveEmbeddedLanguages(lang) {\n    this._langMap.set(lang.name, lang);\n    this._langGraph.set(lang.name, lang);\n    if (lang.embeddedLangs) {\n      for (const embeddedLang of lang.embeddedLangs)\n        this._langGraph.set(embeddedLang, this._langMap.get(embeddedLang));\n    }\n  }\n}\n\nclass Resolver {\n  _langs = /* @__PURE__ */ new Map();\n  _scopeToLang = /* @__PURE__ */ new Map();\n  _injections = /* @__PURE__ */ new Map();\n  _onigLib;\n  constructor(engine, langs) {\n    this._onigLib = {\n      createOnigScanner: (patterns) => engine.createScanner(patterns),\n      createOnigString: (s) => engine.createString(s)\n    };\n    langs.forEach((i) => this.addLanguage(i));\n  }\n  get onigLib() {\n    return this._onigLib;\n  }\n  getLangRegistration(langIdOrAlias) {\n    return this._langs.get(langIdOrAlias);\n  }\n  loadGrammar(scopeName) {\n    return this._scopeToLang.get(scopeName);\n  }\n  addLanguage(l) {\n    this._langs.set(l.name, l);\n    if (l.aliases) {\n      l.aliases.forEach((a) => {\n        this._langs.set(a, l);\n      });\n    }\n    this._scopeToLang.set(l.scopeName, l);\n    if (l.injectTo) {\n      l.injectTo.forEach((i) => {\n        if (!this._injections.get(i))\n          this._injections.set(i, []);\n        this._injections.get(i).push(l.scopeName);\n      });\n    }\n  }\n  getInjections(scopeName) {\n    const scopeParts = scopeName.split(\".\");\n    let injections = [];\n    for (let i = 1; i <= scopeParts.length; i++) {\n      const subScopeName = scopeParts.slice(0, i).join(\".\");\n      injections = [...injections, ...this._injections.get(subScopeName) || []];\n    }\n    return injections;\n  }\n}\n\nlet instancesCount = 0;\nfunction createShikiInternalSync(options) {\n  instancesCount += 1;\n  if (options.warnings !== false && instancesCount >= 10 && instancesCount % 10 === 0)\n    console.warn(`[Shiki] ${instancesCount} instances have been created. Shiki is supposed to be used as a singleton, consider refactoring your code to cache your highlighter instance; Or call \\`highlighter.dispose()\\` to release unused instances.`);\n  let isDisposed = false;\n  if (!options.engine)\n    throw new ShikiError(\"`engine` option is required for synchronous mode\");\n  const langs = (options.langs || []).flat(1);\n  const themes = (options.themes || []).flat(1).map(normalizeTheme);\n  const resolver = new Resolver(options.engine, langs);\n  const _registry = new Registry(resolver, themes, langs, options.langAlias);\n  let _lastTheme;\n  function getLanguage(name) {\n    ensureNotDisposed();\n    const _lang = _registry.getGrammar(typeof name === \"string\" ? name : name.name);\n    if (!_lang)\n      throw new ShikiError(`Language \\`${name}\\` not found, you may need to load it first`);\n    return _lang;\n  }\n  function getTheme(name) {\n    if (name === \"none\")\n      return { bg: \"\", fg: \"\", name: \"none\", settings: [], type: \"dark\" };\n    ensureNotDisposed();\n    const _theme = _registry.getTheme(name);\n    if (!_theme)\n      throw new ShikiError(`Theme \\`${name}\\` not found, you may need to load it first`);\n    return _theme;\n  }\n  function setTheme(name) {\n    ensureNotDisposed();\n    const theme = getTheme(name);\n    if (_lastTheme !== name) {\n      _registry.setTheme(theme);\n      _lastTheme = name;\n    }\n    const colorMap = _registry.getColorMap();\n    return {\n      theme,\n      colorMap\n    };\n  }\n  function getLoadedThemes() {\n    ensureNotDisposed();\n    return _registry.getLoadedThemes();\n  }\n  function getLoadedLanguages() {\n    ensureNotDisposed();\n    return _registry.getLoadedLanguages();\n  }\n  function loadLanguageSync(...langs2) {\n    ensureNotDisposed();\n    _registry.loadLanguages(langs2.flat(1));\n  }\n  async function loadLanguage(...langs2) {\n    return loadLanguageSync(await resolveLangs(langs2));\n  }\n  function loadThemeSync(...themes2) {\n    ensureNotDisposed();\n    for (const theme of themes2.flat(1)) {\n      _registry.loadTheme(theme);\n    }\n  }\n  async function loadTheme(...themes2) {\n    ensureNotDisposed();\n    return loadThemeSync(await resolveThemes(themes2));\n  }\n  function ensureNotDisposed() {\n    if (isDisposed)\n      throw new ShikiError(\"Shiki instance has been disposed\");\n  }\n  function dispose() {\n    if (isDisposed)\n      return;\n    isDisposed = true;\n    _registry.dispose();\n    instancesCount -= 1;\n  }\n  return {\n    setTheme,\n    getTheme,\n    getLanguage,\n    getLoadedThemes,\n    getLoadedLanguages,\n    loadLanguage,\n    loadLanguageSync,\n    loadTheme,\n    loadThemeSync,\n    dispose,\n    [Symbol.dispose]: dispose\n  };\n}\n\nasync function createShikiInternal(options) {\n  if (!options.engine) {\n    warnDeprecated(\"`engine` option is required. Use `createOnigurumaEngine` or `createJavaScriptRegexEngine` to create an engine.\");\n  }\n  const [\n    themes,\n    langs,\n    engine\n  ] = await Promise.all([\n    resolveThemes(options.themes || []),\n    resolveLangs(options.langs || []),\n    options.engine\n  ]);\n  return createShikiInternalSync({\n    ...options,\n    themes,\n    langs,\n    engine\n  });\n}\n\nasync function createHighlighterCore(options) {\n  const internal = await createShikiInternal(options);\n  return {\n    getLastGrammarState: (...args) => getLastGrammarState(internal, ...args),\n    codeToTokensBase: (code, options2) => codeToTokensBase(internal, code, options2),\n    codeToTokensWithThemes: (code, options2) => codeToTokensWithThemes(internal, code, options2),\n    codeToTokens: (code, options2) => codeToTokens(internal, code, options2),\n    codeToHast: (code, options2) => codeToHast(internal, code, options2),\n    codeToHtml: (code, options2) => codeToHtml(internal, code, options2),\n    getBundledLanguages: () => ({}),\n    getBundledThemes: () => ({}),\n    ...internal,\n    getInternalContext: () => internal\n  };\n}\nfunction createHighlighterCoreSync(options) {\n  const internal = createShikiInternalSync(options);\n  return {\n    getLastGrammarState: (...args) => getLastGrammarState(internal, ...args),\n    codeToTokensBase: (code, options2) => codeToTokensBase(internal, code, options2),\n    codeToTokensWithThemes: (code, options2) => codeToTokensWithThemes(internal, code, options2),\n    codeToTokens: (code, options2) => codeToTokens(internal, code, options2),\n    codeToHast: (code, options2) => codeToHast(internal, code, options2),\n    codeToHtml: (code, options2) => codeToHtml(internal, code, options2),\n    getBundledLanguages: () => ({}),\n    getBundledThemes: () => ({}),\n    ...internal,\n    getInternalContext: () => internal\n  };\n}\nfunction makeSingletonHighlighterCore(createHighlighter) {\n  let _shiki;\n  async function getSingletonHighlighterCore2(options) {\n    if (!_shiki) {\n      _shiki = createHighlighter({\n        ...options,\n        themes: options.themes || [],\n        langs: options.langs || []\n      });\n      return _shiki;\n    } else {\n      const s = await _shiki;\n      await Promise.all([\n        s.loadTheme(...options.themes || []),\n        s.loadLanguage(...options.langs || [])\n      ]);\n      return s;\n    }\n  }\n  return getSingletonHighlighterCore2;\n}\nconst getSingletonHighlighterCore = /* @__PURE__ */ makeSingletonHighlighterCore(createHighlighterCore);\n\nfunction createdBundledHighlighter(options) {\n  const bundledLanguages = options.langs;\n  const bundledThemes = options.themes;\n  const engine = options.engine;\n  async function createHighlighter(options2) {\n    function resolveLang(lang) {\n      if (typeof lang === \"string\") {\n        if (isSpecialLang(lang))\n          return [];\n        lang = options2.langAlias?.[lang] || lang;\n        const bundle = bundledLanguages[lang];\n        if (!bundle)\n          throw new ShikiError$1(`Language \\`${lang}\\` is not included in this bundle. You may want to load it from external source.`);\n        return bundle;\n      }\n      return lang;\n    }\n    function resolveTheme(theme) {\n      if (isSpecialTheme(theme))\n        return \"none\";\n      if (typeof theme === \"string\") {\n        const bundle = bundledThemes[theme];\n        if (!bundle)\n          throw new ShikiError$1(`Theme \\`${theme}\\` is not included in this bundle. You may want to load it from external source.`);\n        return bundle;\n      }\n      return theme;\n    }\n    const _themes = (options2.themes ?? []).map((i) => resolveTheme(i));\n    const langs = (options2.langs ?? []).map((i) => resolveLang(i));\n    const core = await createHighlighterCore({\n      engine: options2.engine ?? engine(),\n      ...options2,\n      themes: _themes,\n      langs\n    });\n    return {\n      ...core,\n      loadLanguage(...langs2) {\n        return core.loadLanguage(...langs2.map(resolveLang));\n      },\n      loadTheme(...themes) {\n        return core.loadTheme(...themes.map(resolveTheme));\n      },\n      getBundledLanguages() {\n        return bundledLanguages;\n      },\n      getBundledThemes() {\n        return bundledThemes;\n      }\n    };\n  }\n  return createHighlighter;\n}\nfunction makeSingletonHighlighter(createHighlighter) {\n  let _shiki;\n  async function getSingletonHighlighter(options = {}) {\n    if (!_shiki) {\n      _shiki = createHighlighter({\n        ...options,\n        themes: [],\n        langs: []\n      });\n      const s = await _shiki;\n      await Promise.all([\n        s.loadTheme(...options.themes || []),\n        s.loadLanguage(...options.langs || [])\n      ]);\n      return s;\n    } else {\n      const s = await _shiki;\n      await Promise.all([\n        s.loadTheme(...options.themes || []),\n        s.loadLanguage(...options.langs || [])\n      ]);\n      return s;\n    }\n  }\n  return getSingletonHighlighter;\n}\nfunction createSingletonShorthands(createHighlighter, config) {\n  const getSingletonHighlighter = makeSingletonHighlighter(createHighlighter);\n  async function get(code, options) {\n    const shiki = await getSingletonHighlighter({\n      langs: [options.lang],\n      themes: \"theme\" in options ? [options.theme] : Object.values(options.themes)\n    });\n    const langs = await config?.guessEmbeddedLanguages?.(code, options.lang, shiki);\n    if (langs) {\n      await shiki.loadLanguage(...langs);\n    }\n    return shiki;\n  }\n  return {\n    getSingletonHighlighter(options) {\n      return getSingletonHighlighter(options);\n    },\n    async codeToHtml(code, options) {\n      const shiki = await get(code, options);\n      return shiki.codeToHtml(code, options);\n    },\n    async codeToHast(code, options) {\n      const shiki = await get(code, options);\n      return shiki.codeToHast(code, options);\n    },\n    async codeToTokens(code, options) {\n      const shiki = await get(code, options);\n      return shiki.codeToTokens(code, options);\n    },\n    async codeToTokensBase(code, options) {\n      const shiki = await get(code, options);\n      return shiki.codeToTokensBase(code, options);\n    },\n    async codeToTokensWithThemes(code, options) {\n      const shiki = await get(code, options);\n      return shiki.codeToTokensWithThemes(code, options);\n    },\n    async getLastGrammarState(code, options) {\n      const shiki = await getSingletonHighlighter({\n        langs: [options.lang],\n        themes: [options.theme]\n      });\n      return shiki.getLastGrammarState(code, options);\n    }\n  };\n}\n\nfunction createCssVariablesTheme(options = {}) {\n  const {\n    name = \"css-variables\",\n    variablePrefix = \"--shiki-\",\n    fontStyle = true\n  } = options;\n  const variable = (name2) => {\n    if (options.variableDefaults?.[name2])\n      return `var(${variablePrefix}${name2}, ${options.variableDefaults[name2]})`;\n    return `var(${variablePrefix}${name2})`;\n  };\n  const theme = {\n    name,\n    type: \"dark\",\n    colors: {\n      \"editor.foreground\": variable(\"foreground\"),\n      \"editor.background\": variable(\"background\"),\n      \"terminal.ansiBlack\": variable(\"ansi-black\"),\n      \"terminal.ansiRed\": variable(\"ansi-red\"),\n      \"terminal.ansiGreen\": variable(\"ansi-green\"),\n      \"terminal.ansiYellow\": variable(\"ansi-yellow\"),\n      \"terminal.ansiBlue\": variable(\"ansi-blue\"),\n      \"terminal.ansiMagenta\": variable(\"ansi-magenta\"),\n      \"terminal.ansiCyan\": variable(\"ansi-cyan\"),\n      \"terminal.ansiWhite\": variable(\"ansi-white\"),\n      \"terminal.ansiBrightBlack\": variable(\"ansi-bright-black\"),\n      \"terminal.ansiBrightRed\": variable(\"ansi-bright-red\"),\n      \"terminal.ansiBrightGreen\": variable(\"ansi-bright-green\"),\n      \"terminal.ansiBrightYellow\": variable(\"ansi-bright-yellow\"),\n      \"terminal.ansiBrightBlue\": variable(\"ansi-bright-blue\"),\n      \"terminal.ansiBrightMagenta\": variable(\"ansi-bright-magenta\"),\n      \"terminal.ansiBrightCyan\": variable(\"ansi-bright-cyan\"),\n      \"terminal.ansiBrightWhite\": variable(\"ansi-bright-white\")\n    },\n    tokenColors: [\n      {\n        scope: [\n          \"keyword.operator.accessor\",\n          \"meta.group.braces.round.function.arguments\",\n          \"meta.template.expression\",\n          \"markup.fenced_code meta.embedded.block\"\n        ],\n        settings: {\n          foreground: variable(\"foreground\")\n        }\n      },\n      {\n        scope: \"emphasis\",\n        settings: {\n          fontStyle: \"italic\"\n        }\n      },\n      {\n        scope: [\"strong\", \"markup.heading.markdown\", \"markup.bold.markdown\"],\n        settings: {\n          fontStyle: \"bold\"\n        }\n      },\n      {\n        scope: [\"markup.italic.markdown\"],\n        settings: {\n          fontStyle: \"italic\"\n        }\n      },\n      {\n        scope: \"meta.link.inline.markdown\",\n        settings: {\n          fontStyle: \"underline\",\n          foreground: variable(\"token-link\")\n        }\n      },\n      {\n        scope: [\"string\", \"markup.fenced_code\", \"markup.inline\"],\n        settings: {\n          foreground: variable(\"token-string\")\n        }\n      },\n      {\n        scope: [\"comment\", \"string.quoted.docstring.multi\"],\n        settings: {\n          foreground: variable(\"token-comment\")\n        }\n      },\n      {\n        scope: [\n          \"constant.numeric\",\n          \"constant.language\",\n          \"constant.other.placeholder\",\n          \"constant.character.format.placeholder\",\n          \"variable.language.this\",\n          \"variable.other.object\",\n          \"variable.other.class\",\n          \"variable.other.constant\",\n          \"meta.property-name\",\n          \"meta.property-value\",\n          \"support\"\n        ],\n        settings: {\n          foreground: variable(\"token-constant\")\n        }\n      },\n      {\n        scope: [\n          \"keyword\",\n          \"storage.modifier\",\n          \"storage.type\",\n          \"storage.control.clojure\",\n          \"entity.name.function.clojure\",\n          \"entity.name.tag.yaml\",\n          \"support.function.node\",\n          \"support.type.property-name.json\",\n          \"punctuation.separator.key-value\",\n          \"punctuation.definition.template-expression\"\n        ],\n        settings: {\n          foreground: variable(\"token-keyword\")\n        }\n      },\n      {\n        scope: \"variable.parameter.function\",\n        settings: {\n          foreground: variable(\"token-parameter\")\n        }\n      },\n      {\n        scope: [\n          \"support.function\",\n          \"entity.name.type\",\n          \"entity.other.inherited-class\",\n          \"meta.function-call\",\n          \"meta.instance.constructor\",\n          \"entity.other.attribute-name\",\n          \"entity.name.function\",\n          \"constant.keyword.clojure\"\n        ],\n        settings: {\n          foreground: variable(\"token-function\")\n        }\n      },\n      {\n        scope: [\n          \"entity.name.tag\",\n          \"string.quoted\",\n          \"string.regexp\",\n          \"string.interpolated\",\n          \"string.template\",\n          \"string.unquoted.plain.out.yaml\",\n          \"keyword.other.template\"\n        ],\n        settings: {\n          foreground: variable(\"token-string-expression\")\n        }\n      },\n      {\n        scope: [\n          \"punctuation.definition.arguments\",\n          \"punctuation.definition.dict\",\n          \"punctuation.separator\",\n          \"meta.function-call.arguments\"\n        ],\n        settings: {\n          foreground: variable(\"token-punctuation\")\n        }\n      },\n      {\n        // [Custom] Markdown links\n        scope: [\n          \"markup.underline.link\",\n          \"punctuation.definition.metadata.markdown\"\n        ],\n        settings: {\n          foreground: variable(\"token-link\")\n        }\n      },\n      {\n        // [Custom] Markdown list\n        scope: [\"beginning.punctuation.definition.list.markdown\"],\n        settings: {\n          foreground: variable(\"token-string\")\n        }\n      },\n      {\n        // [Custom] Markdown punctuation definition brackets\n        scope: [\n          \"punctuation.definition.string.begin.markdown\",\n          \"punctuation.definition.string.end.markdown\",\n          \"string.other.link.title.markdown\",\n          \"string.other.link.description.markdown\"\n        ],\n        settings: {\n          foreground: variable(\"token-keyword\")\n        }\n      },\n      {\n        // [Custom] Diff\n        scope: [\n          \"markup.inserted\",\n          \"meta.diff.header.to-file\",\n          \"punctuation.definition.inserted\"\n        ],\n        settings: {\n          foreground: variable(\"token-inserted\")\n        }\n      },\n      {\n        scope: [\n          \"markup.deleted\",\n          \"meta.diff.header.from-file\",\n          \"punctuation.definition.deleted\"\n        ],\n        settings: {\n          foreground: variable(\"token-deleted\")\n        }\n      },\n      {\n        scope: [\n          \"markup.changed\",\n          \"punctuation.definition.changed\"\n        ],\n        settings: {\n          foreground: variable(\"token-changed\")\n        }\n      }\n    ]\n  };\n  if (!fontStyle) {\n    theme.tokenColors = theme.tokenColors?.map((tokenColor) => {\n      if (tokenColor.settings?.fontStyle)\n        delete tokenColor.settings.fontStyle;\n      return tokenColor;\n    });\n  }\n  return theme;\n}\n\nexport { addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createCssVariablesTheme, createHighlighterCore, createHighlighterCoreSync, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createdBundledHighlighter, enableDeprecationWarnings, flatTokenVariants, getSingletonHighlighterCore, getTokenStyleObject, guessEmbeddedLanguages, hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations, warnDeprecated };\n","const bundledThemesInfo = [\n  {\n    \"id\": \"andromeeda\",\n    \"displayName\": \"Andromeeda\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/andromeeda'))\n  },\n  {\n    \"id\": \"aurora-x\",\n    \"displayName\": \"Aurora X\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/aurora-x'))\n  },\n  {\n    \"id\": \"ayu-dark\",\n    \"displayName\": \"Ayu Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/ayu-dark'))\n  },\n  {\n    \"id\": \"catppuccin-frappe\",\n    \"displayName\": \"Catppuccin Frapp\\xE9\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/catppuccin-frappe'))\n  },\n  {\n    \"id\": \"catppuccin-latte\",\n    \"displayName\": \"Catppuccin Latte\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/catppuccin-latte'))\n  },\n  {\n    \"id\": \"catppuccin-macchiato\",\n    \"displayName\": \"Catppuccin Macchiato\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/catppuccin-macchiato'))\n  },\n  {\n    \"id\": \"catppuccin-mocha\",\n    \"displayName\": \"Catppuccin Mocha\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/catppuccin-mocha'))\n  },\n  {\n    \"id\": \"dark-plus\",\n    \"displayName\": \"Dark Plus\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/dark-plus'))\n  },\n  {\n    \"id\": \"dracula\",\n    \"displayName\": \"Dracula Theme\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/dracula'))\n  },\n  {\n    \"id\": \"dracula-soft\",\n    \"displayName\": \"Dracula Theme Soft\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/dracula-soft'))\n  },\n  {\n    \"id\": \"everforest-dark\",\n    \"displayName\": \"Everforest Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/everforest-dark'))\n  },\n  {\n    \"id\": \"everforest-light\",\n    \"displayName\": \"Everforest Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/everforest-light'))\n  },\n  {\n    \"id\": \"github-dark\",\n    \"displayName\": \"GitHub Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/github-dark'))\n  },\n  {\n    \"id\": \"github-dark-default\",\n    \"displayName\": \"GitHub Dark Default\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/github-dark-default'))\n  },\n  {\n    \"id\": \"github-dark-dimmed\",\n    \"displayName\": \"GitHub Dark Dimmed\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/github-dark-dimmed'))\n  },\n  {\n    \"id\": \"github-dark-high-contrast\",\n    \"displayName\": \"GitHub Dark High Contrast\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/github-dark-high-contrast'))\n  },\n  {\n    \"id\": \"github-light\",\n    \"displayName\": \"GitHub Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/github-light'))\n  },\n  {\n    \"id\": \"github-light-default\",\n    \"displayName\": \"GitHub Light Default\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/github-light-default'))\n  },\n  {\n    \"id\": \"github-light-high-contrast\",\n    \"displayName\": \"GitHub Light High Contrast\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/github-light-high-contrast'))\n  },\n  {\n    \"id\": \"gruvbox-dark-hard\",\n    \"displayName\": \"Gruvbox Dark Hard\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-dark-hard'))\n  },\n  {\n    \"id\": \"gruvbox-dark-medium\",\n    \"displayName\": \"Gruvbox Dark Medium\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-dark-medium'))\n  },\n  {\n    \"id\": \"gruvbox-dark-soft\",\n    \"displayName\": \"Gruvbox Dark Soft\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-dark-soft'))\n  },\n  {\n    \"id\": \"gruvbox-light-hard\",\n    \"displayName\": \"Gruvbox Light Hard\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-light-hard'))\n  },\n  {\n    \"id\": \"gruvbox-light-medium\",\n    \"displayName\": \"Gruvbox Light Medium\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-light-medium'))\n  },\n  {\n    \"id\": \"gruvbox-light-soft\",\n    \"displayName\": \"Gruvbox Light Soft\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/gruvbox-light-soft'))\n  },\n  {\n    \"id\": \"houston\",\n    \"displayName\": \"Houston\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/houston'))\n  },\n  {\n    \"id\": \"kanagawa-dragon\",\n    \"displayName\": \"Kanagawa Dragon\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/kanagawa-dragon'))\n  },\n  {\n    \"id\": \"kanagawa-lotus\",\n    \"displayName\": \"Kanagawa Lotus\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/kanagawa-lotus'))\n  },\n  {\n    \"id\": \"kanagawa-wave\",\n    \"displayName\": \"Kanagawa Wave\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/kanagawa-wave'))\n  },\n  {\n    \"id\": \"laserwave\",\n    \"displayName\": \"LaserWave\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/laserwave'))\n  },\n  {\n    \"id\": \"light-plus\",\n    \"displayName\": \"Light Plus\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/light-plus'))\n  },\n  {\n    \"id\": \"material-theme\",\n    \"displayName\": \"Material Theme\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/material-theme'))\n  },\n  {\n    \"id\": \"material-theme-darker\",\n    \"displayName\": \"Material Theme Darker\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/material-theme-darker'))\n  },\n  {\n    \"id\": \"material-theme-lighter\",\n    \"displayName\": \"Material Theme Lighter\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/material-theme-lighter'))\n  },\n  {\n    \"id\": \"material-theme-ocean\",\n    \"displayName\": \"Material Theme Ocean\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/material-theme-ocean'))\n  },\n  {\n    \"id\": \"material-theme-palenight\",\n    \"displayName\": \"Material Theme Palenight\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/material-theme-palenight'))\n  },\n  {\n    \"id\": \"min-dark\",\n    \"displayName\": \"Min Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/min-dark'))\n  },\n  {\n    \"id\": \"min-light\",\n    \"displayName\": \"Min Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/min-light'))\n  },\n  {\n    \"id\": \"monokai\",\n    \"displayName\": \"Monokai\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/monokai'))\n  },\n  {\n    \"id\": \"night-owl\",\n    \"displayName\": \"Night Owl\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/night-owl'))\n  },\n  {\n    \"id\": \"nord\",\n    \"displayName\": \"Nord\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/nord'))\n  },\n  {\n    \"id\": \"one-dark-pro\",\n    \"displayName\": \"One Dark Pro\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/one-dark-pro'))\n  },\n  {\n    \"id\": \"one-light\",\n    \"displayName\": \"One Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/one-light'))\n  },\n  {\n    \"id\": \"plastic\",\n    \"displayName\": \"Plastic\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/plastic'))\n  },\n  {\n    \"id\": \"poimandres\",\n    \"displayName\": \"Poimandres\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/poimandres'))\n  },\n  {\n    \"id\": \"red\",\n    \"displayName\": \"Red\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/red'))\n  },\n  {\n    \"id\": \"rose-pine\",\n    \"displayName\": \"Ros\\xE9 Pine\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/rose-pine'))\n  },\n  {\n    \"id\": \"rose-pine-dawn\",\n    \"displayName\": \"Ros\\xE9 Pine Dawn\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/rose-pine-dawn'))\n  },\n  {\n    \"id\": \"rose-pine-moon\",\n    \"displayName\": \"Ros\\xE9 Pine Moon\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/rose-pine-moon'))\n  },\n  {\n    \"id\": \"slack-dark\",\n    \"displayName\": \"Slack Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/slack-dark'))\n  },\n  {\n    \"id\": \"slack-ochin\",\n    \"displayName\": \"Slack Ochin\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/slack-ochin'))\n  },\n  {\n    \"id\": \"snazzy-light\",\n    \"displayName\": \"Snazzy Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/snazzy-light'))\n  },\n  {\n    \"id\": \"solarized-dark\",\n    \"displayName\": \"Solarized Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/solarized-dark'))\n  },\n  {\n    \"id\": \"solarized-light\",\n    \"displayName\": \"Solarized Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/solarized-light'))\n  },\n  {\n    \"id\": \"synthwave-84\",\n    \"displayName\": \"Synthwave '84\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/synthwave-84'))\n  },\n  {\n    \"id\": \"tokyo-night\",\n    \"displayName\": \"Tokyo Night\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/tokyo-night'))\n  },\n  {\n    \"id\": \"vesper\",\n    \"displayName\": \"Vesper\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/vesper'))\n  },\n  {\n    \"id\": \"vitesse-black\",\n    \"displayName\": \"Vitesse Black\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/vitesse-black'))\n  },\n  {\n    \"id\": \"vitesse-dark\",\n    \"displayName\": \"Vitesse Dark\",\n    \"type\": \"dark\",\n    \"import\": (() => import('@shikijs/themes/vitesse-dark'))\n  },\n  {\n    \"id\": \"vitesse-light\",\n    \"displayName\": \"Vitesse Light\",\n    \"type\": \"light\",\n    \"import\": (() => import('@shikijs/themes/vitesse-light'))\n  }\n];\nconst bundledThemes = Object.fromEntries(bundledThemesInfo.map((i) => [i.id, i.import]));\n\nexport { bundledThemes, bundledThemesInfo };\n","class ShikiError extends Error {\n  constructor(message) {\n    super(message);\n    this.name = \"ShikiError\";\n  }\n}\n\nfunction getHeapMax() {\n  return 2147483648;\n}\nfunction _emscripten_get_now() {\n  return typeof performance !== \"undefined\" ? performance.now() : Date.now();\n}\nconst alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;\nasync function main(init) {\n  let wasmMemory;\n  let buffer;\n  const binding = {};\n  function updateGlobalBufferAndViews(buf) {\n    buffer = buf;\n    binding.HEAPU8 = new Uint8Array(buf);\n    binding.HEAPU32 = new Uint32Array(buf);\n  }\n  function _emscripten_memcpy_big(dest, src, num) {\n    binding.HEAPU8.copyWithin(dest, src, src + num);\n  }\n  function emscripten_realloc_buffer(size) {\n    try {\n      wasmMemory.grow(size - buffer.byteLength + 65535 >>> 16);\n      updateGlobalBufferAndViews(wasmMemory.buffer);\n      return 1;\n    } catch {\n    }\n  }\n  function _emscripten_resize_heap(requestedSize) {\n    const oldSize = binding.HEAPU8.length;\n    requestedSize = requestedSize >>> 0;\n    const maxHeapSize = getHeapMax();\n    if (requestedSize > maxHeapSize)\n      return false;\n    for (let cutDown = 1; cutDown <= 4; cutDown *= 2) {\n      let overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);\n      overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);\n      const newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));\n      const replacement = emscripten_realloc_buffer(newSize);\n      if (replacement)\n        return true;\n    }\n    return false;\n  }\n  const UTF8Decoder = typeof TextDecoder != \"undefined\" ? new TextDecoder(\"utf8\") : void 0;\n  function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead = 1024) {\n    const endIdx = idx + maxBytesToRead;\n    let endPtr = idx;\n    while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\n    if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\n      return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\n    }\n    let str = \"\";\n    while (idx < endPtr) {\n      let u0 = heapOrArray[idx++];\n      if (!(u0 & 128)) {\n        str += String.fromCharCode(u0);\n        continue;\n      }\n      const u1 = heapOrArray[idx++] & 63;\n      if ((u0 & 224) === 192) {\n        str += String.fromCharCode((u0 & 31) << 6 | u1);\n        continue;\n      }\n      const u2 = heapOrArray[idx++] & 63;\n      if ((u0 & 240) === 224) {\n        u0 = (u0 & 15) << 12 | u1 << 6 | u2;\n      } else {\n        u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;\n      }\n      if (u0 < 65536) {\n        str += String.fromCharCode(u0);\n      } else {\n        const ch = u0 - 65536;\n        str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);\n      }\n    }\n    return str;\n  }\n  function UTF8ToString(ptr, maxBytesToRead) {\n    return ptr ? UTF8ArrayToString(binding.HEAPU8, ptr, maxBytesToRead) : \"\";\n  }\n  const asmLibraryArg = {\n    emscripten_get_now: _emscripten_get_now,\n    emscripten_memcpy_big: _emscripten_memcpy_big,\n    emscripten_resize_heap: _emscripten_resize_heap,\n    fd_write: () => 0\n  };\n  async function createWasm() {\n    const info = {\n      env: asmLibraryArg,\n      wasi_snapshot_preview1: asmLibraryArg\n    };\n    const exports = await init(info);\n    wasmMemory = exports.memory;\n    updateGlobalBufferAndViews(wasmMemory.buffer);\n    Object.assign(binding, exports);\n    binding.UTF8ToString = UTF8ToString;\n  }\n  await createWasm();\n  return binding;\n}\n\nvar __defProp = Object.defineProperty;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\nlet onigBinding = null;\nfunction throwLastOnigError(onigBinding2) {\n  throw new ShikiError(onigBinding2.UTF8ToString(onigBinding2.getLastOnigError()));\n}\nclass UtfString {\n  constructor(str) {\n    __publicField(this, \"utf16Length\");\n    __publicField(this, \"utf8Length\");\n    __publicField(this, \"utf16Value\");\n    __publicField(this, \"utf8Value\");\n    __publicField(this, \"utf16OffsetToUtf8\");\n    __publicField(this, \"utf8OffsetToUtf16\");\n    const utf16Length = str.length;\n    const utf8Length = UtfString._utf8ByteLength(str);\n    const computeIndicesMapping = utf8Length !== utf16Length;\n    const utf16OffsetToUtf8 = computeIndicesMapping ? new Uint32Array(utf16Length + 1) : null;\n    if (computeIndicesMapping)\n      utf16OffsetToUtf8[utf16Length] = utf8Length;\n    const utf8OffsetToUtf16 = computeIndicesMapping ? new Uint32Array(utf8Length + 1) : null;\n    if (computeIndicesMapping)\n      utf8OffsetToUtf16[utf8Length] = utf16Length;\n    const utf8Value = new Uint8Array(utf8Length);\n    let i8 = 0;\n    for (let i16 = 0; i16 < utf16Length; i16++) {\n      const charCode = str.charCodeAt(i16);\n      let codePoint = charCode;\n      let wasSurrogatePair = false;\n      if (charCode >= 55296 && charCode <= 56319) {\n        if (i16 + 1 < utf16Length) {\n          const nextCharCode = str.charCodeAt(i16 + 1);\n          if (nextCharCode >= 56320 && nextCharCode <= 57343) {\n            codePoint = (charCode - 55296 << 10) + 65536 | nextCharCode - 56320;\n            wasSurrogatePair = true;\n          }\n        }\n      }\n      if (computeIndicesMapping) {\n        utf16OffsetToUtf8[i16] = i8;\n        if (wasSurrogatePair)\n          utf16OffsetToUtf8[i16 + 1] = i8;\n        if (codePoint <= 127) {\n          utf8OffsetToUtf16[i8 + 0] = i16;\n        } else if (codePoint <= 2047) {\n          utf8OffsetToUtf16[i8 + 0] = i16;\n          utf8OffsetToUtf16[i8 + 1] = i16;\n        } else if (codePoint <= 65535) {\n          utf8OffsetToUtf16[i8 + 0] = i16;\n          utf8OffsetToUtf16[i8 + 1] = i16;\n          utf8OffsetToUtf16[i8 + 2] = i16;\n        } else {\n          utf8OffsetToUtf16[i8 + 0] = i16;\n          utf8OffsetToUtf16[i8 + 1] = i16;\n          utf8OffsetToUtf16[i8 + 2] = i16;\n          utf8OffsetToUtf16[i8 + 3] = i16;\n        }\n      }\n      if (codePoint <= 127) {\n        utf8Value[i8++] = codePoint;\n      } else if (codePoint <= 2047) {\n        utf8Value[i8++] = 192 | (codePoint & 1984) >>> 6;\n        utf8Value[i8++] = 128 | (codePoint & 63) >>> 0;\n      } else if (codePoint <= 65535) {\n        utf8Value[i8++] = 224 | (codePoint & 61440) >>> 12;\n        utf8Value[i8++] = 128 | (codePoint & 4032) >>> 6;\n        utf8Value[i8++] = 128 | (codePoint & 63) >>> 0;\n      } else {\n        utf8Value[i8++] = 240 | (codePoint & 1835008) >>> 18;\n        utf8Value[i8++] = 128 | (codePoint & 258048) >>> 12;\n        utf8Value[i8++] = 128 | (codePoint & 4032) >>> 6;\n        utf8Value[i8++] = 128 | (codePoint & 63) >>> 0;\n      }\n      if (wasSurrogatePair)\n        i16++;\n    }\n    this.utf16Length = utf16Length;\n    this.utf8Length = utf8Length;\n    this.utf16Value = str;\n    this.utf8Value = utf8Value;\n    this.utf16OffsetToUtf8 = utf16OffsetToUtf8;\n    this.utf8OffsetToUtf16 = utf8OffsetToUtf16;\n  }\n  static _utf8ByteLength(str) {\n    let result = 0;\n    for (let i = 0, len = str.length; i < len; i++) {\n      const charCode = str.charCodeAt(i);\n      let codepoint = charCode;\n      let wasSurrogatePair = false;\n      if (charCode >= 55296 && charCode <= 56319) {\n        if (i + 1 < len) {\n          const nextCharCode = str.charCodeAt(i + 1);\n          if (nextCharCode >= 56320 && nextCharCode <= 57343) {\n            codepoint = (charCode - 55296 << 10) + 65536 | nextCharCode - 56320;\n            wasSurrogatePair = true;\n          }\n        }\n      }\n      if (codepoint <= 127)\n        result += 1;\n      else if (codepoint <= 2047)\n        result += 2;\n      else if (codepoint <= 65535)\n        result += 3;\n      else\n        result += 4;\n      if (wasSurrogatePair)\n        i++;\n    }\n    return result;\n  }\n  createString(onigBinding2) {\n    const result = onigBinding2.omalloc(this.utf8Length);\n    onigBinding2.HEAPU8.set(this.utf8Value, result);\n    return result;\n  }\n}\nconst _OnigString = class _OnigString {\n  constructor(str) {\n    __publicField(this, \"id\", ++_OnigString.LAST_ID);\n    __publicField(this, \"_onigBinding\");\n    __publicField(this, \"content\");\n    __publicField(this, \"utf16Length\");\n    __publicField(this, \"utf8Length\");\n    __publicField(this, \"utf16OffsetToUtf8\");\n    __publicField(this, \"utf8OffsetToUtf16\");\n    __publicField(this, \"ptr\");\n    if (!onigBinding)\n      throw new ShikiError(\"Must invoke loadWasm first.\");\n    this._onigBinding = onigBinding;\n    this.content = str;\n    const utfString = new UtfString(str);\n    this.utf16Length = utfString.utf16Length;\n    this.utf8Length = utfString.utf8Length;\n    this.utf16OffsetToUtf8 = utfString.utf16OffsetToUtf8;\n    this.utf8OffsetToUtf16 = utfString.utf8OffsetToUtf16;\n    if (this.utf8Length < 1e4 && !_OnigString._sharedPtrInUse) {\n      if (!_OnigString._sharedPtr)\n        _OnigString._sharedPtr = onigBinding.omalloc(1e4);\n      _OnigString._sharedPtrInUse = true;\n      onigBinding.HEAPU8.set(utfString.utf8Value, _OnigString._sharedPtr);\n      this.ptr = _OnigString._sharedPtr;\n    } else {\n      this.ptr = utfString.createString(onigBinding);\n    }\n  }\n  convertUtf8OffsetToUtf16(utf8Offset) {\n    if (this.utf8OffsetToUtf16) {\n      if (utf8Offset < 0)\n        return 0;\n      if (utf8Offset > this.utf8Length)\n        return this.utf16Length;\n      return this.utf8OffsetToUtf16[utf8Offset];\n    }\n    return utf8Offset;\n  }\n  convertUtf16OffsetToUtf8(utf16Offset) {\n    if (this.utf16OffsetToUtf8) {\n      if (utf16Offset < 0)\n        return 0;\n      if (utf16Offset > this.utf16Length)\n        return this.utf8Length;\n      return this.utf16OffsetToUtf8[utf16Offset];\n    }\n    return utf16Offset;\n  }\n  dispose() {\n    if (this.ptr === _OnigString._sharedPtr)\n      _OnigString._sharedPtrInUse = false;\n    else\n      this._onigBinding.ofree(this.ptr);\n  }\n};\n__publicField(_OnigString, \"LAST_ID\", 0);\n__publicField(_OnigString, \"_sharedPtr\", 0);\n// a pointer to a string of 10000 bytes\n__publicField(_OnigString, \"_sharedPtrInUse\", false);\nlet OnigString = _OnigString;\nclass OnigScanner {\n  constructor(patterns) {\n    __publicField(this, \"_onigBinding\");\n    __publicField(this, \"_ptr\");\n    if (!onigBinding)\n      throw new ShikiError(\"Must invoke loadWasm first.\");\n    const strPtrsArr = [];\n    const strLenArr = [];\n    for (let i = 0, len = patterns.length; i < len; i++) {\n      const utfString = new UtfString(patterns[i]);\n      strPtrsArr[i] = utfString.createString(onigBinding);\n      strLenArr[i] = utfString.utf8Length;\n    }\n    const strPtrsPtr = onigBinding.omalloc(4 * patterns.length);\n    onigBinding.HEAPU32.set(strPtrsArr, strPtrsPtr / 4);\n    const strLenPtr = onigBinding.omalloc(4 * patterns.length);\n    onigBinding.HEAPU32.set(strLenArr, strLenPtr / 4);\n    const scannerPtr = onigBinding.createOnigScanner(strPtrsPtr, strLenPtr, patterns.length);\n    for (let i = 0, len = patterns.length; i < len; i++)\n      onigBinding.ofree(strPtrsArr[i]);\n    onigBinding.ofree(strLenPtr);\n    onigBinding.ofree(strPtrsPtr);\n    if (scannerPtr === 0)\n      throwLastOnigError(onigBinding);\n    this._onigBinding = onigBinding;\n    this._ptr = scannerPtr;\n  }\n  dispose() {\n    this._onigBinding.freeOnigScanner(this._ptr);\n  }\n  findNextMatchSync(string, startPosition, arg) {\n    let options = 0 /* None */;\n    if (typeof arg === \"number\") {\n      options = arg;\n    }\n    if (typeof string === \"string\") {\n      string = new OnigString(string);\n      const result = this._findNextMatchSync(string, startPosition, false, options);\n      string.dispose();\n      return result;\n    }\n    return this._findNextMatchSync(string, startPosition, false, options);\n  }\n  _findNextMatchSync(string, startPosition, debugCall, options) {\n    const onigBinding2 = this._onigBinding;\n    const resultPtr = onigBinding2.findNextOnigScannerMatch(this._ptr, string.id, string.ptr, string.utf8Length, string.convertUtf16OffsetToUtf8(startPosition), options);\n    if (resultPtr === 0) {\n      return null;\n    }\n    const HEAPU32 = onigBinding2.HEAPU32;\n    let offset = resultPtr / 4;\n    const index = HEAPU32[offset++];\n    const count = HEAPU32[offset++];\n    const captureIndices = [];\n    for (let i = 0; i < count; i++) {\n      const beg = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);\n      const end = string.convertUtf8OffsetToUtf16(HEAPU32[offset++]);\n      captureIndices[i] = {\n        start: beg,\n        end,\n        length: end - beg\n      };\n    }\n    return {\n      index,\n      captureIndices\n    };\n  }\n}\nfunction isInstantiatorOptionsObject(dataOrOptions) {\n  return typeof dataOrOptions.instantiator === \"function\";\n}\nfunction isInstantiatorModule(dataOrOptions) {\n  return typeof dataOrOptions.default === \"function\";\n}\nfunction isDataOptionsObject(dataOrOptions) {\n  return typeof dataOrOptions.data !== \"undefined\";\n}\nfunction isResponse(dataOrOptions) {\n  return typeof Response !== \"undefined\" && dataOrOptions instanceof Response;\n}\nfunction isArrayBuffer(data) {\n  return typeof ArrayBuffer !== \"undefined\" && (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) || typeof Buffer !== \"undefined\" && Buffer.isBuffer?.(data) || typeof SharedArrayBuffer !== \"undefined\" && data instanceof SharedArrayBuffer || typeof Uint32Array !== \"undefined\" && data instanceof Uint32Array;\n}\nlet initPromise;\nfunction loadWasm(options) {\n  if (initPromise)\n    return initPromise;\n  async function _load() {\n    onigBinding = await main(async (info) => {\n      let instance = options;\n      instance = await instance;\n      if (typeof instance === \"function\")\n        instance = await instance(info);\n      if (typeof instance === \"function\")\n        instance = await instance(info);\n      if (isInstantiatorOptionsObject(instance)) {\n        instance = await instance.instantiator(info);\n      } else if (isInstantiatorModule(instance)) {\n        instance = await instance.default(info);\n      } else {\n        if (isDataOptionsObject(instance))\n          instance = instance.data;\n        if (isResponse(instance)) {\n          if (typeof WebAssembly.instantiateStreaming === \"function\")\n            instance = await _makeResponseStreamingLoader(instance)(info);\n          else\n            instance = await _makeResponseNonStreamingLoader(instance)(info);\n        } else if (isArrayBuffer(instance)) {\n          instance = await _makeArrayBufferLoader(instance)(info);\n        } else if (instance instanceof WebAssembly.Module) {\n          instance = await _makeArrayBufferLoader(instance)(info);\n        } else if (\"default\" in instance && instance.default instanceof WebAssembly.Module) {\n          instance = await _makeArrayBufferLoader(instance.default)(info);\n        }\n      }\n      if (\"instance\" in instance)\n        instance = instance.instance;\n      if (\"exports\" in instance)\n        instance = instance.exports;\n      return instance;\n    });\n  }\n  initPromise = _load();\n  return initPromise;\n}\nfunction _makeArrayBufferLoader(data) {\n  return (importObject) => WebAssembly.instantiate(data, importObject);\n}\nfunction _makeResponseStreamingLoader(data) {\n  return (importObject) => WebAssembly.instantiateStreaming(data, importObject);\n}\nfunction _makeResponseNonStreamingLoader(data) {\n  return async (importObject) => {\n    const arrayBuffer = await data.arrayBuffer();\n    return WebAssembly.instantiate(arrayBuffer, importObject);\n  };\n}\n\nlet _defaultWasmLoader;\nfunction setDefaultWasmLoader(_loader) {\n  _defaultWasmLoader = _loader;\n}\nfunction getDefaultWasmLoader() {\n  return _defaultWasmLoader;\n}\nasync function createOnigurumaEngine(options) {\n  if (options)\n    await loadWasm(options);\n  return {\n    createScanner(patterns) {\n      return new OnigScanner(patterns.map((p) => typeof p === \"string\" ? p : p.source));\n    },\n    createString(s) {\n      return new OnigString(s);\n    }\n  };\n}\n\nexport { createOnigurumaEngine, getDefaultWasmLoader, loadWasm, setDefaultWasmLoader };\n","import { createSingletonShorthands, createdBundledHighlighter, guessEmbeddedLanguages } from '@shikijs/core';\nexport * from '@shikijs/core';\nimport { bundledThemes } from './themes.mjs';\nexport { bundledThemesInfo } from './themes.mjs';\nimport { createOnigurumaEngine } from '@shikijs/engine-oniguruma';\n\nconst bundledLanguagesInfo = [\n  {\n    \"id\": \"angular-html\",\n    \"name\": \"Angular HTML\",\n    \"import\": (() => import('@shikijs/langs/angular-html'))\n  },\n  {\n    \"id\": \"angular-ts\",\n    \"name\": \"Angular TypeScript\",\n    \"import\": (() => import('@shikijs/langs/angular-ts'))\n  },\n  {\n    \"id\": \"astro\",\n    \"name\": \"Astro\",\n    \"import\": (() => import('@shikijs/langs/astro'))\n  },\n  {\n    \"id\": \"blade\",\n    \"name\": \"Blade\",\n    \"import\": (() => import('@shikijs/langs/blade'))\n  },\n  {\n    \"id\": \"c\",\n    \"name\": \"C\",\n    \"import\": (() => import('@shikijs/langs/c'))\n  },\n  {\n    \"id\": \"coffee\",\n    \"name\": \"CoffeeScript\",\n    \"aliases\": [\n      \"coffeescript\"\n    ],\n    \"import\": (() => import('@shikijs/langs/coffee'))\n  },\n  {\n    \"id\": \"cpp\",\n    \"name\": \"C++\",\n    \"aliases\": [\n      \"c++\"\n    ],\n    \"import\": (() => import('@shikijs/langs/cpp'))\n  },\n  {\n    \"id\": \"css\",\n    \"name\": \"CSS\",\n    \"import\": (() => import('@shikijs/langs/css'))\n  },\n  {\n    \"id\": \"csv\",\n    \"name\": \"CSV\",\n    \"import\": (() => import('@shikijs/langs/csv'))\n  },\n  {\n    \"id\": \"glsl\",\n    \"name\": \"GLSL\",\n    \"import\": (() => import('@shikijs/langs/glsl'))\n  },\n  {\n    \"id\": \"graphql\",\n    \"name\": \"GraphQL\",\n    \"aliases\": [\n      \"gql\"\n    ],\n    \"import\": (() => import('@shikijs/langs/graphql'))\n  },\n  {\n    \"id\": \"haml\",\n    \"name\": \"Ruby Haml\",\n    \"import\": (() => import('@shikijs/langs/haml'))\n  },\n  {\n    \"id\": \"handlebars\",\n    \"name\": \"Handlebars\",\n    \"aliases\": [\n      \"hbs\"\n    ],\n    \"import\": (() => import('@shikijs/langs/handlebars'))\n  },\n  {\n    \"id\": \"html\",\n    \"name\": \"HTML\",\n    \"import\": (() => import('@shikijs/langs/html'))\n  },\n  {\n    \"id\": \"html-derivative\",\n    \"name\": \"HTML (Derivative)\",\n    \"import\": (() => import('@shikijs/langs/html-derivative'))\n  },\n  {\n    \"id\": \"http\",\n    \"name\": \"HTTP\",\n    \"import\": (() => import('@shikijs/langs/http'))\n  },\n  {\n    \"id\": \"hurl\",\n    \"name\": \"Hurl\",\n    \"import\": (() => import('@shikijs/langs/hurl'))\n  },\n  {\n    \"id\": \"imba\",\n    \"name\": \"Imba\",\n    \"import\": (() => import('@shikijs/langs/imba'))\n  },\n  {\n    \"id\": \"java\",\n    \"name\": \"Java\",\n    \"import\": (() => import('@shikijs/langs/java'))\n  },\n  {\n    \"id\": \"javascript\",\n    \"name\": \"JavaScript\",\n    \"aliases\": [\n      \"js\",\n      \"cjs\",\n      \"mjs\"\n    ],\n    \"import\": (() => import('@shikijs/langs/javascript'))\n  },\n  {\n    \"id\": \"jinja\",\n    \"name\": \"Jinja\",\n    \"import\": (() => import('@shikijs/langs/jinja'))\n  },\n  {\n    \"id\": \"jison\",\n    \"name\": \"Jison\",\n    \"import\": (() => import('@shikijs/langs/jison'))\n  },\n  {\n    \"id\": \"json\",\n    \"name\": \"JSON\",\n    \"import\": (() => import('@shikijs/langs/json'))\n  },\n  {\n    \"id\": \"json5\",\n    \"name\": \"JSON5\",\n    \"import\": (() => import('@shikijs/langs/json5'))\n  },\n  {\n    \"id\": \"jsonc\",\n    \"name\": \"JSON with Comments\",\n    \"import\": (() => import('@shikijs/langs/jsonc'))\n  },\n  {\n    \"id\": \"jsonl\",\n    \"name\": \"JSON Lines\",\n    \"import\": (() => import('@shikijs/langs/jsonl'))\n  },\n  {\n    \"id\": \"jsx\",\n    \"name\": \"JSX\",\n    \"import\": (() => import('@shikijs/langs/jsx'))\n  },\n  {\n    \"id\": \"julia\",\n    \"name\": \"Julia\",\n    \"aliases\": [\n      \"jl\"\n    ],\n    \"import\": (() => import('@shikijs/langs/julia'))\n  },\n  {\n    \"id\": \"less\",\n    \"name\": \"Less\",\n    \"import\": (() => import('@shikijs/langs/less'))\n  },\n  {\n    \"id\": \"markdown\",\n    \"name\": \"Markdown\",\n    \"aliases\": [\n      \"md\"\n    ],\n    \"import\": (() => import('@shikijs/langs/markdown'))\n  },\n  {\n    \"id\": \"marko\",\n    \"name\": \"Marko\",\n    \"import\": (() => import('@shikijs/langs/marko'))\n  },\n  {\n    \"id\": \"mdc\",\n    \"name\": \"MDC\",\n    \"import\": (() => import('@shikijs/langs/mdc'))\n  },\n  {\n    \"id\": \"mdx\",\n    \"name\": \"MDX\",\n    \"import\": (() => import('@shikijs/langs/mdx'))\n  },\n  {\n    \"id\": \"php\",\n    \"name\": \"PHP\",\n    \"import\": (() => import('@shikijs/langs/php'))\n  },\n  {\n    \"id\": \"postcss\",\n    \"name\": \"PostCSS\",\n    \"import\": (() => import('@shikijs/langs/postcss'))\n  },\n  {\n    \"id\": \"pug\",\n    \"name\": \"Pug\",\n    \"aliases\": [\n      \"jade\"\n    ],\n    \"import\": (() => import('@shikijs/langs/pug'))\n  },\n  {\n    \"id\": \"python\",\n    \"name\": \"Python\",\n    \"aliases\": [\n      \"py\"\n    ],\n    \"import\": (() => import('@shikijs/langs/python'))\n  },\n  {\n    \"id\": \"r\",\n    \"name\": \"R\",\n    \"import\": (() => import('@shikijs/langs/r'))\n  },\n  {\n    \"id\": \"regexp\",\n    \"name\": \"RegExp\",\n    \"aliases\": [\n      \"regex\"\n    ],\n    \"import\": (() => import('@shikijs/langs/regexp'))\n  },\n  {\n    \"id\": \"sass\",\n    \"name\": \"Sass\",\n    \"import\": (() => import('@shikijs/langs/sass'))\n  },\n  {\n    \"id\": \"scss\",\n    \"name\": \"SCSS\",\n    \"import\": (() => import('@shikijs/langs/scss'))\n  },\n  {\n    \"id\": \"shellscript\",\n    \"name\": \"Shell\",\n    \"aliases\": [\n      \"bash\",\n      \"sh\",\n      \"shell\",\n      \"zsh\"\n    ],\n    \"import\": (() => import('@shikijs/langs/shellscript'))\n  },\n  {\n    \"id\": \"sql\",\n    \"name\": \"SQL\",\n    \"import\": (() => import('@shikijs/langs/sql'))\n  },\n  {\n    \"id\": \"stylus\",\n    \"name\": \"Stylus\",\n    \"aliases\": [\n      \"styl\"\n    ],\n    \"import\": (() => import('@shikijs/langs/stylus'))\n  },\n  {\n    \"id\": \"svelte\",\n    \"name\": \"Svelte\",\n    \"import\": (() => import('@shikijs/langs/svelte'))\n  },\n  {\n    \"id\": \"ts-tags\",\n    \"name\": \"TypeScript with Tags\",\n    \"aliases\": [\n      \"lit\"\n    ],\n    \"import\": (() => import('@shikijs/langs/ts-tags'))\n  },\n  {\n    \"id\": \"tsx\",\n    \"name\": \"TSX\",\n    \"import\": (() => import('@shikijs/langs/tsx'))\n  },\n  {\n    \"id\": \"typescript\",\n    \"name\": \"TypeScript\",\n    \"aliases\": [\n      \"ts\",\n      \"cts\",\n      \"mts\"\n    ],\n    \"import\": (() => import('@shikijs/langs/typescript'))\n  },\n  {\n    \"id\": \"vue\",\n    \"name\": \"Vue\",\n    \"import\": (() => import('@shikijs/langs/vue'))\n  },\n  {\n    \"id\": \"vue-html\",\n    \"name\": \"Vue HTML\",\n    \"import\": (() => import('@shikijs/langs/vue-html'))\n  },\n  {\n    \"id\": \"vue-vine\",\n    \"name\": \"Vue Vine\",\n    \"import\": (() => import('@shikijs/langs/vue-vine'))\n  },\n  {\n    \"id\": \"wasm\",\n    \"name\": \"WebAssembly\",\n    \"import\": (() => import('@shikijs/langs/wasm'))\n  },\n  {\n    \"id\": \"wgsl\",\n    \"name\": \"WGSL\",\n    \"import\": (() => import('@shikijs/langs/wgsl'))\n  },\n  {\n    \"id\": \"wit\",\n    \"name\": \"WebAssembly Interface Types\",\n    \"import\": (() => import('@shikijs/langs/wit'))\n  },\n  {\n    \"id\": \"xml\",\n    \"name\": \"XML\",\n    \"import\": (() => import('@shikijs/langs/xml'))\n  },\n  {\n    \"id\": \"yaml\",\n    \"name\": \"YAML\",\n    \"aliases\": [\n      \"yml\"\n    ],\n    \"import\": (() => import('@shikijs/langs/yaml'))\n  }\n];\nconst bundledLanguagesBase = Object.fromEntries(bundledLanguagesInfo.map((i) => [i.id, i.import]));\nconst bundledLanguagesAlias = Object.fromEntries(bundledLanguagesInfo.flatMap((i) => i.aliases?.map((a) => [a, i.import]) || []));\nconst bundledLanguages = {\n  ...bundledLanguagesBase,\n  ...bundledLanguagesAlias\n};\n\nconst createHighlighter = /* @__PURE__ */ createdBundledHighlighter({\n  langs: bundledLanguages,\n  themes: bundledThemes,\n  engine: () => createOnigurumaEngine(import('shiki/wasm'))\n});\nconst {\n  codeToHtml,\n  codeToHast,\n  codeToTokensBase,\n  codeToTokens,\n  codeToTokensWithThemes,\n  getSingletonHighlighter,\n  getLastGrammarState\n} = /* @__PURE__ */ createSingletonShorthands(\n  createHighlighter,\n  { guessEmbeddedLanguages }\n);\n\nexport { bundledLanguages, bundledLanguagesAlias, bundledLanguagesBase, bundledLanguagesInfo, bundledThemes, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighter, getLastGrammarState, getSingletonHighlighter };\n","import type { ShikiTransformer } from \"shiki/bundle/web\";\n\nimport { cacheGlobally } from \"./utils/cache\";\nimport { bundledLanguages, createHighlighter } from \"shiki/bundle/web\";\n\nexport const languages = Object.keys(bundledLanguages);\n\nexport async function getHighlighter(lang: string) {\n  if (!languages.includes(lang) && lang !== \"text\") {\n    console.error(`Language \"${lang}\" is not supported by Shiki.`);\n    lang = \"text\";\n  }\n  return await cacheGlobally(`shiki-${lang}`, async () => {\n    return await createHighlighter({ themes: [\"vitesse-dark\"], langs: [lang] });\n  })();\n}\n\nconst transformers: ShikiTransformer[] = [\n  { pre: (node) => { node.properties.tabindex = \"-1\"; } },\n];\n\nexport async function highlight(lang = \"text\", code: string) {\n  return (await getHighlighter(lang)).codeToHtml(code, { lang, theme: \"vitesse-dark\", transformers });\n}\n","<script lang=\"ts\">\n  import type { Item } from \"$py/notebook/notebook\";\n\n  import { highlight } from \"../highlight\";\n\n  export let code: string;\n  export let lang = \"text\";\n  export let items: Item[] = [];\n\n  code = code.replaceAll(\"\\r\", \"\");\n</script>\n\n<section class=\"relative overflow-y-scroll rounded-md not-prose [&>pre]:!line-height-relaxed\">\n  {#key code}\n    {#await highlight(lang, code)}\n      <pre class=\"text-white/70\">{code}</pre>\n    {:then code}\n      {@html code}\n    {/await}\n  {/key}\n  {#if items.length}\n    <div class=\"m-2 flex flex-col ws-pre-wrap px-1em text-0.8em line-height-relaxed font-mono\">\n      {#each items as { type, text }}\n        {#if type === \"out\"}\n          <div class=\"text-yellow-2\">{text}</div>\n        {/if}\n        {#if type === \"err\"}\n          <div class=\"text-red-4\">{text}</div>\n        {/if}\n        {#if type === \"repr\"}\n          <div class=\"text-cyan-2\">{text}</div>\n        {/if}\n      {/each}\n    </div>\n  {/if}\n</section>\n\n<style>\n  section :global(pre) {\n    --uno: font-mono overflow-x-scroll;\n  }\n\n  section :global(pre *) {\n    --uno: font-mono selection:bg-white/10;\n  }\n</style>\n","<script lang=\"ts\">\n  import type { Node } from \"mdast\";\n\n  import WithCodeActions from \"../reusable/WithCodeActions.svelte\";\n  import CodeBlock from \"$lib/components/CodeBlock.svelte\";\n\n  export let node: Node;\n</script>\n\n<WithCodeActions {node} let:code>\n  <CodeBlock lang={code.lang ?? \"text\"} code={code.value} />\n</WithCodeActions>\n","<script lang=\"ts\">\n  import type { Node, Table } from \"mdast\";\n\n  export let node: Node;\n\n  $: table = node as Table;\n</script>\n\n<table>\n\n  <thead>\n    <tr>\n      {#each table.children[0].children as cell}\n        <th>\n          {#each cell.children as child}\n            <slot {child} />\n          {/each}\n        </th>\n      {/each}\n    </tr>\n  </thead>\n\n  <tbody>\n    {#each table.children.slice(1) as row}\n      <tr>\n        {#each row.children as cell}\n          <td>\n            {#each cell.children as child}\n              <slot {child} />\n            {/each}\n          </td>\n        {/each}\n      </tr>\n    {/each}\n  </tbody>\n\n</table>\n","<script lang=\"ts\">\n  import type { Heading, List, Node, Parent } from \"mdast\";\n  import type { ComponentType } from \"svelte\";\n\n  import Fallback from \"./Fallback.svelte\";\n  import InlineCode from \"./InlineCode.svelte\";\n  import Link from \"./Link.svelte\";\n  import Code from \"./Pre.svelte\";\n  import Table from \"./Table.svelte\";\n\n  export let node: Node;\n\n  export let OverrideCode: ComponentType | null = null;\n  export let codeProps: Record<string, any> = {};\n  export let inlineCodeProps: Record<string, any> = {};\n\n  function getTagName(node: Node) {\n    switch (node.type) {\n      case \"heading\":\n        return `h${(node as Heading).depth}`;\n\n      case \"list\":\n        return (node as List).ordered ? \"ol\" : \"ul\";\n\n      case \"listItem\":\n        return \"li\";\n\n      case \"strong\":\n        return \"strong\";\n\n      case \"emphasis\":\n        return \"em\";\n\n      case \"paragraph\":\n        return \"p\";\n\n      case \"blockquote\":\n        return \"blockquote\";\n\n      default:\n        console.error(node);\n        return null;\n    }\n  }\n\n  $: children = (node as Parent).children;\n\n</script>\n\n{#if node.type === \"root\"}\n\n  {#each children as child}\n    <svelte:self node={child} {OverrideCode} {codeProps} {inlineCodeProps} />\n  {/each}\n\n{:else if node.type === \"code\"}\n\n  <svelte:component this={OverrideCode ?? Code} {node} {...codeProps} />\n\n{:else if node.type === \"inlineCode\"}\n\n  <InlineCode {node} {...inlineCodeProps} />\n\n{:else if node.type === \"link\"}\n\n  <Link {node}>\n    {#each children as child}\n      <svelte:self node={child} {OverrideCode} {codeProps} {inlineCodeProps} />\n    {/each}\n  </Link>\n\n{:else if node.type === \"table\"}\n\n  <Table {node} let:child>\n    <svelte:self node={child} {OverrideCode} {codeProps} {inlineCodeProps} />\n  </Table>\n\n{:else if \"children\" in node && getTagName(node)}\n\n  <svelte:element this={getTagName(node)}>\n    {#each children as child}\n      <svelte:self node={child} {OverrideCode} {codeProps} {inlineCodeProps} />\n    {/each}\n  </svelte:element>\n\n{:else}\n\n  <Fallback {node} />\n\n{/if}\n"],"file":"_app/immutable/chunks/DLK1coIe.mjs"}