From 3be5285488090ab70254b3080e33e64e6c702d2c Mon Sep 17 00:00:00 2001 From: Christoph Cullmann Date: Mon, 15 Jul 2024 22:27:55 +0200 Subject: sync theme --- .../assets/lib/mermaid/createText-f6615236.js | 4929 -------------------- 1 file changed, 4929 deletions(-) delete mode 100644 themes/blowfish/assets/lib/mermaid/createText-f6615236.js (limited to 'themes/blowfish/assets/lib/mermaid/createText-f6615236.js') diff --git a/themes/blowfish/assets/lib/mermaid/createText-f6615236.js b/themes/blowfish/assets/lib/mermaid/createText-f6615236.js deleted file mode 100644 index 2890332..0000000 --- a/themes/blowfish/assets/lib/mermaid/createText-f6615236.js +++ /dev/null @@ -1,4929 +0,0 @@ -import { b8 as dedent, l as log, b7 as decodeEntities } from "./mermaid-c5809711.js"; -const emptyOptions = {}; -function toString(value, options) { - const settings = options || emptyOptions; - const includeImageAlt = typeof settings.includeImageAlt === "boolean" ? settings.includeImageAlt : true; - const includeHtml = typeof settings.includeHtml === "boolean" ? settings.includeHtml : true; - return one(value, includeImageAlt, includeHtml); -} -function one(value, includeImageAlt, includeHtml) { - if (node(value)) { - if ("value" in value) { - return value.type === "html" && !includeHtml ? "" : value.value; - } - if (includeImageAlt && "alt" in value && value.alt) { - return value.alt; - } - if ("children" in value) { - return all(value.children, includeImageAlt, includeHtml); - } - } - if (Array.isArray(value)) { - return all(value, includeImageAlt, includeHtml); - } - return ""; -} -function all(values, includeImageAlt, includeHtml) { - const result = []; - let index2 = -1; - while (++index2 < values.length) { - result[index2] = one(values[index2], includeImageAlt, includeHtml); - } - return result.join(""); -} -function node(value) { - return Boolean(value && typeof value === "object"); -} -function splice(list2, start, remove, items) { - const end = list2.length; - let chunkStart = 0; - let parameters; - if (start < 0) { - start = -start > end ? 0 : end + start; - } else { - start = start > end ? end : start; - } - remove = remove > 0 ? remove : 0; - if (items.length < 1e4) { - parameters = Array.from(items); - parameters.unshift(start, remove); - list2.splice(...parameters); - } else { - if (remove) - list2.splice(start, remove); - while (chunkStart < items.length) { - parameters = items.slice(chunkStart, chunkStart + 1e4); - parameters.unshift(start, 0); - list2.splice(...parameters); - chunkStart += 1e4; - start += 1e4; - } - } -} -function push(list2, items) { - if (list2.length > 0) { - splice(list2, list2.length, 0, items); - return list2; - } - return items; -} -const hasOwnProperty = {}.hasOwnProperty; -function combineExtensions(extensions) { - const all2 = {}; - let index2 = -1; - while (++index2 < extensions.length) { - syntaxExtension(all2, extensions[index2]); - } - return all2; -} -function syntaxExtension(all2, extension2) { - let hook; - for (hook in extension2) { - const maybe = hasOwnProperty.call(all2, hook) ? all2[hook] : void 0; - const left = maybe || (all2[hook] = {}); - const right = extension2[hook]; - let code; - if (right) { - for (code in right) { - if (!hasOwnProperty.call(left, code)) - left[code] = []; - const value = right[code]; - constructs( - // @ts-expect-error Looks like a list. - left[code], - Array.isArray(value) ? value : value ? [value] : [] - ); - } - } - } -} -function constructs(existing, list2) { - let index2 = -1; - const before = []; - while (++index2 < list2.length) { - (list2[index2].add === "after" ? existing : before).push(list2[index2]); - } - splice(existing, 0, 0, before); -} -const unicodePunctuationRegex = /[!-\/:-@\[-`\{-~\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]/; -const asciiAlpha = regexCheck(/[A-Za-z]/); -const asciiAlphanumeric = regexCheck(/[\dA-Za-z]/); -const asciiAtext = regexCheck(/[#-'*+\--9=?A-Z^-~]/); -function asciiControl(code) { - return ( - // Special whitespace codes (which have negative values), C0 and Control - // character DEL - code !== null && (code < 32 || code === 127) - ); -} -const asciiDigit = regexCheck(/\d/); -const asciiHexDigit = regexCheck(/[\dA-Fa-f]/); -const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/); -function markdownLineEnding(code) { - return code !== null && code < -2; -} -function markdownLineEndingOrSpace(code) { - return code !== null && (code < 0 || code === 32); -} -function markdownSpace(code) { - return code === -2 || code === -1 || code === 32; -} -const unicodePunctuation = regexCheck(unicodePunctuationRegex); -const unicodeWhitespace = regexCheck(/\s/); -function regexCheck(regex) { - return check; - function check(code) { - return code !== null && regex.test(String.fromCharCode(code)); - } -} -function factorySpace(effects, ok, type, max) { - const limit = max ? max - 1 : Number.POSITIVE_INFINITY; - let size = 0; - return start; - function start(code) { - if (markdownSpace(code)) { - effects.enter(type); - return prefix(code); - } - return ok(code); - } - function prefix(code) { - if (markdownSpace(code) && size++ < limit) { - effects.consume(code); - return prefix; - } - effects.exit(type); - return ok(code); - } -} -const content$1 = { - tokenize: initializeContent -}; -function initializeContent(effects) { - const contentStart = effects.attempt( - this.parser.constructs.contentInitial, - afterContentStartConstruct, - paragraphInitial - ); - let previous2; - return contentStart; - function afterContentStartConstruct(code) { - if (code === null) { - effects.consume(code); - return; - } - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return factorySpace(effects, contentStart, "linePrefix"); - } - function paragraphInitial(code) { - effects.enter("paragraph"); - return lineStart(code); - } - function lineStart(code) { - const token = effects.enter("chunkText", { - contentType: "text", - previous: previous2 - }); - if (previous2) { - previous2.next = token; - } - previous2 = token; - return data(code); - } - function data(code) { - if (code === null) { - effects.exit("chunkText"); - effects.exit("paragraph"); - effects.consume(code); - return; - } - if (markdownLineEnding(code)) { - effects.consume(code); - effects.exit("chunkText"); - return lineStart; - } - effects.consume(code); - return data; - } -} -const document$2 = { - tokenize: initializeDocument -}; -const containerConstruct = { - tokenize: tokenizeContainer -}; -function initializeDocument(effects) { - const self = this; - const stack = []; - let continued = 0; - let childFlow; - let childToken; - let lineStartOffset; - return start; - function start(code) { - if (continued < stack.length) { - const item = stack[continued]; - self.containerState = item[1]; - return effects.attempt( - item[0].continuation, - documentContinue, - checkNewContainers - )(code); - } - return checkNewContainers(code); - } - function documentContinue(code) { - continued++; - if (self.containerState._closeFlow) { - self.containerState._closeFlow = void 0; - if (childFlow) { - closeFlow(); - } - const indexBeforeExits = self.events.length; - let indexBeforeFlow = indexBeforeExits; - let point2; - while (indexBeforeFlow--) { - if (self.events[indexBeforeFlow][0] === "exit" && self.events[indexBeforeFlow][1].type === "chunkFlow") { - point2 = self.events[indexBeforeFlow][1].end; - break; - } - } - exitContainers(continued); - let index2 = indexBeforeExits; - while (index2 < self.events.length) { - self.events[index2][1].end = Object.assign({}, point2); - index2++; - } - splice( - self.events, - indexBeforeFlow + 1, - 0, - self.events.slice(indexBeforeExits) - ); - self.events.length = index2; - return checkNewContainers(code); - } - return start(code); - } - function checkNewContainers(code) { - if (continued === stack.length) { - if (!childFlow) { - return documentContinued(code); - } - if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) { - return flowStart(code); - } - self.interrupt = Boolean( - childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack - ); - } - self.containerState = {}; - return effects.check( - containerConstruct, - thereIsANewContainer, - thereIsNoNewContainer - )(code); - } - function thereIsANewContainer(code) { - if (childFlow) - closeFlow(); - exitContainers(continued); - return documentContinued(code); - } - function thereIsNoNewContainer(code) { - self.parser.lazy[self.now().line] = continued !== stack.length; - lineStartOffset = self.now().offset; - return flowStart(code); - } - function documentContinued(code) { - self.containerState = {}; - return effects.attempt( - containerConstruct, - containerContinue, - flowStart - )(code); - } - function containerContinue(code) { - continued++; - stack.push([self.currentConstruct, self.containerState]); - return documentContinued(code); - } - function flowStart(code) { - if (code === null) { - if (childFlow) - closeFlow(); - exitContainers(0); - effects.consume(code); - return; - } - childFlow = childFlow || self.parser.flow(self.now()); - effects.enter("chunkFlow", { - contentType: "flow", - previous: childToken, - _tokenizer: childFlow - }); - return flowContinue(code); - } - function flowContinue(code) { - if (code === null) { - writeToChild(effects.exit("chunkFlow"), true); - exitContainers(0); - effects.consume(code); - return; - } - if (markdownLineEnding(code)) { - effects.consume(code); - writeToChild(effects.exit("chunkFlow")); - continued = 0; - self.interrupt = void 0; - return start; - } - effects.consume(code); - return flowContinue; - } - function writeToChild(token, eof) { - const stream = self.sliceStream(token); - if (eof) - stream.push(null); - token.previous = childToken; - if (childToken) - childToken.next = token; - childToken = token; - childFlow.defineSkip(token.start); - childFlow.write(stream); - if (self.parser.lazy[token.start.line]) { - let index2 = childFlow.events.length; - while (index2--) { - if ( - // The token starts before the line ending… - childFlow.events[index2][1].start.offset < lineStartOffset && // …and either is not ended yet… - (!childFlow.events[index2][1].end || // …or ends after it. - childFlow.events[index2][1].end.offset > lineStartOffset) - ) { - return; - } - } - const indexBeforeExits = self.events.length; - let indexBeforeFlow = indexBeforeExits; - let seen; - let point2; - while (indexBeforeFlow--) { - if (self.events[indexBeforeFlow][0] === "exit" && self.events[indexBeforeFlow][1].type === "chunkFlow") { - if (seen) { - point2 = self.events[indexBeforeFlow][1].end; - break; - } - seen = true; - } - } - exitContainers(continued); - index2 = indexBeforeExits; - while (index2 < self.events.length) { - self.events[index2][1].end = Object.assign({}, point2); - index2++; - } - splice( - self.events, - indexBeforeFlow + 1, - 0, - self.events.slice(indexBeforeExits) - ); - self.events.length = index2; - } - } - function exitContainers(size) { - let index2 = stack.length; - while (index2-- > size) { - const entry = stack[index2]; - self.containerState = entry[1]; - entry[0].exit.call(self, effects); - } - stack.length = size; - } - function closeFlow() { - childFlow.write([null]); - childToken = void 0; - childFlow = void 0; - self.containerState._closeFlow = void 0; - } -} -function tokenizeContainer(effects, ok, nok) { - return factorySpace( - effects, - effects.attempt(this.parser.constructs.document, ok, nok), - "linePrefix", - this.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 - ); -} -function classifyCharacter(code) { - if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) { - return 1; - } - if (unicodePunctuation(code)) { - return 2; - } -} -function resolveAll(constructs2, events, context) { - const called = []; - let index2 = -1; - while (++index2 < constructs2.length) { - const resolve = constructs2[index2].resolveAll; - if (resolve && !called.includes(resolve)) { - events = resolve(events, context); - called.push(resolve); - } - } - return events; -} -const attention = { - name: "attention", - tokenize: tokenizeAttention, - resolveAll: resolveAllAttention -}; -function resolveAllAttention(events, context) { - let index2 = -1; - let open; - let group; - let text2; - let openingSequence; - let closingSequence; - let use; - let nextEvents; - let offset; - while (++index2 < events.length) { - if (events[index2][0] === "enter" && events[index2][1].type === "attentionSequence" && events[index2][1]._close) { - open = index2; - while (open--) { - if (events[open][0] === "exit" && events[open][1].type === "attentionSequence" && events[open][1]._open && // If the markers are the same: - context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index2][1]).charCodeAt(0)) { - if ((events[open][1]._close || events[index2][1]._open) && (events[index2][1].end.offset - events[index2][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index2][1].end.offset - events[index2][1].start.offset) % 3)) { - continue; - } - use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index2][1].end.offset - events[index2][1].start.offset > 1 ? 2 : 1; - const start = Object.assign({}, events[open][1].end); - const end = Object.assign({}, events[index2][1].start); - movePoint(start, -use); - movePoint(end, use); - openingSequence = { - type: use > 1 ? "strongSequence" : "emphasisSequence", - start, - end: Object.assign({}, events[open][1].end) - }; - closingSequence = { - type: use > 1 ? "strongSequence" : "emphasisSequence", - start: Object.assign({}, events[index2][1].start), - end - }; - text2 = { - type: use > 1 ? "strongText" : "emphasisText", - start: Object.assign({}, events[open][1].end), - end: Object.assign({}, events[index2][1].start) - }; - group = { - type: use > 1 ? "strong" : "emphasis", - start: Object.assign({}, openingSequence.start), - end: Object.assign({}, closingSequence.end) - }; - events[open][1].end = Object.assign({}, openingSequence.start); - events[index2][1].start = Object.assign({}, closingSequence.end); - nextEvents = []; - if (events[open][1].end.offset - events[open][1].start.offset) { - nextEvents = push(nextEvents, [ - ["enter", events[open][1], context], - ["exit", events[open][1], context] - ]); - } - nextEvents = push(nextEvents, [ - ["enter", group, context], - ["enter", openingSequence, context], - ["exit", openingSequence, context], - ["enter", text2, context] - ]); - nextEvents = push( - nextEvents, - resolveAll( - context.parser.constructs.insideSpan.null, - events.slice(open + 1, index2), - context - ) - ); - nextEvents = push(nextEvents, [ - ["exit", text2, context], - ["enter", closingSequence, context], - ["exit", closingSequence, context], - ["exit", group, context] - ]); - if (events[index2][1].end.offset - events[index2][1].start.offset) { - offset = 2; - nextEvents = push(nextEvents, [ - ["enter", events[index2][1], context], - ["exit", events[index2][1], context] - ]); - } else { - offset = 0; - } - splice(events, open - 1, index2 - open + 3, nextEvents); - index2 = open + nextEvents.length - offset - 2; - break; - } - } - } - } - index2 = -1; - while (++index2 < events.length) { - if (events[index2][1].type === "attentionSequence") { - events[index2][1].type = "data"; - } - } - return events; -} -function tokenizeAttention(effects, ok) { - const attentionMarkers2 = this.parser.constructs.attentionMarkers.null; - const previous2 = this.previous; - const before = classifyCharacter(previous2); - let marker; - return start; - function start(code) { - marker = code; - effects.enter("attentionSequence"); - return inside(code); - } - function inside(code) { - if (code === marker) { - effects.consume(code); - return inside; - } - const token = effects.exit("attentionSequence"); - const after = classifyCharacter(code); - const open = !after || after === 2 && before || attentionMarkers2.includes(code); - const close = !before || before === 2 && after || attentionMarkers2.includes(previous2); - token._open = Boolean(marker === 42 ? open : open && (before || !close)); - token._close = Boolean(marker === 42 ? close : close && (after || !open)); - return ok(code); - } -} -function movePoint(point2, offset) { - point2.column += offset; - point2.offset += offset; - point2._bufferIndex += offset; -} -const autolink = { - name: "autolink", - tokenize: tokenizeAutolink -}; -function tokenizeAutolink(effects, ok, nok) { - let size = 0; - return start; - function start(code) { - effects.enter("autolink"); - effects.enter("autolinkMarker"); - effects.consume(code); - effects.exit("autolinkMarker"); - effects.enter("autolinkProtocol"); - return open; - } - function open(code) { - if (asciiAlpha(code)) { - effects.consume(code); - return schemeOrEmailAtext; - } - return emailAtext(code); - } - function schemeOrEmailAtext(code) { - if (code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) { - size = 1; - return schemeInsideOrEmailAtext(code); - } - return emailAtext(code); - } - function schemeInsideOrEmailAtext(code) { - if (code === 58) { - effects.consume(code); - size = 0; - return urlInside; - } - if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) { - effects.consume(code); - return schemeInsideOrEmailAtext; - } - size = 0; - return emailAtext(code); - } - function urlInside(code) { - if (code === 62) { - effects.exit("autolinkProtocol"); - effects.enter("autolinkMarker"); - effects.consume(code); - effects.exit("autolinkMarker"); - effects.exit("autolink"); - return ok; - } - if (code === null || code === 32 || code === 60 || asciiControl(code)) { - return nok(code); - } - effects.consume(code); - return urlInside; - } - function emailAtext(code) { - if (code === 64) { - effects.consume(code); - return emailAtSignOrDot; - } - if (asciiAtext(code)) { - effects.consume(code); - return emailAtext; - } - return nok(code); - } - function emailAtSignOrDot(code) { - return asciiAlphanumeric(code) ? emailLabel(code) : nok(code); - } - function emailLabel(code) { - if (code === 46) { - effects.consume(code); - size = 0; - return emailAtSignOrDot; - } - if (code === 62) { - effects.exit("autolinkProtocol").type = "autolinkEmail"; - effects.enter("autolinkMarker"); - effects.consume(code); - effects.exit("autolinkMarker"); - effects.exit("autolink"); - return ok; - } - return emailValue(code); - } - function emailValue(code) { - if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) { - const next = code === 45 ? emailValue : emailLabel; - effects.consume(code); - return next; - } - return nok(code); - } -} -const blankLine = { - tokenize: tokenizeBlankLine, - partial: true -}; -function tokenizeBlankLine(effects, ok, nok) { - return start; - function start(code) { - return markdownSpace(code) ? factorySpace(effects, after, "linePrefix")(code) : after(code); - } - function after(code) { - return code === null || markdownLineEnding(code) ? ok(code) : nok(code); - } -} -const blockQuote = { - name: "blockQuote", - tokenize: tokenizeBlockQuoteStart, - continuation: { - tokenize: tokenizeBlockQuoteContinuation - }, - exit -}; -function tokenizeBlockQuoteStart(effects, ok, nok) { - const self = this; - return start; - function start(code) { - if (code === 62) { - const state = self.containerState; - if (!state.open) { - effects.enter("blockQuote", { - _container: true - }); - state.open = true; - } - effects.enter("blockQuotePrefix"); - effects.enter("blockQuoteMarker"); - effects.consume(code); - effects.exit("blockQuoteMarker"); - return after; - } - return nok(code); - } - function after(code) { - if (markdownSpace(code)) { - effects.enter("blockQuotePrefixWhitespace"); - effects.consume(code); - effects.exit("blockQuotePrefixWhitespace"); - effects.exit("blockQuotePrefix"); - return ok; - } - effects.exit("blockQuotePrefix"); - return ok(code); - } -} -function tokenizeBlockQuoteContinuation(effects, ok, nok) { - const self = this; - return contStart; - function contStart(code) { - if (markdownSpace(code)) { - return factorySpace( - effects, - contBefore, - "linePrefix", - self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 - )(code); - } - return contBefore(code); - } - function contBefore(code) { - return effects.attempt(blockQuote, ok, nok)(code); - } -} -function exit(effects) { - effects.exit("blockQuote"); -} -const characterEscape = { - name: "characterEscape", - tokenize: tokenizeCharacterEscape -}; -function tokenizeCharacterEscape(effects, ok, nok) { - return start; - function start(code) { - effects.enter("characterEscape"); - effects.enter("escapeMarker"); - effects.consume(code); - effects.exit("escapeMarker"); - return inside; - } - function inside(code) { - if (asciiPunctuation(code)) { - effects.enter("characterEscapeValue"); - effects.consume(code); - effects.exit("characterEscapeValue"); - effects.exit("characterEscape"); - return ok; - } - return nok(code); - } -} -const element = document.createElement("i"); -function decodeNamedCharacterReference(value) { - const characterReference2 = "&" + value + ";"; - element.innerHTML = characterReference2; - const char = element.textContent; - if (char.charCodeAt(char.length - 1) === 59 && value !== "semi") { - return false; - } - return char === characterReference2 ? false : char; -} -const characterReference = { - name: "characterReference", - tokenize: tokenizeCharacterReference -}; -function tokenizeCharacterReference(effects, ok, nok) { - const self = this; - let size = 0; - let max; - let test; - return start; - function start(code) { - effects.enter("characterReference"); - effects.enter("characterReferenceMarker"); - effects.consume(code); - effects.exit("characterReferenceMarker"); - return open; - } - function open(code) { - if (code === 35) { - effects.enter("characterReferenceMarkerNumeric"); - effects.consume(code); - effects.exit("characterReferenceMarkerNumeric"); - return numeric; - } - effects.enter("characterReferenceValue"); - max = 31; - test = asciiAlphanumeric; - return value(code); - } - function numeric(code) { - if (code === 88 || code === 120) { - effects.enter("characterReferenceMarkerHexadecimal"); - effects.consume(code); - effects.exit("characterReferenceMarkerHexadecimal"); - effects.enter("characterReferenceValue"); - max = 6; - test = asciiHexDigit; - return value; - } - effects.enter("characterReferenceValue"); - max = 7; - test = asciiDigit; - return value(code); - } - function value(code) { - if (code === 59 && size) { - const token = effects.exit("characterReferenceValue"); - if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) { - return nok(code); - } - effects.enter("characterReferenceMarker"); - effects.consume(code); - effects.exit("characterReferenceMarker"); - effects.exit("characterReference"); - return ok; - } - if (test(code) && size++ < max) { - effects.consume(code); - return value; - } - return nok(code); - } -} -const nonLazyContinuation = { - tokenize: tokenizeNonLazyContinuation, - partial: true -}; -const codeFenced = { - name: "codeFenced", - tokenize: tokenizeCodeFenced, - concrete: true -}; -function tokenizeCodeFenced(effects, ok, nok) { - const self = this; - const closeStart = { - tokenize: tokenizeCloseStart, - partial: true - }; - let initialPrefix = 0; - let sizeOpen = 0; - let marker; - return start; - function start(code) { - return beforeSequenceOpen(code); - } - function beforeSequenceOpen(code) { - const tail = self.events[self.events.length - 1]; - initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0; - marker = code; - effects.enter("codeFenced"); - effects.enter("codeFencedFence"); - effects.enter("codeFencedFenceSequence"); - return sequenceOpen(code); - } - function sequenceOpen(code) { - if (code === marker) { - sizeOpen++; - effects.consume(code); - return sequenceOpen; - } - if (sizeOpen < 3) { - return nok(code); - } - effects.exit("codeFencedFenceSequence"); - return markdownSpace(code) ? factorySpace(effects, infoBefore, "whitespace")(code) : infoBefore(code); - } - function infoBefore(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("codeFencedFence"); - return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code); - } - effects.enter("codeFencedFenceInfo"); - effects.enter("chunkString", { - contentType: "string" - }); - return info(code); - } - function info(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("chunkString"); - effects.exit("codeFencedFenceInfo"); - return infoBefore(code); - } - if (markdownSpace(code)) { - effects.exit("chunkString"); - effects.exit("codeFencedFenceInfo"); - return factorySpace(effects, metaBefore, "whitespace")(code); - } - if (code === 96 && code === marker) { - return nok(code); - } - effects.consume(code); - return info; - } - function metaBefore(code) { - if (code === null || markdownLineEnding(code)) { - return infoBefore(code); - } - effects.enter("codeFencedFenceMeta"); - effects.enter("chunkString", { - contentType: "string" - }); - return meta(code); - } - function meta(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("chunkString"); - effects.exit("codeFencedFenceMeta"); - return infoBefore(code); - } - if (code === 96 && code === marker) { - return nok(code); - } - effects.consume(code); - return meta; - } - function atNonLazyBreak(code) { - return effects.attempt(closeStart, after, contentBefore)(code); - } - function contentBefore(code) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return contentStart; - } - function contentStart(code) { - return initialPrefix > 0 && markdownSpace(code) ? factorySpace( - effects, - beforeContentChunk, - "linePrefix", - initialPrefix + 1 - )(code) : beforeContentChunk(code); - } - function beforeContentChunk(code) { - if (code === null || markdownLineEnding(code)) { - return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code); - } - effects.enter("codeFlowValue"); - return contentChunk(code); - } - function contentChunk(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("codeFlowValue"); - return beforeContentChunk(code); - } - effects.consume(code); - return contentChunk; - } - function after(code) { - effects.exit("codeFenced"); - return ok(code); - } - function tokenizeCloseStart(effects2, ok2, nok2) { - let size = 0; - return startBefore; - function startBefore(code) { - effects2.enter("lineEnding"); - effects2.consume(code); - effects2.exit("lineEnding"); - return start2; - } - function start2(code) { - effects2.enter("codeFencedFence"); - return markdownSpace(code) ? factorySpace( - effects2, - beforeSequenceClose, - "linePrefix", - self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 - )(code) : beforeSequenceClose(code); - } - function beforeSequenceClose(code) { - if (code === marker) { - effects2.enter("codeFencedFenceSequence"); - return sequenceClose(code); - } - return nok2(code); - } - function sequenceClose(code) { - if (code === marker) { - size++; - effects2.consume(code); - return sequenceClose; - } - if (size >= sizeOpen) { - effects2.exit("codeFencedFenceSequence"); - return markdownSpace(code) ? factorySpace(effects2, sequenceCloseAfter, "whitespace")(code) : sequenceCloseAfter(code); - } - return nok2(code); - } - function sequenceCloseAfter(code) { - if (code === null || markdownLineEnding(code)) { - effects2.exit("codeFencedFence"); - return ok2(code); - } - return nok2(code); - } - } -} -function tokenizeNonLazyContinuation(effects, ok, nok) { - const self = this; - return start; - function start(code) { - if (code === null) { - return nok(code); - } - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return lineStart; - } - function lineStart(code) { - return self.parser.lazy[self.now().line] ? nok(code) : ok(code); - } -} -const codeIndented = { - name: "codeIndented", - tokenize: tokenizeCodeIndented -}; -const furtherStart = { - tokenize: tokenizeFurtherStart, - partial: true -}; -function tokenizeCodeIndented(effects, ok, nok) { - const self = this; - return start; - function start(code) { - effects.enter("codeIndented"); - return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code); - } - function afterPrefix(code) { - const tail = self.events[self.events.length - 1]; - return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? atBreak(code) : nok(code); - } - function atBreak(code) { - if (code === null) { - return after(code); - } - if (markdownLineEnding(code)) { - return effects.attempt(furtherStart, atBreak, after)(code); - } - effects.enter("codeFlowValue"); - return inside(code); - } - function inside(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("codeFlowValue"); - return atBreak(code); - } - effects.consume(code); - return inside; - } - function after(code) { - effects.exit("codeIndented"); - return ok(code); - } -} -function tokenizeFurtherStart(effects, ok, nok) { - const self = this; - return furtherStart2; - function furtherStart2(code) { - if (self.parser.lazy[self.now().line]) { - return nok(code); - } - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return furtherStart2; - } - return factorySpace(effects, afterPrefix, "linePrefix", 4 + 1)(code); - } - function afterPrefix(code) { - const tail = self.events[self.events.length - 1]; - return tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? furtherStart2(code) : nok(code); - } -} -const codeText = { - name: "codeText", - tokenize: tokenizeCodeText, - resolve: resolveCodeText, - previous -}; -function resolveCodeText(events) { - let tailExitIndex = events.length - 4; - let headEnterIndex = 3; - let index2; - let enter; - if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) { - index2 = headEnterIndex; - while (++index2 < tailExitIndex) { - if (events[index2][1].type === "codeTextData") { - events[headEnterIndex][1].type = "codeTextPadding"; - events[tailExitIndex][1].type = "codeTextPadding"; - headEnterIndex += 2; - tailExitIndex -= 2; - break; - } - } - } - index2 = headEnterIndex - 1; - tailExitIndex++; - while (++index2 <= tailExitIndex) { - if (enter === void 0) { - if (index2 !== tailExitIndex && events[index2][1].type !== "lineEnding") { - enter = index2; - } - } else if (index2 === tailExitIndex || events[index2][1].type === "lineEnding") { - events[enter][1].type = "codeTextData"; - if (index2 !== enter + 2) { - events[enter][1].end = events[index2 - 1][1].end; - events.splice(enter + 2, index2 - enter - 2); - tailExitIndex -= index2 - enter - 2; - index2 = enter + 2; - } - enter = void 0; - } - } - return events; -} -function previous(code) { - return code !== 96 || this.events[this.events.length - 1][1].type === "characterEscape"; -} -function tokenizeCodeText(effects, ok, nok) { - let sizeOpen = 0; - let size; - let token; - return start; - function start(code) { - effects.enter("codeText"); - effects.enter("codeTextSequence"); - return sequenceOpen(code); - } - function sequenceOpen(code) { - if (code === 96) { - effects.consume(code); - sizeOpen++; - return sequenceOpen; - } - effects.exit("codeTextSequence"); - return between(code); - } - function between(code) { - if (code === null) { - return nok(code); - } - if (code === 32) { - effects.enter("space"); - effects.consume(code); - effects.exit("space"); - return between; - } - if (code === 96) { - token = effects.enter("codeTextSequence"); - size = 0; - return sequenceClose(code); - } - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return between; - } - effects.enter("codeTextData"); - return data(code); - } - function data(code) { - if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) { - effects.exit("codeTextData"); - return between(code); - } - effects.consume(code); - return data; - } - function sequenceClose(code) { - if (code === 96) { - effects.consume(code); - size++; - return sequenceClose; - } - if (size === sizeOpen) { - effects.exit("codeTextSequence"); - effects.exit("codeText"); - return ok(code); - } - token.type = "codeTextData"; - return data(code); - } -} -function subtokenize(events) { - const jumps = {}; - let index2 = -1; - let event; - let lineIndex; - let otherIndex; - let otherEvent; - let parameters; - let subevents; - let more; - while (++index2 < events.length) { - while (index2 in jumps) { - index2 = jumps[index2]; - } - event = events[index2]; - if (index2 && event[1].type === "chunkFlow" && events[index2 - 1][1].type === "listItemPrefix") { - subevents = event[1]._tokenizer.events; - otherIndex = 0; - if (otherIndex < subevents.length && subevents[otherIndex][1].type === "lineEndingBlank") { - otherIndex += 2; - } - if (otherIndex < subevents.length && subevents[otherIndex][1].type === "content") { - while (++otherIndex < subevents.length) { - if (subevents[otherIndex][1].type === "content") { - break; - } - if (subevents[otherIndex][1].type === "chunkText") { - subevents[otherIndex][1]._isInFirstContentOfListItem = true; - otherIndex++; - } - } - } - } - if (event[0] === "enter") { - if (event[1].contentType) { - Object.assign(jumps, subcontent(events, index2)); - index2 = jumps[index2]; - more = true; - } - } else if (event[1]._container) { - otherIndex = index2; - lineIndex = void 0; - while (otherIndex--) { - otherEvent = events[otherIndex]; - if (otherEvent[1].type === "lineEnding" || otherEvent[1].type === "lineEndingBlank") { - if (otherEvent[0] === "enter") { - if (lineIndex) { - events[lineIndex][1].type = "lineEndingBlank"; - } - otherEvent[1].type = "lineEnding"; - lineIndex = otherIndex; - } - } else { - break; - } - } - if (lineIndex) { - event[1].end = Object.assign({}, events[lineIndex][1].start); - parameters = events.slice(lineIndex, index2); - parameters.unshift(event); - splice(events, lineIndex, index2 - lineIndex + 1, parameters); - } - } - } - return !more; -} -function subcontent(events, eventIndex) { - const token = events[eventIndex][1]; - const context = events[eventIndex][2]; - let startPosition = eventIndex - 1; - const startPositions = []; - const tokenizer = token._tokenizer || context.parser[token.contentType](token.start); - const childEvents = tokenizer.events; - const jumps = []; - const gaps = {}; - let stream; - let previous2; - let index2 = -1; - let current = token; - let adjust = 0; - let start = 0; - const breaks = [start]; - while (current) { - while (events[++startPosition][1] !== current) { - } - startPositions.push(startPosition); - if (!current._tokenizer) { - stream = context.sliceStream(current); - if (!current.next) { - stream.push(null); - } - if (previous2) { - tokenizer.defineSkip(current.start); - } - if (current._isInFirstContentOfListItem) { - tokenizer._gfmTasklistFirstContentOfListItem = true; - } - tokenizer.write(stream); - if (current._isInFirstContentOfListItem) { - tokenizer._gfmTasklistFirstContentOfListItem = void 0; - } - } - previous2 = current; - current = current.next; - } - current = token; - while (++index2 < childEvents.length) { - if ( - // Find a void token that includes a break. - childEvents[index2][0] === "exit" && childEvents[index2 - 1][0] === "enter" && childEvents[index2][1].type === childEvents[index2 - 1][1].type && childEvents[index2][1].start.line !== childEvents[index2][1].end.line - ) { - start = index2 + 1; - breaks.push(start); - current._tokenizer = void 0; - current.previous = void 0; - current = current.next; - } - } - tokenizer.events = []; - if (current) { - current._tokenizer = void 0; - current.previous = void 0; - } else { - breaks.pop(); - } - index2 = breaks.length; - while (index2--) { - const slice = childEvents.slice(breaks[index2], breaks[index2 + 1]); - const start2 = startPositions.pop(); - jumps.unshift([start2, start2 + slice.length - 1]); - splice(events, start2, 2, slice); - } - index2 = -1; - while (++index2 < jumps.length) { - gaps[adjust + jumps[index2][0]] = adjust + jumps[index2][1]; - adjust += jumps[index2][1] - jumps[index2][0] - 1; - } - return gaps; -} -const content = { - tokenize: tokenizeContent, - resolve: resolveContent -}; -const continuationConstruct = { - tokenize: tokenizeContinuation, - partial: true -}; -function resolveContent(events) { - subtokenize(events); - return events; -} -function tokenizeContent(effects, ok) { - let previous2; - return chunkStart; - function chunkStart(code) { - effects.enter("content"); - previous2 = effects.enter("chunkContent", { - contentType: "content" - }); - return chunkInside(code); - } - function chunkInside(code) { - if (code === null) { - return contentEnd(code); - } - if (markdownLineEnding(code)) { - return effects.check( - continuationConstruct, - contentContinue, - contentEnd - )(code); - } - effects.consume(code); - return chunkInside; - } - function contentEnd(code) { - effects.exit("chunkContent"); - effects.exit("content"); - return ok(code); - } - function contentContinue(code) { - effects.consume(code); - effects.exit("chunkContent"); - previous2.next = effects.enter("chunkContent", { - contentType: "content", - previous: previous2 - }); - previous2 = previous2.next; - return chunkInside; - } -} -function tokenizeContinuation(effects, ok, nok) { - const self = this; - return startLookahead; - function startLookahead(code) { - effects.exit("chunkContent"); - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return factorySpace(effects, prefixed, "linePrefix"); - } - function prefixed(code) { - if (code === null || markdownLineEnding(code)) { - return nok(code); - } - const tail = self.events[self.events.length - 1]; - if (!self.parser.constructs.disable.null.includes("codeIndented") && tail && tail[1].type === "linePrefix" && tail[2].sliceSerialize(tail[1], true).length >= 4) { - return ok(code); - } - return effects.interrupt(self.parser.constructs.flow, nok, ok)(code); - } -} -function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) { - const limit = max || Number.POSITIVE_INFINITY; - let balance = 0; - return start; - function start(code) { - if (code === 60) { - effects.enter(type); - effects.enter(literalType); - effects.enter(literalMarkerType); - effects.consume(code); - effects.exit(literalMarkerType); - return enclosedBefore; - } - if (code === null || code === 32 || code === 41 || asciiControl(code)) { - return nok(code); - } - effects.enter(type); - effects.enter(rawType); - effects.enter(stringType); - effects.enter("chunkString", { - contentType: "string" - }); - return raw(code); - } - function enclosedBefore(code) { - if (code === 62) { - effects.enter(literalMarkerType); - effects.consume(code); - effects.exit(literalMarkerType); - effects.exit(literalType); - effects.exit(type); - return ok; - } - effects.enter(stringType); - effects.enter("chunkString", { - contentType: "string" - }); - return enclosed(code); - } - function enclosed(code) { - if (code === 62) { - effects.exit("chunkString"); - effects.exit(stringType); - return enclosedBefore(code); - } - if (code === null || code === 60 || markdownLineEnding(code)) { - return nok(code); - } - effects.consume(code); - return code === 92 ? enclosedEscape : enclosed; - } - function enclosedEscape(code) { - if (code === 60 || code === 62 || code === 92) { - effects.consume(code); - return enclosed; - } - return enclosed(code); - } - function raw(code) { - if (!balance && (code === null || code === 41 || markdownLineEndingOrSpace(code))) { - effects.exit("chunkString"); - effects.exit(stringType); - effects.exit(rawType); - effects.exit(type); - return ok(code); - } - if (balance < limit && code === 40) { - effects.consume(code); - balance++; - return raw; - } - if (code === 41) { - effects.consume(code); - balance--; - return raw; - } - if (code === null || code === 32 || code === 40 || asciiControl(code)) { - return nok(code); - } - effects.consume(code); - return code === 92 ? rawEscape : raw; - } - function rawEscape(code) { - if (code === 40 || code === 41 || code === 92) { - effects.consume(code); - return raw; - } - return raw(code); - } -} -function factoryLabel(effects, ok, nok, type, markerType, stringType) { - const self = this; - let size = 0; - let seen; - return start; - function start(code) { - effects.enter(type); - effects.enter(markerType); - effects.consume(code); - effects.exit(markerType); - effects.enter(stringType); - return atBreak; - } - function atBreak(code) { - if (size > 999 || code === null || code === 91 || code === 93 && !seen || // To do: remove in the future once we’ve switched from - // `micromark-extension-footnote` to `micromark-extension-gfm-footnote`, - // which doesn’t need this. - // Hidden footnotes hook. - /* c8 ignore next 3 */ - code === 94 && !size && "_hiddenFootnoteSupport" in self.parser.constructs) { - return nok(code); - } - if (code === 93) { - effects.exit(stringType); - effects.enter(markerType); - effects.consume(code); - effects.exit(markerType); - effects.exit(type); - return ok; - } - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return atBreak; - } - effects.enter("chunkString", { - contentType: "string" - }); - return labelInside(code); - } - function labelInside(code) { - if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) { - effects.exit("chunkString"); - return atBreak(code); - } - effects.consume(code); - if (!seen) - seen = !markdownSpace(code); - return code === 92 ? labelEscape : labelInside; - } - function labelEscape(code) { - if (code === 91 || code === 92 || code === 93) { - effects.consume(code); - size++; - return labelInside; - } - return labelInside(code); - } -} -function factoryTitle(effects, ok, nok, type, markerType, stringType) { - let marker; - return start; - function start(code) { - if (code === 34 || code === 39 || code === 40) { - effects.enter(type); - effects.enter(markerType); - effects.consume(code); - effects.exit(markerType); - marker = code === 40 ? 41 : code; - return begin; - } - return nok(code); - } - function begin(code) { - if (code === marker) { - effects.enter(markerType); - effects.consume(code); - effects.exit(markerType); - effects.exit(type); - return ok; - } - effects.enter(stringType); - return atBreak(code); - } - function atBreak(code) { - if (code === marker) { - effects.exit(stringType); - return begin(marker); - } - if (code === null) { - return nok(code); - } - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return factorySpace(effects, atBreak, "linePrefix"); - } - effects.enter("chunkString", { - contentType: "string" - }); - return inside(code); - } - function inside(code) { - if (code === marker || code === null || markdownLineEnding(code)) { - effects.exit("chunkString"); - return atBreak(code); - } - effects.consume(code); - return code === 92 ? escape : inside; - } - function escape(code) { - if (code === marker || code === 92) { - effects.consume(code); - return inside; - } - return inside(code); - } -} -function factoryWhitespace(effects, ok) { - let seen; - return start; - function start(code) { - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - seen = true; - return start; - } - if (markdownSpace(code)) { - return factorySpace( - effects, - start, - seen ? "linePrefix" : "lineSuffix" - )(code); - } - return ok(code); - } -} -function normalizeIdentifier(value) { - return value.replace(/[\t\n\r ]+/g, " ").replace(/^ | $/g, "").toLowerCase().toUpperCase(); -} -const definition = { - name: "definition", - tokenize: tokenizeDefinition -}; -const titleBefore = { - tokenize: tokenizeTitleBefore, - partial: true -}; -function tokenizeDefinition(effects, ok, nok) { - const self = this; - let identifier; - return start; - function start(code) { - effects.enter("definition"); - return before(code); - } - function before(code) { - return factoryLabel.call( - self, - effects, - labelAfter, - // Note: we don’t need to reset the way `markdown-rs` does. - nok, - "definitionLabel", - "definitionLabelMarker", - "definitionLabelString" - )(code); - } - function labelAfter(code) { - identifier = normalizeIdentifier( - self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1) - ); - if (code === 58) { - effects.enter("definitionMarker"); - effects.consume(code); - effects.exit("definitionMarker"); - return markerAfter; - } - return nok(code); - } - function markerAfter(code) { - return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, destinationBefore)(code) : destinationBefore(code); - } - function destinationBefore(code) { - return factoryDestination( - effects, - destinationAfter, - // Note: we don’t need to reset the way `markdown-rs` does. - nok, - "definitionDestination", - "definitionDestinationLiteral", - "definitionDestinationLiteralMarker", - "definitionDestinationRaw", - "definitionDestinationString" - )(code); - } - function destinationAfter(code) { - return effects.attempt(titleBefore, after, after)(code); - } - function after(code) { - return markdownSpace(code) ? factorySpace(effects, afterWhitespace, "whitespace")(code) : afterWhitespace(code); - } - function afterWhitespace(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("definition"); - self.parser.defined.push(identifier); - return ok(code); - } - return nok(code); - } -} -function tokenizeTitleBefore(effects, ok, nok) { - return titleBefore2; - function titleBefore2(code) { - return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, beforeMarker)(code) : nok(code); - } - function beforeMarker(code) { - return factoryTitle( - effects, - titleAfter, - nok, - "definitionTitle", - "definitionTitleMarker", - "definitionTitleString" - )(code); - } - function titleAfter(code) { - return markdownSpace(code) ? factorySpace(effects, titleAfterOptionalWhitespace, "whitespace")(code) : titleAfterOptionalWhitespace(code); - } - function titleAfterOptionalWhitespace(code) { - return code === null || markdownLineEnding(code) ? ok(code) : nok(code); - } -} -const hardBreakEscape = { - name: "hardBreakEscape", - tokenize: tokenizeHardBreakEscape -}; -function tokenizeHardBreakEscape(effects, ok, nok) { - return start; - function start(code) { - effects.enter("hardBreakEscape"); - effects.consume(code); - return after; - } - function after(code) { - if (markdownLineEnding(code)) { - effects.exit("hardBreakEscape"); - return ok(code); - } - return nok(code); - } -} -const headingAtx = { - name: "headingAtx", - tokenize: tokenizeHeadingAtx, - resolve: resolveHeadingAtx -}; -function resolveHeadingAtx(events, context) { - let contentEnd = events.length - 2; - let contentStart = 3; - let content2; - let text2; - if (events[contentStart][1].type === "whitespace") { - contentStart += 2; - } - if (contentEnd - 2 > contentStart && events[contentEnd][1].type === "whitespace") { - contentEnd -= 2; - } - if (events[contentEnd][1].type === "atxHeadingSequence" && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === "whitespace")) { - contentEnd -= contentStart + 1 === contentEnd ? 2 : 4; - } - if (contentEnd > contentStart) { - content2 = { - type: "atxHeadingText", - start: events[contentStart][1].start, - end: events[contentEnd][1].end - }; - text2 = { - type: "chunkText", - start: events[contentStart][1].start, - end: events[contentEnd][1].end, - contentType: "text" - }; - splice(events, contentStart, contentEnd - contentStart + 1, [ - ["enter", content2, context], - ["enter", text2, context], - ["exit", text2, context], - ["exit", content2, context] - ]); - } - return events; -} -function tokenizeHeadingAtx(effects, ok, nok) { - let size = 0; - return start; - function start(code) { - effects.enter("atxHeading"); - return before(code); - } - function before(code) { - effects.enter("atxHeadingSequence"); - return sequenceOpen(code); - } - function sequenceOpen(code) { - if (code === 35 && size++ < 6) { - effects.consume(code); - return sequenceOpen; - } - if (code === null || markdownLineEndingOrSpace(code)) { - effects.exit("atxHeadingSequence"); - return atBreak(code); - } - return nok(code); - } - function atBreak(code) { - if (code === 35) { - effects.enter("atxHeadingSequence"); - return sequenceFurther(code); - } - if (code === null || markdownLineEnding(code)) { - effects.exit("atxHeading"); - return ok(code); - } - if (markdownSpace(code)) { - return factorySpace(effects, atBreak, "whitespace")(code); - } - effects.enter("atxHeadingText"); - return data(code); - } - function sequenceFurther(code) { - if (code === 35) { - effects.consume(code); - return sequenceFurther; - } - effects.exit("atxHeadingSequence"); - return atBreak(code); - } - function data(code) { - if (code === null || code === 35 || markdownLineEndingOrSpace(code)) { - effects.exit("atxHeadingText"); - return atBreak(code); - } - effects.consume(code); - return data; - } -} -const htmlBlockNames = [ - "address", - "article", - "aside", - "base", - "basefont", - "blockquote", - "body", - "caption", - "center", - "col", - "colgroup", - "dd", - "details", - "dialog", - "dir", - "div", - "dl", - "dt", - "fieldset", - "figcaption", - "figure", - "footer", - "form", - "frame", - "frameset", - "h1", - "h2", - "h3", - "h4", - "h5", - "h6", - "head", - "header", - "hr", - "html", - "iframe", - "legend", - "li", - "link", - "main", - "menu", - "menuitem", - "nav", - "noframes", - "ol", - "optgroup", - "option", - "p", - "param", - "search", - "section", - "summary", - "table", - "tbody", - "td", - "tfoot", - "th", - "thead", - "title", - "tr", - "track", - "ul" -]; -const htmlRawNames = ["pre", "script", "style", "textarea"]; -const htmlFlow = { - name: "htmlFlow", - tokenize: tokenizeHtmlFlow, - resolveTo: resolveToHtmlFlow, - concrete: true -}; -const blankLineBefore = { - tokenize: tokenizeBlankLineBefore, - partial: true -}; -const nonLazyContinuationStart = { - tokenize: tokenizeNonLazyContinuationStart, - partial: true -}; -function resolveToHtmlFlow(events) { - let index2 = events.length; - while (index2--) { - if (events[index2][0] === "enter" && events[index2][1].type === "htmlFlow") { - break; - } - } - if (index2 > 1 && events[index2 - 2][1].type === "linePrefix") { - events[index2][1].start = events[index2 - 2][1].start; - events[index2 + 1][1].start = events[index2 - 2][1].start; - events.splice(index2 - 2, 2); - } - return events; -} -function tokenizeHtmlFlow(effects, ok, nok) { - const self = this; - let marker; - let closingTag; - let buffer; - let index2; - let markerB; - return start; - function start(code) { - return before(code); - } - function before(code) { - effects.enter("htmlFlow"); - effects.enter("htmlFlowData"); - effects.consume(code); - return open; - } - function open(code) { - if (code === 33) { - effects.consume(code); - return declarationOpen; - } - if (code === 47) { - effects.consume(code); - closingTag = true; - return tagCloseStart; - } - if (code === 63) { - effects.consume(code); - marker = 3; - return self.interrupt ? ok : continuationDeclarationInside; - } - if (asciiAlpha(code)) { - effects.consume(code); - buffer = String.fromCharCode(code); - return tagName; - } - return nok(code); - } - function declarationOpen(code) { - if (code === 45) { - effects.consume(code); - marker = 2; - return commentOpenInside; - } - if (code === 91) { - effects.consume(code); - marker = 5; - index2 = 0; - return cdataOpenInside; - } - if (asciiAlpha(code)) { - effects.consume(code); - marker = 4; - return self.interrupt ? ok : continuationDeclarationInside; - } - return nok(code); - } - function commentOpenInside(code) { - if (code === 45) { - effects.consume(code); - return self.interrupt ? ok : continuationDeclarationInside; - } - return nok(code); - } - function cdataOpenInside(code) { - const value = "CDATA["; - if (code === value.charCodeAt(index2++)) { - effects.consume(code); - if (index2 === value.length) { - return self.interrupt ? ok : continuation; - } - return cdataOpenInside; - } - return nok(code); - } - function tagCloseStart(code) { - if (asciiAlpha(code)) { - effects.consume(code); - buffer = String.fromCharCode(code); - return tagName; - } - return nok(code); - } - function tagName(code) { - if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { - const slash = code === 47; - const name = buffer.toLowerCase(); - if (!slash && !closingTag && htmlRawNames.includes(name)) { - marker = 1; - return self.interrupt ? ok(code) : continuation(code); - } - if (htmlBlockNames.includes(buffer.toLowerCase())) { - marker = 6; - if (slash) { - effects.consume(code); - return basicSelfClosing; - } - return self.interrupt ? ok(code) : continuation(code); - } - marker = 7; - return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : closingTag ? completeClosingTagAfter(code) : completeAttributeNameBefore(code); - } - if (code === 45 || asciiAlphanumeric(code)) { - effects.consume(code); - buffer += String.fromCharCode(code); - return tagName; - } - return nok(code); - } - function basicSelfClosing(code) { - if (code === 62) { - effects.consume(code); - return self.interrupt ? ok : continuation; - } - return nok(code); - } - function completeClosingTagAfter(code) { - if (markdownSpace(code)) { - effects.consume(code); - return completeClosingTagAfter; - } - return completeEnd(code); - } - function completeAttributeNameBefore(code) { - if (code === 47) { - effects.consume(code); - return completeEnd; - } - if (code === 58 || code === 95 || asciiAlpha(code)) { - effects.consume(code); - return completeAttributeName; - } - if (markdownSpace(code)) { - effects.consume(code); - return completeAttributeNameBefore; - } - return completeEnd(code); - } - function completeAttributeName(code) { - if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) { - effects.consume(code); - return completeAttributeName; - } - return completeAttributeNameAfter(code); - } - function completeAttributeNameAfter(code) { - if (code === 61) { - effects.consume(code); - return completeAttributeValueBefore; - } - if (markdownSpace(code)) { - effects.consume(code); - return completeAttributeNameAfter; - } - return completeAttributeNameBefore(code); - } - function completeAttributeValueBefore(code) { - if (code === null || code === 60 || code === 61 || code === 62 || code === 96) { - return nok(code); - } - if (code === 34 || code === 39) { - effects.consume(code); - markerB = code; - return completeAttributeValueQuoted; - } - if (markdownSpace(code)) { - effects.consume(code); - return completeAttributeValueBefore; - } - return completeAttributeValueUnquoted(code); - } - function completeAttributeValueQuoted(code) { - if (code === markerB) { - effects.consume(code); - markerB = null; - return completeAttributeValueQuotedAfter; - } - if (code === null || markdownLineEnding(code)) { - return nok(code); - } - effects.consume(code); - return completeAttributeValueQuoted; - } - function completeAttributeValueUnquoted(code) { - if (code === null || code === 34 || code === 39 || code === 47 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) { - return completeAttributeNameAfter(code); - } - effects.consume(code); - return completeAttributeValueUnquoted; - } - function completeAttributeValueQuotedAfter(code) { - if (code === 47 || code === 62 || markdownSpace(code)) { - return completeAttributeNameBefore(code); - } - return nok(code); - } - function completeEnd(code) { - if (code === 62) { - effects.consume(code); - return completeAfter; - } - return nok(code); - } - function completeAfter(code) { - if (code === null || markdownLineEnding(code)) { - return continuation(code); - } - if (markdownSpace(code)) { - effects.consume(code); - return completeAfter; - } - return nok(code); - } - function continuation(code) { - if (code === 45 && marker === 2) { - effects.consume(code); - return continuationCommentInside; - } - if (code === 60 && marker === 1) { - effects.consume(code); - return continuationRawTagOpen; - } - if (code === 62 && marker === 4) { - effects.consume(code); - return continuationClose; - } - if (code === 63 && marker === 3) { - effects.consume(code); - return continuationDeclarationInside; - } - if (code === 93 && marker === 5) { - effects.consume(code); - return continuationCdataInside; - } - if (markdownLineEnding(code) && (marker === 6 || marker === 7)) { - effects.exit("htmlFlowData"); - return effects.check( - blankLineBefore, - continuationAfter, - continuationStart - )(code); - } - if (code === null || markdownLineEnding(code)) { - effects.exit("htmlFlowData"); - return continuationStart(code); - } - effects.consume(code); - return continuation; - } - function continuationStart(code) { - return effects.check( - nonLazyContinuationStart, - continuationStartNonLazy, - continuationAfter - )(code); - } - function continuationStartNonLazy(code) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return continuationBefore; - } - function continuationBefore(code) { - if (code === null || markdownLineEnding(code)) { - return continuationStart(code); - } - effects.enter("htmlFlowData"); - return continuation(code); - } - function continuationCommentInside(code) { - if (code === 45) { - effects.consume(code); - return continuationDeclarationInside; - } - return continuation(code); - } - function continuationRawTagOpen(code) { - if (code === 47) { - effects.consume(code); - buffer = ""; - return continuationRawEndTag; - } - return continuation(code); - } - function continuationRawEndTag(code) { - if (code === 62) { - const name = buffer.toLowerCase(); - if (htmlRawNames.includes(name)) { - effects.consume(code); - return continuationClose; - } - return continuation(code); - } - if (asciiAlpha(code) && buffer.length < 8) { - effects.consume(code); - buffer += String.fromCharCode(code); - return continuationRawEndTag; - } - return continuation(code); - } - function continuationCdataInside(code) { - if (code === 93) { - effects.consume(code); - return continuationDeclarationInside; - } - return continuation(code); - } - function continuationDeclarationInside(code) { - if (code === 62) { - effects.consume(code); - return continuationClose; - } - if (code === 45 && marker === 2) { - effects.consume(code); - return continuationDeclarationInside; - } - return continuation(code); - } - function continuationClose(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("htmlFlowData"); - return continuationAfter(code); - } - effects.consume(code); - return continuationClose; - } - function continuationAfter(code) { - effects.exit("htmlFlow"); - return ok(code); - } -} -function tokenizeNonLazyContinuationStart(effects, ok, nok) { - const self = this; - return start; - function start(code) { - if (markdownLineEnding(code)) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return after; - } - return nok(code); - } - function after(code) { - return self.parser.lazy[self.now().line] ? nok(code) : ok(code); - } -} -function tokenizeBlankLineBefore(effects, ok, nok) { - return start; - function start(code) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return effects.attempt(blankLine, ok, nok); - } -} -const htmlText = { - name: "htmlText", - tokenize: tokenizeHtmlText -}; -function tokenizeHtmlText(effects, ok, nok) { - const self = this; - let marker; - let index2; - let returnState; - return start; - function start(code) { - effects.enter("htmlText"); - effects.enter("htmlTextData"); - effects.consume(code); - return open; - } - function open(code) { - if (code === 33) { - effects.consume(code); - return declarationOpen; - } - if (code === 47) { - effects.consume(code); - return tagCloseStart; - } - if (code === 63) { - effects.consume(code); - return instruction; - } - if (asciiAlpha(code)) { - effects.consume(code); - return tagOpen; - } - return nok(code); - } - function declarationOpen(code) { - if (code === 45) { - effects.consume(code); - return commentOpenInside; - } - if (code === 91) { - effects.consume(code); - index2 = 0; - return cdataOpenInside; - } - if (asciiAlpha(code)) { - effects.consume(code); - return declaration; - } - return nok(code); - } - function commentOpenInside(code) { - if (code === 45) { - effects.consume(code); - return commentEnd; - } - return nok(code); - } - function comment(code) { - if (code === null) { - return nok(code); - } - if (code === 45) { - effects.consume(code); - return commentClose; - } - if (markdownLineEnding(code)) { - returnState = comment; - return lineEndingBefore(code); - } - effects.consume(code); - return comment; - } - function commentClose(code) { - if (code === 45) { - effects.consume(code); - return commentEnd; - } - return comment(code); - } - function commentEnd(code) { - return code === 62 ? end(code) : code === 45 ? commentClose(code) : comment(code); - } - function cdataOpenInside(code) { - const value = "CDATA["; - if (code === value.charCodeAt(index2++)) { - effects.consume(code); - return index2 === value.length ? cdata : cdataOpenInside; - } - return nok(code); - } - function cdata(code) { - if (code === null) { - return nok(code); - } - if (code === 93) { - effects.consume(code); - return cdataClose; - } - if (markdownLineEnding(code)) { - returnState = cdata; - return lineEndingBefore(code); - } - effects.consume(code); - return cdata; - } - function cdataClose(code) { - if (code === 93) { - effects.consume(code); - return cdataEnd; - } - return cdata(code); - } - function cdataEnd(code) { - if (code === 62) { - return end(code); - } - if (code === 93) { - effects.consume(code); - return cdataEnd; - } - return cdata(code); - } - function declaration(code) { - if (code === null || code === 62) { - return end(code); - } - if (markdownLineEnding(code)) { - returnState = declaration; - return lineEndingBefore(code); - } - effects.consume(code); - return declaration; - } - function instruction(code) { - if (code === null) { - return nok(code); - } - if (code === 63) { - effects.consume(code); - return instructionClose; - } - if (markdownLineEnding(code)) { - returnState = instruction; - return lineEndingBefore(code); - } - effects.consume(code); - return instruction; - } - function instructionClose(code) { - return code === 62 ? end(code) : instruction(code); - } - function tagCloseStart(code) { - if (asciiAlpha(code)) { - effects.consume(code); - return tagClose; - } - return nok(code); - } - function tagClose(code) { - if (code === 45 || asciiAlphanumeric(code)) { - effects.consume(code); - return tagClose; - } - return tagCloseBetween(code); - } - function tagCloseBetween(code) { - if (markdownLineEnding(code)) { - returnState = tagCloseBetween; - return lineEndingBefore(code); - } - if (markdownSpace(code)) { - effects.consume(code); - return tagCloseBetween; - } - return end(code); - } - function tagOpen(code) { - if (code === 45 || asciiAlphanumeric(code)) { - effects.consume(code); - return tagOpen; - } - if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { - return tagOpenBetween(code); - } - return nok(code); - } - function tagOpenBetween(code) { - if (code === 47) { - effects.consume(code); - return end; - } - if (code === 58 || code === 95 || asciiAlpha(code)) { - effects.consume(code); - return tagOpenAttributeName; - } - if (markdownLineEnding(code)) { - returnState = tagOpenBetween; - return lineEndingBefore(code); - } - if (markdownSpace(code)) { - effects.consume(code); - return tagOpenBetween; - } - return end(code); - } - function tagOpenAttributeName(code) { - if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) { - effects.consume(code); - return tagOpenAttributeName; - } - return tagOpenAttributeNameAfter(code); - } - function tagOpenAttributeNameAfter(code) { - if (code === 61) { - effects.consume(code); - return tagOpenAttributeValueBefore; - } - if (markdownLineEnding(code)) { - returnState = tagOpenAttributeNameAfter; - return lineEndingBefore(code); - } - if (markdownSpace(code)) { - effects.consume(code); - return tagOpenAttributeNameAfter; - } - return tagOpenBetween(code); - } - function tagOpenAttributeValueBefore(code) { - if (code === null || code === 60 || code === 61 || code === 62 || code === 96) { - return nok(code); - } - if (code === 34 || code === 39) { - effects.consume(code); - marker = code; - return tagOpenAttributeValueQuoted; - } - if (markdownLineEnding(code)) { - returnState = tagOpenAttributeValueBefore; - return lineEndingBefore(code); - } - if (markdownSpace(code)) { - effects.consume(code); - return tagOpenAttributeValueBefore; - } - effects.consume(code); - return tagOpenAttributeValueUnquoted; - } - function tagOpenAttributeValueQuoted(code) { - if (code === marker) { - effects.consume(code); - marker = void 0; - return tagOpenAttributeValueQuotedAfter; - } - if (code === null) { - return nok(code); - } - if (markdownLineEnding(code)) { - returnState = tagOpenAttributeValueQuoted; - return lineEndingBefore(code); - } - effects.consume(code); - return tagOpenAttributeValueQuoted; - } - function tagOpenAttributeValueUnquoted(code) { - if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) { - return nok(code); - } - if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { - return tagOpenBetween(code); - } - effects.consume(code); - return tagOpenAttributeValueUnquoted; - } - function tagOpenAttributeValueQuotedAfter(code) { - if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) { - return tagOpenBetween(code); - } - return nok(code); - } - function end(code) { - if (code === 62) { - effects.consume(code); - effects.exit("htmlTextData"); - effects.exit("htmlText"); - return ok; - } - return nok(code); - } - function lineEndingBefore(code) { - effects.exit("htmlTextData"); - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return lineEndingAfter; - } - function lineEndingAfter(code) { - return markdownSpace(code) ? factorySpace( - effects, - lineEndingAfterPrefix, - "linePrefix", - self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 - )(code) : lineEndingAfterPrefix(code); - } - function lineEndingAfterPrefix(code) { - effects.enter("htmlTextData"); - return returnState(code); - } -} -const labelEnd = { - name: "labelEnd", - tokenize: tokenizeLabelEnd, - resolveTo: resolveToLabelEnd, - resolveAll: resolveAllLabelEnd -}; -const resourceConstruct = { - tokenize: tokenizeResource -}; -const referenceFullConstruct = { - tokenize: tokenizeReferenceFull -}; -const referenceCollapsedConstruct = { - tokenize: tokenizeReferenceCollapsed -}; -function resolveAllLabelEnd(events) { - let index2 = -1; - while (++index2 < events.length) { - const token = events[index2][1]; - if (token.type === "labelImage" || token.type === "labelLink" || token.type === "labelEnd") { - events.splice(index2 + 1, token.type === "labelImage" ? 4 : 2); - token.type = "data"; - index2++; - } - } - return events; -} -function resolveToLabelEnd(events, context) { - let index2 = events.length; - let offset = 0; - let token; - let open; - let close; - let media; - while (index2--) { - token = events[index2][1]; - if (open) { - if (token.type === "link" || token.type === "labelLink" && token._inactive) { - break; - } - if (events[index2][0] === "enter" && token.type === "labelLink") { - token._inactive = true; - } - } else if (close) { - if (events[index2][0] === "enter" && (token.type === "labelImage" || token.type === "labelLink") && !token._balanced) { - open = index2; - if (token.type !== "labelLink") { - offset = 2; - break; - } - } - } else if (token.type === "labelEnd") { - close = index2; - } - } - const group = { - type: events[open][1].type === "labelLink" ? "link" : "image", - start: Object.assign({}, events[open][1].start), - end: Object.assign({}, events[events.length - 1][1].end) - }; - const label = { - type: "label", - start: Object.assign({}, events[open][1].start), - end: Object.assign({}, events[close][1].end) - }; - const text2 = { - type: "labelText", - start: Object.assign({}, events[open + offset + 2][1].end), - end: Object.assign({}, events[close - 2][1].start) - }; - media = [ - ["enter", group, context], - ["enter", label, context] - ]; - media = push(media, events.slice(open + 1, open + offset + 3)); - media = push(media, [["enter", text2, context]]); - media = push( - media, - resolveAll( - context.parser.constructs.insideSpan.null, - events.slice(open + offset + 4, close - 3), - context - ) - ); - media = push(media, [ - ["exit", text2, context], - events[close - 2], - events[close - 1], - ["exit", label, context] - ]); - media = push(media, events.slice(close + 1)); - media = push(media, [["exit", group, context]]); - splice(events, open, events.length, media); - return events; -} -function tokenizeLabelEnd(effects, ok, nok) { - const self = this; - let index2 = self.events.length; - let labelStart; - let defined; - while (index2--) { - if ((self.events[index2][1].type === "labelImage" || self.events[index2][1].type === "labelLink") && !self.events[index2][1]._balanced) { - labelStart = self.events[index2][1]; - break; - } - } - return start; - function start(code) { - if (!labelStart) { - return nok(code); - } - if (labelStart._inactive) { - return labelEndNok(code); - } - defined = self.parser.defined.includes( - normalizeIdentifier( - self.sliceSerialize({ - start: labelStart.end, - end: self.now() - }) - ) - ); - effects.enter("labelEnd"); - effects.enter("labelMarker"); - effects.consume(code); - effects.exit("labelMarker"); - effects.exit("labelEnd"); - return after; - } - function after(code) { - if (code === 40) { - return effects.attempt( - resourceConstruct, - labelEndOk, - defined ? labelEndOk : labelEndNok - )(code); - } - if (code === 91) { - return effects.attempt( - referenceFullConstruct, - labelEndOk, - defined ? referenceNotFull : labelEndNok - )(code); - } - return defined ? labelEndOk(code) : labelEndNok(code); - } - function referenceNotFull(code) { - return effects.attempt( - referenceCollapsedConstruct, - labelEndOk, - labelEndNok - )(code); - } - function labelEndOk(code) { - return ok(code); - } - function labelEndNok(code) { - labelStart._balanced = true; - return nok(code); - } -} -function tokenizeResource(effects, ok, nok) { - return resourceStart; - function resourceStart(code) { - effects.enter("resource"); - effects.enter("resourceMarker"); - effects.consume(code); - effects.exit("resourceMarker"); - return resourceBefore; - } - function resourceBefore(code) { - return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceOpen)(code) : resourceOpen(code); - } - function resourceOpen(code) { - if (code === 41) { - return resourceEnd(code); - } - return factoryDestination( - effects, - resourceDestinationAfter, - resourceDestinationMissing, - "resourceDestination", - "resourceDestinationLiteral", - "resourceDestinationLiteralMarker", - "resourceDestinationRaw", - "resourceDestinationString", - 32 - )(code); - } - function resourceDestinationAfter(code) { - return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceBetween)(code) : resourceEnd(code); - } - function resourceDestinationMissing(code) { - return nok(code); - } - function resourceBetween(code) { - if (code === 34 || code === 39 || code === 40) { - return factoryTitle( - effects, - resourceTitleAfter, - nok, - "resourceTitle", - "resourceTitleMarker", - "resourceTitleString" - )(code); - } - return resourceEnd(code); - } - function resourceTitleAfter(code) { - return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, resourceEnd)(code) : resourceEnd(code); - } - function resourceEnd(code) { - if (code === 41) { - effects.enter("resourceMarker"); - effects.consume(code); - effects.exit("resourceMarker"); - effects.exit("resource"); - return ok; - } - return nok(code); - } -} -function tokenizeReferenceFull(effects, ok, nok) { - const self = this; - return referenceFull; - function referenceFull(code) { - return factoryLabel.call( - self, - effects, - referenceFullAfter, - referenceFullMissing, - "reference", - "referenceMarker", - "referenceString" - )(code); - } - function referenceFullAfter(code) { - return self.parser.defined.includes( - normalizeIdentifier( - self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1) - ) - ) ? ok(code) : nok(code); - } - function referenceFullMissing(code) { - return nok(code); - } -} -function tokenizeReferenceCollapsed(effects, ok, nok) { - return referenceCollapsedStart; - function referenceCollapsedStart(code) { - effects.enter("reference"); - effects.enter("referenceMarker"); - effects.consume(code); - effects.exit("referenceMarker"); - return referenceCollapsedOpen; - } - function referenceCollapsedOpen(code) { - if (code === 93) { - effects.enter("referenceMarker"); - effects.consume(code); - effects.exit("referenceMarker"); - effects.exit("reference"); - return ok; - } - return nok(code); - } -} -const labelStartImage = { - name: "labelStartImage", - tokenize: tokenizeLabelStartImage, - resolveAll: labelEnd.resolveAll -}; -function tokenizeLabelStartImage(effects, ok, nok) { - const self = this; - return start; - function start(code) { - effects.enter("labelImage"); - effects.enter("labelImageMarker"); - effects.consume(code); - effects.exit("labelImageMarker"); - return open; - } - function open(code) { - if (code === 91) { - effects.enter("labelMarker"); - effects.consume(code); - effects.exit("labelMarker"); - effects.exit("labelImage"); - return after; - } - return nok(code); - } - function after(code) { - return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code); - } -} -const labelStartLink = { - name: "labelStartLink", - tokenize: tokenizeLabelStartLink, - resolveAll: labelEnd.resolveAll -}; -function tokenizeLabelStartLink(effects, ok, nok) { - const self = this; - return start; - function start(code) { - effects.enter("labelLink"); - effects.enter("labelMarker"); - effects.consume(code); - effects.exit("labelMarker"); - effects.exit("labelLink"); - return after; - } - function after(code) { - return code === 94 && "_hiddenFootnoteSupport" in self.parser.constructs ? nok(code) : ok(code); - } -} -const lineEnding = { - name: "lineEnding", - tokenize: tokenizeLineEnding -}; -function tokenizeLineEnding(effects, ok) { - return start; - function start(code) { - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - return factorySpace(effects, ok, "linePrefix"); - } -} -const thematicBreak = { - name: "thematicBreak", - tokenize: tokenizeThematicBreak -}; -function tokenizeThematicBreak(effects, ok, nok) { - let size = 0; - let marker; - return start; - function start(code) { - effects.enter("thematicBreak"); - return before(code); - } - function before(code) { - marker = code; - return atBreak(code); - } - function atBreak(code) { - if (code === marker) { - effects.enter("thematicBreakSequence"); - return sequence(code); - } - if (size >= 3 && (code === null || markdownLineEnding(code))) { - effects.exit("thematicBreak"); - return ok(code); - } - return nok(code); - } - function sequence(code) { - if (code === marker) { - effects.consume(code); - size++; - return sequence; - } - effects.exit("thematicBreakSequence"); - return markdownSpace(code) ? factorySpace(effects, atBreak, "whitespace")(code) : atBreak(code); - } -} -const list = { - name: "list", - tokenize: tokenizeListStart, - continuation: { - tokenize: tokenizeListContinuation - }, - exit: tokenizeListEnd -}; -const listItemPrefixWhitespaceConstruct = { - tokenize: tokenizeListItemPrefixWhitespace, - partial: true -}; -const indentConstruct = { - tokenize: tokenizeIndent, - partial: true -}; -function tokenizeListStart(effects, ok, nok) { - const self = this; - const tail = self.events[self.events.length - 1]; - let initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0; - let size = 0; - return start; - function start(code) { - const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? "listUnordered" : "listOrdered"); - if (kind === "listUnordered" ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) { - if (!self.containerState.type) { - self.containerState.type = kind; - effects.enter(kind, { - _container: true - }); - } - if (kind === "listUnordered") { - effects.enter("listItemPrefix"); - return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code); - } - if (!self.interrupt || code === 49) { - effects.enter("listItemPrefix"); - effects.enter("listItemValue"); - return inside(code); - } - } - return nok(code); - } - function inside(code) { - if (asciiDigit(code) && ++size < 10) { - effects.consume(code); - return inside; - } - if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) { - effects.exit("listItemValue"); - return atMarker(code); - } - return nok(code); - } - function atMarker(code) { - effects.enter("listItemMarker"); - effects.consume(code); - effects.exit("listItemMarker"); - self.containerState.marker = self.containerState.marker || code; - return effects.check( - blankLine, - // Can’t be empty when interrupting. - self.interrupt ? nok : onBlank, - effects.attempt( - listItemPrefixWhitespaceConstruct, - endOfPrefix, - otherPrefix - ) - ); - } - function onBlank(code) { - self.containerState.initialBlankLine = true; - initialSize++; - return endOfPrefix(code); - } - function otherPrefix(code) { - if (markdownSpace(code)) { - effects.enter("listItemPrefixWhitespace"); - effects.consume(code); - effects.exit("listItemPrefixWhitespace"); - return endOfPrefix; - } - return nok(code); - } - function endOfPrefix(code) { - self.containerState.size = initialSize + self.sliceSerialize(effects.exit("listItemPrefix"), true).length; - return ok(code); - } -} -function tokenizeListContinuation(effects, ok, nok) { - const self = this; - self.containerState._closeFlow = void 0; - return effects.check(blankLine, onBlank, notBlank); - function onBlank(code) { - self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; - return factorySpace( - effects, - ok, - "listItemIndent", - self.containerState.size + 1 - )(code); - } - function notBlank(code) { - if (self.containerState.furtherBlankLines || !markdownSpace(code)) { - self.containerState.furtherBlankLines = void 0; - self.containerState.initialBlankLine = void 0; - return notInCurrentItem(code); - } - self.containerState.furtherBlankLines = void 0; - self.containerState.initialBlankLine = void 0; - return effects.attempt(indentConstruct, ok, notInCurrentItem)(code); - } - function notInCurrentItem(code) { - self.containerState._closeFlow = true; - self.interrupt = void 0; - return factorySpace( - effects, - effects.attempt(list, ok, nok), - "linePrefix", - self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 - )(code); - } -} -function tokenizeIndent(effects, ok, nok) { - const self = this; - return factorySpace( - effects, - afterPrefix, - "listItemIndent", - self.containerState.size + 1 - ); - function afterPrefix(code) { - const tail = self.events[self.events.length - 1]; - return tail && tail[1].type === "listItemIndent" && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code); - } -} -function tokenizeListEnd(effects) { - effects.exit(this.containerState.type); -} -function tokenizeListItemPrefixWhitespace(effects, ok, nok) { - const self = this; - return factorySpace( - effects, - afterPrefix, - "listItemPrefixWhitespace", - self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4 + 1 - ); - function afterPrefix(code) { - const tail = self.events[self.events.length - 1]; - return !markdownSpace(code) && tail && tail[1].type === "listItemPrefixWhitespace" ? ok(code) : nok(code); - } -} -const setextUnderline = { - name: "setextUnderline", - tokenize: tokenizeSetextUnderline, - resolveTo: resolveToSetextUnderline -}; -function resolveToSetextUnderline(events, context) { - let index2 = events.length; - let content2; - let text2; - let definition2; - while (index2--) { - if (events[index2][0] === "enter") { - if (events[index2][1].type === "content") { - content2 = index2; - break; - } - if (events[index2][1].type === "paragraph") { - text2 = index2; - } - } else { - if (events[index2][1].type === "content") { - events.splice(index2, 1); - } - if (!definition2 && events[index2][1].type === "definition") { - definition2 = index2; - } - } - } - const heading = { - type: "setextHeading", - start: Object.assign({}, events[text2][1].start), - end: Object.assign({}, events[events.length - 1][1].end) - }; - events[text2][1].type = "setextHeadingText"; - if (definition2) { - events.splice(text2, 0, ["enter", heading, context]); - events.splice(definition2 + 1, 0, ["exit", events[content2][1], context]); - events[content2][1].end = Object.assign({}, events[definition2][1].end); - } else { - events[content2][1] = heading; - } - events.push(["exit", heading, context]); - return events; -} -function tokenizeSetextUnderline(effects, ok, nok) { - const self = this; - let marker; - return start; - function start(code) { - let index2 = self.events.length; - let paragraph; - while (index2--) { - if (self.events[index2][1].type !== "lineEnding" && self.events[index2][1].type !== "linePrefix" && self.events[index2][1].type !== "content") { - paragraph = self.events[index2][1].type === "paragraph"; - break; - } - } - if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) { - effects.enter("setextHeadingLine"); - marker = code; - return before(code); - } - return nok(code); - } - function before(code) { - effects.enter("setextHeadingLineSequence"); - return inside(code); - } - function inside(code) { - if (code === marker) { - effects.consume(code); - return inside; - } - effects.exit("setextHeadingLineSequence"); - return markdownSpace(code) ? factorySpace(effects, after, "lineSuffix")(code) : after(code); - } - function after(code) { - if (code === null || markdownLineEnding(code)) { - effects.exit("setextHeadingLine"); - return ok(code); - } - return nok(code); - } -} -const flow$1 = { - tokenize: initializeFlow -}; -function initializeFlow(effects) { - const self = this; - const initial = effects.attempt( - // Try to parse a blank line. - blankLine, - atBlankEnding, - // Try to parse initial flow (essentially, only code). - effects.attempt( - this.parser.constructs.flowInitial, - afterConstruct, - factorySpace( - effects, - effects.attempt( - this.parser.constructs.flow, - afterConstruct, - effects.attempt(content, afterConstruct) - ), - "linePrefix" - ) - ) - ); - return initial; - function atBlankEnding(code) { - if (code === null) { - effects.consume(code); - return; - } - effects.enter("lineEndingBlank"); - effects.consume(code); - effects.exit("lineEndingBlank"); - self.currentConstruct = void 0; - return initial; - } - function afterConstruct(code) { - if (code === null) { - effects.consume(code); - return; - } - effects.enter("lineEnding"); - effects.consume(code); - effects.exit("lineEnding"); - self.currentConstruct = void 0; - return initial; - } -} -const resolver = { - resolveAll: createResolver() -}; -const string$1 = initializeFactory("string"); -const text$1 = initializeFactory("text"); -function initializeFactory(field) { - return { - tokenize: initializeText, - resolveAll: createResolver( - field === "text" ? resolveAllLineSuffixes : void 0 - ) - }; - function initializeText(effects) { - const self = this; - const constructs2 = this.parser.constructs[field]; - const text2 = effects.attempt(constructs2, start, notText); - return start; - function start(code) { - return atBreak(code) ? text2(code) : notText(code); - } - function notText(code) { - if (code === null) { - effects.consume(code); - return; - } - effects.enter("data"); - effects.consume(code); - return data; - } - function data(code) { - if (atBreak(code)) { - effects.exit("data"); - return text2(code); - } - effects.consume(code); - return data; - } - function atBreak(code) { - if (code === null) { - return true; - } - const list2 = constructs2[code]; - let index2 = -1; - if (list2) { - while (++index2 < list2.length) { - const item = list2[index2]; - if (!item.previous || item.previous.call(self, self.previous)) { - return true; - } - } - } - return false; - } - } -} -function createResolver(extraResolver) { - return resolveAllText; - function resolveAllText(events, context) { - let index2 = -1; - let enter; - while (++index2 <= events.length) { - if (enter === void 0) { - if (events[index2] && events[index2][1].type === "data") { - enter = index2; - index2++; - } - } else if (!events[index2] || events[index2][1].type !== "data") { - if (index2 !== enter + 2) { - events[enter][1].end = events[index2 - 1][1].end; - events.splice(enter + 2, index2 - enter - 2); - index2 = enter + 2; - } - enter = void 0; - } - } - return extraResolver ? extraResolver(events, context) : events; - } -} -function resolveAllLineSuffixes(events, context) { - let eventIndex = 0; - while (++eventIndex <= events.length) { - if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") { - const data = events[eventIndex - 1][1]; - const chunks = context.sliceStream(data); - let index2 = chunks.length; - let bufferIndex = -1; - let size = 0; - let tabs; - while (index2--) { - const chunk = chunks[index2]; - if (typeof chunk === "string") { - bufferIndex = chunk.length; - while (chunk.charCodeAt(bufferIndex - 1) === 32) { - size++; - bufferIndex--; - } - if (bufferIndex) - break; - bufferIndex = -1; - } else if (chunk === -2) { - tabs = true; - size++; - } else if (chunk === -1) - ; - else { - index2++; - break; - } - } - if (size) { - const token = { - type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing", - start: { - line: data.end.line, - column: data.end.column - size, - offset: data.end.offset - size, - _index: data.start._index + index2, - _bufferIndex: index2 ? bufferIndex : data.start._bufferIndex + bufferIndex - }, - end: Object.assign({}, data.end) - }; - data.end = Object.assign({}, token.start); - if (data.start.offset === data.end.offset) { - Object.assign(data, token); - } else { - events.splice( - eventIndex, - 0, - ["enter", token, context], - ["exit", token, context] - ); - eventIndex += 2; - } - } - eventIndex++; - } - } - return events; -} -function createTokenizer(parser, initialize, from) { - let point2 = Object.assign( - from ? Object.assign({}, from) : { - line: 1, - column: 1, - offset: 0 - }, - { - _index: 0, - _bufferIndex: -1 - } - ); - const columnStart = {}; - const resolveAllConstructs = []; - let chunks = []; - let stack = []; - const effects = { - consume, - enter, - exit: exit2, - attempt: constructFactory(onsuccessfulconstruct), - check: constructFactory(onsuccessfulcheck), - interrupt: constructFactory(onsuccessfulcheck, { - interrupt: true - }) - }; - const context = { - previous: null, - code: null, - containerState: {}, - events: [], - parser, - sliceStream, - sliceSerialize, - now, - defineSkip, - write - }; - let state = initialize.tokenize.call(context, effects); - if (initialize.resolveAll) { - resolveAllConstructs.push(initialize); - } - return context; - function write(slice) { - chunks = push(chunks, slice); - main(); - if (chunks[chunks.length - 1] !== null) { - return []; - } - addResult(initialize, 0); - context.events = resolveAll(resolveAllConstructs, context.events, context); - return context.events; - } - function sliceSerialize(token, expandTabs) { - return serializeChunks(sliceStream(token), expandTabs); - } - function sliceStream(token) { - return sliceChunks(chunks, token); - } - function now() { - const { line, column, offset, _index, _bufferIndex } = point2; - return { - line, - column, - offset, - _index, - _bufferIndex - }; - } - function defineSkip(value) { - columnStart[value.line] = value.column; - accountForPotentialSkip(); - } - function main() { - let chunkIndex; - while (point2._index < chunks.length) { - const chunk = chunks[point2._index]; - if (typeof chunk === "string") { - chunkIndex = point2._index; - if (point2._bufferIndex < 0) { - point2._bufferIndex = 0; - } - while (point2._index === chunkIndex && point2._bufferIndex < chunk.length) { - go(chunk.charCodeAt(point2._bufferIndex)); - } - } else { - go(chunk); - } - } - } - function go(code) { - state = state(code); - } - function consume(code) { - if (markdownLineEnding(code)) { - point2.line++; - point2.column = 1; - point2.offset += code === -3 ? 2 : 1; - accountForPotentialSkip(); - } else if (code !== -1) { - point2.column++; - point2.offset++; - } - if (point2._bufferIndex < 0) { - point2._index++; - } else { - point2._bufferIndex++; - if (point2._bufferIndex === chunks[point2._index].length) { - point2._bufferIndex = -1; - point2._index++; - } - } - context.previous = code; - } - function enter(type, fields) { - const token = fields || {}; - token.type = type; - token.start = now(); - context.events.push(["enter", token, context]); - stack.push(token); - return token; - } - function exit2(type) { - const token = stack.pop(); - token.end = now(); - context.events.push(["exit", token, context]); - return token; - } - function onsuccessfulconstruct(construct, info) { - addResult(construct, info.from); - } - function onsuccessfulcheck(_, info) { - info.restore(); - } - function constructFactory(onreturn, fields) { - return hook; - function hook(constructs2, returnState, bogusState) { - let listOfConstructs; - let constructIndex; - let currentConstruct; - let info; - return Array.isArray(constructs2) ? handleListOfConstructs(constructs2) : "tokenize" in constructs2 ? ( - // @ts-expect-error Looks like a construct. - handleListOfConstructs([constructs2]) - ) : handleMapOfConstructs(constructs2); - function handleMapOfConstructs(map) { - return start; - function start(code) { - const def = code !== null && map[code]; - const all2 = code !== null && map.null; - const list2 = [ - // To do: add more extension tests. - /* c8 ignore next 2 */ - ...Array.isArray(def) ? def : def ? [def] : [], - ...Array.isArray(all2) ? all2 : all2 ? [all2] : [] - ]; - return handleListOfConstructs(list2)(code); - } - } - function handleListOfConstructs(list2) { - listOfConstructs = list2; - constructIndex = 0; - if (list2.length === 0) { - return bogusState; - } - return handleConstruct(list2[constructIndex]); - } - function handleConstruct(construct) { - return start; - function start(code) { - info = store(); - currentConstruct = construct; - if (!construct.partial) { - context.currentConstruct = construct; - } - if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) { - return nok(); - } - return construct.tokenize.call( - // If we do have fields, create an object w/ `context` as its - // prototype. - // This allows a “live binding”, which is needed for `interrupt`. - fields ? Object.assign(Object.create(context), fields) : context, - effects, - ok, - nok - )(code); - } - } - function ok(code) { - onreturn(currentConstruct, info); - return returnState; - } - function nok(code) { - info.restore(); - if (++constructIndex < listOfConstructs.length) { - return handleConstruct(listOfConstructs[constructIndex]); - } - return bogusState; - } - } - } - function addResult(construct, from2) { - if (construct.resolveAll && !resolveAllConstructs.includes(construct)) { - resolveAllConstructs.push(construct); - } - if (construct.resolve) { - splice( - context.events, - from2, - context.events.length - from2, - construct.resolve(context.events.slice(from2), context) - ); - } - if (construct.resolveTo) { - context.events = construct.resolveTo(context.events, context); - } - } - function store() { - const startPoint = now(); - const startPrevious = context.previous; - const startCurrentConstruct = context.currentConstruct; - const startEventsIndex = context.events.length; - const startStack = Array.from(stack); - return { - restore, - from: startEventsIndex - }; - function restore() { - point2 = startPoint; - context.previous = startPrevious; - context.currentConstruct = startCurrentConstruct; - context.events.length = startEventsIndex; - stack = startStack; - accountForPotentialSkip(); - } - } - function accountForPotentialSkip() { - if (point2.line in columnStart && point2.column < 2) { - point2.column = columnStart[point2.line]; - point2.offset += columnStart[point2.line] - 1; - } - } -} -function sliceChunks(chunks, token) { - const startIndex = token.start._index; - const startBufferIndex = token.start._bufferIndex; - const endIndex = token.end._index; - const endBufferIndex = token.end._bufferIndex; - let view; - if (startIndex === endIndex) { - view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)]; - } else { - view = chunks.slice(startIndex, endIndex); - if (startBufferIndex > -1) { - const head = view[0]; - if (typeof head === "string") { - view[0] = head.slice(startBufferIndex); - } else { - view.shift(); - } - } - if (endBufferIndex > 0) { - view.push(chunks[endIndex].slice(0, endBufferIndex)); - } - } - return view; -} -function serializeChunks(chunks, expandTabs) { - let index2 = -1; - const result = []; - let atTab; - while (++index2 < chunks.length) { - const chunk = chunks[index2]; - let value; - if (typeof chunk === "string") { - value = chunk; - } else - switch (chunk) { - case -5: { - value = "\r"; - break; - } - case -4: { - value = "\n"; - break; - } - case -3: { - value = "\r\n"; - break; - } - case -2: { - value = expandTabs ? " " : " "; - break; - } - case -1: { - if (!expandTabs && atTab) - continue; - value = " "; - break; - } - default: { - value = String.fromCharCode(chunk); - } - } - atTab = chunk === -2; - result.push(value); - } - return result.join(""); -} -const document$1 = { - [42]: list, - [43]: list, - [45]: list, - [48]: list, - [49]: list, - [50]: list, - [51]: list, - [52]: list, - [53]: list, - [54]: list, - [55]: list, - [56]: list, - [57]: list, - [62]: blockQuote -}; -const contentInitial = { - [91]: definition -}; -const flowInitial = { - [-2]: codeIndented, - [-1]: codeIndented, - [32]: codeIndented -}; -const flow = { - [35]: headingAtx, - [42]: thematicBreak, - [45]: [setextUnderline, thematicBreak], - [60]: htmlFlow, - [61]: setextUnderline, - [95]: thematicBreak, - [96]: codeFenced, - [126]: codeFenced -}; -const string = { - [38]: characterReference, - [92]: characterEscape -}; -const text = { - [-5]: lineEnding, - [-4]: lineEnding, - [-3]: lineEnding, - [33]: labelStartImage, - [38]: characterReference, - [42]: attention, - [60]: [autolink, htmlText], - [91]: labelStartLink, - [92]: [hardBreakEscape, characterEscape], - [93]: labelEnd, - [95]: attention, - [96]: codeText -}; -const insideSpan = { - null: [attention, resolver] -}; -const attentionMarkers = { - null: [42, 95] -}; -const disable = { - null: [] -}; -const defaultConstructs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ - __proto__: null, - attentionMarkers, - contentInitial, - disable, - document: document$1, - flow, - flowInitial, - insideSpan, - string, - text -}, Symbol.toStringTag, { value: "Module" })); -function parse(options) { - const settings = options || {}; - const constructs2 = ( - /** @type {FullNormalizedExtension} */ - combineExtensions([defaultConstructs, ...settings.extensions || []]) - ); - const parser = { - defined: [], - lazy: {}, - constructs: constructs2, - content: create(content$1), - document: create(document$2), - flow: create(flow$1), - string: create(string$1), - text: create(text$1) - }; - return parser; - function create(initial) { - return creator; - function creator(from) { - return createTokenizer(parser, initial, from); - } - } -} -const search = /[\0\t\n\r]/g; -function preprocess() { - let column = 1; - let buffer = ""; - let start = true; - let atCarriageReturn; - return preprocessor; - function preprocessor(value, encoding, end) { - const chunks = []; - let match; - let next; - let startPosition; - let endPosition; - let code; - value = buffer + value.toString(encoding); - startPosition = 0; - buffer = ""; - if (start) { - if (value.charCodeAt(0) === 65279) { - startPosition++; - } - start = void 0; - } - while (startPosition < value.length) { - search.lastIndex = startPosition; - match = search.exec(value); - endPosition = match && match.index !== void 0 ? match.index : value.length; - code = value.charCodeAt(endPosition); - if (!match) { - buffer = value.slice(startPosition); - break; - } - if (code === 10 && startPosition === endPosition && atCarriageReturn) { - chunks.push(-3); - atCarriageReturn = void 0; - } else { - if (atCarriageReturn) { - chunks.push(-5); - atCarriageReturn = void 0; - } - if (startPosition < endPosition) { - chunks.push(value.slice(startPosition, endPosition)); - column += endPosition - startPosition; - } - switch (code) { - case 0: { - chunks.push(65533); - column++; - break; - } - case 9: { - next = Math.ceil(column / 4) * 4; - chunks.push(-2); - while (column++ < next) - chunks.push(-1); - break; - } - case 10: { - chunks.push(-4); - column = 1; - break; - } - default: { - atCarriageReturn = true; - column = 1; - } - } - } - startPosition = endPosition + 1; - } - if (end) { - if (atCarriageReturn) - chunks.push(-5); - if (buffer) - chunks.push(buffer); - chunks.push(null); - } - return chunks; - } -} -function postprocess(events) { - while (!subtokenize(events)) { - } - return events; -} -function decodeNumericCharacterReference(value, base) { - const code = Number.parseInt(value, base); - if ( - // C0 except for HT, LF, FF, CR, space. - code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of C0, and C1 controls. - code > 126 && code < 160 || // Lone high surrogates and low surrogates. - code > 55295 && code < 57344 || // Noncharacters. - code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range - code > 1114111 - ) { - return "�"; - } - return String.fromCharCode(code); -} -const characterEscapeOrReference = /\\([!-/:-@[-`{-~])|&(#(?:\d{1,7}|x[\da-f]{1,6})|[\da-z]{1,31});/gi; -function decodeString(value) { - return value.replace(characterEscapeOrReference, decode); -} -function decode($0, $1, $2) { - if ($1) { - return $1; - } - const head = $2.charCodeAt(0); - if (head === 35) { - const head2 = $2.charCodeAt(1); - const hex = head2 === 120 || head2 === 88; - return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10); - } - return decodeNamedCharacterReference($2) || $0; -} -function stringifyPosition(value) { - if (!value || typeof value !== "object") { - return ""; - } - if ("position" in value || "type" in value) { - return position(value.position); - } - if ("start" in value || "end" in value) { - return position(value); - } - if ("line" in value || "column" in value) { - return point$1(value); - } - return ""; -} -function point$1(point2) { - return index(point2 && point2.line) + ":" + index(point2 && point2.column); -} -function position(pos) { - return point$1(pos && pos.start) + "-" + point$1(pos && pos.end); -} -function index(value) { - return value && typeof value === "number" ? value : 1; -} -const own = {}.hasOwnProperty; -const fromMarkdown = ( - /** - * @type {( - * ((value: Value, encoding: Encoding, options?: Options | null | undefined) => Root) & - * ((value: Value, options?: Options | null | undefined) => Root) - * )} - */ - /** - * @param {Value} value - * @param {Encoding | Options | null | undefined} [encoding] - * @param {Options | null | undefined} [options] - * @returns {Root} - */ - function(value, encoding, options) { - if (typeof encoding !== "string") { - options = encoding; - encoding = void 0; - } - return compiler(options)( - postprocess( - parse(options).document().write(preprocess()(value, encoding, true)) - ) - ); - } -); -function compiler(options) { - const config = { - transforms: [], - canContainEols: ["emphasis", "fragment", "heading", "paragraph", "strong"], - enter: { - autolink: opener(link), - autolinkProtocol: onenterdata, - autolinkEmail: onenterdata, - atxHeading: opener(heading), - blockQuote: opener(blockQuote2), - characterEscape: onenterdata, - characterReference: onenterdata, - codeFenced: opener(codeFlow), - codeFencedFenceInfo: buffer, - codeFencedFenceMeta: buffer, - codeIndented: opener(codeFlow, buffer), - codeText: opener(codeText2, buffer), - codeTextData: onenterdata, - data: onenterdata, - codeFlowValue: onenterdata, - definition: opener(definition2), - definitionDestinationString: buffer, - definitionLabelString: buffer, - definitionTitleString: buffer, - emphasis: opener(emphasis), - hardBreakEscape: opener(hardBreak), - hardBreakTrailing: opener(hardBreak), - htmlFlow: opener(html, buffer), - htmlFlowData: onenterdata, - htmlText: opener(html, buffer), - htmlTextData: onenterdata, - image: opener(image), - label: buffer, - link: opener(link), - listItem: opener(listItem), - listItemValue: onenterlistitemvalue, - listOrdered: opener(list2, onenterlistordered), - listUnordered: opener(list2), - paragraph: opener(paragraph), - reference: onenterreference, - referenceString: buffer, - resourceDestinationString: buffer, - resourceTitleString: buffer, - setextHeading: opener(heading), - strong: opener(strong), - thematicBreak: opener(thematicBreak2) - }, - exit: { - atxHeading: closer(), - atxHeadingSequence: onexitatxheadingsequence, - autolink: closer(), - autolinkEmail: onexitautolinkemail, - autolinkProtocol: onexitautolinkprotocol, - blockQuote: closer(), - characterEscapeValue: onexitdata, - characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker, - characterReferenceMarkerNumeric: onexitcharacterreferencemarker, - characterReferenceValue: onexitcharacterreferencevalue, - codeFenced: closer(onexitcodefenced), - codeFencedFence: onexitcodefencedfence, - codeFencedFenceInfo: onexitcodefencedfenceinfo, - codeFencedFenceMeta: onexitcodefencedfencemeta, - codeFlowValue: onexitdata, - codeIndented: closer(onexitcodeindented), - codeText: closer(onexitcodetext), - codeTextData: onexitdata, - data: onexitdata, - definition: closer(), - definitionDestinationString: onexitdefinitiondestinationstring, - definitionLabelString: onexitdefinitionlabelstring, - definitionTitleString: onexitdefinitiontitlestring, - emphasis: closer(), - hardBreakEscape: closer(onexithardbreak), - hardBreakTrailing: closer(onexithardbreak), - htmlFlow: closer(onexithtmlflow), - htmlFlowData: onexitdata, - htmlText: closer(onexithtmltext), - htmlTextData: onexitdata, - image: closer(onexitimage), - label: onexitlabel, - labelText: onexitlabeltext, - lineEnding: onexitlineending, - link: closer(onexitlink), - listItem: closer(), - listOrdered: closer(), - listUnordered: closer(), - paragraph: closer(), - referenceString: onexitreferencestring, - resourceDestinationString: onexitresourcedestinationstring, - resourceTitleString: onexitresourcetitlestring, - resource: onexitresource, - setextHeading: closer(onexitsetextheading), - setextHeadingLineSequence: onexitsetextheadinglinesequence, - setextHeadingText: onexitsetextheadingtext, - strong: closer(), - thematicBreak: closer() - } - }; - configure(config, (options || {}).mdastExtensions || []); - const data = {}; - return compile; - function compile(events) { - let tree = { - type: "root", - children: [] - }; - const context = { - stack: [tree], - tokenStack: [], - config, - enter, - exit: exit2, - buffer, - resume, - setData, - getData - }; - const listStack = []; - let index2 = -1; - while (++index2 < events.length) { - if (events[index2][1].type === "listOrdered" || events[index2][1].type === "listUnordered") { - if (events[index2][0] === "enter") { - listStack.push(index2); - } else { - const tail = listStack.pop(); - index2 = prepareList(events, tail, index2); - } - } - } - index2 = -1; - while (++index2 < events.length) { - const handler = config[events[index2][0]]; - if (own.call(handler, events[index2][1].type)) { - handler[events[index2][1].type].call( - Object.assign( - { - sliceSerialize: events[index2][2].sliceSerialize - }, - context - ), - events[index2][1] - ); - } - } - if (context.tokenStack.length > 0) { - const tail = context.tokenStack[context.tokenStack.length - 1]; - const handler = tail[1] || defaultOnError; - handler.call(context, void 0, tail[0]); - } - tree.position = { - start: point( - events.length > 0 ? events[0][1].start : { - line: 1, - column: 1, - offset: 0 - } - ), - end: point( - events.length > 0 ? events[events.length - 2][1].end : { - line: 1, - column: 1, - offset: 0 - } - ) - }; - index2 = -1; - while (++index2 < config.transforms.length) { - tree = config.transforms[index2](tree) || tree; - } - return tree; - } - function prepareList(events, start, length) { - let index2 = start - 1; - let containerBalance = -1; - let listSpread = false; - let listItem2; - let lineIndex; - let firstBlankLineIndex; - let atMarker; - while (++index2 <= length) { - const event = events[index2]; - if (event[1].type === "listUnordered" || event[1].type === "listOrdered" || event[1].type === "blockQuote") { - if (event[0] === "enter") { - containerBalance++; - } else { - containerBalance--; - } - atMarker = void 0; - } else if (event[1].type === "lineEndingBlank") { - if (event[0] === "enter") { - if (listItem2 && !atMarker && !containerBalance && !firstBlankLineIndex) { - firstBlankLineIndex = index2; - } - atMarker = void 0; - } - } else if (event[1].type === "linePrefix" || event[1].type === "listItemValue" || event[1].type === "listItemMarker" || event[1].type === "listItemPrefix" || event[1].type === "listItemPrefixWhitespace") - ; - else { - atMarker = void 0; - } - if (!containerBalance && event[0] === "enter" && event[1].type === "listItemPrefix" || containerBalance === -1 && event[0] === "exit" && (event[1].type === "listUnordered" || event[1].type === "listOrdered")) { - if (listItem2) { - let tailIndex = index2; - lineIndex = void 0; - while (tailIndex--) { - const tailEvent = events[tailIndex]; - if (tailEvent[1].type === "lineEnding" || tailEvent[1].type === "lineEndingBlank") { - if (tailEvent[0] === "exit") - continue; - if (lineIndex) { - events[lineIndex][1].type = "lineEndingBlank"; - listSpread = true; - } - tailEvent[1].type = "lineEnding"; - lineIndex = tailIndex; - } else if (tailEvent[1].type === "linePrefix" || tailEvent[1].type === "blockQuotePrefix" || tailEvent[1].type === "blockQuotePrefixWhitespace" || tailEvent[1].type === "blockQuoteMarker" || tailEvent[1].type === "listItemIndent") - ; - else { - break; - } - } - if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) { - listItem2._spread = true; - } - listItem2.end = Object.assign( - {}, - lineIndex ? events[lineIndex][1].start : event[1].end - ); - events.splice(lineIndex || index2, 0, ["exit", listItem2, event[2]]); - index2++; - length++; - } - if (event[1].type === "listItemPrefix") { - listItem2 = { - type: "listItem", - _spread: false, - start: Object.assign({}, event[1].start), - // @ts-expect-error: we’ll add `end` in a second. - end: void 0 - }; - events.splice(index2, 0, ["enter", listItem2, event[2]]); - index2++; - length++; - firstBlankLineIndex = void 0; - atMarker = true; - } - } - } - events[start][1]._spread = listSpread; - return length; - } - function setData(key, value) { - data[key] = value; - } - function getData(key) { - return data[key]; - } - function opener(create, and) { - return open; - function open(token) { - enter.call(this, create(token), token); - if (and) - and.call(this, token); - } - } - function buffer() { - this.stack.push({ - type: "fragment", - children: [] - }); - } - function enter(node2, token, errorHandler) { - const parent = this.stack[this.stack.length - 1]; - parent.children.push(node2); - this.stack.push(node2); - this.tokenStack.push([token, errorHandler]); - node2.position = { - start: point(token.start) - }; - return node2; - } - function closer(and) { - return close; - function close(token) { - if (and) - and.call(this, token); - exit2.call(this, token); - } - } - function exit2(token, onExitError) { - const node2 = this.stack.pop(); - const open = this.tokenStack.pop(); - if (!open) { - throw new Error( - "Cannot close `" + token.type + "` (" + stringifyPosition({ - start: token.start, - end: token.end - }) + "): it’s not open" - ); - } else if (open[0].type !== token.type) { - if (onExitError) { - onExitError.call(this, token, open[0]); - } else { - const handler = open[1] || defaultOnError; - handler.call(this, token, open[0]); - } - } - node2.position.end = point(token.end); - return node2; - } - function resume() { - return toString(this.stack.pop()); - } - function onenterlistordered() { - setData("expectingFirstListItemValue", true); - } - function onenterlistitemvalue(token) { - if (getData("expectingFirstListItemValue")) { - const ancestor = this.stack[this.stack.length - 2]; - ancestor.start = Number.parseInt(this.sliceSerialize(token), 10); - setData("expectingFirstListItemValue"); - } - } - function onexitcodefencedfenceinfo() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.lang = data2; - } - function onexitcodefencedfencemeta() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.meta = data2; - } - function onexitcodefencedfence() { - if (getData("flowCodeInside")) - return; - this.buffer(); - setData("flowCodeInside", true); - } - function onexitcodefenced() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.value = data2.replace(/^(\r?\n|\r)|(\r?\n|\r)$/g, ""); - setData("flowCodeInside"); - } - function onexitcodeindented() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.value = data2.replace(/(\r?\n|\r)$/g, ""); - } - function onexitdefinitionlabelstring(token) { - const label = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.label = label; - node2.identifier = normalizeIdentifier( - this.sliceSerialize(token) - ).toLowerCase(); - } - function onexitdefinitiontitlestring() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.title = data2; - } - function onexitdefinitiondestinationstring() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.url = data2; - } - function onexitatxheadingsequence(token) { - const node2 = this.stack[this.stack.length - 1]; - if (!node2.depth) { - const depth = this.sliceSerialize(token).length; - node2.depth = depth; - } - } - function onexitsetextheadingtext() { - setData("setextHeadingSlurpLineEnding", true); - } - function onexitsetextheadinglinesequence(token) { - const node2 = this.stack[this.stack.length - 1]; - node2.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2; - } - function onexitsetextheading() { - setData("setextHeadingSlurpLineEnding"); - } - function onenterdata(token) { - const node2 = this.stack[this.stack.length - 1]; - let tail = node2.children[node2.children.length - 1]; - if (!tail || tail.type !== "text") { - tail = text2(); - tail.position = { - start: point(token.start) - }; - node2.children.push(tail); - } - this.stack.push(tail); - } - function onexitdata(token) { - const tail = this.stack.pop(); - tail.value += this.sliceSerialize(token); - tail.position.end = point(token.end); - } - function onexitlineending(token) { - const context = this.stack[this.stack.length - 1]; - if (getData("atHardBreak")) { - const tail = context.children[context.children.length - 1]; - tail.position.end = point(token.end); - setData("atHardBreak"); - return; - } - if (!getData("setextHeadingSlurpLineEnding") && config.canContainEols.includes(context.type)) { - onenterdata.call(this, token); - onexitdata.call(this, token); - } - } - function onexithardbreak() { - setData("atHardBreak", true); - } - function onexithtmlflow() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.value = data2; - } - function onexithtmltext() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.value = data2; - } - function onexitcodetext() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.value = data2; - } - function onexitlink() { - const node2 = this.stack[this.stack.length - 1]; - if (getData("inReference")) { - const referenceType = getData("referenceType") || "shortcut"; - node2.type += "Reference"; - node2.referenceType = referenceType; - delete node2.url; - delete node2.title; - } else { - delete node2.identifier; - delete node2.label; - } - setData("referenceType"); - } - function onexitimage() { - const node2 = this.stack[this.stack.length - 1]; - if (getData("inReference")) { - const referenceType = getData("referenceType") || "shortcut"; - node2.type += "Reference"; - node2.referenceType = referenceType; - delete node2.url; - delete node2.title; - } else { - delete node2.identifier; - delete node2.label; - } - setData("referenceType"); - } - function onexitlabeltext(token) { - const string2 = this.sliceSerialize(token); - const ancestor = this.stack[this.stack.length - 2]; - ancestor.label = decodeString(string2); - ancestor.identifier = normalizeIdentifier(string2).toLowerCase(); - } - function onexitlabel() { - const fragment = this.stack[this.stack.length - 1]; - const value = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - setData("inReference", true); - if (node2.type === "link") { - const children = fragment.children; - node2.children = children; - } else { - node2.alt = value; - } - } - function onexitresourcedestinationstring() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.url = data2; - } - function onexitresourcetitlestring() { - const data2 = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.title = data2; - } - function onexitresource() { - setData("inReference"); - } - function onenterreference() { - setData("referenceType", "collapsed"); - } - function onexitreferencestring(token) { - const label = this.resume(); - const node2 = this.stack[this.stack.length - 1]; - node2.label = label; - node2.identifier = normalizeIdentifier( - this.sliceSerialize(token) - ).toLowerCase(); - setData("referenceType", "full"); - } - function onexitcharacterreferencemarker(token) { - setData("characterReferenceType", token.type); - } - function onexitcharacterreferencevalue(token) { - const data2 = this.sliceSerialize(token); - const type = getData("characterReferenceType"); - let value; - if (type) { - value = decodeNumericCharacterReference( - data2, - type === "characterReferenceMarkerNumeric" ? 10 : 16 - ); - setData("characterReferenceType"); - } else { - const result = decodeNamedCharacterReference(data2); - value = result; - } - const tail = this.stack.pop(); - tail.value += value; - tail.position.end = point(token.end); - } - function onexitautolinkprotocol(token) { - onexitdata.call(this, token); - const node2 = this.stack[this.stack.length - 1]; - node2.url = this.sliceSerialize(token); - } - function onexitautolinkemail(token) { - onexitdata.call(this, token); - const node2 = this.stack[this.stack.length - 1]; - node2.url = "mailto:" + this.sliceSerialize(token); - } - function blockQuote2() { - return { - type: "blockquote", - children: [] - }; - } - function codeFlow() { - return { - type: "code", - lang: null, - meta: null, - value: "" - }; - } - function codeText2() { - return { - type: "inlineCode", - value: "" - }; - } - function definition2() { - return { - type: "definition", - identifier: "", - label: null, - title: null, - url: "" - }; - } - function emphasis() { - return { - type: "emphasis", - children: [] - }; - } - function heading() { - return { - type: "heading", - depth: void 0, - children: [] - }; - } - function hardBreak() { - return { - type: "break" - }; - } - function html() { - return { - type: "html", - value: "" - }; - } - function image() { - return { - type: "image", - title: null, - url: "", - alt: null - }; - } - function link() { - return { - type: "link", - title: null, - url: "", - children: [] - }; - } - function list2(token) { - return { - type: "list", - ordered: token.type === "listOrdered", - start: null, - spread: token._spread, - children: [] - }; - } - function listItem(token) { - return { - type: "listItem", - spread: token._spread, - checked: null, - children: [] - }; - } - function paragraph() { - return { - type: "paragraph", - children: [] - }; - } - function strong() { - return { - type: "strong", - children: [] - }; - } - function text2() { - return { - type: "text", - value: "" - }; - } - function thematicBreak2() { - return { - type: "thematicBreak" - }; - } -} -function point(d) { - return { - line: d.line, - column: d.column, - offset: d.offset - }; -} -function configure(combined, extensions) { - let index2 = -1; - while (++index2 < extensions.length) { - const value = extensions[index2]; - if (Array.isArray(value)) { - configure(combined, value); - } else { - extension(combined, value); - } - } -} -function extension(combined, extension2) { - let key; - for (key in extension2) { - if (own.call(extension2, key)) { - if (key === "canContainEols") { - const right = extension2[key]; - if (right) { - combined[key].push(...right); - } - } else if (key === "transforms") { - const right = extension2[key]; - if (right) { - combined[key].push(...right); - } - } else if (key === "enter" || key === "exit") { - const right = extension2[key]; - if (right) { - Object.assign(combined[key], right); - } - } - } - } -} -function defaultOnError(left, right) { - if (left) { - throw new Error( - "Cannot close `" + left.type + "` (" + stringifyPosition({ - start: left.start, - end: left.end - }) + "): a different token (`" + right.type + "`, " + stringifyPosition({ - start: right.start, - end: right.end - }) + ") is open" - ); - } else { - throw new Error( - "Cannot close document, a token (`" + right.type + "`, " + stringifyPosition({ - start: right.start, - end: right.end - }) + ") is still open" - ); - } -} -function preprocessMarkdown(markdown) { - const withoutMultipleNewlines = markdown.replace(/\n{2,}/g, "\n"); - const withoutExtraSpaces = dedent(withoutMultipleNewlines); - return withoutExtraSpaces; -} -function markdownToLines(markdown) { - const preprocessedMarkdown = preprocessMarkdown(markdown); - const { children } = fromMarkdown(preprocessedMarkdown); - const lines = [[]]; - let currentLine = 0; - function processNode(node2, parentType = "normal") { - if (node2.type === "text") { - const textLines = node2.value.split("\n"); - textLines.forEach((textLine, index2) => { - if (index2 !== 0) { - currentLine++; - lines.push([]); - } - textLine.split(" ").forEach((word) => { - if (word) { - lines[currentLine].push({ content: word, type: parentType }); - } - }); - }); - } else if (node2.type === "strong" || node2.type === "emphasis") { - node2.children.forEach((contentNode) => { - processNode(contentNode, node2.type); - }); - } - } - children.forEach((treeNode) => { - if (treeNode.type === "paragraph") { - treeNode.children.forEach((contentNode) => { - processNode(contentNode); - }); - } - }); - return lines; -} -function markdownToHTML(markdown) { - const { children } = fromMarkdown(markdown); - function output(node2) { - if (node2.type === "text") { - return node2.value.replace(/\n/g, "
"); - } else if (node2.type === "strong") { - return `${node2.children.map(output).join("")}`; - } else if (node2.type === "emphasis") { - return `${node2.children.map(output).join("")}`; - } else if (node2.type === "paragraph") { - return `

${node2.children.map(output).join("")}

`; - } - return `Unsupported markdown: ${node2.type}`; - } - return children.map(output).join(""); -} -function splitTextToChars(text2) { - if (Intl.Segmenter) { - return [...new Intl.Segmenter().segment(text2)].map((s) => s.segment); - } - return [...text2]; -} -function splitWordToFitWidth(checkFit, word) { - const characters = splitTextToChars(word.content); - return splitWordToFitWidthRecursion(checkFit, [], characters, word.type); -} -function splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type) { - if (remainingChars.length === 0) { - return [ - { content: usedChars.join(""), type }, - { content: "", type } - ]; - } - const [nextChar, ...rest] = remainingChars; - const newWord = [...usedChars, nextChar]; - if (checkFit([{ content: newWord.join(""), type }])) { - return splitWordToFitWidthRecursion(checkFit, newWord, rest, type); - } - if (usedChars.length === 0 && nextChar) { - usedChars.push(nextChar); - remainingChars.shift(); - } - return [ - { content: usedChars.join(""), type }, - { content: remainingChars.join(""), type } - ]; -} -function splitLineToFitWidth(line, checkFit) { - if (line.some(({ content: content2 }) => content2.includes("\n"))) { - throw new Error("splitLineToFitWidth does not support newlines in the line"); - } - return splitLineToFitWidthRecursion(line, checkFit); -} -function splitLineToFitWidthRecursion(words, checkFit, lines = [], newLine = []) { - if (words.length === 0) { - if (newLine.length > 0) { - lines.push(newLine); - } - return lines.length > 0 ? lines : []; - } - let joiner = ""; - if (words[0].content === " ") { - joiner = " "; - words.shift(); - } - const nextWord = words.shift() ?? { content: " ", type: "normal" }; - const lineWithNextWord = [...newLine]; - if (joiner !== "") { - lineWithNextWord.push({ content: joiner, type: "normal" }); - } - lineWithNextWord.push(nextWord); - if (checkFit(lineWithNextWord)) { - return splitLineToFitWidthRecursion(words, checkFit, lines, lineWithNextWord); - } - if (newLine.length > 0) { - lines.push(newLine); - words.unshift(nextWord); - } else if (nextWord.content) { - const [line, rest] = splitWordToFitWidth(checkFit, nextWord); - lines.push([line]); - if (rest.content) { - words.unshift(rest); - } - } - return splitLineToFitWidthRecursion(words, checkFit, lines); -} -function applyStyle(dom, styleFn) { - if (styleFn) { - dom.attr("style", styleFn); - } -} -function addHtmlSpan(element2, node2, width, classes, addBackground = false) { - const fo = element2.append("foreignObject"); - const div = fo.append("xhtml:div"); - const label = node2.label; - const labelClass = node2.isNode ? "nodeLabel" : "edgeLabel"; - div.html( - ` - " + label + "" - ); - applyStyle(div, node2.labelStyle); - div.style("display", "table-cell"); - div.style("white-space", "nowrap"); - div.style("max-width", width + "px"); - div.attr("xmlns", "http://www.w3.org/1999/xhtml"); - if (addBackground) { - div.attr("class", "labelBkg"); - } - let bbox = div.node().getBoundingClientRect(); - if (bbox.width === width) { - div.style("display", "table"); - div.style("white-space", "break-spaces"); - div.style("width", width + "px"); - bbox = div.node().getBoundingClientRect(); - } - fo.style("width", bbox.width); - fo.style("height", bbox.height); - return fo.node(); -} -function createTspan(textElement, lineIndex, lineHeight) { - return textElement.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", lineIndex * lineHeight - 0.1 + "em").attr("dy", lineHeight + "em"); -} -function computeWidthOfText(parentNode, lineHeight, line) { - const testElement = parentNode.append("text"); - const testSpan = createTspan(testElement, 1, lineHeight); - updateTextContentAndStyles(testSpan, line); - const textLength = testSpan.node().getComputedTextLength(); - testElement.remove(); - return textLength; -} -function computeDimensionOfText(parentNode, lineHeight, text2) { - var _a; - const testElement = parentNode.append("text"); - const testSpan = createTspan(testElement, 1, lineHeight); - updateTextContentAndStyles(testSpan, [{ content: text2, type: "normal" }]); - const textDimension = (_a = testSpan.node()) == null ? void 0 : _a.getBoundingClientRect(); - if (textDimension) { - testElement.remove(); - } - return textDimension; -} -function createFormattedText(width, g, structuredText, addBackground = false) { - const lineHeight = 1.1; - const labelGroup = g.append("g"); - const bkg = labelGroup.insert("rect").attr("class", "background"); - const textElement = labelGroup.append("text").attr("y", "-10.1"); - let lineIndex = 0; - for (const line of structuredText) { - const checkWidth = (line2) => computeWidthOfText(labelGroup, lineHeight, line2) <= width; - const linesUnderWidth = checkWidth(line) ? [line] : splitLineToFitWidth(line, checkWidth); - for (const preparedLine of linesUnderWidth) { - const tspan = createTspan(textElement, lineIndex, lineHeight); - updateTextContentAndStyles(tspan, preparedLine); - lineIndex++; - } - } - if (addBackground) { - const bbox = textElement.node().getBBox(); - const padding = 2; - bkg.attr("x", -padding).attr("y", -padding).attr("width", bbox.width + 2 * padding).attr("height", bbox.height + 2 * padding); - return labelGroup.node(); - } else { - return textElement.node(); - } -} -function updateTextContentAndStyles(tspan, wrappedLine) { - tspan.text(""); - wrappedLine.forEach((word, index2) => { - const innerTspan = tspan.append("tspan").attr("font-style", word.type === "emphasis" ? "italic" : "normal").attr("class", "text-inner-tspan").attr("font-weight", word.type === "strong" ? "bold" : "normal"); - if (index2 === 0) { - innerTspan.text(word.content); - } else { - innerTspan.text(" " + word.content); - } - }); -} -const createText = (el, text2 = "", { - style = "", - isTitle = false, - classes = "", - useHtmlLabels = true, - isNode = true, - width = 200, - addSvgBackground = false -} = {}) => { - log.info("createText", text2, style, isTitle, classes, useHtmlLabels, isNode, addSvgBackground); - if (useHtmlLabels) { - const htmlText2 = markdownToHTML(text2); - const node2 = { - isNode, - label: decodeEntities(htmlText2).replace( - /fa[blrs]?:fa-[\w-]+/g, - // cspell: disable-line - (s) => `` - ), - labelStyle: style.replace("fill:", "color:") - }; - const vertexNode = addHtmlSpan(el, node2, width, classes, addSvgBackground); - return vertexNode; - } else { - const structuredText = markdownToLines(text2); - const svgLabel = createFormattedText(width, el, structuredText, addSvgBackground); - return svgLabel; - } -}; -export { - createText as a, - computeDimensionOfText as c -}; -- cgit v1.2.3