${e.children.map(t).join("")}
` : `Unsupported markdown: ${e.type}`; + } + return r.map(t).join(""); +} +function Mr(n) { + return Intl.Segmenter ? [...new Intl.Segmenter().segment(n)].map((r) => r.segment) : [...n]; +} +function jr(n, r) { + const t = Mr(r.content); + return gt(n, [], t, r.type); +} +function gt(n, r, t, e) { + if (t.length === 0) + return [ + { content: r.join(""), type: e }, + { content: "", type: e } + ]; + const [u, ...i] = t, l = [...r, u]; + return n([{ content: l.join(""), type: e }]) ? gt(n, l, i, e) : (r.length === 0 && u && (r.push(u), t.shift()), [ + { content: r.join(""), type: e }, + { content: t.join(""), type: e } + ]); +} +function Rr(n, r) { + if (n.some(({ content: t }) => t.includes(` +`))) + throw new Error("splitLineToFitWidth does not support newlines in the line"); + return Bn(n, r); +} +function Bn(n, r, t = [], e = []) { + if (n.length === 0) + return e.length > 0 && t.push(e), t.length > 0 ? t : []; + let u = ""; + n[0].content === " " && (u = " ", n.shift()); + const i = n.shift() ?? { content: " ", type: "normal" }, l = [...e]; + if (u !== "" && l.push({ content: u, type: "normal" }), l.push(i), r(l)) + return Bn(n, r, t, l); + if (e.length > 0) + t.push(e), n.unshift(i); + else if (i.content) { + const [a, m] = jr(r, i); + t.push([a]), m.content && n.unshift(m); + } + return Bn(n, r, t); +} +function qr(n, r) { + r && n.attr("style", r); +} +function Hr(n, r, t, e, u = !1) { + const i = n.append("foreignObject"), l = i.append("xhtml:div"), a = r.label, m = r.isNode ? "nodeLabel" : "edgeLabel"; + l.html( + ` + " + a + "" + ), qr(l, r.labelStyle), l.style("display", "table-cell"), l.style("white-space", "nowrap"), l.style("max-width", t + "px"), l.attr("xmlns", "http://www.w3.org/1999/xhtml"), u && l.attr("class", "labelBkg"); + let c = l.node().getBoundingClientRect(); + return c.width === t && (l.style("display", "table"), l.style("white-space", "break-spaces"), l.style("width", t + "px"), c = l.node().getBoundingClientRect()), i.style("width", c.width), i.style("height", c.height), i.node(); +} +function Pn(n, r, t) { + return n.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", r * t - 0.1 + "em").attr("dy", t + "em"); +} +function Nr(n, r, t) { + const e = n.append("text"), u = Pn(e, 1, r); + _n(u, t); + const i = u.node().getComputedTextLength(); + return e.remove(), i; +} +function Qr(n, r, t) { + var l; + const e = n.append("text"), u = Pn(e, 1, r); + _n(u, [{ content: t, type: "normal" }]); + const i = (l = u.node()) == null ? void 0 : l.getBoundingClientRect(); + return i && e.remove(), i; +} +function Vr(n, r, t, e = !1) { + const i = r.append("g"), l = i.insert("rect").attr("class", "background"), a = i.append("text").attr("y", "-10.1"); + let m = 0; + for (const c of t) { + const p = (x) => Nr(i, 1.1, x) <= n, f = p(c) ? [c] : Rr(c, p); + for (const x of f) { + const h = Pn(a, m, 1.1); + _n(h, x), m++; + } + } + if (e) { + const c = a.node().getBBox(), p = 2; + return l.attr("x", -p).attr("y", -p).attr("width", c.width + 2 * p).attr("height", c.height + 2 * p), i.node(); + } else + return a.node(); +} +function _n(n, r) { + n.text(""), r.forEach((t, e) => { + const u = n.append("tspan").attr("font-style", t.type === "emphasis" ? "italic" : "normal").attr("class", "text-inner-tspan").attr("font-weight", t.type === "strong" ? "bold" : "normal"); + e === 0 ? u.text(t.content) : u.text(" " + t.content); + }); +} +const Ur = (n, r = "", { + style: t = "", + isTitle: e = !1, + classes: u = "", + useHtmlLabels: i = !0, + isNode: l = !0, + width: a = 200, + addSvgBackground: m = !1 +} = {}) => { + if (zt.info("createText", r, t, e, u, i, l, m), i) { + const c = _r(r), p = { + isNode: l, + label: It(c).replace( + /fa[blrs]?:fa-[\w-]+/g, + // cspell: disable-line + (x) => `` + ), + labelStyle: t.replace("fill:", "color:") + }; + return Hr(n, p, a, u, m); + } else { + const c = Pr(r); + return Vr(a, n, c, m); + } +}; +export { + Ur as a, + Qr as c +}; diff --git a/themes/blowfish/assets/lib/mermaid/createText-b70fe78a.js b/themes/blowfish/assets/lib/mermaid/createText-b70fe78a.js new file mode 100644 index 0000000..2b6e8ff --- /dev/null +++ b/themes/blowfish/assets/lib/mermaid/createText-b70fe78a.js @@ -0,0 +1,4929 @@ +import { b8 as dedent, l as log, b7 as decodeEntities } from "./mermaid-dcacb631.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, "${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 +}; diff --git a/themes/blowfish/assets/lib/mermaid/createText-ca0c5216.js b/themes/blowfish/assets/lib/mermaid/createText-ca0c5216.js new file mode 100644 index 0000000..f0810a2 --- /dev/null +++ b/themes/blowfish/assets/lib/mermaid/createText-ca0c5216.js @@ -0,0 +1,251 @@ +import { l as log, M as decodeEntities } from "./mermaid-6dc72991.js"; +import { fromMarkdown } from "mdast-util-from-markdown"; +import { dedent } from "ts-dedent"; +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(node, parentType = "normal") { + if (node.type === "text") { + const textLines = node.value.split("\n"); + textLines.forEach((textLine, index) => { + if (index !== 0) { + currentLine++; + lines.push([]); + } + textLine.split(" ").forEach((word) => { + if (word) { + lines[currentLine].push({ content: word, type: parentType }); + } + }); + }); + } else if (node.type === "strong" || node.type === "emphasis") { + node.children.forEach((contentNode) => { + processNode(contentNode, node.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(node) { + if (node.type === "text") { + return node.value.replace(/\n/g, "${node.children.map(output).join("")}
`; + } + return `Unsupported markdown: ${node.type}`; + } + return children.map(output).join(""); +} +function splitTextToChars(text) { + if (Intl.Segmenter) { + return [...new Intl.Segmenter().segment(text)].map((s) => s.segment); + } + return [...text]; +} +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 }) => content.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(element, node, width, classes, addBackground = false) { + const fo = element.append("foreignObject"); + const div = fo.append("xhtml:div"); + const label = node.label; + const labelClass = node.isNode ? "nodeLabel" : "edgeLabel"; + div.html( + ` + " + label + "" + ); + applyStyle(div, node.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, text) { + var _a; + const testElement = parentNode.append("text"); + const testSpan = createTspan(testElement, 1, lineHeight); + updateTextContentAndStyles(testSpan, [{ content: text, 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, index) => { + 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 (index === 0) { + innerTspan.text(word.content); + } else { + innerTspan.text(" " + word.content); + } + }); +} +const createText = (el, text = "", { + style = "", + isTitle = false, + classes = "", + useHtmlLabels = true, + isNode = true, + width = 200, + addSvgBackground = false +} = {}) => { + log.info("createText", text, style, isTitle, classes, useHtmlLabels, isNode, addSvgBackground); + if (useHtmlLabels) { + const htmlText = markdownToHTML(text); + const node = { + isNode, + label: decodeEntities(htmlText).replace( + /fa[blrs]?:fa-[\w-]+/g, + // cspell: disable-line + (s) => `` + ), + labelStyle: style.replace("fill:", "color:") + }; + const vertexNode = addHtmlSpan(el, node, width, classes, addSvgBackground); + return vertexNode; + } else { + const structuredText = markdownToLines(text); + const svgLabel = createFormattedText(width, el, structuredText, addSvgBackground); + return svgLabel; + } +}; +export { + createText as a, + computeDimensionOfText as c +}; diff --git a/themes/blowfish/assets/lib/mermaid/edges-066a5561.js b/themes/blowfish/assets/lib/mermaid/edges-066a5561.js new file mode 100644 index 0000000..aee0212 --- /dev/null +++ b/themes/blowfish/assets/lib/mermaid/edges-066a5561.js @@ -0,0 +1,1840 @@ +import { l as log, m as evaluate, c as getConfig, M as decodeEntities, d as sanitizeText, u as utils } from "./mermaid-6dc72991.js"; +import { select, line, curveBasis } from "d3"; +import { a as createText } from "./createText-ca0c5216.js"; +const insertMarkers = (elem, markerArray, type, id) => { + markerArray.forEach((markerName) => { + markers[markerName](elem, type, id); + }); +}; +const extension = (elem, type, id) => { + log.trace("Making markers for ", id); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-extensionStart").attr("class", "marker extension " + type).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 1,7 L18,13 V 1 Z"); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-extensionEnd").attr("class", "marker extension " + type).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 1,1 V 13 L18,7 Z"); +}; +const composition = (elem, type, id) => { + elem.append("defs").append("marker").attr("id", id + "_" + type + "-compositionStart").attr("class", "marker composition " + type).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-compositionEnd").attr("class", "marker composition " + type).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); +}; +const aggregation = (elem, type, id) => { + elem.append("defs").append("marker").attr("id", id + "_" + type + "-aggregationStart").attr("class", "marker aggregation " + type).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-aggregationEnd").attr("class", "marker aggregation " + type).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); +}; +const dependency = (elem, type, id) => { + elem.append("defs").append("marker").attr("id", id + "_" + type + "-dependencyStart").attr("class", "marker dependency " + type).attr("refX", 6).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 5,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-dependencyEnd").attr("class", "marker dependency " + type).attr("refX", 13).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L14,7 L9,1 Z"); +}; +const lollipop = (elem, type, id) => { + elem.append("defs").append("marker").attr("id", id + "_" + type + "-lollipopStart").attr("class", "marker lollipop " + type).attr("refX", 13).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); + elem.append("defs").append("marker").attr("id", id + "_" + type + "-lollipopEnd").attr("class", "marker lollipop " + type).attr("refX", 1).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); +}; +const point = (elem, type, id) => { + elem.append("marker").attr("id", id + "_" + type + "-pointEnd").attr("class", "marker " + type).attr("viewBox", "0 0 10 10").attr("refX", 6).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id + "_" + type + "-pointStart").attr("class", "marker " + type).attr("viewBox", "0 0 10 10").attr("refX", 4.5).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 5 L 10 10 L 10 0 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); +}; +const circle$1 = (elem, type, id) => { + elem.append("marker").attr("id", id + "_" + type + "-circleEnd").attr("class", "marker " + type).attr("viewBox", "0 0 10 10").attr("refX", 11).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id + "_" + type + "-circleStart").attr("class", "marker " + type).attr("viewBox", "0 0 10 10").attr("refX", -1).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); +}; +const cross = (elem, type, id) => { + elem.append("marker").attr("id", id + "_" + type + "-crossEnd").attr("class", "marker cross " + type).attr("viewBox", "0 0 11 11").attr("refX", 12).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id + "_" + type + "-crossStart").attr("class", "marker cross " + type).attr("viewBox", "0 0 11 11").attr("refX", -1).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); +}; +const barb = (elem, type, id) => { + elem.append("defs").append("marker").attr("id", id + "_" + type + "-barbEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 14).attr("markerUnits", "strokeWidth").attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z"); +}; +const markers = { + extension, + composition, + aggregation, + dependency, + lollipop, + point, + circle: circle$1, + cross, + barb +}; +const insertMarkers$1 = insertMarkers; +function applyStyle(dom, styleFn) { + if (styleFn) { + dom.attr("style", styleFn); + } +} +function addHtmlLabel(node) { + const fo = select(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")); + const div = fo.append("xhtml:div"); + const label = node.label; + const labelClass = node.isNode ? "nodeLabel" : "edgeLabel"; + div.html( + '" + label + "" + ); + applyStyle(div, node.labelStyle); + div.style("display", "inline-block"); + div.style("white-space", "nowrap"); + div.attr("xmlns", "http://www.w3.org/1999/xhtml"); + return fo.node(); +} +const createLabel = (_vertexText, style, isTitle, isNode) => { + let vertexText = _vertexText || ""; + if (typeof vertexText === "object") { + vertexText = vertexText[0]; + } + if (evaluate(getConfig().flowchart.htmlLabels)) { + vertexText = vertexText.replace(/\\n|\n/g, "y.args);SX(b),d=id(d,[...b])}else d=u.args;if(!d)return;let p=_X(i,s);const v="config";return d[v]!==void 0&&(p==="flowchart-v2"&&(p="flowchart"),d[p]=d[v],delete d[v]),d},fje=function(i,s=null){try{const u=new RegExp(`[%]{2}(?![{]${mRt.source})(?=[}][%]{2}).*
-`,"ig");i=i.trim().replace(u,"").replace(/'/gm,'"'),Xe.debug(`Detecting diagram directive${s!==null?" type:"+s:""} based on the text:${i}`);let d;const p=[];for(;(d=UF.exec(i))!==null;)if(d.index===UF.lastIndex&&UF.lastIndex++,d&&!s||s&&d[1]&&d[1].match(s)||s&&d[2]&&d[2].match(s)){const v=d[1]?d[1]:d[2],b=d[3]?d[3].trim():d[4]?JSON.parse(d[4].trim()):null;p.push({type:v,args:b})}return p.length===0?{type:i,args:null}:p.length===1?p[0]:p}catch(u){return Xe.error(`ERROR: ${u.message} - Unable to parse directive type: '${s}' based on the text: '${i}'`),{type:void 0,args:null}}},wRt=function(i){return i.replace(UF,"")},yRt=function(i,s){for(const[u,d]of s.entries())if(d.match(i))return u;return-1};function Ov(i,s){if(!i)return s;const u=`curve${i.charAt(0).toUpperCase()+i.slice(1)}`;return bRt[u]??s}function xRt(i,s){const u=i.trim();if(u)return s.securityLevel!=="loose"?p9.sanitizeUrl(u):u}const kRt=(i,...s)=>{const u=i.split("."),d=u.length-1,p=u[d];let v=window;for(let b=0;b p?R=new jv(u,y):u==p&&d =A?R=new jv(u+i.width,y+A*i.width/2):R=new jv(b+T/_*i.height/2,d+i.height):u v?P>=A?R=new jv(u+i.width,y-A*i.width/2):R=new jv(b+i.height/2*T/_,d):u>p&&d>v&&(P>=A?R=new jv(u,y-i.width/2*A):R=new jv(b-i.height/2*T/_,d)),R},mUt=function(i,s){let u={x:0,y:0};u.x=s.x+s.width/2,u.y=s.y+s.height/2;let d=Mqe(i,u);u.x=i.x+i.width/2,u.y=i.y+i.height/2;let p=Mqe(s,u);return{startPoint:d,endPoint:p}};const vUt=function(i,s,u,d){let p=0;for(let v of s){p=p+1;let b=v.wrap&&$s.wrap,y=bUt($s);d.db.getC4Type()==="C4Dynamic"&&(v.label.text=p+": "+v.label.text);let _=H4(v.label.text,y);$3("label",v,b,y,_),v.techn&&v.techn.text!==""&&(_=H4(v.techn.text,y),$3("techn",v,b,y,_)),v.descr&&v.descr.text!==""&&(_=H4(v.descr.text,y),$3("descr",v,b,y,_));let A=u(v.from),P=u(v.to),R=mUt(A,P);v.startPoint=R.startPoint,v.endPoint=R.endPoint}J4.drawRels(i,s,$s)};function Dqe(i,s,u,d,p){let v=new _qe(p);v.data.widthLimit=u.data.widthLimit/Math.min(Hbe,d.length);for(let[b,y]of d.entries()){let T=0;y.image={width:0,height:0,Y:0},y.sprite&&(y.image.width=48,y.image.height=48,y.image.Y=T,T=y.image.Y+y.image.height);let _=y.wrap&&$s.wrap,A=DQ($s);if(A.fontSize=A.fontSize+2,A.fontWeight="bold",$3("label",y,_,A,v.data.widthLimit),y.label.Y=T+8,T=y.label.Y+y.label.height,y.type&&y.type.text!==""){y.type.text="["+y.type.text+"]";let j=DQ($s);$3("type",y,_,j,v.data.widthLimit),y.type.Y=T+5,T=y.type.Y+y.type.height}if(y.descr&&y.descr.text!==""){let j=DQ($s);j.fontSize=j.fontSize-2,$3("descr",y,_,j,v.data.widthLimit),y.descr.Y=T+20,T=y.descr.Y+y.descr.height}if(b==0||b%Hbe===0){let j=u.data.startx+$s.diagramMarginX,K=u.data.stopy+$s.diagramMarginY+T;v.setData(j,j,K,K)}else{let j=v.data.stopx!==v.data.startx?v.data.stopx+$s.diagramMarginX:v.data.startx,K=v.data.starty;v.setData(j,j,K,K)}v.name=y.alias;let P=p.db.getC4ShapeArray(y.alias),R=p.db.getC4ShapeKeys(y.alias);R.length>0&&Lqe(v,i,P,R),s=y.alias;let F=p.db.getBoundarys(s);F.length>0&&Dqe(i,s,v,F,p),y.alias!=="global"&&Aqe(i,y,v),u.data.stopy=Math.max(v.data.stopy+$s.c4ShapeMargin,u.data.stopy),u.data.stopx=Math.max(v.data.stopx+$s.c4ShapeMargin,u.data.stopx),LQ=Math.max(LQ,u.data.stopx),MQ=Math.max(MQ,u.data.stopy)}}const Iqe={drawPersonOrSystemArray:Lqe,drawBoundary:Aqe,setConf:Vbe,draw:function(i,s,u,d){$s=qt().c4;const p=qt().securityLevel;let v;p==="sandbox"&&(v=Ir("#i"+s));const b=Ir(p==="sandbox"?v.nodes()[0].contentDocument.body:"body");let y=d.db;d.db.setWrap($s.wrap),Sqe=y.getC4ShapeInRow(),Hbe=y.getC4BoundaryInRow(),Xe.debug(`C:${JSON.stringify($s,null,2)}`);const T=p==="sandbox"?b.select(`[id="${s}"]`):Ir(`[id="${s}"]`);J4.insertComputerIcon(T),J4.insertDatabaseIcon(T),J4.insertClockIcon(T);let _=new _qe(d);_.setData($s.diagramMarginX,$s.diagramMarginX,$s.diagramMarginY,$s.diagramMarginY),_.data.widthLimit=screen.availWidth,LQ=$s.diagramMarginX,MQ=$s.diagramMarginY;const A=d.db.getTitle();let P=d.db.getBoundarys("");Dqe(T,"",_,P,d),J4.insertArrowHead(T),J4.insertArrowEnd(T),J4.insertArrowCrossHead(T),J4.insertArrowFilledHead(T),vUt(T,d.db.getRels(),d.db.getC4Shape,d),_.data.stopx=LQ,_.data.stopy=MQ;const R=_.data;let j=R.stopy-R.starty+2*$s.diagramMarginY;const ee=R.stopx-R.startx+2*$s.diagramMarginX;A&&T.append("text").text(A).attr("x",(R.stopx-R.startx)/2-4*$s.diagramMarginX).attr("y",R.starty+$s.diagramMarginY),Ng(T,j,ee,$s.useMaxWidth);const ie=A?60:0;T.attr("viewBox",R.startx-$s.diagramMarginX+" -"+($s.diagramMarginY+ie)+" "+ee+" "+(j+ie)),Xe.debug("models:",R)}},wUt=Object.freeze(Object.defineProperty({__proto__:null,diagram:{parser:DVt,db:$be,renderer:Iqe,styles:i=>`.person {
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},lex:function(){var qn=this.next();return qn||this.lex()},begin:function(qn){this.conditionStack.push(qn)},popState:function(){var qn=this.conditionStack.length-1;return qn>0?this.conditionStack.pop():this.conditionStack[0]},_currentRules:function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},topState:function(qn){return qn=this.conditionStack.length-1-Math.abs(qn||0),qn>=0?this.conditionStack[qn]:"INITIAL"},pushState:function(qn){this.begin(qn)},stateStackSize:function(){return this.conditionStack.length},options:{},performAction:function(qn,Un,At,wt){switch(At){case 0:return 6;case 1:return 7;case 2:return 8;case 3:return 9;case 4:return 22;case 5:return 23;case 6:return this.begin("acc_title"),24;case 7:return this.popState(),"acc_title_value";case 8:return this.begin("acc_descr"),26;case 9:return this.popState(),"acc_descr_value";case 10:this.begin("acc_descr_multiline");break;case 11:this.popState();break;case 12:return"acc_descr_multiline_value";case 13:break;case 14:c;break;case 15:return 12;case 16:break;case 17:return 11;case 18:return 15;case 19:return 16;case 20:return 17;case 21:return 18;case 22:return this.begin("person_ext"),45;case 23:return this.begin("person"),44;case 24:return this.begin("system_ext_queue"),51;case 25:return this.begin("system_ext_db"),50;case 26:return this.begin("system_ext"),49;case 27:return this.begin("system_queue"),48;case 28:return this.begin("system_db"),47;case 29:return this.begin("system"),46;case 30:return this.begin("boundary"),37;case 31:return this.begin("enterprise_boundary"),34;case 32:return this.begin("system_boundary"),36;case 33:return this.begin("container_ext_queue"),57;case 34:return this.begin("container_ext_db"),56;case 35:return this.begin("container_ext"),55;case 36:return this.begin("container_queue"),54;case 37:return this.begin("container_db"),53;case 38:return this.begin("container"),52;case 39:return this.begin("container_boundary"),38;case 40:return this.begin("component_ext_queue"),63;case 41:return this.begin("component_ext_db"),62;case 42:return this.begin("component_ext"),61;case 43:return this.begin("component_queue"),60;case 44:return this.begin("component_db"),59;case 45:return this.begin("component"),58;case 46:return this.begin("node"),39;case 47:return this.begin("node"),39;case 48:return this.begin("node_l"),40;case 49:return this.begin("node_r"),41;case 50:return this.begin("rel"),64;case 51:return this.begin("birel"),65;case 52:return this.begin("rel_u"),66;case 53:return this.begin("rel_u"),66;case 54:return this.begin("rel_d"),67;case 55:return this.begin("rel_d"),67;case 56:return this.begin("rel_l"),68;case 57:return this.begin("rel_l"),68;case 58:return this.begin("rel_r"),69;case 59:return this.begin("rel_r"),69;case 60:return this.begin("rel_b"),70;case 61:return this.begin("rel_index"),71;case 62:return this.begin("update_el_style"),72;case 63:return this.begin("update_rel_style"),73;case 64:return this.begin("update_layout_config"),74;case 65:return"EOF_IN_STRUCT";case 66:return this.begin("attribute"),"ATTRIBUTE_EMPTY";case 67:this.begin("attribute");break;case 68:this.popState(),this.popState();break;case 69:return 80;case 70:break;case 71:return 80;case 72:this.begin("string");break;case 73:this.popState();break;case 74:return"STR";case 75:this.begin("string_kv");break;case 76:return this.begin("string_kv_key"),"STR_KEY";case 77:this.popState(),this.begin("string_kv_value");break;case 78:return"STR_VALUE";case 79:this.popState(),this.popState();break;case 80:return"STR";case 81:return"LBRACE";case 82:return"RBRACE";case 83:return"SPACE";case 84:return"EOL";case 85:return 14}},rules:[/^(?:.*direction\s+TB[^\n]*)/,/^(?:.*direction\s+BT[^\n]*)/,/^(?:.*direction\s+RL[^\n]*)/,/^(?:.*direction\s+LR[^\n]*)/,/^(?:title\s[^#\n;]+)/,/^(?:accDescription\s[^#\n;]+)/,/^(?:accTitle\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*:\s*)/,/^(?:(?!\n||)*[^\n]*)/,/^(?:accDescr\s*\{\s*)/,/^(?:[\}])/,/^(?:[^\}]*)/,/^(?:%%(?!\{)*[^\n]*(\r?\n?)+)/,/^(?:%%[^\n]*(\r?\n)*)/,/^(?:\s*(\r?\n)+)/,/^(?:\s+)/,/^(?:C4Context\b)/,/^(?:C4Container\b)/,/^(?:C4Component\b)/,/^(?:C4Dynamic\b)/,/^(?:C4Deployment\b)/,/^(?:Person_Ext\b)/,/^(?:Person\b)/,/^(?:SystemQueue_Ext\b)/,/^(?:SystemDb_Ext\b)/,/^(?:System_Ext\b)/,/^(?:SystemQueue\b)/,/^(?:SystemDb\b)/,/^(?:System\b)/,/^(?:Boundary\b)/,/^(?:Enterprise_Boundary\b)/,/^(?:System_Boundary\b)/,/^(?:ContainerQueue_Ext\b)/,/^(?:ContainerDb_Ext\b)/,/^(?:Container_Ext\b)/,/^(?:ContainerQueue\b)/,/^(?:ContainerDb\b)/,/^(?:Container\b)/,/^(?:Container_Boundary\b)/,/^(?:ComponentQueue_Ext\b)/,/^(?:ComponentDb_Ext\b)/,/^(?:Component_Ext\b)/,/^(?:ComponentQueue\b)/,/^(?:ComponentDb\b)/,/^(?:Component\b)/,/^(?:Deployment_Node\b)/,/^(?:Node\b)/,/^(?:Node_L\b)/,/^(?:Node_R\b)/,/^(?:Rel\b)/,/^(?:BiRel\b)/,/^(?:Rel_Up\b)/,/^(?:Rel_U\b)/,/^(?:Rel_Down\b)/,/^(?:Rel_D\b)/,/^(?:Rel_Left\b)/,/^(?:Rel_L\b)/,/^(?:Rel_Right\b)/,/^(?:Rel_R\b)/,/^(?:Rel_Back\b)/,/^(?:RelIndex\b)/,/^(?:UpdateElementStyle\b)/,/^(?:UpdateRelStyle\b)/,/^(?:UpdateLayoutConfig\b)/,/^(?:$)/,/^(?:[(][ ]*[,])/,/^(?:[(])/,/^(?:[)])/,/^(?:,,)/,/^(?:,)/,/^(?:[ ]*["]["])/,/^(?:[ ]*["])/,/^(?:["])/,/^(?:[^"]*)/,/^(?:[ ]*[\$])/,/^(?:[^=]*)/,/^(?:[=][ ]*["])/,/^(?:[^"]+)/,/^(?:["])/,/^(?:[^,]+)/,/^(?:\{)/,/^(?:\})/,/^(?:[\s]+)/,/^(?:[\n\r]+)/,/^(?:$)/],conditions:{acc_descr_multiline:{rules:[11,12],inclusive:!1},acc_descr:{rules:[9],inclusive:!1},acc_title:{rules:[7],inclusive:!1},string_kv_value:{rules:[78,79],inclusive:!1},string_kv_key:{rules:[77],inclusive:!1},string_kv:{rules:[76],inclusive:!1},string:{rules:[73,74],inclusive:!1},attribute:{rules:[68,69,70,71,72,75,80],inclusive:!1},update_layout_config:{rules:[65,66,67,68],inclusive:!1},update_rel_style:{rules:[65,66,67,68],inclusive:!1},update_el_style:{rules:[65,66,67,68],inclusive:!1},rel_b:{rules:[65,66,67,68],inclusive:!1},rel_r:{rules:[65,66,67,68],inclusive:!1},rel_l:{rules:[65,66,67,68],inclusive:!1},rel_d:{rules:[65,66,67,68],inclusive:!1},rel_u:{rules:[65,66,67,68],inclusive:!1},rel_bi:{rules:[],inclusive:!1},rel:{rules:[65,66,67,68],inclusive:!1},node_r:{rules:[65,66,67,68],inclusive:!1},node_l:{rules:[65,66,67,68],inclusive:!1},node:{rules:[65,66,67,68],inclusive:!1},index:{rules:[],inclusive:!1},rel_index:{rules:[65,66,67,68],inclusive:!1},component_ext_queue:{rules:[],inclusive:!1},component_ext_db:{rules:[65,66,67,68],inclusive:!1},component_ext:{rules:[65,66,67,68],inclusive:!1},component_queue:{rules:[65,66,67,68],inclusive:!1},component_db:{rules:[65,66,67,68],inclusive:!1},component:{rules:[65,66,67,68],inclusive:!1},container_boundary:{rules:[65,66,67,68],inclusive:!1},container_ext_queue:{rules:[65,66,67,68],inclusive:!1},container_ext_db:{rules:[65,66,67,68],inclusive:!1},container_ext:{rules:[65,66,67,68],inclusive:!1},container_queue:{rules:[65,66,67,68],inclusive:!1},container_db:{rules:[65,66,67,68],inclusive:!1},container:{rules:[65,66,67,68],inclusive:!1},birel:{rules:[65,66,67,68],inclusive:!1},system_boundary:{rules:[65,66,67,68],inclusive:!1},enterprise_boundary:{rules:[65,66,67,68],inclusive:!1},boundary:{rules:[65,66,67,68],inclusive:!1},system_ext_queue:{rules:[65,66,67,68],inclusive:!1},system_ext_db:{rules:[65,66,67,68],inclusive:!1},system_ext:{rules:[65,66,67,68],inclusive:!1},system_queue:{rules:[65,66,67,68],inclusive:!1},system_db:{rules:[65,66,67,68],inclusive:!1},system:{rules:[65,66,67,68],inclusive:!1},person_ext:{rules:[65,66,67,68],inclusive:!1},person:{rules:[65,66,67,68],inclusive:!1},INITIAL:{rules:[0,1,2,3,4,5,6,8,10,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,81,82,83,84,85],inclusive:!0}}};return Tr}();Ma.lexer=zs;function ao(){this.yy={}}return ao.prototype=Ma,Ma.Parser=ao,new ao}();CQ.parser=CQ;const DVt=CQ;let R3=[],M9=[""],Op="global",j3="",Q4=[{alias:"global",label:{text:"global"},type:{text:"global"},tags:null,link:null,parentBoundary:""}],pR=[],Rbe="",jbe=!1,SQ=4,_Q=2;var xqe;const IVt=function(){return xqe},OVt=function(i){xqe=Yf(i,qt())},NVt=function(i,s,u,d,p,v,b,y,T){if(i==null||s===void 0||s===null||u===void 0||u===null||d===void 0||d===null)return;let _={};const A=pR.find(P=>P.from===s&&P.to===u);if(A?_=A:pR.push(_),_.type=i,_.from=s,_.to=u,_.label={text:d},p==null)_.techn={text:""};else if(typeof p=="object"){let[P,R]=Object.entries(p)[0];_[P]={text:R}}else _.techn={text:p};if(v==null)_.descr={text:""};else if(typeof v=="object"){let[P,R]=Object.entries(v)[0];_[P]={text:R}}else _.descr={text:v};if(typeof b=="object"){let[P,R]=Object.entries(b)[0];_[P]=R}else _.sprite=b;if(typeof y=="object"){let[P,R]=Object.entries(y)[0];_[P]=R}else _.tags=y;if(typeof T=="object"){let[P,R]=Object.entries(T)[0];_[P]=R}else _.link=T;_.wrap=D9()},PVt=function(i,s,u,d,p,v,b){if(s===null||u===null)return;let y={};const T=R3.find(_=>_.alias===s);if(T&&s===T.alias?y=T:(y.alias=s,R3.push(y)),u==null?y.label={text:""}:y.label={text:u},d==null)y.descr={text:""};else if(typeof d=="object"){let[_,A]=Object.entries(d)[0];y[_]={text:A}}else y.descr={text:d};if(typeof p=="object"){let[_,A]=Object.entries(p)[0];y[_]=A}else y.sprite=p;if(typeof v=="object"){let[_,A]=Object.entries(v)[0];y[_]=A}else y.tags=v;if(typeof b=="object"){let[_,A]=Object.entries(b)[0];y[_]=A}else y.link=b;y.typeC4Shape={text:i},y.parentBoundary=Op,y.wrap=D9()},BVt=function(i,s,u,d,p,v,b,y){if(s===null||u===null)return;let T={};const _=R3.find(A=>A.alias===s);if(_&&s===_.alias?T=_:(T.alias=s,R3.push(T)),u==null?T.label={text:""}:T.label={text:u},d==null)T.techn={text:""};else if(typeof d=="object"){let[A,P]=Object.entries(d)[0];T[A]={text:P}}else T.techn={text:d};if(p==null)T.descr={text:""};else if(typeof p=="object"){let[A,P]=Object.entries(p)[0];T[A]={text:P}}else T.descr={text:p};if(typeof v=="object"){let[A,P]=Object.entries(v)[0];T[A]=P}else T.sprite=v;if(typeof b=="object"){let[A,P]=Object.entries(b)[0];T[A]=P}else T.tags=b;if(typeof y=="object"){let[A,P]=Object.entries(y)[0];T[A]=P}else T.link=y;T.wrap=D9(),T.typeC4Shape={text:i},T.parentBoundary=Op},FVt=function(i,s,u,d,p,v,b,y){if(s===null||u===null)return;let T={};const _=R3.find(A=>A.alias===s);if(_&&s===_.alias?T=_:(T.alias=s,R3.push(T)),u==null?T.label={text:""}:T.label={text:u},d==null)T.techn={text:""};else if(typeof d=="object"){let[A,P]=Object.entries(d)[0];T[A]={text:P}}else T.techn={text:d};if(p==null)T.descr={text:""};else if(typeof p=="object"){let[A,P]=Object.entries(p)[0];T[A]={text:P}}else T.descr={text:p};if(typeof v=="object"){let[A,P]=Object.entries(v)[0];T[A]=P}else T.sprite=v;if(typeof b=="object"){let[A,P]=Object.entries(b)[0];T[A]=P}else T.tags=b;if(typeof y=="object"){let[A,P]=Object.entries(y)[0];T[A]=P}else T.link=y;T.wrap=D9(),T.typeC4Shape={text:i},T.parentBoundary=Op},RVt=function(i,s,u,d,p){if(i===null||s===null)return;let v={};const b=Q4.find(y=>y.alias===i);if(b&&i===b.alias?v=b:(v.alias=i,Q4.push(v)),s==null?v.label={text:""}:v.label={text:s},u==null)v.type={text:"system"};else if(typeof u=="object"){let[y,T]=Object.entries(u)[0];v[y]={text:T}}else v.type={text:u};if(typeof d=="object"){let[y,T]=Object.entries(d)[0];v[y]=T}else v.tags=d;if(typeof p=="object"){let[y,T]=Object.entries(p)[0];v[y]=T}else v.link=p;v.parentBoundary=Op,v.wrap=D9(),j3=Op,Op=i,M9.push(j3)},jVt=function(i,s,u,d,p){if(i===null||s===null)return;let v={};const b=Q4.find(y=>y.alias===i);if(b&&i===b.alias?v=b:(v.alias=i,Q4.push(v)),s==null?v.label={text:""}:v.label={text:s},u==null)v.type={text:"container"};else if(typeof u=="object"){let[y,T]=Object.entries(u)[0];v[y]={text:T}}else v.type={text:u};if(typeof d=="object"){let[y,T]=Object.entries(d)[0];v[y]=T}else v.tags=d;if(typeof p=="object"){let[y,T]=Object.entries(p)[0];v[y]=T}else v.link=p;v.parentBoundary=Op,v.wrap=D9(),j3=Op,Op=i,M9.push(j3)},$Vt=function(i,s,u,d,p,v,b,y){if(s===null||u===null)return;let T={};const _=Q4.find(A=>A.alias===s);if(_&&s===_.alias?T=_:(T.alias=s,Q4.push(T)),u==null?T.label={text:""}:T.label={text:u},d==null)T.type={text:"node"};else if(typeof d=="object"){let[A,P]=Object.entries(d)[0];T[A]={text:P}}else T.type={text:d};if(p==null)T.descr={text:""};else if(typeof p=="object"){let[A,P]=Object.entries(p)[0];T[A]={text:P}}else T.descr={text:p};if(typeof b=="object"){let[A,P]=Object.entries(b)[0];T[A]=P}else T.tags=b;if(typeof y=="object"){let[A,P]=Object.entries(y)[0];T[A]=P}else T.link=y;T.nodeType=i,T.parentBoundary=Op,T.wrap=D9(),j3=Op,Op=s,M9.push(j3)},zVt=function(){Op=j3,M9.pop(),j3=M9.pop(),M9.push(j3)},qVt=function(i,s,u,d,p,v,b,y,T,_,A){let P=R3.find(R=>R.alias===s);if(!(P===void 0&&(P=Q4.find(R=>R.alias===s),P===void 0))){if(u!=null)if(typeof u=="object"){let[R,F]=Object.entries(u)[0];P[R]=F}else P.bgColor=u;if(d!=null)if(typeof d=="object"){let[R,F]=Object.entries(d)[0];P[R]=F}else P.fontColor=d;if(p!=null)if(typeof p=="object"){let[R,F]=Object.entries(p)[0];P[R]=F}else P.borderColor=p;if(v!=null)if(typeof v=="object"){let[R,F]=Object.entries(v)[0];P[R]=F}else P.shadowing=v;if(b!=null)if(typeof b=="object"){let[R,F]=Object.entries(b)[0];P[R]=F}else P.shape=b;if(y!=null)if(typeof y=="object"){let[R,F]=Object.entries(y)[0];P[R]=F}else P.sprite=y;if(T!=null)if(typeof T=="object"){let[R,F]=Object.entries(T)[0];P[R]=F}else P.techn=T;if(_!=null)if(typeof _=="object"){let[R,F]=Object.entries(_)[0];P[R]=F}else P.legendText=_;if(A!=null)if(typeof A=="object"){let[R,F]=Object.entries(A)[0];P[R]=F}else P.legendSprite=A}},HVt=function(i,s,u,d,p,v,b){const y=pR.find(T=>T.from===s&&T.to===u);if(y!==void 0){if(d!=null)if(typeof d=="object"){let[T,_]=Object.entries(d)[0];y[T]=_}else y.textColor=d;if(p!=null)if(typeof p=="object"){let[T,_]=Object.entries(p)[0];y[T]=_}else y.lineColor=p;if(v!=null)if(typeof v=="object"){let[T,_]=Object.entries(v)[0];y[T]=parseInt(_)}else y.offsetX=parseInt(v);if(b!=null)if(typeof b=="object"){let[T,_]=Object.entries(b)[0];y[T]=parseInt(_)}else y.offsetY=parseInt(b)}},VVt=function(i,s,u){let d=SQ,p=_Q;if(typeof s=="object"){const v=Object.values(s)[0];d=parseInt(v)}else d=parseInt(s);if(typeof u=="object"){const v=Object.values(u)[0];p=parseInt(v)}else p=parseInt(u);d>=1&&(SQ=d),p>=1&&(_Q=p)},UVt=function(){return SQ},GVt=function(){return _Q},KVt=function(){return Op},WVt=function(){return j3},kqe=function(i){return i==null?R3:R3.filter(s=>s.parentBoundary===i)},YVt=function(i){return R3.find(s=>s.alias===i)},XVt=function(i){return Object.keys(kqe(i))},Eqe=function(i){return i==null?Q4:Q4.filter(s=>s.parentBoundary===i)},QVt=Eqe,JVt=function(){return pR},ZVt=function(){return Rbe},eUt=function(i){jbe=i},D9=function(){return jbe},$be={addPersonOrSystem:PVt,addPersonOrSystemBoundary:RVt,addContainer:BVt,addContainerBoundary:jVt,addComponent:FVt,addDeploymentNode:$Vt,popBoundaryParseStack:zVt,addRel:NVt,updateElStyle:qVt,updateRelStyle:HVt,updateLayoutConfig:VVt,autoWrap:D9,setWrap:eUt,getC4ShapeArray:kqe,getC4Shape:YVt,getC4ShapeKeys:XVt,getBoundaries:Eqe,getBoundarys:QVt,getCurrentBoundaryParse:KVt,getParentBoundaryParse:WVt,getRels:JVt,getTitle:ZVt,getC4Type:IVt,getC4ShapeInRow:UVt,getC4BoundaryInRow:GVt,setAccTitle:Bg,getAccTitle:Cp,getAccDescription:_p,setAccDescription:Sp,getConfig:()=>qt().c4,clear:function(){R3=[],Q4=[{alias:"global",label:{text:"global"},type:{text:"global"},tags:null,link:null,parentBoundary:""}],j3="",Op="global",M9=[""],pR=[],M9=[""],Rbe="",jbe=!1,SQ=4,_Q=2},LINETYPE:{SOLID:0,DOTTED:1,NOTE:2,SOLID_CROSS:3,DOTTED_CROSS:4,SOLID_OPEN:5,DOTTED_OPEN:6,LOOP_START:10,LOOP_END:11,ALT_START:12,ALT_ELSE:13,ALT_END:14,OPT_START:15,OPT_END:16,ACTIVE_START:17,ACTIVE_END:18,PAR_START:19,PAR_AND:20,PAR_END:21,RECT_START:22,RECT_END:23,SOLID_POINT:24,DOTTED_POINT:25},ARROWTYPE:{FILLED:0,OPEN:1},PLACEMENT:{LEFTOF:0,RIGHTOF:1,OVER:2},setTitle:function(i){Rbe=Yf(i,qt())},setC4Type:OVt},AQ=(i,s)=>{const u=i.append("rect");if(u.attr("x",s.x),u.attr("y",s.y),u.attr("fill",s.fill),u.attr("stroke",s.stroke),u.attr("width",s.width),u.attr("height",s.height),s.name&&u.attr("name",s.name),s.rx!==void 0&&u.attr("rx",s.rx),s.ry!==void 0&&u.attr("ry",s.ry),s.attrs!==void 0)for(const d in s.attrs)u.attr(d,s.attrs[d]);return s.class!==void 0&&u.attr("class",s.class),u},Tqe=(i,s)=>{const u={x:s.startx,y:s.starty,width:s.stopx-s.startx,height:s.stopy-s.starty,fill:s.fill,stroke:s.stroke,class:"rect"};AQ(i,u).lower()},tUt=(i,s)=>{const u=s.text.replace(fD," "),d=i.append("text");d.attr("x",s.x),d.attr("y",s.y),d.attr("class","legend"),d.style("text-anchor",s.anchor),s.class!==void 0&&d.attr("class",s.class);const p=d.append("tspan");return p.attr("x",s.x+s.textMargin*2),p.text(u),d},nUt=(i,s,u,d)=>{const p=i.append("image");p.attr("x",s),p.attr("y",u);const v=p9.sanitizeUrl(d);p.attr("xlink:href",v)},rUt=(i,s,u,d)=>{const p=i.append("use");p.attr("x",s),p.attr("y",u);const v=p9.sanitizeUrl(d);p.attr("xlink:href",`#${v}`)},qC=()=>({x:0,y:0,width:100,height:100,fill:"#EDF2AE",stroke:"#666",anchor:"start",rx:0,ry:0}),zbe=()=>({x:0,y:0,width:100,height:100,"text-anchor":"start",style:"#666",textMargin:0,rx:0,ry:0,tspan:!0}),qbe=function(i,s){return AQ(i,s)},Cqe=function(i,s,u,d,p,v){const b=i.append("image");b.attr("width",s),b.attr("height",u),b.attr("x",d),b.attr("y",p);let y=v.startsWith("data:image/png;base64")?v:p9.sanitizeUrl(v);b.attr("xlink:href",y)},iUt=(i,s,u)=>{const d=i.append("g");let p=0;for(let v of s){let b=v.textColor?v.textColor:"#444444",y=v.lineColor?v.lineColor:"#444444",T=v.offsetX?parseInt(v.offsetX):0,_=v.offsetY?parseInt(v.offsetY):0,A="";if(p===0){let R=d.append("line");R.attr("x1",v.startPoint.x),R.attr("y1",v.startPoint.y),R.attr("x2",v.endPoint.x),R.attr("y2",v.endPoint.y),R.attr("stroke-width","1"),R.attr("stroke",y),R.style("fill","none"),v.type!=="rel_b"&&R.attr("marker-end","url("+A+"#arrowhead)"),(v.type==="birel"||v.type==="rel_b")&&R.attr("marker-start","url("+A+"#arrowend)"),p=-1}else{let R=d.append("path");R.attr("fill","none").attr("stroke-width","1").attr("stroke",y).attr("d","Mstartx,starty Qcontrolx,controly stopx,stopy ".replaceAll("startx",v.startPoint.x).replaceAll("starty",v.startPoint.y).replaceAll("controlx",v.startPoint.x+(v.endPoint.x-v.startPoint.x)/2-(v.endPoint.x-v.startPoint.x)/4).replaceAll("controly",v.startPoint.y+(v.endPoint.y-v.startPoint.y)/2).replaceAll("stopx",v.endPoint.x).replaceAll("stopy",v.endPoint.y)),v.type!=="rel_b"&&R.attr("marker-end","url("+A+"#arrowhead)"),(v.type==="birel"||v.type==="rel_b")&&R.attr("marker-start","url("+A+"#arrowend)")}let P=u.messageFont();F7(u)(v.label.text,d,Math.min(v.startPoint.x,v.endPoint.x)+Math.abs(v.endPoint.x-v.startPoint.x)/2+T,Math.min(v.startPoint.y,v.endPoint.y)+Math.abs(v.endPoint.y-v.startPoint.y)/2+_,v.label.width,v.label.height,{fill:b},P),v.techn&&v.techn.text!==""&&(P=u.messageFont(),F7(u)("["+v.techn.text+"]",d,Math.min(v.startPoint.x,v.endPoint.x)+Math.abs(v.endPoint.x-v.startPoint.x)/2+T,Math.min(v.startPoint.y,v.endPoint.y)+Math.abs(v.endPoint.y-v.startPoint.y)/2+u.messageFontSize+5+_,Math.max(v.label.width,v.techn.width),v.techn.height,{fill:b,"font-style":"italic"},P))}},sUt=function(i,s,u){const d=i.append("g");let p=s.bgColor?s.bgColor:"none",v=s.borderColor?s.borderColor:"#444444",b=s.fontColor?s.fontColor:"black",y={"stroke-width":1,"stroke-dasharray":"7.0,7.0"};s.nodeType&&(y={"stroke-width":1});let T={x:s.x,y:s.y,fill:p,stroke:v,width:s.width,height:s.height,rx:2.5,ry:2.5,attrs:y};qbe(d,T);let _=u.boundaryFont();_.fontWeight="bold",_.fontSize=_.fontSize+2,_.fontColor=b,F7(u)(s.label.text,d,s.x,s.y+s.label.Y,s.width,s.height,{fill:"#444444"},_),s.type&&s.type.text!==""&&(_=u.boundaryFont(),_.fontColor=b,F7(u)(s.type.text,d,s.x,s.y+s.type.Y,s.width,s.height,{fill:"#444444"},_)),s.descr&&s.descr.text!==""&&(_=u.boundaryFont(),_.fontSize=_.fontSize-2,_.fontColor=b,F7(u)(s.descr.text,d,s.x,s.y+s.descr.Y,s.width,s.height,{fill:"#444444"},_))},aUt=function(i,s,u){var P;let d=s.bgColor?s.bgColor:u[s.typeC4Shape.text+"_bg_color"],p=s.borderColor?s.borderColor:u[s.typeC4Shape.text+"_border_color"],v=s.fontColor?s.fontColor:"#FFFFFF",b="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAACD0lEQVR4Xu2YoU4EMRCGT+4j8Ai8AhaH4QHgAUjQuFMECUgMIUgwJAgMhgQsAYUiJCiQIBBY+EITsjfTdme6V24v4c8vyGbb+ZjOtN0bNcvjQXmkH83WvYBWto6PLm6v7p7uH1/w2fXD+PBycX1Pv2l3IdDm/vn7x+dXQiAubRzoURa7gRZWd0iGRIiJbOnhnfYBQZNJjNbuyY2eJG8fkDE3bbG4ep6MHUAsgYxmE3nVs6VsBWJSGccsOlFPmLIViMzLOB7pCVO2AtHJMohH7Fh6zqitQK7m0rJvAVYgGcEpe//PLdDz65sM4pF9N7ICcXDKIB5Nv6j7tD0NoSdM2QrU9Gg0ewE1LqBhHR3BBdvj2vapnidjHxD/q6vd7Pvhr31AwcY8eXMTXAKECZZJFXuEq27aLgQK5uLMohCenGGuGewOxSjBvYBqeG6B+Nqiblggdjnc+ZXDy+FNFpFzw76O3UBAROuXh6FoiAcf5g9eTvUgzy0nWg6I8cXHRUpg5bOVBCo+KDpFajOf23GgPme7RSQ+lacIENUgJ6gg1k6HjgOlqnLqip4tEuhv0hNEMXUD0clyXE3p6pZA0S2nnvTlXwLJEZWlb7cTQH1+USgTN4VhAenm/wea1OCAOmqo6fE1WCb9WSKBah+rbUWPWAmE2Rvk0ApiB45eOyNAzU8xcTvj8KvkKEoOaIYeHNA3ZuygAvFMUO0AAAAASUVORK5CYII=";switch(s.typeC4Shape.text){case"person":b="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAACD0lEQVR4Xu2YoU4EMRCGT+4j8Ai8AhaH4QHgAUjQuFMECUgMIUgwJAgMhgQsAYUiJCiQIBBY+EITsjfTdme6V24v4c8vyGbb+ZjOtN0bNcvjQXmkH83WvYBWto6PLm6v7p7uH1/w2fXD+PBycX1Pv2l3IdDm/vn7x+dXQiAubRzoURa7gRZWd0iGRIiJbOnhnfYBQZNJjNbuyY2eJG8fkDE3bbG4ep6MHUAsgYxmE3nVs6VsBWJSGccsOlFPmLIViMzLOB7pCVO2AtHJMohH7Fh6zqitQK7m0rJvAVYgGcEpe//PLdDz65sM4pF9N7ICcXDKIB5Nv6j7tD0NoSdM2QrU9Gg0ewE1LqBhHR3BBdvj2vapnidjHxD/q6vd7Pvhr31AwcY8eXMTXAKECZZJFXuEq27aLgQK5uLMohCenGGuGewOxSjBvYBqeG6B+Nqiblggdjnc+ZXDy+FNFpFzw76O3UBAROuXh6FoiAcf5g9eTvUgzy0nWg6I8cXHRUpg5bOVBCo+KDpFajOf23GgPme7RSQ+lacIENUgJ6gg1k6HjgOlqnLqip4tEuhv0hNEMXUD0clyXE3p6pZA0S2nnvTlXwLJEZWlb7cTQH1+USgTN4VhAenm/wea1OCAOmqo6fE1WCb9WSKBah+rbUWPWAmE2Rvk0ApiB45eOyNAzU8xcTvj8KvkKEoOaIYeHNA3ZuygAvFMUO0AAAAASUVORK5CYII=";break;case"external_person":b="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAIAAADYYG7QAAAB6ElEQVR4Xu2YLY+EMBCG9+dWr0aj0Wg0Go1Go0+j8Xdv2uTCvv1gpt0ebHKPuhDaeW4605Z9mJvx4AdXUyTUdd08z+u6flmWZRnHsWkafk9DptAwDPu+f0eAYtu2PEaGWuj5fCIZrBAC2eLBAnRCsEkkxmeaJp7iDJ2QMDdHsLg8SxKFEJaAo8lAXnmuOFIhTMpxxKATebo4UiFknuNo4OniSIXQyRxEA3YsnjGCVEjVXD7yLUAqxBGUyPv/Y4W2beMgGuS7kVQIBycH0fD+oi5pezQETxdHKmQKGk1eQEYldK+jw5GxPfZ9z7Mk0Qnhf1W1m3w//EUn5BDmSZsbR44QQLBEqrBHqOrmSKaQAxdnLArCrxZcM7A7ZKs4ioRq8LFC+NpC3WCBJsvpVw5edm9iEXFuyNfxXAgSwfrFQ1c0iNda8AdejvUgnktOtJQQxmcfFzGglc5WVCj7oDgFqU18boeFSs52CUh8LE8BIVQDT1ABrB0HtgSEYlX5doJnCwv9TXocKCaKbnwhdDKPq4lf3SwU3HLq4V/+WYhHVMa/3b4IlfyikAduCkcBc7mQ3/z/Qq/cTuikhkzB12Ae/mcJC9U+Vo8Ej1gWAtgbeGgFsAMHr50BIWOLCbezvhpBFUdY6EJuJ/QDW0XoMX60zZ0AAAAASUVORK5CYII=";break}const y=i.append("g");y.attr("class","person-man");const T=qC();switch(s.typeC4Shape.text){case"person":case"external_person":case"system":case"external_system":case"container":case"external_container":case"component":case"external_component":T.x=s.x,T.y=s.y,T.fill=d,T.width=s.width,T.height=s.height,T.stroke=p,T.rx=2.5,T.ry=2.5,T.attrs={"stroke-width":.5},qbe(y,T);break;case"system_db":case"external_system_db":case"container_db":case"external_container_db":case"component_db":case"external_component_db":y.append("path").attr("fill",d).attr("stroke-width","0.5").attr("stroke",p).attr("d","Mstartx,startyc0,-10 half,-10 half,-10c0,0 half,0 half,10l0,heightc0,10 -half,10 -half,10c0,0 -half,0 -half,-10l0,-height".replaceAll("startx",s.x).replaceAll("starty",s.y).replaceAll("half",s.width/2).replaceAll("height",s.height)),y.append("path").attr("fill","none").attr("stroke-width","0.5").attr("stroke",p).attr("d","Mstartx,startyc0,10 half,10 half,10c0,0 half,0 half,-10".replaceAll("startx",s.x).replaceAll("starty",s.y).replaceAll("half",s.width/2));break;case"system_queue":case"external_system_queue":case"container_queue":case"external_container_queue":case"component_queue":case"external_component_queue":y.append("path").attr("fill",d).attr("stroke-width","0.5").attr("stroke",p).attr("d","Mstartx,startylwidth,0c5,0 5,half 5,halfc0,0 0,half -5,halfl-width,0c-5,0 -5,-half -5,-halfc0,0 0,-half 5,-half".replaceAll("startx",s.x).replaceAll("starty",s.y).replaceAll("width",s.width).replaceAll("half",s.height/2)),y.append("path").attr("fill","none").attr("stroke-width","0.5").attr("stroke",p).attr("d","Mstartx,startyc-5,0 -5,half -5,halfc0,half 5,half 5,half".replaceAll("startx",s.x+s.width).replaceAll("starty",s.y).replaceAll("half",s.height/2));break}let _=pUt(u,s.typeC4Shape.text);switch(y.append("text").attr("fill",v).attr("font-family",_.fontFamily).attr("font-size",_.fontSize-2).attr("font-style","italic").attr("lengthAdjust","spacing").attr("textLength",s.typeC4Shape.width).attr("x",s.x+s.width/2-s.typeC4Shape.width/2).attr("y",s.y+s.typeC4Shape.Y).text("<<"+s.typeC4Shape.text+">>"),s.typeC4Shape.text){case"person":case"external_person":Cqe(y,48,48,s.x+s.width/2-24,s.y+s.image.Y,b);break}let A=u[s.typeC4Shape.text+"Font"]();return A.fontWeight="bold",A.fontSize=A.fontSize+2,A.fontColor=v,F7(u)(s.label.text,y,s.x,s.y+s.label.Y,s.width,s.height,{fill:v},A),A=u[s.typeC4Shape.text+"Font"](),A.fontColor=v,s.techn&&((P=s.techn)==null?void 0:P.text)!==""?F7(u)(s.techn.text,y,s.x,s.y+s.techn.Y,s.width,s.height,{fill:v,"font-style":"italic"},A):s.type&&s.type.text!==""&&F7(u)(s.type.text,y,s.x,s.y+s.type.Y,s.width,s.height,{fill:v,"font-style":"italic"},A),s.descr&&s.descr.text!==""&&(A=u.personFont(),A.fontColor=v,F7(u)(s.descr.text,y,s.x,s.y+s.descr.Y,s.width,s.height,{fill:v},A)),s.height},oUt=function(i){i.append("defs").append("symbol").attr("id","database").attr("fill-rule","evenodd").attr("clip-rule","evenodd").append("path").attr("transform","scale(.5)").attr("d","M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z")},cUt=function(i){i.append("defs").append("symbol").attr("id","computer").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z")},uUt=function(i){i.append("defs").append("symbol").attr("id","clock").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z")},lUt=function(i){i.append("defs").append("marker").attr("id","arrowhead").attr("refX",9).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z")},hUt=function(i){i.append("defs").append("marker").attr("id","arrowend").attr("refX",1).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 10 0 L 0 5 L 10 10 z")},fUt=function(i){i.append("defs").append("marker").attr("id","filled-head").attr("refX",18).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},dUt=function(i){i.append("defs").append("marker").attr("id","sequencenumber").attr("refX",15).attr("refY",15).attr("markerWidth",60).attr("markerHeight",40).attr("orient","auto").append("circle").attr("cx",15).attr("cy",15).attr("r",6)},gUt=function(i){const u=i.append("defs").append("marker").attr("id","crosshead").attr("markerWidth",15).attr("markerHeight",8).attr("orient","auto").attr("refX",16).attr("refY",4);u.append("path").attr("fill","black").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 9,2 V 6 L16,4 Z"),u.append("path").attr("fill","none").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1px").attr("d","M 0,1 L 6,7 M 6,1 L 0,7")},pUt=(i,s)=>({fontFamily:i[s+"FontFamily"],fontSize:i[s+"FontSize"],fontWeight:i[s+"FontWeight"]}),F7=function(){function i(p,v,b,y,T,_,A){const P=v.append("text").attr("x",b+T/2).attr("y",y+_/2+5).style("text-anchor","middle").text(p);d(P,A)}function s(p,v,b,y,T,_,A,P){const{fontSize:R,fontFamily:F,fontWeight:j}=P,K=p.split(ci.lineBreakRegex);for(let ee=0;ee p?R=new jv(u,y):u==p&&d =A?R=new jv(u+i.width,y+A*i.width/2):R=new jv(b+T/_*i.height/2,d+i.height):u v?P>=A?R=new jv(u+i.width,y-A*i.width/2):R=new jv(b+i.height/2*T/_,d):u>p&&d>v&&(P>=A?R=new jv(u,y-i.width/2*A):R=new jv(b-i.height/2*T/_,d)),R},mUt=function(i,s){let u={x:0,y:0};u.x=s.x+s.width/2,u.y=s.y+s.height/2;let d=Mqe(i,u);u.x=i.x+i.width/2,u.y=i.y+i.height/2;let p=Mqe(s,u);return{startPoint:d,endPoint:p}};const vUt=function(i,s,u,d){let p=0;for(let v of s){p=p+1;let b=v.wrap&&$s.wrap,y=bUt($s);d.db.getC4Type()==="C4Dynamic"&&(v.label.text=p+": "+v.label.text);let _=H4(v.label.text,y);$3("label",v,b,y,_),v.techn&&v.techn.text!==""&&(_=H4(v.techn.text,y),$3("techn",v,b,y,_)),v.descr&&v.descr.text!==""&&(_=H4(v.descr.text,y),$3("descr",v,b,y,_));let A=u(v.from),P=u(v.to),R=mUt(A,P);v.startPoint=R.startPoint,v.endPoint=R.endPoint}J4.drawRels(i,s,$s)};function Dqe(i,s,u,d,p){let v=new _qe(p);v.data.widthLimit=u.data.widthLimit/Math.min(Hbe,d.length);for(let[b,y]of d.entries()){let T=0;y.image={width:0,height:0,Y:0},y.sprite&&(y.image.width=48,y.image.height=48,y.image.Y=T,T=y.image.Y+y.image.height);let _=y.wrap&&$s.wrap,A=DQ($s);if(A.fontSize=A.fontSize+2,A.fontWeight="bold",$3("label",y,_,A,v.data.widthLimit),y.label.Y=T+8,T=y.label.Y+y.label.height,y.type&&y.type.text!==""){y.type.text="["+y.type.text+"]";let j=DQ($s);$3("type",y,_,j,v.data.widthLimit),y.type.Y=T+5,T=y.type.Y+y.type.height}if(y.descr&&y.descr.text!==""){let j=DQ($s);j.fontSize=j.fontSize-2,$3("descr",y,_,j,v.data.widthLimit),y.descr.Y=T+20,T=y.descr.Y+y.descr.height}if(b==0||b%Hbe===0){let j=u.data.startx+$s.diagramMarginX,K=u.data.stopy+$s.diagramMarginY+T;v.setData(j,j,K,K)}else{let j=v.data.stopx!==v.data.startx?v.data.stopx+$s.diagramMarginX:v.data.startx,K=v.data.starty;v.setData(j,j,K,K)}v.name=y.alias;let P=p.db.getC4ShapeArray(y.alias),R=p.db.getC4ShapeKeys(y.alias);R.length>0&&Lqe(v,i,P,R),s=y.alias;let F=p.db.getBoundarys(s);F.length>0&&Dqe(i,s,v,F,p),y.alias!=="global"&&Aqe(i,y,v),u.data.stopy=Math.max(v.data.stopy+$s.c4ShapeMargin,u.data.stopy),u.data.stopx=Math.max(v.data.stopx+$s.c4ShapeMargin,u.data.stopx),LQ=Math.max(LQ,u.data.stopx),MQ=Math.max(MQ,u.data.stopy)}}const Iqe={drawPersonOrSystemArray:Lqe,drawBoundary:Aqe,setConf:Vbe,draw:function(i,s,u,d){$s=qt().c4;const p=qt().securityLevel;let v;p==="sandbox"&&(v=Ir("#i"+s));const b=Ir(p==="sandbox"?v.nodes()[0].contentDocument.body:"body");let y=d.db;d.db.setWrap($s.wrap),Sqe=y.getC4ShapeInRow(),Hbe=y.getC4BoundaryInRow(),Xe.debug(`C:${JSON.stringify($s,null,2)}`);const T=p==="sandbox"?b.select(`[id="${s}"]`):Ir(`[id="${s}"]`);J4.insertComputerIcon(T),J4.insertDatabaseIcon(T),J4.insertClockIcon(T);let _=new _qe(d);_.setData($s.diagramMarginX,$s.diagramMarginX,$s.diagramMarginY,$s.diagramMarginY),_.data.widthLimit=screen.availWidth,LQ=$s.diagramMarginX,MQ=$s.diagramMarginY;const A=d.db.getTitle();let P=d.db.getBoundarys("");Dqe(T,"",_,P,d),J4.insertArrowHead(T),J4.insertArrowEnd(T),J4.insertArrowCrossHead(T),J4.insertArrowFilledHead(T),vUt(T,d.db.getRels(),d.db.getC4Shape,d),_.data.stopx=LQ,_.data.stopy=MQ;const R=_.data;let j=R.stopy-R.starty+2*$s.diagramMarginY;const ee=R.stopx-R.startx+2*$s.diagramMarginX;A&&T.append("text").text(A).attr("x",(R.stopx-R.startx)/2-4*$s.diagramMarginX).attr("y",R.starty+$s.diagramMarginY),Ng(T,j,ee,$s.useMaxWidth);const ie=A?60:0;T.attr("viewBox",R.startx-$s.diagramMarginX+" -"+($s.diagramMarginY+ie)+" "+ee+" "+(j+ie)),Xe.debug("models:",R)}},wUt=Object.freeze(Object.defineProperty({__proto__:null,diagram:{parser:DVt,db:$be,renderer:Iqe,styles:i=>`.person {
stroke: ${i.personBorder};
fill: ${i.personBkg};
}
@@ -361,13 +361,13 @@ Expecting `+Ba.join(", ")+", got '"+(this.terminals_[Xc]||Xc)+"'":ga="Parse erro
Expecting `+l5.join(", ")+", got '"+(this.terminals_[y1]||y1)+"'":X3="Parse error on line "+(z0+1)+": Unexpected "+(y1==$9?"end of input":"'"+(this.terminals_[y1]||y1)+"'"),this.parseError(X3,{text:Eh.match,token:this.terminals_[y1]||y1,line:Eh.yylineno,loc:z9,expected:l5})}if(ld[0]instanceof Array&&ld.length>1)throw new Error("Parse Error: multiple actions possible at state: "+ud+", token: "+y1);switch(ld[0]){case 1:Qa.push(y1),Nu.push(Eh.yytext),Ot.push(Eh.yylloc),Qa.push(ld[1]),y1=null,Bp=Eh.yyleng,Kt=Eh.yytext,z0=Eh.yylineno,z9=Eh.yylloc;break;case 2:if(G2=this.productions_[ld[1]][1],Vv.$=Nu[Nu.length-G2],Vv._$={first_line:Ot[Ot.length-(G2||1)].first_line,last_line:Ot[Ot.length-1].last_line,first_column:Ot[Ot.length-(G2||1)].first_column,last_column:Ot[Ot.length-1].last_column},mm&&(Vv._$.range=[Ot[Ot.length-(G2||1)].range[0],Ot[Ot.length-1].range[1]]),q9=this.performAction.apply(Vv,[Kt,Bp,z0,zg.yy,ld[1],Nu,Ot].concat(c5)),typeof q9<"u")return q9;G2&&(Qa=Qa.slice(0,-1*G2*2),Nu=Nu.slice(0,-1*G2),Ot=Ot.slice(0,-1*G2)),Qa.push(this.productions_[ld[1]][0]),Nu.push(Vv.$),Ot.push(Vv._$),X7=W3[Qa[Qa.length-2]][Qa[Qa.length-1]],Qa.push(X7);break;case 3:return!0}}return!0}},Yh=function(){var $0={EOF:1,parseError:function(Bs,Qa){if(this.yy.parser)this.yy.parser.parseError(Bs,Qa);else throw new Error(Bs)},setInput:function(Wi,Bs){return this.yy=Bs||this.yy||{},this._input=Wi,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var Wi=this._input[0];this.yytext+=Wi,this.yyleng++,this.offset++,this.match+=Wi,this.matched+=Wi;var Bs=Wi.match(/(?:\r\n?|\n).*/g);return Bs?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),Wi},unput:function(Wi){var Bs=Wi.length,Qa=Wi.split(/(?:\r\n?|\n)/g);this._input=Wi+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-Bs),this.offset-=Bs;var Bi=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),Qa.length-1&&(this.yylineno-=Qa.length-1);var Nu=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:Qa?(Qa.length===Bi.length?this.yylloc.first_column:0)+Bi[Bi.length-Qa.length].length-Qa[0].length:this.yylloc.first_column-Bs},this.options.ranges&&(this.yylloc.range=[Nu[0],Nu[0]+this.yyleng-Bs]),this.yyleng=this.yytext.length,this},more:function(){return this._more=!0,this},reject:function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},less:function(Wi){this.unput(this.match.slice(Wi))},pastInput:function(){var Wi=this.matched.substr(0,this.matched.length-this.match.length);return(Wi.length>20?"...":"")+Wi.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var Wi=this.match;return Wi.length<20&&(Wi+=this._input.substr(0,20-Wi.length)),(Wi.substr(0,20)+(Wi.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var Wi=this.pastInput(),Bs=new Array(Wi.length+1).join("-");return Wi+this.upcomingInput()+`
`+Bs+"^"},test_match:function(Wi,Bs){var Qa,Bi,Nu;if(this.options.backtrack_lexer&&(Nu={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(Nu.yylloc.range=this.yylloc.range.slice(0))),Bi=Wi[0].match(/(?:\r\n?|\n).*/g),Bi&&(this.yylineno+=Bi.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:Bi?Bi[Bi.length-1].length-Bi[Bi.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+Wi[0].length},this.yytext+=Wi[0],this.match+=Wi[0],this.matches=Wi,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(Wi[0].length),this.matched+=Wi[0],Qa=this.performAction.call(this,this.yy,this,Bs,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),Qa)return Qa;if(this._backtrack){for(var Ot in Nu)this[Ot]=Nu[Ot];return!1}return!1},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var Wi,Bs,Qa,Bi;this._more||(this.yytext="",this.match="");for(var Nu=this._currentRules(),Ot=0;Ot 0}function e5(i,s,u){var d=i.x,p=i.y,v=[],b=Number.POSITIVE_INFINITY,y=Number.POSITIVE_INFINITY;s.forEach(function(j){b=Math.min(b,j.x),y=Math.min(y,j.y)});for(var T=d-i.width/2-b,_=p-i.height/2-y,A=0;A 0}function KZt(i,s,u){var d=i.x,p=i.y,v=[],b=Number.POSITIVE_INFINITY,y=Number.POSITIVE_INFINITY;typeof s.forEach=="function"?s.forEach(function(j){b=Math.min(b,j.x),y=Math.min(y,j.y)}):(b=Math.min(b,s.x),y=Math.min(y,s.y));for(var T=d-i.width/2-b,_=p-i.height/2-y,A=0;A {Se.add(Ce.from),Se.add(Ce.to)}),j=j.filter(Ce=>Se.has(Ce))}await din(_,A,P,j,0,K,!1);const be=await xin(K,A,pe,d);Zf.insertArrowHead(_),Zf.insertArrowCrossHead(_),Zf.insertArrowFilledHead(_),Zf.insertSequenceNumber(_);function ae(Se,Ce){const ke=ni.endActivation(Se);ke.starty+18>Ce&&(ke.starty=Ce-6,Ce+=12),Zf.drawActivation(_,ke,Ce,En,bJ(Se.from.actor).length),ni.insert(ke.startx,Ce-10,ke.stopx,Ce)}let ne=1,se=1;const de=[],X=[];let ge=0;for(const Se of K){let Ce,ke,Ke;switch(Se.type){case d.db.LINETYPE.NOTE:ni.resetVerticalPos(),ke=Se.noteModel,await lin(_,ke);break;case d.db.LINETYPE.ACTIVE_START:ni.newActivation(Se,_,A);break;case d.db.LINETYPE.ACTIVE_END:ae(Se,ni.getVerticalPos());break;case d.db.LINETYPE.LOOP_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.LOOP_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"loop",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.RECT_START:a5(be,Se,En.boxMargin,En.boxMargin,Ft=>ni.newLoop(void 0,Ft.message));break;case d.db.LINETYPE.RECT_END:Ce=ni.endLoop(),X.push(Ce),ni.models.addLoop(Ce),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos());break;case d.db.LINETYPE.OPT_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.OPT_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"opt",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.ALT_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.ALT_ELSE:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.ALT_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"alt",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.PAR_START:case d.db.LINETYPE.PAR_OVER_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft)),ni.saveVerticalPos();break;case d.db.LINETYPE.PAR_AND:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.PAR_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"par",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.AUTONUMBER:ne=Se.message.start||ne,se=Se.message.step||se,Se.message.visible?d.db.enableSequenceNumbers():d.db.disableSequenceNumbers();break;case d.db.LINETYPE.CRITICAL_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.CRITICAL_OPTION:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.CRITICAL_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"critical",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.BREAK_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.BREAK_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"break",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;default:try{Ke=Se.msgModel,Ke.starty=ni.getVerticalPos(),Ke.sequenceIndex=ne,Ke.sequenceVisible=d.db.showSequenceNumbers();const Ft=await hin(_,Ke);gin(Se,Ke,Ft,ge,A,P,R),de.push({messageModel:Ke,lineStartY:Ft}),ni.models.addMessage(Ke)}catch(Ft){Xe.error("error while drawing message",Ft)}}[d.db.LINETYPE.SOLID_OPEN,d.db.LINETYPE.DOTTED_OPEN,d.db.LINETYPE.SOLID,d.db.LINETYPE.DOTTED,d.db.LINETYPE.SOLID_CROSS,d.db.LINETYPE.DOTTED_CROSS,d.db.LINETYPE.SOLID_POINT,d.db.LINETYPE.DOTTED_POINT].includes(Se.type)&&(ne=ne+se),ge++}Xe.debug("createdActors",P),Xe.debug("destroyedActors",R),await Sve(_,A,j,!1);for(const Se of de)await fin(_,Se.messageModel,Se.lineStartY,d);En.mirrorActors&&await Sve(_,A,j,!0),X.forEach(Se=>Zf.drawBackgroundRect(_,Se)),zGe(_,A,j,En);for(const Se of ni.models.boxes)Se.height=ni.getVerticalPos()-Se.y,ni.insert(Se.x,Se.y,Se.x+Se.width,Se.height),Se.startx=Se.x,Se.starty=Se.y,Se.stopx=Se.startx+Se.width,Se.stopy=Se.starty+Se.height,Se.stroke="rgb(0,0,0, 0.5)",await Zf.drawBox(_,Se,En);ie&&ni.bumpVerticalPos(En.boxMargin);const W=VGe(_,A,j,T),{bounds:xe}=ni.getBounds();let U=xe.stopy-xe.starty;U 2,P=K=>y?-K:K;i.from===i.to?_=T:(i.activate&&!A&&(_+=P(En.activationWidth/2-1)),[u.db.LINETYPE.SOLID_OPEN,u.db.LINETYPE.DOTTED_OPEN].includes(i.type)||(_+=P(3)));const R=[d,p,v,b],F=Math.abs(T-_);i.wrap&&i.message&&(i.message=Ao.wrapLabel(i.message,li.getMax(F+2*En.wrapPadding,En.width),eS(En)));const j=Ao.calculateTextDimensions(i.message,eS(En));return{width:li.getMax(i.wrap?0:j.width+2*En.wrapPadding,F+2*En.wrapPadding,En.width),height:0,startx:T,stopx:_,starty:0,stopy:0,message:i.message,type:i.type,wrap:i.wrap,fromBounds:Math.min.apply(null,R),toBounds:Math.max.apply(null,R)}},xin=async function(i,s,u,d){const p={},v=[];let b,y,T;for(const _ of i){switch(_.id=Ao.random({length:10}),_.type){case d.db.LINETYPE.LOOP_START:case d.db.LINETYPE.ALT_START:case d.db.LINETYPE.OPT_START:case d.db.LINETYPE.PAR_START:case d.db.LINETYPE.PAR_OVER_START:case d.db.LINETYPE.CRITICAL_START:case d.db.LINETYPE.BREAK_START:v.push({id:_.id,msg:_.message,from:Number.MAX_SAFE_INTEGER,to:Number.MIN_SAFE_INTEGER,width:0});break;case d.db.LINETYPE.ALT_ELSE:case d.db.LINETYPE.PAR_AND:case d.db.LINETYPE.CRITICAL_OPTION:_.message&&(b=v.pop(),p[b.id]=b,p[_.id]=b,v.push(b));break;case d.db.LINETYPE.LOOP_END:case d.db.LINETYPE.ALT_END:case d.db.LINETYPE.OPT_END:case d.db.LINETYPE.PAR_END:case d.db.LINETYPE.CRITICAL_END:case d.db.LINETYPE.BREAK_END:b=v.pop(),p[b.id]=b;break;case d.db.LINETYPE.ACTIVE_START:{const P=s[_.from?_.from.actor:_.to.actor],R=bJ(_.from?_.from.actor:_.to.actor).length,F=P.x+P.width/2+(R-1)*En.activationWidth/2,j={startx:F,stopx:F+En.activationWidth,actor:_.from.actor,enabled:!0};ni.activations.push(j)}break;case d.db.LINETYPE.ACTIVE_END:{const P=ni.activations.map(R=>R.actor).lastIndexOf(_.from.actor);delete ni.activations.splice(P,1)[0]}break}_.placement!==void 0?(y=await win(_,s,d),_.noteModel=y,v.forEach(P=>{b=P,b.from=li.getMin(b.from,y.startx),b.to=li.getMax(b.to,y.startx+y.width),b.width=li.getMax(b.width,Math.abs(b.from-b.to))-En.labelBoxWidth})):(T=yin(_,s,d),_.msgModel=T,T.startx&&T.stopx&&v.length>0&&v.forEach(P=>{if(b=P,T.startx===T.stopx){const R=s[_.from],F=s[_.to];b.from=li.getMin(R.x-T.width/2,R.x-R.width/2,b.from),b.to=li.getMax(F.x+T.width/2,F.x+R.width/2,b.to),b.width=li.getMax(b.width,Math.abs(b.to-b.from))-En.labelBoxWidth}else b.from=li.getMin(T.startx,b.from),b.to=li.getMax(T.stopx,b.to),b.width=li.getMax(b.width,T.width)-En.labelBoxWidth}))}return ni.activations=[],Xe.debug("Loop type widths:",p),p},kin=Object.freeze(Object.defineProperty({__proto__:null,diagram:{parser:yrn,db:FGe,renderer:{bounds:ni,drawActors:Sve,drawActorsPopup:VGe,setConf:UGe,draw:pin},styles:Urn,init:({wrap:i})=>{FGe.setWrap(i)}}},Symbol.toStringTag,{value:"Module"}));var _ve=function(){var i=function(ao,Tr,Fn,qn){for(Fn=Fn||{},qn=ao.length;qn--;Fn[ao[qn]]=Tr);return Fn},s=[1,17],u=[1,18],d=[1,19],p=[1,39],v=[1,40],b=[1,25],y=[1,23],T=[1,24],_=[1,31],A=[1,32],P=[1,33],R=[1,34],F=[1,35],j=[1,36],K=[1,26],ee=[1,27],ie=[1,28],oe=[1,29],pe=[1,43],be=[1,30],ae=[1,42],ne=[1,44],se=[1,41],de=[1,45],X=[1,9],ge=[1,8,9],W=[1,56],xe=[1,57],U=[1,58],Fe=[1,59],Pe=[1,60],je=[1,61],Ie=[1,62],Se=[1,8,9,39],Ce=[1,74],ke=[1,8,9,12,13,21,37,39,42,59,60,61,62,63,64,65,70,72],Ke=[1,8,9,12,13,19,21,37,39,42,46,59,60,61,62,63,64,65,70,72,74,80,95,97,98],Ft=[13,74,80,95,97,98],Ne=[13,64,65,74,80,95,97,98],gn=[13,59,60,61,62,63,74,80,95,97,98],_t=[1,93],Et=[1,110],Gt=[1,108],ln=[1,102],xt=[1,103],Pt=[1,104],Qe=[1,105],Dt=[1,106],kt=[1,107],On=[1,109],ht=[1,8,9,37,39,42],zr=[1,8,9,21],yt=[1,8,9,78],ji=[1,8,9,21,73,74,78,80,81,82,83,84,85],xi={trace:function(){},yy:{},symbols_:{error:2,start:3,mermaidDoc:4,statements:5,graphConfig:6,CLASS_DIAGRAM:7,NEWLINE:8,EOF:9,statement:10,classLabel:11,SQS:12,STR:13,SQE:14,namespaceName:15,alphaNumToken:16,className:17,classLiteralName:18,GENERICTYPE:19,relationStatement:20,LABEL:21,namespaceStatement:22,classStatement:23,memberStatement:24,annotationStatement:25,clickStatement:26,styleStatement:27,cssClassStatement:28,noteStatement:29,direction:30,acc_title:31,acc_title_value:32,acc_descr:33,acc_descr_value:34,acc_descr_multiline_value:35,namespaceIdentifier:36,STRUCT_START:37,classStatements:38,STRUCT_STOP:39,NAMESPACE:40,classIdentifier:41,STYLE_SEPARATOR:42,members:43,CLASS:44,ANNOTATION_START:45,ANNOTATION_END:46,MEMBER:47,SEPARATOR:48,relation:49,NOTE_FOR:50,noteText:51,NOTE:52,direction_tb:53,direction_bt:54,direction_rl:55,direction_lr:56,relationType:57,lineType:58,AGGREGATION:59,EXTENSION:60,COMPOSITION:61,DEPENDENCY:62,LOLLIPOP:63,LINE:64,DOTTED_LINE:65,CALLBACK:66,LINK:67,LINK_TARGET:68,CLICK:69,CALLBACK_NAME:70,CALLBACK_ARGS:71,HREF:72,STYLE:73,ALPHA:74,stylesOpt:75,CSSCLASS:76,style:77,COMMA:78,styleComponent:79,NUM:80,COLON:81,UNIT:82,SPACE:83,BRKT:84,PCT:85,commentToken:86,textToken:87,graphCodeTokens:88,textNoTagsToken:89,TAGSTART:90,TAGEND:91,"==":92,"--":93,DEFAULT:94,MINUS:95,keywords:96,UNICODE_TEXT:97,BQUOTE_STR:98,$accept:0,$end:1},terminals_:{2:"error",7:"CLASS_DIAGRAM",8:"NEWLINE",9:"EOF",12:"SQS",13:"STR",14:"SQE",19:"GENERICTYPE",21:"LABEL",31:"acc_title",32:"acc_title_value",33:"acc_descr",34:"acc_descr_value",35:"acc_descr_multiline_value",37:"STRUCT_START",39:"STRUCT_STOP",40:"NAMESPACE",42:"STYLE_SEPARATOR",44:"CLASS",45:"ANNOTATION_START",46:"ANNOTATION_END",47:"MEMBER",48:"SEPARATOR",50:"NOTE_FOR",52:"NOTE",53:"direction_tb",54:"direction_bt",55:"direction_rl",56:"direction_lr",59:"AGGREGATION",60:"EXTENSION",61:"COMPOSITION",62:"DEPENDENCY",63:"LOLLIPOP",64:"LINE",65:"DOTTED_LINE",66:"CALLBACK",67:"LINK",68:"LINK_TARGET",69:"CLICK",70:"CALLBACK_NAME",71:"CALLBACK_ARGS",72:"HREF",73:"STYLE",74:"ALPHA",76:"CSSCLASS",78:"COMMA",80:"NUM",81:"COLON",82:"UNIT",83:"SPACE",84:"BRKT",85:"PCT",88:"graphCodeTokens",90:"TAGSTART",91:"TAGEND",92:"==",93:"--",94:"DEFAULT",95:"MINUS",96:"keywords",97:"UNICODE_TEXT",98:"BQUOTE_STR"},productions_:[0,[3,1],[3,1],[4,1],[6,4],[5,1],[5,2],[5,3],[11,3],[15,1],[15,2],[17,1],[17,1],[17,2],[17,2],[17,2],[10,1],[10,2],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,2],[10,2],[10,1],[22,4],[22,5],[36,2],[38,1],[38,2],[38,3],[23,1],[23,3],[23,4],[23,6],[41,2],[41,3],[25,4],[43,1],[43,2],[24,1],[24,2],[24,1],[24,1],[20,3],[20,4],[20,4],[20,5],[29,3],[29,2],[30,1],[30,1],[30,1],[30,1],[49,3],[49,2],[49,2],[49,1],[57,1],[57,1],[57,1],[57,1],[57,1],[58,1],[58,1],[26,3],[26,4],[26,3],[26,4],[26,4],[26,5],[26,3],[26,4],[26,4],[26,5],[26,4],[26,5],[26,5],[26,6],[27,3],[28,3],[75,1],[75,3],[77,1],[77,2],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[86,1],[86,1],[87,1],[87,1],[87,1],[87,1],[87,1],[87,1],[87,1],[89,1],[89,1],[89,1],[89,1],[16,1],[16,1],[16,1],[16,1],[18,1],[51,1]],performAction:function(Tr,Fn,qn,Un,At,wt,on){var fn=wt.length-1;switch(At){case 8:this.$=wt[fn-1];break;case 9:case 11:case 12:this.$=wt[fn];break;case 10:case 13:this.$=wt[fn-1]+wt[fn];break;case 14:case 15:this.$=wt[fn-1]+"~"+wt[fn]+"~";break;case 16:Un.addRelation(wt[fn]);break;case 17:wt[fn-1].title=Un.cleanupLabel(wt[fn]),Un.addRelation(wt[fn-1]);break;case 27:this.$=wt[fn].trim(),Un.setAccTitle(this.$);break;case 28:case 29:this.$=wt[fn].trim(),Un.setAccDescription(this.$);break;case 30:Un.addClassesToNamespace(wt[fn-3],wt[fn-1]);break;case 31:Un.addClassesToNamespace(wt[fn-4],wt[fn-1]);break;case 32:this.$=wt[fn],Un.addNamespace(wt[fn]);break;case 33:this.$=[wt[fn]];break;case 34:this.$=[wt[fn-1]];break;case 35:wt[fn].unshift(wt[fn-2]),this.$=wt[fn];break;case 37:Un.setCssClass(wt[fn-2],wt[fn]);break;case 38:Un.addMembers(wt[fn-3],wt[fn-1]);break;case 39:Un.setCssClass(wt[fn-5],wt[fn-3]),Un.addMembers(wt[fn-5],wt[fn-1]);break;case 40:this.$=wt[fn],Un.addClass(wt[fn]);break;case 41:this.$=wt[fn-1],Un.addClass(wt[fn-1]),Un.setClassLabel(wt[fn-1],wt[fn]);break;case 42:Un.addAnnotation(wt[fn],wt[fn-2]);break;case 43:this.$=[wt[fn]];break;case 44:wt[fn].push(wt[fn-1]),this.$=wt[fn];break;case 45:break;case 46:Un.addMember(wt[fn-1],Un.cleanupLabel(wt[fn]));break;case 47:break;case 48:break;case 49:this.$={id1:wt[fn-2],id2:wt[fn],relation:wt[fn-1],relationTitle1:"none",relationTitle2:"none"};break;case 50:this.$={id1:wt[fn-3],id2:wt[fn],relation:wt[fn-1],relationTitle1:wt[fn-2],relationTitle2:"none"};break;case 51:this.$={id1:wt[fn-3],id2:wt[fn],relation:wt[fn-2],relationTitle1:"none",relationTitle2:wt[fn-1]};break;case 52:this.$={id1:wt[fn-4],id2:wt[fn],relation:wt[fn-2],relationTitle1:wt[fn-3],relationTitle2:wt[fn-1]};break;case 53:Un.addNote(wt[fn],wt[fn-1]);break;case 54:Un.addNote(wt[fn]);break;case 55:Un.setDirection("TB");break;case 56:Un.setDirection("BT");break;case 57:Un.setDirection("RL");break;case 58:Un.setDirection("LR");break;case 59:this.$={type1:wt[fn-2],type2:wt[fn],lineType:wt[fn-1]};break;case 60:this.$={type1:"none",type2:wt[fn],lineType:wt[fn-1]};break;case 61:this.$={type1:wt[fn-1],type2:"none",lineType:wt[fn]};break;case 62:this.$={type1:"none",type2:"none",lineType:wt[fn]};break;case 63:this.$=Un.relationType.AGGREGATION;break;case 64:this.$=Un.relationType.EXTENSION;break;case 65:this.$=Un.relationType.COMPOSITION;break;case 66:this.$=Un.relationType.DEPENDENCY;break;case 67:this.$=Un.relationType.LOLLIPOP;break;case 68:this.$=Un.lineType.LINE;break;case 69:this.$=Un.lineType.DOTTED_LINE;break;case 70:case 76:this.$=wt[fn-2],Un.setClickEvent(wt[fn-1],wt[fn]);break;case 71:case 77:this.$=wt[fn-3],Un.setClickEvent(wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-2],wt[fn]);break;case 72:this.$=wt[fn-2],Un.setLink(wt[fn-1],wt[fn]);break;case 73:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn-1],wt[fn]);break;case 74:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-2],wt[fn]);break;case 75:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-2],wt[fn]),Un.setTooltip(wt[fn-3],wt[fn-1]);break;case 78:this.$=wt[fn-3],Un.setClickEvent(wt[fn-2],wt[fn-1],wt[fn]);break;case 79:this.$=wt[fn-4],Un.setClickEvent(wt[fn-3],wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-3],wt[fn]);break;case 80:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn]);break;case 81:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-1],wt[fn]);break;case 82:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-1]),Un.setTooltip(wt[fn-3],wt[fn]);break;case 83:this.$=wt[fn-5],Un.setLink(wt[fn-4],wt[fn-2],wt[fn]),Un.setTooltip(wt[fn-4],wt[fn-1]);break;case 84:this.$=wt[fn-2],Un.setCssStyle(wt[fn-1],wt[fn]);break;case 85:Un.setCssClass(wt[fn-1],wt[fn]);break;case 86:this.$=[wt[fn]];break;case 87:wt[fn-2].push(wt[fn]),this.$=wt[fn-2];break;case 89:this.$=wt[fn-1]+wt[fn];break}},table:[{3:1,4:2,5:3,6:4,7:[1,6],10:5,16:37,17:20,18:38,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,31:s,33:u,35:d,36:21,40:p,41:22,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de},{1:[3]},{1:[2,1]},{1:[2,2]},{1:[2,3]},i(X,[2,5],{8:[1,46]}),{8:[1,47]},i(ge,[2,16],{21:[1,48]}),i(ge,[2,18]),i(ge,[2,19]),i(ge,[2,20]),i(ge,[2,21]),i(ge,[2,22]),i(ge,[2,23]),i(ge,[2,24]),i(ge,[2,25]),i(ge,[2,26]),{32:[1,49]},{34:[1,50]},i(ge,[2,29]),i(ge,[2,45],{49:51,57:54,58:55,13:[1,52],21:[1,53],59:W,60:xe,61:U,62:Fe,63:Pe,64:je,65:Ie}),{37:[1,63]},i(Se,[2,36],{37:[1,65],42:[1,64]}),i(ge,[2,47]),i(ge,[2,48]),{16:66,74:pe,80:ae,95:ne,97:se},{16:37,17:67,18:38,74:pe,80:ae,95:ne,97:se,98:de},{16:37,17:68,18:38,74:pe,80:ae,95:ne,97:se,98:de},{16:37,17:69,18:38,74:pe,80:ae,95:ne,97:se,98:de},{74:[1,70]},{13:[1,71]},{16:37,17:72,18:38,74:pe,80:ae,95:ne,97:se,98:de},{13:Ce,51:73},i(ge,[2,55]),i(ge,[2,56]),i(ge,[2,57]),i(ge,[2,58]),i(ke,[2,11],{16:37,18:38,17:75,19:[1,76],74:pe,80:ae,95:ne,97:se,98:de}),i(ke,[2,12],{19:[1,77]}),{15:78,16:79,74:pe,80:ae,95:ne,97:se},{16:37,17:80,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ke,[2,112]),i(Ke,[2,113]),i(Ke,[2,114]),i(Ke,[2,115]),i([1,8,9,12,13,19,21,37,39,42,59,60,61,62,63,64,65,70,72],[2,116]),i(X,[2,6],{10:5,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,17:20,36:21,41:22,16:37,18:38,5:81,31:s,33:u,35:d,40:p,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de}),{5:82,10:5,16:37,17:20,18:38,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,31:s,33:u,35:d,36:21,40:p,41:22,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de},i(ge,[2,17]),i(ge,[2,27]),i(ge,[2,28]),{13:[1,84],16:37,17:83,18:38,74:pe,80:ae,95:ne,97:se,98:de},{49:85,57:54,58:55,59:W,60:xe,61:U,62:Fe,63:Pe,64:je,65:Ie},i(ge,[2,46]),{58:86,64:je,65:Ie},i(Ft,[2,62],{57:87,59:W,60:xe,61:U,62:Fe,63:Pe}),i(Ne,[2,63]),i(Ne,[2,64]),i(Ne,[2,65]),i(Ne,[2,66]),i(Ne,[2,67]),i(gn,[2,68]),i(gn,[2,69]),{8:[1,89],23:90,38:88,41:22,44:v},{16:91,74:pe,80:ae,95:ne,97:se},{43:92,47:_t},{46:[1,94]},{13:[1,95]},{13:[1,96]},{70:[1,97],72:[1,98]},{21:Et,73:Gt,74:ln,75:99,77:100,79:101,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On},{74:[1,111]},{13:Ce,51:112},i(ge,[2,54]),i(ge,[2,117]),i(ke,[2,13]),i(ke,[2,14]),i(ke,[2,15]),{37:[2,32]},{15:113,16:79,37:[2,9],74:pe,80:ae,95:ne,97:se},i(ht,[2,40],{11:114,12:[1,115]}),i(X,[2,7]),{9:[1,116]},i(zr,[2,49]),{16:37,17:117,18:38,74:pe,80:ae,95:ne,97:se,98:de},{13:[1,119],16:37,17:118,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ft,[2,61],{57:120,59:W,60:xe,61:U,62:Fe,63:Pe}),i(Ft,[2,60]),{39:[1,121]},{23:90,38:122,41:22,44:v},{8:[1,123],39:[2,33]},i(Se,[2,37],{37:[1,124]}),{39:[1,125]},{39:[2,43],43:126,47:_t},{16:37,17:127,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(ge,[2,70],{13:[1,128]}),i(ge,[2,72],{13:[1,130],68:[1,129]}),i(ge,[2,76],{13:[1,131],71:[1,132]}),{13:[1,133]},i(ge,[2,84],{78:[1,134]}),i(yt,[2,86],{79:135,21:Et,73:Gt,74:ln,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On}),i(ji,[2,88]),i(ji,[2,90]),i(ji,[2,91]),i(ji,[2,92]),i(ji,[2,93]),i(ji,[2,94]),i(ji,[2,95]),i(ji,[2,96]),i(ji,[2,97]),i(ji,[2,98]),i(ge,[2,85]),i(ge,[2,53]),{37:[2,10]},i(ht,[2,41]),{13:[1,136]},{1:[2,4]},i(zr,[2,51]),i(zr,[2,50]),{16:37,17:137,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ft,[2,59]),i(ge,[2,30]),{39:[1,138]},{23:90,38:139,39:[2,34],41:22,44:v},{43:140,47:_t},i(Se,[2,38]),{39:[2,44]},i(ge,[2,42]),i(ge,[2,71]),i(ge,[2,73]),i(ge,[2,74],{68:[1,141]}),i(ge,[2,77]),i(ge,[2,78],{13:[1,142]}),i(ge,[2,80],{13:[1,144],68:[1,143]}),{21:Et,73:Gt,74:ln,77:145,79:101,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On},i(ji,[2,89]),{14:[1,146]},i(zr,[2,52]),i(ge,[2,31]),{39:[2,35]},{39:[1,147]},i(ge,[2,75]),i(ge,[2,79]),i(ge,[2,81]),i(ge,[2,82],{68:[1,148]}),i(yt,[2,87],{79:135,21:Et,73:Gt,74:ln,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On}),i(ht,[2,8]),i(Se,[2,39]),i(ge,[2,83])],defaultActions:{2:[2,1],3:[2,2],4:[2,3],78:[2,32],113:[2,10],116:[2,4],126:[2,44],139:[2,35]},parseError:function(Tr,Fn){if(Fn.recoverable)this.trace(Tr);else{var qn=new Error(Tr);throw qn.hash=Fn,qn}},parse:function(Tr){var Fn=this,qn=[0],Un=[],At=[null],wt=[],on=this.table,fn="",An=0,oo=0,jo=2,$o=1,Pa=wt.slice.call(arguments,1),wo=Object.create(this.lexer),_s={yy:{}};for(var tl in this.yy)Object.prototype.hasOwnProperty.call(this.yy,tl)&&(_s.yy[tl]=this.yy[tl]);wo.setInput(Tr,_s.yy),_s.yy.lexer=wo,_s.yy.parser=this,typeof wo.yylloc>"u"&&(wo.yylloc={});var da=wo.yylloc;wt.push(da);var j0=wo.options&&wo.options.ranges;typeof _s.yy.parseError=="function"?this.parseError=_s.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function pm(){var ga;return ga=Un.pop()||wo.lex()||$o,typeof ga!="number"&&(ga instanceof Array&&(Un=ga,ga=Un.pop()),ga=Fn.symbols_[ga]||ga),ga}for(var Ml,Xc,Bc,ja,Ou={},Sa,Po,Fc,xa;;){if(Xc=qn[qn.length-1],this.defaultActions[Xc]?Bc=this.defaultActions[Xc]:((Ml===null||typeof Ml>"u")&&(Ml=pm()),Bc=on[Xc]&&on[Xc][Ml]),typeof Bc>"u"||!Bc.length||!Bc[0]){var Ba="";xa=[];for(Sa in on[Xc])this.terminals_[Sa]&&Sa>jo&&xa.push("'"+this.terminals_[Sa]+"'");wo.showPosition?Ba="Parse error on line "+(An+1)+`:
+`,ZC=18*2,RGe="actor-top",jGe="actor-bottom",Eve=function(i,s){return AQ(i,s)},Grn=function(i,s,u,d,p){if(s.links===void 0||s.links===null||Object.keys(s.links).length===0)return{height:0,width:0};const v=s.links,b=s.actorCnt,y=s.rectData;var T="none";p&&(T="block !important");const _=i.append("g");_.attr("id","actor"+b+"_popup"),_.attr("class","actorPopupMenu"),_.attr("display",T);var A="";y.class!==void 0&&(A=" "+y.class);let P=y.width>u?y.width:u;const R=_.append("rect");if(R.attr("class","actorPopupMenuPanel"+A),R.attr("x",y.x),R.attr("y",y.height),R.attr("fill",y.fill),R.attr("stroke",y.stroke),R.attr("width",P),R.attr("height",y.height),R.attr("rx",y.rx),R.attr("ry",y.ry),v!=null){var F=20;for(let ee in v){var j=_.append("a"),K=p9.sanitizeUrl(v[ee]);j.attr("xlink:href",K),j.attr("target","_blank"),uin(d)(ee,j,y.x+10,y.height+F,P,20,{class:"actor"},d),F+=30}}return R.attr("height",F),{height:y.height+F,width:P}},Krn=function(i){return"var pu = document.getElementById('"+i+"'); if (pu != null) { pu.style.display = pu.style.display == 'block' ? 'none' : 'block'; }"},pJ=async function(i,s,u=null){let d=i.append("foreignObject");const p=await CC(s.text,Vh()),b=d.append("xhtml:div").attr("style","width: fit-content;").attr("xmlns","http://www.w3.org/1999/xhtml").html(p).node().getBoundingClientRect();if(d.attr("height",Math.round(b.height)).attr("width",Math.round(b.width)),s.class==="noteText"){const y=i.node().firstChild;y.setAttribute("height",b.height+2*s.textMargin);const T=y.getBBox();d.attr("x",Math.round(T.x+T.width/2-b.width/2)).attr("y",Math.round(T.y+T.height/2-b.height/2))}else if(u){let{startx:y,stopx:T,starty:_}=u;if(y>T){const A=y;y=T,T=A}d.attr("x",Math.round(y+Math.abs(y-T)/2-b.width/2)),s.class==="loopText"?d.attr("y",Math.round(_)):d.attr("y",Math.round(_-b.height))}return[d]},YD=function(i,s){let u=0,d=0;const p=s.text.split(ci.lineBreakRegex),[v,b]=NC(s.fontSize);let y=[],T=0,_=()=>s.y;if(s.valign!==void 0&&s.textMargin!==void 0&&s.textMargin>0)switch(s.valign){case"top":case"start":_=()=>Math.round(s.y+s.textMargin);break;case"middle":case"center":_=()=>Math.round(s.y+(u+d+s.textMargin)/2);break;case"bottom":case"end":_=()=>Math.round(s.y+(u+d+2*s.textMargin)-s.textMargin);break}if(s.anchor!==void 0&&s.textMargin!==void 0&&s.width!==void 0)switch(s.anchor){case"left":case"start":s.x=Math.round(s.x+s.textMargin),s.anchor="start",s.dominantBaseline="middle",s.alignmentBaseline="middle";break;case"middle":case"center":s.x=Math.round(s.x+s.width/2),s.anchor="middle",s.dominantBaseline="middle",s.alignmentBaseline="middle";break;case"right":case"end":s.x=Math.round(s.x+s.width-s.textMargin),s.anchor="end",s.dominantBaseline="middle",s.alignmentBaseline="middle";break}for(let[A,P]of p.entries()){s.textMargin!==void 0&&s.textMargin===0&&v!==void 0&&(T=A*v);const R=i.append("text");R.attr("x",s.x),R.attr("y",_()),s.anchor!==void 0&&R.attr("text-anchor",s.anchor).attr("dominant-baseline",s.dominantBaseline).attr("alignment-baseline",s.alignmentBaseline),s.fontFamily!==void 0&&R.style("font-family",s.fontFamily),b!==void 0&&R.style("font-size",b),s.fontWeight!==void 0&&R.style("font-weight",s.fontWeight),s.fill!==void 0&&R.attr("fill",s.fill),s.class!==void 0&&R.attr("class",s.class),s.dy!==void 0?R.attr("dy",s.dy):T!==0&&R.attr("dy",T);const F=P||hje;if(s.tspan){const j=R.append("tspan");j.attr("x",s.x),s.fill!==void 0&&j.attr("fill",s.fill),j.text(F)}else R.text(F);s.valign!==void 0&&s.textMargin!==void 0&&s.textMargin>0&&(d+=(R._groups||R)[0][0].getBBox().height,u=d),y.push(R)}return y},$Ge=function(i,s){function u(p,v,b,y,T){return p+","+v+" "+(p+b)+","+v+" "+(p+b)+","+(v+y-T)+" "+(p+b-T*1.2)+","+(v+y)+" "+p+","+(v+y)}const d=i.append("polygon");return d.attr("points",u(s.x,s.y,s.width,s.height,7)),d.attr("class","labelBox"),s.y=s.y+s.height/2,YD(i,s),d};let s5=-1;const zGe=(i,s,u,d)=>{i.select&&u.forEach(p=>{const v=s[p],b=i.select("#actor"+v.actorCnt);!d.mirrorActors&&v.stopy?b.attr("y2",v.stopy+v.height/2):d.mirrorActors&&b.attr("y2",v.stopy)})},Wrn=async function(i,s,u,d){const p=d?s.stopy:s.starty,v=s.x+s.width/2,b=p+5,y=i.append("g").lower();var T=y;d||(s5++,Object.keys(s.links||{}).length&&!u.forceMenus&&T.attr("onclick",Krn(`actor${s5}_popup`)).attr("cursor","pointer"),T.append("line").attr("id","actor"+s5).attr("x1",v).attr("y1",b).attr("x2",v).attr("y2",2e3).attr("class","actor-line").attr("class","200").attr("stroke-width","0.5px").attr("stroke","#999"),T=y.append("g"),s.actorCnt=s5,s.links!=null&&T.attr("id","root-"+s5));const _=qC();var A="actor";s.properties!=null&&s.properties.class?A=s.properties.class:_.fill="#eaeaea",d?A+=` ${jGe}`:A+=` ${RGe}`,_.x=s.x,_.y=p,_.width=s.width,_.height=s.height,_.class=A,_.rx=3,_.ry=3,_.name=s.name;const P=Eve(T,_);if(s.rectData=_,s.properties!=null&&s.properties.icon){const F=s.properties.icon.trim();F.charAt(0)==="@"?rUt(T,_.x+_.width-20,_.y+10,F.substr(1)):nUt(T,_.x+_.width-20,_.y+10,F)}await Tve(u,Dv(s.description))(s.description,T,_.x,_.y,_.width,_.height,{class:"actor"},u);let R=s.height;if(P.node){const F=P.node().getBBox();s.height=F.height,R=F.height}return R},Yrn=async function(i,s,u,d){const p=d?s.stopy:s.starty,v=s.x+s.width/2,b=p+80;i.lower(),d||(s5++,i.append("line").attr("id","actor"+s5).attr("x1",v).attr("y1",b).attr("x2",v).attr("y2",2e3).attr("class","actor-line").attr("class","200").attr("stroke-width","0.5px").attr("stroke","#999"),s.actorCnt=s5);const y=i.append("g");let T="actor-man";d?T+=` ${jGe}`:T+=` ${RGe}`,y.attr("class",T),y.attr("name",s.name);const _=qC();_.x=s.x,_.y=p,_.fill="#eaeaea",_.width=s.width,_.height=s.height,_.class="actor",_.rx=3,_.ry=3,y.append("line").attr("id","actor-man-torso"+s5).attr("x1",v).attr("y1",p+25).attr("x2",v).attr("y2",p+45),y.append("line").attr("id","actor-man-arms"+s5).attr("x1",v-ZC/2).attr("y1",p+33).attr("x2",v+ZC/2).attr("y2",p+33),y.append("line").attr("x1",v-ZC/2).attr("y1",p+60).attr("x2",v).attr("y2",p+45),y.append("line").attr("x1",v).attr("y1",p+45).attr("x2",v+ZC/2-2).attr("y2",p+60);const A=y.append("circle");A.attr("cx",s.x+s.width/2),A.attr("cy",p+10),A.attr("r",15),A.attr("width",s.width),A.attr("height",s.height);const P=y.node().getBBox();return s.height=P.height,await Tve(u,Dv(s.description))(s.description,y,_.x,_.y+35,_.width,_.height,{class:"actor"},u),s.height},Xrn=async function(i,s,u,d){switch(s.type){case"actor":return await Yrn(i,s,u,d);case"participant":return await Wrn(i,s,u,d)}},Qrn=async function(i,s,u){const p=i.append("g");qGe(p,s),s.name&&await Tve(u)(s.name,p,s.x,s.y+(s.textMaxHeight||0)/2,s.width,0,{class:"text"},u),p.lower()},Jrn=function(i){return i.append("g")},Zrn=function(i,s,u,d,p){const v=qC(),b=s.anchored;v.x=s.startx,v.y=s.starty,v.class="activation"+p%3,v.width=s.stopx-s.startx,v.height=u-s.starty,Eve(b,v)},ein=async function(i,s,u,d){const{boxMargin:p,boxTextMargin:v,labelBoxHeight:b,labelBoxWidth:y,messageFontFamily:T,messageFontSize:_,messageFontWeight:A}=d,P=i.append("g"),R=function(K,ee,ie,oe){return P.append("line").attr("x1",K).attr("y1",ee).attr("x2",ie).attr("y2",oe).attr("class","loopLine")};R(s.startx,s.starty,s.stopx,s.starty),R(s.stopx,s.starty,s.stopx,s.stopy),R(s.startx,s.stopy,s.stopx,s.stopy),R(s.startx,s.starty,s.startx,s.stopy),s.sections!==void 0&&s.sections.forEach(function(K){R(s.startx,K.y,s.stopx,K.y).style("stroke-dasharray","3, 3")});let F=zbe();F.text=u,F.x=s.startx,F.y=s.starty,F.fontFamily=T,F.fontSize=_,F.fontWeight=A,F.anchor="middle",F.valign="middle",F.tspan=!1,F.width=y||50,F.height=b||20,F.textMargin=v,F.class="labelText",$Ge(P,F),F=HGe(),F.text=s.title,F.x=s.startx+y/2+(s.stopx-s.startx)/2,F.y=s.starty+p+v,F.anchor="middle",F.valign="middle",F.textMargin=v,F.class="loopText",F.fontFamily=T,F.fontSize=_,F.fontWeight=A,F.wrap=!0;let j=Dv(F.text)?await pJ(P,F,s):YD(P,F);if(s.sectionTitles!==void 0){for(const[K,ee]of Object.entries(s.sectionTitles))if(ee.message){F.text=ee.message,F.x=s.startx+(s.stopx-s.startx)/2,F.y=s.sections[K].y+p+v,F.class="loopText",F.anchor="middle",F.valign="middle",F.tspan=!1,F.fontFamily=T,F.fontSize=_,F.fontWeight=A,F.wrap=s.wrap,Dv(F.text)?(s.starty=s.sections[K].y,await pJ(P,F,s)):YD(P,F);let ie=Math.round(j.map(oe=>(oe._groups||oe)[0][0].getBBox().height).reduce((oe,pe)=>oe+pe));s.sections[K].height+=ie-(p+v)}}return s.height=Math.round(s.stopy-s.starty),P},qGe=function(i,s){Tqe(i,s)},tin=function(i){i.append("defs").append("symbol").attr("id","database").attr("fill-rule","evenodd").attr("clip-rule","evenodd").append("path").attr("transform","scale(.5)").attr("d","M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z")},nin=function(i){i.append("defs").append("symbol").attr("id","computer").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z")},rin=function(i){i.append("defs").append("symbol").attr("id","clock").attr("width","24").attr("height","24").append("path").attr("transform","scale(.5)").attr("d","M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z")},iin=function(i){i.append("defs").append("marker").attr("id","arrowhead").attr("refX",7.9).attr("refY",5).attr("markerUnits","userSpaceOnUse").attr("markerWidth",12).attr("markerHeight",12).attr("orient","auto").append("path").attr("d","M 0 0 L 10 5 L 0 10 z")},sin=function(i){i.append("defs").append("marker").attr("id","filled-head").attr("refX",15.5).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 18,7 L9,13 L14,7 L9,1 Z")},ain=function(i){i.append("defs").append("marker").attr("id","sequencenumber").attr("refX",15).attr("refY",15).attr("markerWidth",60).attr("markerHeight",40).attr("orient","auto").append("circle").attr("cx",15).attr("cy",15).attr("r",6)},oin=function(i){i.append("defs").append("marker").attr("id","crosshead").attr("markerWidth",15).attr("markerHeight",8).attr("orient","auto").attr("refX",4).attr("refY",4.5).append("path").attr("fill","none").attr("stroke","#000000").style("stroke-dasharray","0, 0").attr("stroke-width","1pt").attr("d","M 1,2 L 6,7 M 6,2 L 1,7")},HGe=function(){return{x:0,y:0,fill:void 0,anchor:void 0,style:"#666",width:void 0,height:void 0,textMargin:0,rx:0,ry:0,tspan:!0,valign:void 0}},cin=function(){return{x:0,y:0,fill:"#EDF2AE",stroke:"#666",width:100,anchor:"start",height:100,rx:0,ry:0}},Tve=function(){function i(v,b,y,T,_,A,P){const R=b.append("text").attr("x",y+_/2).attr("y",T+A/2+5).style("text-anchor","middle").text(v);p(R,P)}function s(v,b,y,T,_,A,P,R){const{actorFontSize:F,actorFontFamily:j,actorFontWeight:K}=R,[ee,ie]=NC(F),oe=v.split(ci.lineBreakRegex);for(let pe=0;pe {Se.add(Ce.from),Se.add(Ce.to)}),j=j.filter(Ce=>Se.has(Ce))}await din(_,A,P,j,0,K,!1);const be=await xin(K,A,pe,d);Zf.insertArrowHead(_),Zf.insertArrowCrossHead(_),Zf.insertArrowFilledHead(_),Zf.insertSequenceNumber(_);function ae(Se,Ce){const ke=ni.endActivation(Se);ke.starty+18>Ce&&(ke.starty=Ce-6,Ce+=12),Zf.drawActivation(_,ke,Ce,En,bJ(Se.from.actor).length),ni.insert(ke.startx,Ce-10,ke.stopx,Ce)}let ne=1,se=1;const de=[],X=[];let ge=0;for(const Se of K){let Ce,ke,Ke;switch(Se.type){case d.db.LINETYPE.NOTE:ni.resetVerticalPos(),ke=Se.noteModel,await lin(_,ke);break;case d.db.LINETYPE.ACTIVE_START:ni.newActivation(Se,_,A);break;case d.db.LINETYPE.ACTIVE_END:ae(Se,ni.getVerticalPos());break;case d.db.LINETYPE.LOOP_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.LOOP_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"loop",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.RECT_START:a5(be,Se,En.boxMargin,En.boxMargin,Ft=>ni.newLoop(void 0,Ft.message));break;case d.db.LINETYPE.RECT_END:Ce=ni.endLoop(),X.push(Ce),ni.models.addLoop(Ce),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos());break;case d.db.LINETYPE.OPT_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.OPT_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"opt",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.ALT_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.ALT_ELSE:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.ALT_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"alt",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.PAR_START:case d.db.LINETYPE.PAR_OVER_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft)),ni.saveVerticalPos();break;case d.db.LINETYPE.PAR_AND:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.PAR_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"par",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.AUTONUMBER:ne=Se.message.start||ne,se=Se.message.step||se,Se.message.visible?d.db.enableSequenceNumbers():d.db.disableSequenceNumbers();break;case d.db.LINETYPE.CRITICAL_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.CRITICAL_OPTION:a5(be,Se,En.boxMargin+En.boxTextMargin,En.boxMargin,Ft=>ni.addSectionToLoop(Ft));break;case d.db.LINETYPE.CRITICAL_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"critical",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;case d.db.LINETYPE.BREAK_START:a5(be,Se,En.boxMargin,En.boxMargin+En.boxTextMargin,Ft=>ni.newLoop(Ft));break;case d.db.LINETYPE.BREAK_END:Ce=ni.endLoop(),await Zf.drawLoop(_,Ce,"break",En),ni.bumpVerticalPos(Ce.stopy-ni.getVerticalPos()),ni.models.addLoop(Ce);break;default:try{Ke=Se.msgModel,Ke.starty=ni.getVerticalPos(),Ke.sequenceIndex=ne,Ke.sequenceVisible=d.db.showSequenceNumbers();const Ft=await hin(_,Ke);gin(Se,Ke,Ft,ge,A,P,R),de.push({messageModel:Ke,lineStartY:Ft}),ni.models.addMessage(Ke)}catch(Ft){Xe.error("error while drawing message",Ft)}}[d.db.LINETYPE.SOLID_OPEN,d.db.LINETYPE.DOTTED_OPEN,d.db.LINETYPE.SOLID,d.db.LINETYPE.DOTTED,d.db.LINETYPE.SOLID_CROSS,d.db.LINETYPE.DOTTED_CROSS,d.db.LINETYPE.SOLID_POINT,d.db.LINETYPE.DOTTED_POINT].includes(Se.type)&&(ne=ne+se),ge++}Xe.debug("createdActors",P),Xe.debug("destroyedActors",R),await Sve(_,A,j,!1);for(const Se of de)await fin(_,Se.messageModel,Se.lineStartY,d);En.mirrorActors&&await Sve(_,A,j,!0),X.forEach(Se=>Zf.drawBackgroundRect(_,Se)),zGe(_,A,j,En);for(const Se of ni.models.boxes)Se.height=ni.getVerticalPos()-Se.y,ni.insert(Se.x,Se.y,Se.x+Se.width,Se.height),Se.startx=Se.x,Se.starty=Se.y,Se.stopx=Se.startx+Se.width,Se.stopy=Se.starty+Se.height,Se.stroke="rgb(0,0,0, 0.5)",await Zf.drawBox(_,Se,En);ie&&ni.bumpVerticalPos(En.boxMargin);const W=VGe(_,A,j,T),{bounds:xe}=ni.getBounds();let U=xe.stopy-xe.starty;U 2,P=K=>y?-K:K;i.from===i.to?_=T:(i.activate&&!A&&(_+=P(En.activationWidth/2-1)),[u.db.LINETYPE.SOLID_OPEN,u.db.LINETYPE.DOTTED_OPEN].includes(i.type)||(_+=P(3)));const R=[d,p,v,b],F=Math.abs(T-_);i.wrap&&i.message&&(i.message=Ao.wrapLabel(i.message,ci.getMax(F+2*En.wrapPadding,En.width),eS(En)));const j=Ao.calculateTextDimensions(i.message,eS(En));return{width:ci.getMax(i.wrap?0:j.width+2*En.wrapPadding,F+2*En.wrapPadding,En.width),height:0,startx:T,stopx:_,starty:0,stopy:0,message:i.message,type:i.type,wrap:i.wrap,fromBounds:Math.min.apply(null,R),toBounds:Math.max.apply(null,R)}},xin=async function(i,s,u,d){const p={},v=[];let b,y,T;for(const _ of i){switch(_.id=Ao.random({length:10}),_.type){case d.db.LINETYPE.LOOP_START:case d.db.LINETYPE.ALT_START:case d.db.LINETYPE.OPT_START:case d.db.LINETYPE.PAR_START:case d.db.LINETYPE.PAR_OVER_START:case d.db.LINETYPE.CRITICAL_START:case d.db.LINETYPE.BREAK_START:v.push({id:_.id,msg:_.message,from:Number.MAX_SAFE_INTEGER,to:Number.MIN_SAFE_INTEGER,width:0});break;case d.db.LINETYPE.ALT_ELSE:case d.db.LINETYPE.PAR_AND:case d.db.LINETYPE.CRITICAL_OPTION:_.message&&(b=v.pop(),p[b.id]=b,p[_.id]=b,v.push(b));break;case d.db.LINETYPE.LOOP_END:case d.db.LINETYPE.ALT_END:case d.db.LINETYPE.OPT_END:case d.db.LINETYPE.PAR_END:case d.db.LINETYPE.CRITICAL_END:case d.db.LINETYPE.BREAK_END:b=v.pop(),p[b.id]=b;break;case d.db.LINETYPE.ACTIVE_START:{const P=s[_.from?_.from.actor:_.to.actor],R=bJ(_.from?_.from.actor:_.to.actor).length,F=P.x+P.width/2+(R-1)*En.activationWidth/2,j={startx:F,stopx:F+En.activationWidth,actor:_.from.actor,enabled:!0};ni.activations.push(j)}break;case d.db.LINETYPE.ACTIVE_END:{const P=ni.activations.map(R=>R.actor).lastIndexOf(_.from.actor);delete ni.activations.splice(P,1)[0]}break}_.placement!==void 0?(y=await win(_,s,d),_.noteModel=y,v.forEach(P=>{b=P,b.from=ci.getMin(b.from,y.startx),b.to=ci.getMax(b.to,y.startx+y.width),b.width=ci.getMax(b.width,Math.abs(b.from-b.to))-En.labelBoxWidth})):(T=yin(_,s,d),_.msgModel=T,T.startx&&T.stopx&&v.length>0&&v.forEach(P=>{if(b=P,T.startx===T.stopx){const R=s[_.from],F=s[_.to];b.from=ci.getMin(R.x-T.width/2,R.x-R.width/2,b.from),b.to=ci.getMax(F.x+T.width/2,F.x+R.width/2,b.to),b.width=ci.getMax(b.width,Math.abs(b.to-b.from))-En.labelBoxWidth}else b.from=ci.getMin(T.startx,b.from),b.to=ci.getMax(T.stopx,b.to),b.width=ci.getMax(b.width,T.width)-En.labelBoxWidth}))}return ni.activations=[],Xe.debug("Loop type widths:",p),p},kin=Object.freeze(Object.defineProperty({__proto__:null,diagram:{parser:yrn,db:FGe,renderer:{bounds:ni,drawActors:Sve,drawActorsPopup:VGe,setConf:UGe,draw:pin},styles:Urn,init:({wrap:i})=>{FGe.setWrap(i)}}},Symbol.toStringTag,{value:"Module"}));var _ve=function(){var i=function(ao,Tr,Fn,qn){for(Fn=Fn||{},qn=ao.length;qn--;Fn[ao[qn]]=Tr);return Fn},s=[1,17],u=[1,18],d=[1,19],p=[1,39],v=[1,40],b=[1,25],y=[1,23],T=[1,24],_=[1,31],A=[1,32],P=[1,33],R=[1,34],F=[1,35],j=[1,36],K=[1,26],ee=[1,27],ie=[1,28],oe=[1,29],pe=[1,43],be=[1,30],ae=[1,42],ne=[1,44],se=[1,41],de=[1,45],X=[1,9],ge=[1,8,9],W=[1,56],xe=[1,57],U=[1,58],Fe=[1,59],Pe=[1,60],je=[1,61],Ie=[1,62],Se=[1,8,9,39],Ce=[1,74],ke=[1,8,9,12,13,21,37,39,42,59,60,61,62,63,64,65,70,72],Ke=[1,8,9,12,13,19,21,37,39,42,46,59,60,61,62,63,64,65,70,72,74,80,95,97,98],Ft=[13,74,80,95,97,98],Ne=[13,64,65,74,80,95,97,98],gn=[13,59,60,61,62,63,74,80,95,97,98],_t=[1,93],Et=[1,110],Gt=[1,108],ln=[1,102],xt=[1,103],Pt=[1,104],Qe=[1,105],Dt=[1,106],kt=[1,107],On=[1,109],ht=[1,8,9,37,39,42],zr=[1,8,9,21],yt=[1,8,9,78],ji=[1,8,9,21,73,74,78,80,81,82,83,84,85],xi={trace:function(){},yy:{},symbols_:{error:2,start:3,mermaidDoc:4,statements:5,graphConfig:6,CLASS_DIAGRAM:7,NEWLINE:8,EOF:9,statement:10,classLabel:11,SQS:12,STR:13,SQE:14,namespaceName:15,alphaNumToken:16,className:17,classLiteralName:18,GENERICTYPE:19,relationStatement:20,LABEL:21,namespaceStatement:22,classStatement:23,memberStatement:24,annotationStatement:25,clickStatement:26,styleStatement:27,cssClassStatement:28,noteStatement:29,direction:30,acc_title:31,acc_title_value:32,acc_descr:33,acc_descr_value:34,acc_descr_multiline_value:35,namespaceIdentifier:36,STRUCT_START:37,classStatements:38,STRUCT_STOP:39,NAMESPACE:40,classIdentifier:41,STYLE_SEPARATOR:42,members:43,CLASS:44,ANNOTATION_START:45,ANNOTATION_END:46,MEMBER:47,SEPARATOR:48,relation:49,NOTE_FOR:50,noteText:51,NOTE:52,direction_tb:53,direction_bt:54,direction_rl:55,direction_lr:56,relationType:57,lineType:58,AGGREGATION:59,EXTENSION:60,COMPOSITION:61,DEPENDENCY:62,LOLLIPOP:63,LINE:64,DOTTED_LINE:65,CALLBACK:66,LINK:67,LINK_TARGET:68,CLICK:69,CALLBACK_NAME:70,CALLBACK_ARGS:71,HREF:72,STYLE:73,ALPHA:74,stylesOpt:75,CSSCLASS:76,style:77,COMMA:78,styleComponent:79,NUM:80,COLON:81,UNIT:82,SPACE:83,BRKT:84,PCT:85,commentToken:86,textToken:87,graphCodeTokens:88,textNoTagsToken:89,TAGSTART:90,TAGEND:91,"==":92,"--":93,DEFAULT:94,MINUS:95,keywords:96,UNICODE_TEXT:97,BQUOTE_STR:98,$accept:0,$end:1},terminals_:{2:"error",7:"CLASS_DIAGRAM",8:"NEWLINE",9:"EOF",12:"SQS",13:"STR",14:"SQE",19:"GENERICTYPE",21:"LABEL",31:"acc_title",32:"acc_title_value",33:"acc_descr",34:"acc_descr_value",35:"acc_descr_multiline_value",37:"STRUCT_START",39:"STRUCT_STOP",40:"NAMESPACE",42:"STYLE_SEPARATOR",44:"CLASS",45:"ANNOTATION_START",46:"ANNOTATION_END",47:"MEMBER",48:"SEPARATOR",50:"NOTE_FOR",52:"NOTE",53:"direction_tb",54:"direction_bt",55:"direction_rl",56:"direction_lr",59:"AGGREGATION",60:"EXTENSION",61:"COMPOSITION",62:"DEPENDENCY",63:"LOLLIPOP",64:"LINE",65:"DOTTED_LINE",66:"CALLBACK",67:"LINK",68:"LINK_TARGET",69:"CLICK",70:"CALLBACK_NAME",71:"CALLBACK_ARGS",72:"HREF",73:"STYLE",74:"ALPHA",76:"CSSCLASS",78:"COMMA",80:"NUM",81:"COLON",82:"UNIT",83:"SPACE",84:"BRKT",85:"PCT",88:"graphCodeTokens",90:"TAGSTART",91:"TAGEND",92:"==",93:"--",94:"DEFAULT",95:"MINUS",96:"keywords",97:"UNICODE_TEXT",98:"BQUOTE_STR"},productions_:[0,[3,1],[3,1],[4,1],[6,4],[5,1],[5,2],[5,3],[11,3],[15,1],[15,2],[17,1],[17,1],[17,2],[17,2],[17,2],[10,1],[10,2],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,1],[10,2],[10,2],[10,1],[22,4],[22,5],[36,2],[38,1],[38,2],[38,3],[23,1],[23,3],[23,4],[23,6],[41,2],[41,3],[25,4],[43,1],[43,2],[24,1],[24,2],[24,1],[24,1],[20,3],[20,4],[20,4],[20,5],[29,3],[29,2],[30,1],[30,1],[30,1],[30,1],[49,3],[49,2],[49,2],[49,1],[57,1],[57,1],[57,1],[57,1],[57,1],[58,1],[58,1],[26,3],[26,4],[26,3],[26,4],[26,4],[26,5],[26,3],[26,4],[26,4],[26,5],[26,4],[26,5],[26,5],[26,6],[27,3],[28,3],[75,1],[75,3],[77,1],[77,2],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[79,1],[86,1],[86,1],[87,1],[87,1],[87,1],[87,1],[87,1],[87,1],[87,1],[89,1],[89,1],[89,1],[89,1],[16,1],[16,1],[16,1],[16,1],[18,1],[51,1]],performAction:function(Tr,Fn,qn,Un,At,wt,on){var fn=wt.length-1;switch(At){case 8:this.$=wt[fn-1];break;case 9:case 11:case 12:this.$=wt[fn];break;case 10:case 13:this.$=wt[fn-1]+wt[fn];break;case 14:case 15:this.$=wt[fn-1]+"~"+wt[fn]+"~";break;case 16:Un.addRelation(wt[fn]);break;case 17:wt[fn-1].title=Un.cleanupLabel(wt[fn]),Un.addRelation(wt[fn-1]);break;case 27:this.$=wt[fn].trim(),Un.setAccTitle(this.$);break;case 28:case 29:this.$=wt[fn].trim(),Un.setAccDescription(this.$);break;case 30:Un.addClassesToNamespace(wt[fn-3],wt[fn-1]);break;case 31:Un.addClassesToNamespace(wt[fn-4],wt[fn-1]);break;case 32:this.$=wt[fn],Un.addNamespace(wt[fn]);break;case 33:this.$=[wt[fn]];break;case 34:this.$=[wt[fn-1]];break;case 35:wt[fn].unshift(wt[fn-2]),this.$=wt[fn];break;case 37:Un.setCssClass(wt[fn-2],wt[fn]);break;case 38:Un.addMembers(wt[fn-3],wt[fn-1]);break;case 39:Un.setCssClass(wt[fn-5],wt[fn-3]),Un.addMembers(wt[fn-5],wt[fn-1]);break;case 40:this.$=wt[fn],Un.addClass(wt[fn]);break;case 41:this.$=wt[fn-1],Un.addClass(wt[fn-1]),Un.setClassLabel(wt[fn-1],wt[fn]);break;case 42:Un.addAnnotation(wt[fn],wt[fn-2]);break;case 43:this.$=[wt[fn]];break;case 44:wt[fn].push(wt[fn-1]),this.$=wt[fn];break;case 45:break;case 46:Un.addMember(wt[fn-1],Un.cleanupLabel(wt[fn]));break;case 47:break;case 48:break;case 49:this.$={id1:wt[fn-2],id2:wt[fn],relation:wt[fn-1],relationTitle1:"none",relationTitle2:"none"};break;case 50:this.$={id1:wt[fn-3],id2:wt[fn],relation:wt[fn-1],relationTitle1:wt[fn-2],relationTitle2:"none"};break;case 51:this.$={id1:wt[fn-3],id2:wt[fn],relation:wt[fn-2],relationTitle1:"none",relationTitle2:wt[fn-1]};break;case 52:this.$={id1:wt[fn-4],id2:wt[fn],relation:wt[fn-2],relationTitle1:wt[fn-3],relationTitle2:wt[fn-1]};break;case 53:Un.addNote(wt[fn],wt[fn-1]);break;case 54:Un.addNote(wt[fn]);break;case 55:Un.setDirection("TB");break;case 56:Un.setDirection("BT");break;case 57:Un.setDirection("RL");break;case 58:Un.setDirection("LR");break;case 59:this.$={type1:wt[fn-2],type2:wt[fn],lineType:wt[fn-1]};break;case 60:this.$={type1:"none",type2:wt[fn],lineType:wt[fn-1]};break;case 61:this.$={type1:wt[fn-1],type2:"none",lineType:wt[fn]};break;case 62:this.$={type1:"none",type2:"none",lineType:wt[fn]};break;case 63:this.$=Un.relationType.AGGREGATION;break;case 64:this.$=Un.relationType.EXTENSION;break;case 65:this.$=Un.relationType.COMPOSITION;break;case 66:this.$=Un.relationType.DEPENDENCY;break;case 67:this.$=Un.relationType.LOLLIPOP;break;case 68:this.$=Un.lineType.LINE;break;case 69:this.$=Un.lineType.DOTTED_LINE;break;case 70:case 76:this.$=wt[fn-2],Un.setClickEvent(wt[fn-1],wt[fn]);break;case 71:case 77:this.$=wt[fn-3],Un.setClickEvent(wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-2],wt[fn]);break;case 72:this.$=wt[fn-2],Un.setLink(wt[fn-1],wt[fn]);break;case 73:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn-1],wt[fn]);break;case 74:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-2],wt[fn]);break;case 75:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-2],wt[fn]),Un.setTooltip(wt[fn-3],wt[fn-1]);break;case 78:this.$=wt[fn-3],Un.setClickEvent(wt[fn-2],wt[fn-1],wt[fn]);break;case 79:this.$=wt[fn-4],Un.setClickEvent(wt[fn-3],wt[fn-2],wt[fn-1]),Un.setTooltip(wt[fn-3],wt[fn]);break;case 80:this.$=wt[fn-3],Un.setLink(wt[fn-2],wt[fn]);break;case 81:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-1],wt[fn]);break;case 82:this.$=wt[fn-4],Un.setLink(wt[fn-3],wt[fn-1]),Un.setTooltip(wt[fn-3],wt[fn]);break;case 83:this.$=wt[fn-5],Un.setLink(wt[fn-4],wt[fn-2],wt[fn]),Un.setTooltip(wt[fn-4],wt[fn-1]);break;case 84:this.$=wt[fn-2],Un.setCssStyle(wt[fn-1],wt[fn]);break;case 85:Un.setCssClass(wt[fn-1],wt[fn]);break;case 86:this.$=[wt[fn]];break;case 87:wt[fn-2].push(wt[fn]),this.$=wt[fn-2];break;case 89:this.$=wt[fn-1]+wt[fn];break}},table:[{3:1,4:2,5:3,6:4,7:[1,6],10:5,16:37,17:20,18:38,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,31:s,33:u,35:d,36:21,40:p,41:22,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de},{1:[3]},{1:[2,1]},{1:[2,2]},{1:[2,3]},i(X,[2,5],{8:[1,46]}),{8:[1,47]},i(ge,[2,16],{21:[1,48]}),i(ge,[2,18]),i(ge,[2,19]),i(ge,[2,20]),i(ge,[2,21]),i(ge,[2,22]),i(ge,[2,23]),i(ge,[2,24]),i(ge,[2,25]),i(ge,[2,26]),{32:[1,49]},{34:[1,50]},i(ge,[2,29]),i(ge,[2,45],{49:51,57:54,58:55,13:[1,52],21:[1,53],59:W,60:xe,61:U,62:Fe,63:Pe,64:je,65:Ie}),{37:[1,63]},i(Se,[2,36],{37:[1,65],42:[1,64]}),i(ge,[2,47]),i(ge,[2,48]),{16:66,74:pe,80:ae,95:ne,97:se},{16:37,17:67,18:38,74:pe,80:ae,95:ne,97:se,98:de},{16:37,17:68,18:38,74:pe,80:ae,95:ne,97:se,98:de},{16:37,17:69,18:38,74:pe,80:ae,95:ne,97:se,98:de},{74:[1,70]},{13:[1,71]},{16:37,17:72,18:38,74:pe,80:ae,95:ne,97:se,98:de},{13:Ce,51:73},i(ge,[2,55]),i(ge,[2,56]),i(ge,[2,57]),i(ge,[2,58]),i(ke,[2,11],{16:37,18:38,17:75,19:[1,76],74:pe,80:ae,95:ne,97:se,98:de}),i(ke,[2,12],{19:[1,77]}),{15:78,16:79,74:pe,80:ae,95:ne,97:se},{16:37,17:80,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ke,[2,112]),i(Ke,[2,113]),i(Ke,[2,114]),i(Ke,[2,115]),i([1,8,9,12,13,19,21,37,39,42,59,60,61,62,63,64,65,70,72],[2,116]),i(X,[2,6],{10:5,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,17:20,36:21,41:22,16:37,18:38,5:81,31:s,33:u,35:d,40:p,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de}),{5:82,10:5,16:37,17:20,18:38,20:7,22:8,23:9,24:10,25:11,26:12,27:13,28:14,29:15,30:16,31:s,33:u,35:d,36:21,40:p,41:22,44:v,45:b,47:y,48:T,50:_,52:A,53:P,54:R,55:F,56:j,66:K,67:ee,69:ie,73:oe,74:pe,76:be,80:ae,95:ne,97:se,98:de},i(ge,[2,17]),i(ge,[2,27]),i(ge,[2,28]),{13:[1,84],16:37,17:83,18:38,74:pe,80:ae,95:ne,97:se,98:de},{49:85,57:54,58:55,59:W,60:xe,61:U,62:Fe,63:Pe,64:je,65:Ie},i(ge,[2,46]),{58:86,64:je,65:Ie},i(Ft,[2,62],{57:87,59:W,60:xe,61:U,62:Fe,63:Pe}),i(Ne,[2,63]),i(Ne,[2,64]),i(Ne,[2,65]),i(Ne,[2,66]),i(Ne,[2,67]),i(gn,[2,68]),i(gn,[2,69]),{8:[1,89],23:90,38:88,41:22,44:v},{16:91,74:pe,80:ae,95:ne,97:se},{43:92,47:_t},{46:[1,94]},{13:[1,95]},{13:[1,96]},{70:[1,97],72:[1,98]},{21:Et,73:Gt,74:ln,75:99,77:100,79:101,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On},{74:[1,111]},{13:Ce,51:112},i(ge,[2,54]),i(ge,[2,117]),i(ke,[2,13]),i(ke,[2,14]),i(ke,[2,15]),{37:[2,32]},{15:113,16:79,37:[2,9],74:pe,80:ae,95:ne,97:se},i(ht,[2,40],{11:114,12:[1,115]}),i(X,[2,7]),{9:[1,116]},i(zr,[2,49]),{16:37,17:117,18:38,74:pe,80:ae,95:ne,97:se,98:de},{13:[1,119],16:37,17:118,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ft,[2,61],{57:120,59:W,60:xe,61:U,62:Fe,63:Pe}),i(Ft,[2,60]),{39:[1,121]},{23:90,38:122,41:22,44:v},{8:[1,123],39:[2,33]},i(Se,[2,37],{37:[1,124]}),{39:[1,125]},{39:[2,43],43:126,47:_t},{16:37,17:127,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(ge,[2,70],{13:[1,128]}),i(ge,[2,72],{13:[1,130],68:[1,129]}),i(ge,[2,76],{13:[1,131],71:[1,132]}),{13:[1,133]},i(ge,[2,84],{78:[1,134]}),i(yt,[2,86],{79:135,21:Et,73:Gt,74:ln,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On}),i(ji,[2,88]),i(ji,[2,90]),i(ji,[2,91]),i(ji,[2,92]),i(ji,[2,93]),i(ji,[2,94]),i(ji,[2,95]),i(ji,[2,96]),i(ji,[2,97]),i(ji,[2,98]),i(ge,[2,85]),i(ge,[2,53]),{37:[2,10]},i(ht,[2,41]),{13:[1,136]},{1:[2,4]},i(zr,[2,51]),i(zr,[2,50]),{16:37,17:137,18:38,74:pe,80:ae,95:ne,97:se,98:de},i(Ft,[2,59]),i(ge,[2,30]),{39:[1,138]},{23:90,38:139,39:[2,34],41:22,44:v},{43:140,47:_t},i(Se,[2,38]),{39:[2,44]},i(ge,[2,42]),i(ge,[2,71]),i(ge,[2,73]),i(ge,[2,74],{68:[1,141]}),i(ge,[2,77]),i(ge,[2,78],{13:[1,142]}),i(ge,[2,80],{13:[1,144],68:[1,143]}),{21:Et,73:Gt,74:ln,77:145,79:101,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On},i(ji,[2,89]),{14:[1,146]},i(zr,[2,52]),i(ge,[2,31]),{39:[2,35]},{39:[1,147]},i(ge,[2,75]),i(ge,[2,79]),i(ge,[2,81]),i(ge,[2,82],{68:[1,148]}),i(yt,[2,87],{79:135,21:Et,73:Gt,74:ln,80:xt,81:Pt,82:Qe,83:Dt,84:kt,85:On}),i(ht,[2,8]),i(Se,[2,39]),i(ge,[2,83])],defaultActions:{2:[2,1],3:[2,2],4:[2,3],78:[2,32],113:[2,10],116:[2,4],126:[2,44],139:[2,35]},parseError:function(Tr,Fn){if(Fn.recoverable)this.trace(Tr);else{var qn=new Error(Tr);throw qn.hash=Fn,qn}},parse:function(Tr){var Fn=this,qn=[0],Un=[],At=[null],wt=[],on=this.table,fn="",An=0,oo=0,jo=2,$o=1,Pa=wt.slice.call(arguments,1),wo=Object.create(this.lexer),_s={yy:{}};for(var tl in this.yy)Object.prototype.hasOwnProperty.call(this.yy,tl)&&(_s.yy[tl]=this.yy[tl]);wo.setInput(Tr,_s.yy),_s.yy.lexer=wo,_s.yy.parser=this,typeof wo.yylloc>"u"&&(wo.yylloc={});var da=wo.yylloc;wt.push(da);var j0=wo.options&&wo.options.ranges;typeof _s.yy.parseError=="function"?this.parseError=_s.yy.parseError:this.parseError=Object.getPrototypeOf(this).parseError;function pm(){var ga;return ga=Un.pop()||wo.lex()||$o,typeof ga!="number"&&(ga instanceof Array&&(Un=ga,ga=Un.pop()),ga=Fn.symbols_[ga]||ga),ga}for(var Ml,Xc,Bc,ja,Ou={},Sa,Po,Fc,xa;;){if(Xc=qn[qn.length-1],this.defaultActions[Xc]?Bc=this.defaultActions[Xc]:((Ml===null||typeof Ml>"u")&&(Ml=pm()),Bc=on[Xc]&&on[Xc][Ml]),typeof Bc>"u"||!Bc.length||!Bc[0]){var Ba="";xa=[];for(Sa in on[Xc])this.terminals_[Sa]&&Sa>jo&&xa.push("'"+this.terminals_[Sa]+"'");wo.showPosition?Ba="Parse error on line "+(An+1)+`:
`+wo.showPosition()+`
Expecting `+xa.join(", ")+", got '"+(this.terminals_[Ml]||Ml)+"'":Ba="Parse error on line "+(An+1)+": Unexpected "+(Ml==$o?"end of input":"'"+(this.terminals_[Ml]||Ml)+"'"),this.parseError(Ba,{text:wo.match,token:this.terminals_[Ml]||Ml,line:wo.yylineno,loc:da,expected:xa})}if(Bc[0]instanceof Array&&Bc.length>1)throw new Error("Parse Error: multiple actions possible at state: "+Xc+", token: "+Ml);switch(Bc[0]){case 1:qn.push(Ml),At.push(wo.yytext),wt.push(wo.yylloc),qn.push(Bc[1]),Ml=null,oo=wo.yyleng,fn=wo.yytext,An=wo.yylineno,da=wo.yylloc;break;case 2:if(Po=this.productions_[Bc[1]][1],Ou.$=At[At.length-Po],Ou._$={first_line:wt[wt.length-(Po||1)].first_line,last_line:wt[wt.length-1].last_line,first_column:wt[wt.length-(Po||1)].first_column,last_column:wt[wt.length-1].last_column},j0&&(Ou._$.range=[wt[wt.length-(Po||1)].range[0],wt[wt.length-1].range[1]]),ja=this.performAction.apply(Ou,[fn,oo,An,_s.yy,Bc[1],At,wt].concat(Pa)),typeof ja<"u")return ja;Po&&(qn=qn.slice(0,-1*Po*2),At=At.slice(0,-1*Po),wt=wt.slice(0,-1*Po)),qn.push(this.productions_[Bc[1]][0]),At.push(Ou.$),wt.push(Ou._$),Fc=on[qn[qn.length-2]][qn[qn.length-1]],qn.push(Fc);break;case 3:return!0}}return!0}},Ma=function(){var ao={EOF:1,parseError:function(Fn,qn){if(this.yy.parser)this.yy.parser.parseError(Fn,qn);else throw new Error(Fn)},setInput:function(Tr,Fn){return this.yy=Fn||this.yy||{},this._input=Tr,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var Tr=this._input[0];this.yytext+=Tr,this.yyleng++,this.offset++,this.match+=Tr,this.matched+=Tr;var Fn=Tr.match(/(?:\r\n?|\n).*/g);return Fn?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),Tr},unput:function(Tr){var Fn=Tr.length,qn=Tr.split(/(?:\r\n?|\n)/g);this._input=Tr+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-Fn),this.offset-=Fn;var Un=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),qn.length-1&&(this.yylineno-=qn.length-1);var At=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:qn?(qn.length===Un.length?this.yylloc.first_column:0)+Un[Un.length-qn.length].length-qn[0].length:this.yylloc.first_column-Fn},this.options.ranges&&(this.yylloc.range=[At[0],At[0]+this.yyleng-Fn]),this.yyleng=this.yytext.length,this},more:function(){return this._more=!0,this},reject:function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},less:function(Tr){this.unput(this.match.slice(Tr))},pastInput:function(){var Tr=this.matched.substr(0,this.matched.length-this.match.length);return(Tr.length>20?"...":"")+Tr.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var Tr=this.match;return Tr.length<20&&(Tr+=this._input.substr(0,20-Tr.length)),(Tr.substr(0,20)+(Tr.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var Tr=this.pastInput(),Fn=new Array(Tr.length+1).join("-");return Tr+this.upcomingInput()+`
`+Fn+"^"},test_match:function(Tr,Fn){var qn,Un,At;if(this.options.backtrack_lexer&&(At={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(At.yylloc.range=this.yylloc.range.slice(0))),Un=Tr[0].match(/(?:\r\n?|\n).*/g),Un&&(this.yylineno+=Un.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:Un?Un[Un.length-1].length-Un[Un.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+Tr[0].length},this.yytext+=Tr[0],this.match+=Tr[0],this.matches=Tr,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(Tr[0].length),this.matched+=Tr[0],qn=this.performAction.call(this,this.yy,this,Fn,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),qn)return qn;if(this._backtrack){for(var wt in At)this[wt]=At[wt];return!1}return!1},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var Tr,Fn,qn,Un;this._more||(this.yytext="",this.match="");for(var At=this._currentRules(),wt=0;wt
"},u),li.lineBreakRegex.test(i)))return i;const d=i.split(" "),p=[];let v="";return d.forEach((b,y)=>{const T=H4(`${b} `,u),_=H4(v,u);if(T>s){const{hyphenatedStrings:R,remainingWord:F}=MRt(b,s,"-",u);p.push(v,...R),v=F}else _+T>=s?(p.push(v),v=b):v=[v,b].filter(Boolean).join(" ");y+1===d.length&&p.push(v)}),p.filter(b=>b!=="").join(u.joinWith)},(i,s,u)=>`${i}${s}${u.fontSize}${u.fontWeight}${u.fontFamily}${u.joinWith}`),MRt=bD((i,s,u="-",d)=>{d=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",margin:0},d);const p=[...i],v=[];let b="";return p.forEach((y,T)=>{const _=`${b}${y}`;if(H4(_,d)>=s){const P=T+1,R=p.length===P,F=`${_}${u}`;v.push(R?_:F),b=""}else b=_}),{hyphenatedStrings:v,remainingWord:b}},(i,s,u="-",d)=>`${i}${s}${u}${d.fontSize}${d.fontWeight}${d.fontFamily}`);function E2e(i,s){return T2e(i,s).height}function H4(i,s){return T2e(i,s).width}const T2e=bD((i,s)=>{const{fontSize:u=12,fontFamily:d="Arial",fontWeight:p=400}=s;if(!i)return{width:0,height:0};const[,v]=NC(u),b=["sans-serif",d],y=i.split(li.lineBreakRegex),T=[],_=Ir("body");if(!_.remove)return{width:0,height:0,lineHeight:0};const A=_.append("svg");for(const R of b){let F=0;const j={width:0,height:0,lineHeight:0};for(const K of y){const ee=ARt();ee.text=K||hje;const ie=LRt(A,ee).style("font-size",v).style("font-weight",p).style("font-family",R),oe=(ie._groups||ie)[0][0].getBBox();if(oe.width===0&&oe.height===0)throw new Error("svg element not in render tree");j.width=Math.round(Math.max(j.width,oe.width)),F=Math.round(oe.height),j.height+=F,j.lineHeight=Math.round(Math.max(j.lineHeight,F))}T.push(j)}A.remove();const P=isNaN(T[1].height)||isNaN(T[1].width)||isNaN(T[1].lineHeight)||T[0].height>T[1].height&&T[0].width>T[1].width&&T[0].lineHeight>T[1].lineHeight?0:1;return T[P]},(i,s)=>`${i}${s.fontSize}${s.fontWeight}${s.fontFamily}`);class DRt{constructor(s=!1,u){this.count=0,this.count=u?u.length:0,this.next=s?()=>this.count++:()=>Date.now()}}let $X;const IRt=function(i){return $X=$X||document.createElement("div"),i=escape(i).replace(/%26/g,"&").replace(/%23/g,"#").replace(/%3B/g,";"),$X.innerHTML=i,unescape($X.textContent)};function wje(i){return"str"in i}const ORt=(i,s,u,d)=>{var v;if(!d)return;const p=(v=i.node())==null?void 0:v.getBBox();p&&i.append("text").text(d).attr("x",p.x+p.width/2).attr("y",-u).attr("class",s)},NC=i=>{if(typeof i=="number")return[i,i+"px"];const s=parseInt(i??"",10);return Number.isNaN(s)?[void 0,void 0]:i===String(s)?[s,i+"px"]:[s,i]};function JF(i,s){return jX({},i,s)}const Ao={assignWithDepth:id,wrapLabel:vje,calculateTextHeight:E2e,calculateTextWidth:H4,calculateTextDimensions:T2e,cleanAndMerge:JF,detectInit:vRt,detectDirective:fje,isSubstringInArray:yRt,interpolateToCurve:Ov,calcLabelPosition:TRt,calcCardinalityPosition:CRt,calcTerminalLabelPosition:SRt,formatUrl:xRt,getStylesFromArray:om,generateId:bje,random:mje,runFunc:kRt,entityDecode:IRt,insertTitle:ORt,parseFontSize:NC,InitIDGenerator:DRt},NRt=function(i){let s=i;return s=s.replace(/style.*:\S*#.*;/g,function(u){return u.substring(0,u.length-1)}),s=s.replace(/classDef.*:\S*#.*;/g,function(u){return u.substring(0,u.length-1)}),s=s.replace(/#\w+;/g,function(u){const d=u.substring(1,u.length-1);return/^\+?\d+$/.test(d)?"fl°°"+d+"¶ß":"fl°"+d+"¶ß"}),s},ZF=function(i){return i.replace(/fl°°/g,"").replace(/fl°/g,"&").replace(/¶ß/g,";")};var yje="comm",xje="rule",kje="decl",PRt="@import",BRt="@keyframes",FRt="@layer",Eje=Math.abs,C2e=String.fromCharCode;function Tje(i){return i.trim()}function zX(i,s,u){return i.replace(s,u)}function RRt(i,s,u){return i.indexOf(s,u)}function eR(i,s){return i.charCodeAt(s)|0}function tR(i,s,u){return i.slice(s,u)}function _7(i){return i.length}function jRt(i){return i.length}function qX(i,s){return s.push(i),i}var HX=1,xD=1,Cje=0,Nv=0,I0=0,kD="";function S2e(i,s,u,d,p,v,b,y){return{value:i,root:s,parent:u,type:d,props:p,children:v,line:HX,column:xD,length:b,return:"",siblings:y}}function $Rt(){return I0}function zRt(){return I0=Nv>0?eR(kD,--Nv):0,xD--,I0===10&&(xD=1,HX--),I0}function B3(){return I0=Nv
"},u),ci.lineBreakRegex.test(i)))return i;const d=i.split(" "),p=[];let v="";return d.forEach((b,y)=>{const T=H4(`${b} `,u),_=H4(v,u);if(T>s){const{hyphenatedStrings:R,remainingWord:F}=MRt(b,s,"-",u);p.push(v,...R),v=F}else _+T>=s?(p.push(v),v=b):v=[v,b].filter(Boolean).join(" ");y+1===d.length&&p.push(v)}),p.filter(b=>b!=="").join(u.joinWith)},(i,s,u)=>`${i}${s}${u.fontSize}${u.fontWeight}${u.fontFamily}${u.joinWith}`),MRt=bD((i,s,u="-",d)=>{d=Object.assign({fontSize:12,fontWeight:400,fontFamily:"Arial",margin:0},d);const p=[...i],v=[];let b="";return p.forEach((y,T)=>{const _=`${b}${y}`;if(H4(_,d)>=s){const P=T+1,R=p.length===P,F=`${_}${u}`;v.push(R?_:F),b=""}else b=_}),{hyphenatedStrings:v,remainingWord:b}},(i,s,u="-",d)=>`${i}${s}${u}${d.fontSize}${d.fontWeight}${d.fontFamily}`);function E2e(i,s){return T2e(i,s).height}function H4(i,s){return T2e(i,s).width}const T2e=bD((i,s)=>{const{fontSize:u=12,fontFamily:d="Arial",fontWeight:p=400}=s;if(!i)return{width:0,height:0};const[,v]=NC(u),b=["sans-serif",d],y=i.split(ci.lineBreakRegex),T=[],_=Ir("body");if(!_.remove)return{width:0,height:0,lineHeight:0};const A=_.append("svg");for(const R of b){let F=0;const j={width:0,height:0,lineHeight:0};for(const K of y){const ee=ARt();ee.text=K||hje;const ie=LRt(A,ee).style("font-size",v).style("font-weight",p).style("font-family",R),oe=(ie._groups||ie)[0][0].getBBox();if(oe.width===0&&oe.height===0)throw new Error("svg element not in render tree");j.width=Math.round(Math.max(j.width,oe.width)),F=Math.round(oe.height),j.height+=F,j.lineHeight=Math.round(Math.max(j.lineHeight,F))}T.push(j)}A.remove();const P=isNaN(T[1].height)||isNaN(T[1].width)||isNaN(T[1].lineHeight)||T[0].height>T[1].height&&T[0].width>T[1].width&&T[0].lineHeight>T[1].lineHeight?0:1;return T[P]},(i,s)=>`${i}${s.fontSize}${s.fontWeight}${s.fontFamily}`);class DRt{constructor(s=!1,u){this.count=0,this.count=u?u.length:0,this.next=s?()=>this.count++:()=>Date.now()}}let $X;const IRt=function(i){return $X=$X||document.createElement("div"),i=escape(i).replace(/%26/g,"&").replace(/%23/g,"#").replace(/%3B/g,";"),$X.innerHTML=i,unescape($X.textContent)};function wje(i){return"str"in i}const ORt=(i,s,u,d)=>{var v;if(!d)return;const p=(v=i.node())==null?void 0:v.getBBox();p&&i.append("text").text(d).attr("x",p.x+p.width/2).attr("y",-u).attr("class",s)},NC=i=>{if(typeof i=="number")return[i,i+"px"];const s=parseInt(i??"",10);return Number.isNaN(s)?[void 0,void 0]:i===String(s)?[s,i+"px"]:[s,i]};function JF(i,s){return jX({},i,s)}const Ao={assignWithDepth:id,wrapLabel:vje,calculateTextHeight:E2e,calculateTextWidth:H4,calculateTextDimensions:T2e,cleanAndMerge:JF,detectInit:vRt,detectDirective:fje,isSubstringInArray:yRt,interpolateToCurve:Ov,calcLabelPosition:TRt,calcCardinalityPosition:CRt,calcTerminalLabelPosition:SRt,formatUrl:xRt,getStylesFromArray:om,generateId:bje,random:mje,runFunc:kRt,entityDecode:IRt,insertTitle:ORt,parseFontSize:NC,InitIDGenerator:DRt},NRt=function(i){let s=i;return s=s.replace(/style.*:\S*#.*;/g,function(u){return u.substring(0,u.length-1)}),s=s.replace(/classDef.*:\S*#.*;/g,function(u){return u.substring(0,u.length-1)}),s=s.replace(/#\w+;/g,function(u){const d=u.substring(1,u.length-1);return/^\+?\d+$/.test(d)?"fl°°"+d+"¶ß":"fl°"+d+"¶ß"}),s},ZF=function(i){return i.replace(/fl°°/g,"").replace(/fl°/g,"&").replace(/¶ß/g,";")};var yje="comm",xje="rule",kje="decl",PRt="@import",BRt="@keyframes",FRt="@layer",Eje=Math.abs,C2e=String.fromCharCode;function Tje(i){return i.trim()}function zX(i,s,u){return i.replace(s,u)}function RRt(i,s,u){return i.indexOf(s,u)}function eR(i,s){return i.charCodeAt(s)|0}function tR(i,s,u){return i.slice(s,u)}function _7(i){return i.length}function jRt(i){return i.length}function qX(i,s){return s.push(i),i}var HX=1,xD=1,Cje=0,Nv=0,I0=0,kD="";function S2e(i,s,u,d,p,v,b,y){return{value:i,root:s,parent:u,type:d,props:p,children:v,line:HX,column:xD,length:b,return:"",siblings:y}}function $Rt(){return I0}function zRt(){return I0=Nv>0?eR(kD,--Nv):0,xD--,I0===10&&(xD=1,HX--),I0}function B3(){return I0=Nvs||v&&b&&T&&!y&&!_||d&&b&&T||!u&&T||!p)return 1;if(!d&&!v&&!_&&i=y)return T;var _=u[d];return T*(_=="desc"?-1:1)}}return i.index-s.index}function PWt(i,s,u){s.length?s=RD(s,function(v){return D0(v)?function(b){return zQ(b,v.length===1?v[0]:v)}:v}):s=[OC];var d=-1;s=RD(s,NX(I9));var p=VHe(i,function(v,b,y){var T=RD(s,function(_){return _(v)});return{criteria:T,index:++d,value:v}});return IWt(p,function(v,b){return NWt(v,b,u)})}function BWt(i,s){return DWt(i,s,function(u,d){return zHe(i,d)})}var FWt=rGt(function(i,s){return i==null?{}:BWt(i,s)});const ER=FWt;var RWt=Math.ceil,jWt=Math.max;function $Wt(i,s,u,d){for(var p=-1,v=jWt(RWt((s-i)/(u||1)),0),b=Array(v);v--;)b[d?v:++p]=i,i+=u;return b}function zWt(i){return function(s,u,d){return d&&typeof d!="number"&&QF(s,u,d)&&(u=d=void 0),s=jQ(s),u===void 0?(u=s,s=0):u=jQ(u),d=d===void 0?s1&&QF(i,s[0],s[1])?s=[]:u>2&&QF(s[0],s[1],s[2])&&(s=[s[0]]),PWt(i,qQ(s,1),[])});const CR=VWt;var UWt=1/0,GWt=CD&&1/Jbe(new CD([,-0]))[1]==UWt?function(i){return new CD(i)}:zUt;const KWt=GWt;var WWt=200;function YWt(i,s,u){var d=-1,p=UUt,v=i.length,b=!0,y=[],T=y;if(u)b=!1,p=mWt;else if(v>=WWt){var _=s?null:KWt(i);if(_)return Jbe(_);b=!1,p=IHe,T=new xR}else T=s?[]:y;e:for(;++d
"),Xe.debug("vertexText"+p);const v={isNode:d,label:ZF(p).replace(/fa[blrs]?:fa-[\w-]+/g,y=>``),labelStyle:s.replace("fill:","color:")};return OQt(v)}else{const v=document.createElementNS("http://www.w3.org/2000/svg","text");v.setAttribute("style",s.replace("color:","fill:"));let b=[];typeof p=="string"?b=p.split(/\\n|\n|
/gi):Array.isArray(p)?b=p:b=[];for(const y of b){const T=document.createElementNS("http://www.w3.org/2000/svg","tspan");T.setAttributeNS("http://www.w3.org/XML/1998/namespace","xml:space","preserve"),T.setAttribute("dy","1em"),T.setAttribute("x","0"),u?T.setAttribute("class","title-row"):T.setAttribute("class","row"),T.textContent=y.trim(),v.appendChild(T)}return v}},NQt={};function PQt(i,s){const u=s||NQt,d=typeof u.includeImageAlt=="boolean"?u.includeImageAlt:!0,p=typeof u.includeHtml=="boolean"?u.includeHtml:!0;return $Ve(i,d,p)}function $Ve(i,s,u){if(BQt(i)){if("value"in i)return i.type==="html"&&!u?"":i.value;if(s&&"alt"in i&&i.alt)return i.alt;if("children"in i)return zVe(i.children,s,u)}return Array.isArray(i)?zVe(i,s,u):""}function zVe(i,s,u){const d=[];let p=-1;for(;++p=4?s(b):i.interrupt(d.parser.constructs.flow,u,s)(b)}}function ZVe(i,s,u,d,p,v,b,y,T){const _=T||Number.POSITIVE_INFINITY;let A=0;return P;function P(ie){return ie===60?(i.enter(d),i.enter(p),i.enter(v),i.consume(ie),i.exit(v),R):ie===null||ie===32||ie===41||_me(ie)?u(ie):(i.enter(d),i.enter(b),i.enter(y),i.enter("chunkString",{contentType:"string"}),K(ie))}function R(ie){return ie===62?(i.enter(v),i.consume(ie),i.exit(v),i.exit(p),i.exit(d),s):(i.enter(y),i.enter("chunkString",{contentType:"string"}),F(ie))}function F(ie){return ie===62?(i.exit("chunkString"),i.exit(y),R(ie)):ie===null||ie===60||so(ie)?u(ie):(i.consume(ie),ie===92?j:F)}function j(ie){return ie===60||ie===62||ie===92?(i.consume(ie),F):F(ie)}function K(ie){return!A&&(ie===null||ie===41||z2(ie))?(i.exit("chunkString"),i.exit(y),i.exit(b),i.exit(d),s(ie)):A<_&&ie===40?(i.consume(ie),A++,K):ie===41?(i.consume(ie),A--,K):ie===null||ie===32||ie===40||_me(ie)?u(ie):(i.consume(ie),ie===92?ee:K)}function ee(ie){return ie===40||ie===41||ie===92?(i.consume(ie),K):K(ie)}}function eUe(i,s,u,d,p,v){const b=this;let y=0,T;return _;function _(F){return i.enter(d),i.enter(p),i.consume(F),i.exit(p),i.enter(v),A}function A(F){return y>999||F===null||F===91||F===93&&!T||F===94&&!y&&"_hiddenFootnoteSupport"in b.parser.constructs?u(F):F===93?(i.exit(v),i.enter(p),i.consume(F),i.exit(p),i.exit(d),s):so(F)?(i.enter("lineEnding"),i.consume(F),i.exit("lineEnding"),A):(i.enter("chunkString",{contentType:"string"}),P(F))}function P(F){return F===null||F===91||F===93||so(F)||y++>999?(i.exit("chunkString"),A(F)):(i.consume(F),T||(T=!Iu(F)),F===92?R:P)}function R(F){return F===91||F===92||F===93?(i.consume(F),y++,P):P(F)}}function tUe(i,s,u,d,p,v){let b;return y;function y(R){return R===34||R===39||R===40?(i.enter(d),i.enter(p),i.consume(R),i.exit(p),b=R===40?41:R,T):u(R)}function T(R){return R===b?(i.enter(p),i.consume(R),i.exit(p),i.exit(d),s):(i.enter(v),_(R))}function _(R){return R===b?(i.exit(v),T(b)):R===null?u(R):so(R)?(i.enter("lineEnding"),i.consume(R),i.exit("lineEnding"),Kl(i,_,"linePrefix")):(i.enter("chunkString",{contentType:"string"}),A(R))}function A(R){return R===b||R===null||so(R)?(i.exit("chunkString"),_(R)):(i.consume(R),R===92?P:A)}function P(R){return R===b||R===92?(i.consume(R),A):A(R)}}function LR(i,s){let u;return d;function d(p){return so(p)?(i.enter("lineEnding"),i.consume(p),i.exit("lineEnding"),u=!0,d):Iu(p)?Kl(i,d,u?"linePrefix":"lineSuffix")(p):s(p)}}function HD(i){return i.replace(/[\t\n\r ]+/g," ").replace(/^ | $/g,"").toLowerCase().toUpperCase()}const kJt={name:"definition",tokenize:TJt},EJt={tokenize:CJt,partial:!0};function TJt(i,s,u){const d=this;let p;return v;function v(F){return i.enter("definition"),b(F)}function b(F){return eUe.call(d,i,y,u,"definitionLabel","definitionLabelMarker","definitionLabelString")(F)}function y(F){return p=HD(d.sliceSerialize(d.events[d.events.length-1][1]).slice(1,-1)),F===58?(i.enter("definitionMarker"),i.consume(F),i.exit("definitionMarker"),T):u(F)}function T(F){return z2(F)?LR(i,_)(F):_(F)}function _(F){return ZVe(i,A,u,"definitionDestination","definitionDestinationLiteral","definitionDestinationLiteralMarker","definitionDestinationRaw","definitionDestinationString")(F)}function A(F){return i.attempt(EJt,P,P)(F)}function P(F){return Iu(F)?Kl(i,R,"whitespace")(F):R(F)}function R(F){return F===null||so(F)?(i.exit("definition"),d.parser.defined.push(p),s(F)):u(F)}}function CJt(i,s,u){return d;function d(y){return z2(y)?LR(i,p)(y):u(y)}function p(y){return tUe(i,v,u,"definitionTitle","definitionTitleMarker","definitionTitleString")(y)}function v(y){return Iu(y)?Kl(i,b,"whitespace")(y):b(y)}function b(y){return y===null||so(y)?s(y):u(y)}}const SJt={name:"hardBreakEscape",tokenize:_Jt};function _Jt(i,s,u){return d;function d(v){return i.enter("hardBreakEscape"),i.consume(v),p}function p(v){return so(v)?(i.exit("hardBreakEscape"),s(v)):u(v)}}const AJt={name:"headingAtx",tokenize:MJt,resolve:LJt};function LJt(i,s){let u=i.length-2,d=3,p,v;return i[d][1].type==="whitespace"&&(d+=2),u-2>d&&i[u][1].type==="whitespace"&&(u-=2),i[u][1].type==="atxHeadingSequence"&&(d===u-1||u-4>d&&i[u-2][1].type==="whitespace")&&(u-=d+1===u?2:4),u>d&&(p={type:"atxHeadingText",start:i[d][1].start,end:i[u][1].end},v={type:"chunkText",start:i[d][1].start,end:i[u][1].end,contentType:"text"},t5(i,d,u-d+1,[["enter",p,s],["enter",v,s],["exit",v,s],["exit",p,s]])),i}function MJt(i,s,u){let d=0;return p;function p(A){return i.enter("atxHeading"),v(A)}function v(A){return i.enter("atxHeadingSequence"),b(A)}function b(A){return A===35&&d++<6?(i.consume(A),b):A===null||z2(A)?(i.exit("atxHeadingSequence"),y(A)):u(A)}function y(A){return A===35?(i.enter("atxHeadingSequence"),T(A)):A===null||so(A)?(i.exit("atxHeading"),s(A)):Iu(A)?Kl(i,y,"whitespace")(A):(i.enter("atxHeadingText"),_(A))}function T(A){return A===35?(i.consume(A),T):(i.exit("atxHeadingSequence"),y(A))}function _(A){return A===null||A===35||z2(A)?(i.exit("atxHeadingText"),y(A)):(i.consume(A),_)}}const DJt=["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"],nUe=["pre","script","style","textarea"],IJt={name:"htmlFlow",tokenize:BJt,resolveTo:PJt,concrete:!0},OJt={tokenize:RJt,partial:!0},NJt={tokenize:FJt,partial:!0};function PJt(i){let s=i.length;for(;s--&&!(i[s][0]==="enter"&&i[s][1].type==="htmlFlow"););return s>1&&i[s-2][1].type==="linePrefix"&&(i[s][1].start=i[s-2][1].start,i[s+1][1].start=i[s-2][1].start,i.splice(s-2,2)),i}function BJt(i,s,u){const d=this;let p,v,b,y,T;return _;function _(Ne){return A(Ne)}function A(Ne){return i.enter("htmlFlow"),i.enter("htmlFlowData"),i.consume(Ne),P}function P(Ne){return Ne===33?(i.consume(Ne),R):Ne===47?(i.consume(Ne),v=!0,K):Ne===63?(i.consume(Ne),p=3,d.interrupt?s:ke):n5(Ne)?(i.consume(Ne),b=String.fromCharCode(Ne),ee):u(Ne)}function R(Ne){return Ne===45?(i.consume(Ne),p=2,F):Ne===91?(i.consume(Ne),p=5,y=0,j):n5(Ne)?(i.consume(Ne),p=4,d.interrupt?s:ke):u(Ne)}function F(Ne){return Ne===45?(i.consume(Ne),d.interrupt?s:ke):u(Ne)}function j(Ne){const gn="CDATA[";return Ne===gn.charCodeAt(y++)?(i.consume(Ne),y===gn.length?d.interrupt?s:xe:j):u(Ne)}function K(Ne){return n5(Ne)?(i.consume(Ne),b=String.fromCharCode(Ne),ee):u(Ne)}function ee(Ne){if(Ne===null||Ne===47||Ne===62||z2(Ne)){const gn=Ne===47,_t=b.toLowerCase();return!gn&&!v&&nUe.includes(_t)?(p=1,d.interrupt?s(Ne):xe(Ne)):DJt.includes(b.toLowerCase())?(p=6,gn?(i.consume(Ne),ie):d.interrupt?s(Ne):xe(Ne)):(p=7,d.interrupt&&!d.parser.lazy[d.now().line]?u(Ne):v?oe(Ne):pe(Ne))}return Ne===45||H3(Ne)?(i.consume(Ne),b+=String.fromCharCode(Ne),ee):u(Ne)}function ie(Ne){return Ne===62?(i.consume(Ne),d.interrupt?s:xe):u(Ne)}function oe(Ne){return Iu(Ne)?(i.consume(Ne),oe):ge(Ne)}function pe(Ne){return Ne===47?(i.consume(Ne),ge):Ne===58||Ne===95||n5(Ne)?(i.consume(Ne),be):Iu(Ne)?(i.consume(Ne),pe):ge(Ne)}function be(Ne){return Ne===45||Ne===46||Ne===58||Ne===95||H3(Ne)?(i.consume(Ne),be):ae(Ne)}function ae(Ne){return Ne===61?(i.consume(Ne),ne):Iu(Ne)?(i.consume(Ne),ae):pe(Ne)}function ne(Ne){return Ne===null||Ne===60||Ne===61||Ne===62||Ne===96?u(Ne):Ne===34||Ne===39?(i.consume(Ne),T=Ne,se):Iu(Ne)?(i.consume(Ne),ne):de(Ne)}function se(Ne){return Ne===T?(i.consume(Ne),T=null,X):Ne===null||so(Ne)?u(Ne):(i.consume(Ne),se)}function de(Ne){return Ne===null||Ne===34||Ne===39||Ne===47||Ne===60||Ne===61||Ne===62||Ne===96||z2(Ne)?ae(Ne):(i.consume(Ne),de)}function X(Ne){return Ne===47||Ne===62||Iu(Ne)?pe(Ne):u(Ne)}function ge(Ne){return Ne===62?(i.consume(Ne),W):u(Ne)}function W(Ne){return Ne===null||so(Ne)?xe(Ne):Iu(Ne)?(i.consume(Ne),W):u(Ne)}function xe(Ne){return Ne===45&&p===2?(i.consume(Ne),je):Ne===60&&p===1?(i.consume(Ne),Ie):Ne===62&&p===4?(i.consume(Ne),Ke):Ne===63&&p===3?(i.consume(Ne),ke):Ne===93&&p===5?(i.consume(Ne),Ce):so(Ne)&&(p===6||p===7)?(i.exit("htmlFlowData"),i.check(OJt,Ft,U)(Ne)):Ne===null||so(Ne)?(i.exit("htmlFlowData"),U(Ne)):(i.consume(Ne),xe)}function U(Ne){return i.check(NJt,Fe,Ft)(Ne)}function Fe(Ne){return i.enter("lineEnding"),i.consume(Ne),i.exit("lineEnding"),Pe}function Pe(Ne){return Ne===null||so(Ne)?U(Ne):(i.enter("htmlFlowData"),xe(Ne))}function je(Ne){return Ne===45?(i.consume(Ne),ke):xe(Ne)}function Ie(Ne){return Ne===47?(i.consume(Ne),b="",Se):xe(Ne)}function Se(Ne){if(Ne===62){const gn=b.toLowerCase();return nUe.includes(gn)?(i.consume(Ne),Ke):xe(Ne)}return n5(Ne)&&b.length<8?(i.consume(Ne),b+=String.fromCharCode(Ne),Se):xe(Ne)}function Ce(Ne){return Ne===93?(i.consume(Ne),ke):xe(Ne)}function ke(Ne){return Ne===62?(i.consume(Ne),Ke):Ne===45&&p===2?(i.consume(Ne),ke):xe(Ne)}function Ke(Ne){return Ne===null||so(Ne)?(i.exit("htmlFlowData"),Ft(Ne)):(i.consume(Ne),Ke)}function Ft(Ne){return i.exit("htmlFlow"),s(Ne)}}function FJt(i,s,u){const d=this;return p;function p(b){return so(b)?(i.enter("lineEnding"),i.consume(b),i.exit("lineEnding"),v):u(b)}function v(b){return d.parser.lazy[d.now().line]?u(b):s(b)}}function RJt(i,s,u){return d;function d(p){return i.enter("lineEnding"),i.consume(p),i.exit("lineEnding"),i.attempt(YQ,s,u)}}const jJt={name:"htmlText",tokenize:$Jt};function $Jt(i,s,u){const d=this;let p,v,b;return y;function y(ke){return i.enter("htmlText"),i.enter("htmlTextData"),i.consume(ke),T}function T(ke){return ke===33?(i.consume(ke),_):ke===47?(i.consume(ke),ae):ke===63?(i.consume(ke),pe):n5(ke)?(i.consume(ke),de):u(ke)}function _(ke){return ke===45?(i.consume(ke),A):ke===91?(i.consume(ke),v=0,j):n5(ke)?(i.consume(ke),oe):u(ke)}function A(ke){return ke===45?(i.consume(ke),F):u(ke)}function P(ke){return ke===null?u(ke):ke===45?(i.consume(ke),R):so(ke)?(b=P,Ie(ke)):(i.consume(ke),P)}function R(ke){return ke===45?(i.consume(ke),F):P(ke)}function F(ke){return ke===62?je(ke):ke===45?R(ke):P(ke)}function j(ke){const Ke="CDATA[";return ke===Ke.charCodeAt(v++)?(i.consume(ke),v===Ke.length?K:j):u(ke)}function K(ke){return ke===null?u(ke):ke===93?(i.consume(ke),ee):so(ke)?(b=K,Ie(ke)):(i.consume(ke),K)}function ee(ke){return ke===93?(i.consume(ke),ie):K(ke)}function ie(ke){return ke===62?je(ke):ke===93?(i.consume(ke),ie):K(ke)}function oe(ke){return ke===null||ke===62?je(ke):so(ke)?(b=oe,Ie(ke)):(i.consume(ke),oe)}function pe(ke){return ke===null?u(ke):ke===63?(i.consume(ke),be):so(ke)?(b=pe,Ie(ke)):(i.consume(ke),pe)}function be(ke){return ke===62?je(ke):pe(ke)}function ae(ke){return n5(ke)?(i.consume(ke),ne):u(ke)}function ne(ke){return ke===45||H3(ke)?(i.consume(ke),ne):se(ke)}function se(ke){return so(ke)?(b=se,Ie(ke)):Iu(ke)?(i.consume(ke),se):je(ke)}function de(ke){return ke===45||H3(ke)?(i.consume(ke),de):ke===47||ke===62||z2(ke)?X(ke):u(ke)}function X(ke){return ke===47?(i.consume(ke),je):ke===58||ke===95||n5(ke)?(i.consume(ke),ge):so(ke)?(b=X,Ie(ke)):Iu(ke)?(i.consume(ke),X):je(ke)}function ge(ke){return ke===45||ke===46||ke===58||ke===95||H3(ke)?(i.consume(ke),ge):W(ke)}function W(ke){return ke===61?(i.consume(ke),xe):so(ke)?(b=W,Ie(ke)):Iu(ke)?(i.consume(ke),W):X(ke)}function xe(ke){return ke===null||ke===60||ke===61||ke===62||ke===96?u(ke):ke===34||ke===39?(i.consume(ke),p=ke,U):so(ke)?(b=xe,Ie(ke)):Iu(ke)?(i.consume(ke),xe):(i.consume(ke),Fe)}function U(ke){return ke===p?(i.consume(ke),p=void 0,Pe):ke===null?u(ke):so(ke)?(b=U,Ie(ke)):(i.consume(ke),U)}function Fe(ke){return ke===null||ke===34||ke===39||ke===60||ke===61||ke===96?u(ke):ke===47||ke===62||z2(ke)?X(ke):(i.consume(ke),Fe)}function Pe(ke){return ke===47||ke===62||z2(ke)?X(ke):u(ke)}function je(ke){return ke===62?(i.consume(ke),i.exit("htmlTextData"),i.exit("htmlText"),s):u(ke)}function Ie(ke){return i.exit("htmlTextData"),i.enter("lineEnding"),i.consume(ke),i.exit("lineEnding"),Se}function Se(ke){return Iu(ke)?Kl(i,Ce,"linePrefix",d.parser.constructs.disable.null.includes("codeIndented")?void 0:4)(ke):Ce(ke)}function Ce(ke){return i.enter("htmlTextData"),b(ke)}}const Ome={name:"labelEnd",tokenize:GJt,resolveTo:UJt,resolveAll:VJt},zJt={tokenize:KJt},qJt={tokenize:WJt},HJt={tokenize:YJt};function VJt(i){let s=-1;for(;++s
"):P,s.labelStyle,!0,!0));if(f1(qt().flowchart.htmlLabels)){const K=F.children[0],ee=Ir(F);A=K.getBoundingClientRect(),ee.attr("width",A.width),ee.attr("height",A.height)}const j=s.padding/2;return Ir(F).attr("transform","translate( "+(A.width>R.width?0:(R.width-A.width)/2)+", "+(R.height+j+5)+")"),Ir(_).attr("transform","translate( "+(A.width
/gi):Array.isArray(i)?u=i:u=[];for(const d of u){const p=document.createElementNS("http://www.w3.org/2000/svg","tspan");p.setAttributeNS("http://www.w3.org/XML/1998/namespace","xml:space","preserve"),p.setAttribute("dy","1em"),p.setAttribute("x","0"),p.setAttribute("class","row"),p.textContent=d.trim(),s.appendChild(p)}return s},xtn=i=>{let s="",u=0;return i.forEach(d=>{const p=R0==="TB"?H7[d].y:H7[d].x;p>=u&&(s=d,u=p)}),s||void 0},YUe=(i,s,u)=>{const d=qt().gitGraph,p=i.append("g").attr("class","commit-bullets"),v=i.append("g").attr("class","commit-labels");let b=0;R0==="TB"&&(b=30);const T=Object.keys(s).sort((R,F)=>s[R].seq-s[F].seq),_=d.parallelCommits,A=10,P=40;T.forEach(R=>{const F=s[R];if(_)if(F.parents.length){const ie=xtn(F.parents);b=R0==="TB"?H7[ie].y+P:H7[ie].x+P}else b=0,R0==="TB"&&(b=30);const j=b+A,K=R0==="TB"?j:H2[F.branch].pos,ee=R0==="TB"?H2[F.branch].pos:j;if(u){let ie,oe=F.customType!==void 0&&F.customType!==""?F.customType:F.type;switch(oe){case ad.NORMAL:ie="commit-normal";break;case ad.REVERSE:ie="commit-reverse";break;case ad.HIGHLIGHT:ie="commit-highlight";break;case ad.MERGE:ie="commit-merge";break;case ad.CHERRY_PICK:ie="commit-cherry-pick";break;default:ie="commit-normal"}if(oe===ad.HIGHLIGHT){const pe=p.append("rect");pe.attr("x",ee-10),pe.attr("y",K-10),pe.attr("height",20),pe.attr("width",20),pe.attr("class",`commit ${F.id} commit-highlight${H2[F.branch].index%XC} ${ie}-outer`),p.append("rect").attr("x",ee-6).attr("y",K-6).attr("height",12).attr("width",12).attr("class",`commit ${F.id} commit${H2[F.branch].index%XC} ${ie}-inner`)}else if(oe===ad.CHERRY_PICK)p.append("circle").attr("cx",ee).attr("cy",K).attr("r",10).attr("class",`commit ${F.id} ${ie}`),p.append("circle").attr("cx",ee-3).attr("cy",K+2).attr("r",2.75).attr("fill","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("circle").attr("cx",ee+3).attr("cy",K+2).attr("r",2.75).attr("fill","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("line").attr("x1",ee+3).attr("y1",K+1).attr("x2",ee).attr("y2",K-5).attr("stroke","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("line").attr("x1",ee-3).attr("y1",K+1).attr("x2",ee).attr("y2",K-5).attr("stroke","#fff").attr("class",`commit ${F.id} ${ie}`);else{const pe=p.append("circle");if(pe.attr("cx",ee),pe.attr("cy",K),pe.attr("r",F.type===ad.MERGE?9:10),pe.attr("class",`commit ${F.id} commit${H2[F.branch].index%XC}`),oe===ad.MERGE){const be=p.append("circle");be.attr("cx",ee),be.attr("cy",K),be.attr("r",6),be.attr("class",`commit ${ie} ${F.id} commit${H2[F.branch].index%XC}`)}oe===ad.REVERSE&&p.append("path").attr("d",`M ${ee-5},${K-5}L${ee+5},${K+5}M${ee-5},${K+5}L${ee+5},${K-5}`).attr("class",`commit ${ie} ${F.id} commit${H2[F.branch].index%XC}`)}}if(R0==="TB"?H7[F.id]={x:ee,y:j}:H7[F.id]={x:j,y:K},u){if(F.type!==ad.CHERRY_PICK&&(F.customId&&F.type===ad.MERGE||F.type!==ad.MERGE)&&d.showCommitLabel){const pe=v.append("g"),be=pe.insert("rect").attr("class","commit-label-bkg"),ae=pe.append("text").attr("x",b).attr("y",K+25).attr("class","commit-label").text(F.id);let ne=ae.node().getBBox();if(be.attr("x",j-ne.width/2-2).attr("y",K+13.5).attr("width",ne.width+2*2).attr("height",ne.height+2*2),R0==="TB"&&(be.attr("x",ee-(ne.width+4*4+5)).attr("y",K-12),ae.attr("x",ee-(ne.width+4*4)).attr("y",K+ne.height-12)),R0!=="TB"&&ae.attr("x",j-ne.width/2),d.rotateCommitLabel)if(R0==="TB")ae.attr("transform","rotate(-45, "+ee+", "+K+")"),be.attr("transform","rotate(-45, "+ee+", "+K+")");else{let se=-7.5-(ne.width+10)/25*9.5,de=10+ne.width/25*8.5;pe.attr("transform","translate("+se+", "+de+") rotate(-45, "+b+", "+K+")")}}if(F.tag){const pe=v.insert("polygon"),be=v.append("circle"),ae=v.append("text").attr("y",K-16).attr("class","tag-label").text(F.tag);let ne=ae.node().getBBox();ae.attr("x",j-ne.width/2);const se=ne.height/2,de=K-19.2;pe.attr("class","tag-label-bkg").attr("points",`
+`+this.showPosition(),{text:"",token:null,line:this.yylineno})},lex:function(){var se=this.next();return se||this.lex()},begin:function(se){this.conditionStack.push(se)},popState:function(){var se=this.conditionStack.length-1;return se>0?this.conditionStack.pop():this.conditionStack[0]},_currentRules:function(){return this.conditionStack.length&&this.conditionStack[this.conditionStack.length-1]?this.conditions[this.conditionStack[this.conditionStack.length-1]].rules:this.conditions.INITIAL.rules},topState:function(se){return se=this.conditionStack.length-1-Math.abs(se||0),se>=0?this.conditionStack[se]:"INITIAL"},pushState:function(se){this.begin(se)},stateStackSize:function(){return this.conditionStack.length},options:{"case-insensitive":!0},performAction:function(se,de,X,ge){switch(X){case 0:return this.begin("acc_title"),19;case 1:return this.popState(),"acc_title_value";case 2:return this.begin("acc_descr"),21;case 3:return this.popState(),"acc_descr_value";case 4:this.begin("acc_descr_multiline");break;case 5:this.popState();break;case 6:return"acc_descr_multiline_value";case 7:return 13;case 8:break;case 9:break;case 10:return 5;case 11:return 40;case 12:return 32;case 13:return 38;case 14:return 42;case 15:return 43;case 16:return 44;case 17:return 45;case 18:return 35;case 19:return 28;case 20:return 29;case 21:return 37;case 22:return 31;case 23:return 34;case 24:return 26;case 25:return 9;case 26:return 9;case 27:return 8;case 28:return"CARET";case 29:this.begin("options");break;case 30:this.popState();break;case 31:return 12;case 32:return 36;case 33:this.begin("string");break;case 34:this.popState();break;case 35:return 33;case 36:return 30;case 37:return 46;case 38:return 7}},rules:[/^(?:accTitle\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*:\s*)/i,/^(?:(?!\n||)*[^\n]*)/i,/^(?:accDescr\s*\{\s*)/i,/^(?:[\}])/i,/^(?:[^\}]*)/i,/^(?:(\r?\n)+)/i,/^(?:#[^\n]*)/i,/^(?:%[^\n]*)/i,/^(?:gitGraph\b)/i,/^(?:commit(?=\s|$))/i,/^(?:id:)/i,/^(?:type:)/i,/^(?:msg:)/i,/^(?:NORMAL\b)/i,/^(?:REVERSE\b)/i,/^(?:HIGHLIGHT\b)/i,/^(?:tag:)/i,/^(?:branch(?=\s|$))/i,/^(?:order:)/i,/^(?:merge(?=\s|$))/i,/^(?:cherry-pick(?=\s|$))/i,/^(?:parent:)/i,/^(?:checkout(?=\s|$))/i,/^(?:LR\b)/i,/^(?:TB\b)/i,/^(?::)/i,/^(?:\^)/i,/^(?:options\r?\n)/i,/^(?:[ \r\n\t]+end\b)/i,/^(?:[\s\S]+(?=[ \r\n\t]+end))/i,/^(?:["]["])/i,/^(?:["])/i,/^(?:["])/i,/^(?:[^"]*)/i,/^(?:[0-9]+(?=\s|$))/i,/^(?:\w([-\./\w]*[-\w])?)/i,/^(?:$)/i,/^(?:\s+)/i],conditions:{acc_descr_multiline:{rules:[5,6],inclusive:!1},acc_descr:{rules:[3],inclusive:!1},acc_title:{rules:[1],inclusive:!1},options:{rules:[30,31],inclusive:!1},string:{rules:[34,35],inclusive:!1},INITIAL:{rules:[0,2,4,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,32,33,36,37,38,39],inclusive:!0}}};return ae}();oe.lexer=pe;function be(){this.yy={}}return be.prototype=oe,oe.Parser=be,new be}();Kme.parser=Kme;const ttn=Kme;let oJ=qt().gitGraph.mainBranchName,ntn=qt().gitGraph.mainBranchOrder,b1={},Np=null,OR={};OR[oJ]={name:oJ,order:ntn};let F0={};F0[oJ]=Np;let sd=oJ,qUe="LR",YC=0;function Wme(){return mje({length:7})}function rtn(i,s){const u=Object.create(null);return i.reduce((d,p)=>{const v=s(p);return u[v]||(u[v]=!0,d.push(p)),d},[])}const itn=function(i){qUe=i};let HUe={};const stn=function(i){Xe.debug("options str",i),i=i&&i.trim(),i=i||"{}";try{HUe=JSON.parse(i)}catch(s){Xe.error("error while parsing gitGraph options",s.message)}},atn=function(){return HUe},otn=function(i,s,u,d){Xe.debug("Entering commit:",i,s,u,d),s=ci.sanitizeText(s,qt()),i=ci.sanitizeText(i,qt()),d=ci.sanitizeText(d,qt());const p={id:s||YC+"-"+Wme(),message:i,seq:YC++,type:u||UD.NORMAL,tag:d||"",parents:Np==null?[]:[Np.id],branch:sd};Np=p,b1[p.id]=p,F0[sd]=p.id,Xe.debug("in pushCommit "+p.id)},ctn=function(i,s){if(i=ci.sanitizeText(i,qt()),F0[i]===void 0)F0[i]=Np!=null?Np.id:null,OR[i]={name:i,order:s?parseInt(s,10):null},VUe(i),Xe.debug("in createBranch");else{let u=new Error('Trying to create an existing branch. (Help: Either use a new name if you want create a new branch or try using "checkout '+i+'")');throw u.hash={text:"branch "+i,token:"branch "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:['"checkout '+i+'"']},u}},utn=function(i,s,u,d){i=ci.sanitizeText(i,qt()),s=ci.sanitizeText(s,qt());const p=b1[F0[sd]],v=b1[F0[i]];if(sd===i){let y=new Error('Incorrect usage of "merge". Cannot merge a branch to itself');throw y.hash={text:"merge "+i,token:"merge "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["branch abc"]},y}else if(p===void 0||!p){let y=new Error('Incorrect usage of "merge". Current branch ('+sd+")has no commits");throw y.hash={text:"merge "+i,token:"merge "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["commit"]},y}else if(F0[i]===void 0){let y=new Error('Incorrect usage of "merge". Branch to be merged ('+i+") does not exist");throw y.hash={text:"merge "+i,token:"merge "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["branch "+i]},y}else if(v===void 0||!v){let y=new Error('Incorrect usage of "merge". Branch to be merged ('+i+") has no commits");throw y.hash={text:"merge "+i,token:"merge "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:['"commit"']},y}else if(p===v){let y=new Error('Incorrect usage of "merge". Both branches have same head');throw y.hash={text:"merge "+i,token:"merge "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["branch abc"]},y}else if(s&&b1[s]!==void 0){let y=new Error('Incorrect usage of "merge". Commit with id:'+s+" already exists, use different custom Id");throw y.hash={text:"merge "+i+s+u+d,token:"merge "+i+s+u+d,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["merge "+i+" "+s+"_UNIQUE "+u+" "+d]},y}const b={id:s||YC+"-"+Wme(),message:"merged branch "+i+" into "+sd,seq:YC++,parents:[Np==null?null:Np.id,F0[i]],branch:sd,type:UD.MERGE,customType:u,customId:!!s,tag:d||""};Np=b,b1[b.id]=b,F0[sd]=b.id,Xe.debug(F0),Xe.debug("in mergeBranch")},ltn=function(i,s,u,d){if(Xe.debug("Entering cherryPick:",i,s,u),i=ci.sanitizeText(i,qt()),s=ci.sanitizeText(s,qt()),u=ci.sanitizeText(u,qt()),d=ci.sanitizeText(d,qt()),!i||b1[i]===void 0){let b=new Error('Incorrect usage of "cherryPick". Source commit id should exist and provided');throw b.hash={text:"cherryPick "+i+" "+s,token:"cherryPick "+i+" "+s,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["cherry-pick abc"]},b}let p=b1[i],v=p.branch;if(d&&!(Array.isArray(p.parents)&&p.parents.includes(d)))throw new Error("Invalid operation: The specified parent commit is not an immediate parent of the cherry-picked commit.");if(p.type===UD.MERGE&&!d)throw new Error("Incorrect usage of cherry-pick: If the source commit is a merge commit, an immediate parent commit must be specified.");if(!s||b1[s]===void 0){if(v===sd){let T=new Error('Incorrect usage of "cherryPick". Source commit is already on current branch');throw T.hash={text:"cherryPick "+i+" "+s,token:"cherryPick "+i+" "+s,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["cherry-pick abc"]},T}const b=b1[F0[sd]];if(b===void 0||!b){let T=new Error('Incorrect usage of "cherry-pick". Current branch ('+sd+")has no commits");throw T.hash={text:"cherryPick "+i+" "+s,token:"cherryPick "+i+" "+s,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:["cherry-pick abc"]},T}const y={id:YC+"-"+Wme(),message:"cherry-picked "+p+" into "+sd,seq:YC++,parents:[Np==null?null:Np.id,p.id],branch:sd,type:UD.CHERRY_PICK,tag:u??`cherry-pick:${p.id}${p.type===UD.MERGE?`|parent:${d}`:""}`};Np=y,b1[y.id]=y,F0[sd]=y.id,Xe.debug(F0),Xe.debug("in cherryPick")}},VUe=function(i){if(i=ci.sanitizeText(i,qt()),F0[i]===void 0){let s=new Error('Trying to checkout branch which is not yet created. (Help try using "branch '+i+'")');throw s.hash={text:"checkout "+i,token:"checkout "+i,line:"1",loc:{first_line:1,last_line:1,first_column:1,last_column:1},expected:['"branch '+i+'"']},s}else{sd=i;const s=F0[sd];Np=b1[s]}};function UUe(i,s,u){const d=i.indexOf(s);d===-1?i.push(u):i.splice(d,1,u)}function GUe(i){const s=i.reduce((p,v)=>p.seq>v.seq?p:v,i[0]);let u="";i.forEach(function(p){p===s?u+=" *":u+=" |"});const d=[u,s.id,s.seq];for(let p in F0)F0[p]===s.id&&d.push(p);if(Xe.debug(d.join(" ")),s.parents&&s.parents.length==2){const p=b1[s.parents[0]];UUe(i,s,p),i.push(b1[s.parents[1]])}else{if(s.parents.length==0)return;{const p=b1[s.parents];UUe(i,s,p)}}i=rtn(i,p=>p.id),GUe(i)}const htn=function(){Xe.debug(b1);const i=KUe()[0];GUe([i])},ftn=function(){b1={},Np=null;let i=qt().gitGraph.mainBranchName,s=qt().gitGraph.mainBranchOrder;F0={},F0[i]=null,OR={},OR[i]={name:i,order:s},sd=i,YC=0,Pg()},dtn=function(){return Object.values(OR).map((s,u)=>s.order!==null?s:{...s,order:parseFloat(`0.${u}`,10)}).sort((s,u)=>s.order-u.order).map(({name:s})=>({name:s}))},gtn=function(){return F0},ptn=function(){return b1},KUe=function(){const i=Object.keys(b1).map(function(s){return b1[s]});return i.forEach(function(s){Xe.debug(s.id)}),i.sort((s,u)=>s.seq-u.seq),i},btn=function(){return sd},mtn=function(){return qUe},vtn=function(){return Np},UD={NORMAL:0,REVERSE:1,HIGHLIGHT:2,MERGE:3,CHERRY_PICK:4},wtn={getConfig:()=>qt().gitGraph,setDirection:itn,setOptions:stn,getOptions:atn,commit:otn,branch:ctn,merge:utn,cherryPick:ltn,checkout:VUe,prettyPrint:htn,clear:ftn,getBranchesAsObjArray:dtn,getBranches:gtn,getCommits:ptn,getCommitsArray:KUe,getCurrentBranch:btn,getDirection:mtn,getHead:vtn,setAccTitle:Bg,getAccTitle:Cp,getAccDescription:_p,setAccDescription:Sp,setDiagramTitle:cm,getDiagramTitle:Ap,commitType:UD};let NR={};const ad={NORMAL:0,REVERSE:1,HIGHLIGHT:2,MERGE:3,CHERRY_PICK:4},XC=8;let H2={},H7={},cJ=[],PR=0,R0="LR";const ytn=()=>{H2={},H7={},NR={},PR=0,cJ=[],R0="LR"},WUe=i=>{const s=document.createElementNS("http://www.w3.org/2000/svg","text");let u=[];typeof i=="string"?u=i.split(/\\n|\n|
/gi):Array.isArray(i)?u=i:u=[];for(const d of u){const p=document.createElementNS("http://www.w3.org/2000/svg","tspan");p.setAttributeNS("http://www.w3.org/XML/1998/namespace","xml:space","preserve"),p.setAttribute("dy","1em"),p.setAttribute("x","0"),p.setAttribute("class","row"),p.textContent=d.trim(),s.appendChild(p)}return s},xtn=i=>{let s="",u=0;return i.forEach(d=>{const p=R0==="TB"?H7[d].y:H7[d].x;p>=u&&(s=d,u=p)}),s||void 0},YUe=(i,s,u)=>{const d=qt().gitGraph,p=i.append("g").attr("class","commit-bullets"),v=i.append("g").attr("class","commit-labels");let b=0;R0==="TB"&&(b=30);const T=Object.keys(s).sort((R,F)=>s[R].seq-s[F].seq),_=d.parallelCommits,A=10,P=40;T.forEach(R=>{const F=s[R];if(_)if(F.parents.length){const ie=xtn(F.parents);b=R0==="TB"?H7[ie].y+P:H7[ie].x+P}else b=0,R0==="TB"&&(b=30);const j=b+A,K=R0==="TB"?j:H2[F.branch].pos,ee=R0==="TB"?H2[F.branch].pos:j;if(u){let ie,oe=F.customType!==void 0&&F.customType!==""?F.customType:F.type;switch(oe){case ad.NORMAL:ie="commit-normal";break;case ad.REVERSE:ie="commit-reverse";break;case ad.HIGHLIGHT:ie="commit-highlight";break;case ad.MERGE:ie="commit-merge";break;case ad.CHERRY_PICK:ie="commit-cherry-pick";break;default:ie="commit-normal"}if(oe===ad.HIGHLIGHT){const pe=p.append("rect");pe.attr("x",ee-10),pe.attr("y",K-10),pe.attr("height",20),pe.attr("width",20),pe.attr("class",`commit ${F.id} commit-highlight${H2[F.branch].index%XC} ${ie}-outer`),p.append("rect").attr("x",ee-6).attr("y",K-6).attr("height",12).attr("width",12).attr("class",`commit ${F.id} commit${H2[F.branch].index%XC} ${ie}-inner`)}else if(oe===ad.CHERRY_PICK)p.append("circle").attr("cx",ee).attr("cy",K).attr("r",10).attr("class",`commit ${F.id} ${ie}`),p.append("circle").attr("cx",ee-3).attr("cy",K+2).attr("r",2.75).attr("fill","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("circle").attr("cx",ee+3).attr("cy",K+2).attr("r",2.75).attr("fill","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("line").attr("x1",ee+3).attr("y1",K+1).attr("x2",ee).attr("y2",K-5).attr("stroke","#fff").attr("class",`commit ${F.id} ${ie}`),p.append("line").attr("x1",ee-3).attr("y1",K+1).attr("x2",ee).attr("y2",K-5).attr("stroke","#fff").attr("class",`commit ${F.id} ${ie}`);else{const pe=p.append("circle");if(pe.attr("cx",ee),pe.attr("cy",K),pe.attr("r",F.type===ad.MERGE?9:10),pe.attr("class",`commit ${F.id} commit${H2[F.branch].index%XC}`),oe===ad.MERGE){const be=p.append("circle");be.attr("cx",ee),be.attr("cy",K),be.attr("r",6),be.attr("class",`commit ${ie} ${F.id} commit${H2[F.branch].index%XC}`)}oe===ad.REVERSE&&p.append("path").attr("d",`M ${ee-5},${K-5}L${ee+5},${K+5}M${ee-5},${K+5}L${ee+5},${K-5}`).attr("class",`commit ${ie} ${F.id} commit${H2[F.branch].index%XC}`)}}if(R0==="TB"?H7[F.id]={x:ee,y:j}:H7[F.id]={x:j,y:K},u){if(F.type!==ad.CHERRY_PICK&&(F.customId&&F.type===ad.MERGE||F.type!==ad.MERGE)&&d.showCommitLabel){const pe=v.append("g"),be=pe.insert("rect").attr("class","commit-label-bkg"),ae=pe.append("text").attr("x",b).attr("y",K+25).attr("class","commit-label").text(F.id);let ne=ae.node().getBBox();if(be.attr("x",j-ne.width/2-2).attr("y",K+13.5).attr("width",ne.width+2*2).attr("height",ne.height+2*2),R0==="TB"&&(be.attr("x",ee-(ne.width+4*4+5)).attr("y",K-12),ae.attr("x",ee-(ne.width+4*4)).attr("y",K+ne.height-12)),R0!=="TB"&&ae.attr("x",j-ne.width/2),d.rotateCommitLabel)if(R0==="TB")ae.attr("transform","rotate(-45, "+ee+", "+K+")"),be.attr("transform","rotate(-45, "+ee+", "+K+")");else{let se=-7.5-(ne.width+10)/25*9.5,de=10+ne.width/25*8.5;pe.attr("transform","translate("+se+", "+de+") rotate(-45, "+b+", "+K+")")}}if(F.tag){const pe=v.insert("polygon"),be=v.append("circle"),ae=v.append("text").attr("y",K-16).attr("class","tag-label").text(F.tag);let ne=ae.node().getBBox();ae.attr("x",j-ne.width/2);const se=ne.height/2,de=K-19.2;pe.attr("class","tag-label-bkg").attr("points",`
${b-ne.width/2-4/2},${de+2}
${b-ne.width/2-4/2},${de-2}
${j-ne.width/2-4},${de-se-2}
@@ -616,7 +616,7 @@ Expecting `+kt.join(", ")+", got '"+(this.terminals_[_t]||_t)+"'":On="Parse erro
Expecting `+xi.join(", ")+", got '"+(this.terminals_[Qe]||Qe)+"'":Ma="Parse error on line "+(ke+1)+": Unexpected "+(Qe==Ne?"end of input":"'"+(this.terminals_[Qe]||Qe)+"'"),this.parseError(Ma,{text:_t.match,token:this.terminals_[Qe]||Qe,line:_t.yylineno,loc:ln,expected:xi})}if(kt[0]instanceof Array&&kt.length>1)throw new Error("Parse Error: multiple actions possible at state: "+Dt+", token: "+Qe);switch(kt[0]){case 1:Fe.push(Qe),je.push(_t.yytext),Ie.push(_t.yylloc),Fe.push(kt[1]),Qe=null,Ke=_t.yyleng,Ce=_t.yytext,ke=_t.yylineno,ln=_t.yylloc;break;case 2:if(yt=this.productions_[kt[1]][1],ht.$=je[je.length-yt],ht._$={first_line:Ie[Ie.length-(yt||1)].first_line,last_line:Ie[Ie.length-1].last_line,first_column:Ie[Ie.length-(yt||1)].first_column,last_column:Ie[Ie.length-1].last_column},xt&&(ht._$.range=[Ie[Ie.length-(yt||1)].range[0],Ie[Ie.length-1].range[1]]),On=this.performAction.apply(ht,[Ce,Ke,ke,Et.yy,kt[1],je,Ie].concat(gn)),typeof On<"u")return On;yt&&(Fe=Fe.slice(0,-1*yt*2),je=je.slice(0,-1*yt),Ie=Ie.slice(0,-1*yt)),Fe.push(this.productions_[kt[1]][0]),je.push(ht.$),Ie.push(ht._$),ji=Se[Fe[Fe.length-2]][Fe[Fe.length-1]],Fe.push(ji);break;case 3:return!0}}return!0}},X=function(){var W={EOF:1,parseError:function(U,Fe){if(this.yy.parser)this.yy.parser.parseError(U,Fe);else throw new Error(U)},setInput:function(xe,U){return this.yy=U||this.yy||{},this._input=xe,this._more=this._backtrack=this.done=!1,this.yylineno=this.yyleng=0,this.yytext=this.matched=this.match="",this.conditionStack=["INITIAL"],this.yylloc={first_line:1,first_column:0,last_line:1,last_column:0},this.options.ranges&&(this.yylloc.range=[0,0]),this.offset=0,this},input:function(){var xe=this._input[0];this.yytext+=xe,this.yyleng++,this.offset++,this.match+=xe,this.matched+=xe;var U=xe.match(/(?:\r\n?|\n).*/g);return U?(this.yylineno++,this.yylloc.last_line++):this.yylloc.last_column++,this.options.ranges&&this.yylloc.range[1]++,this._input=this._input.slice(1),xe},unput:function(xe){var U=xe.length,Fe=xe.split(/(?:\r\n?|\n)/g);this._input=xe+this._input,this.yytext=this.yytext.substr(0,this.yytext.length-U),this.offset-=U;var Pe=this.match.split(/(?:\r\n?|\n)/g);this.match=this.match.substr(0,this.match.length-1),this.matched=this.matched.substr(0,this.matched.length-1),Fe.length-1&&(this.yylineno-=Fe.length-1);var je=this.yylloc.range;return this.yylloc={first_line:this.yylloc.first_line,last_line:this.yylineno+1,first_column:this.yylloc.first_column,last_column:Fe?(Fe.length===Pe.length?this.yylloc.first_column:0)+Pe[Pe.length-Fe.length].length-Fe[0].length:this.yylloc.first_column-U},this.options.ranges&&(this.yylloc.range=[je[0],je[0]+this.yyleng-U]),this.yyleng=this.yytext.length,this},more:function(){return this._more=!0,this},reject:function(){if(this.options.backtrack_lexer)this._backtrack=!0;else return this.parseError("Lexical error on line "+(this.yylineno+1)+`. You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).
`+this.showPosition(),{text:"",token:null,line:this.yylineno});return this},less:function(xe){this.unput(this.match.slice(xe))},pastInput:function(){var xe=this.matched.substr(0,this.matched.length-this.match.length);return(xe.length>20?"...":"")+xe.substr(-20).replace(/\n/g,"")},upcomingInput:function(){var xe=this.match;return xe.length<20&&(xe+=this._input.substr(0,20-xe.length)),(xe.substr(0,20)+(xe.length>20?"...":"")).replace(/\n/g,"")},showPosition:function(){var xe=this.pastInput(),U=new Array(xe.length+1).join("-");return xe+this.upcomingInput()+`
`+U+"^"},test_match:function(xe,U){var Fe,Pe,je;if(this.options.backtrack_lexer&&(je={yylineno:this.yylineno,yylloc:{first_line:this.yylloc.first_line,last_line:this.last_line,first_column:this.yylloc.first_column,last_column:this.yylloc.last_column},yytext:this.yytext,match:this.match,matches:this.matches,matched:this.matched,yyleng:this.yyleng,offset:this.offset,_more:this._more,_input:this._input,yy:this.yy,conditionStack:this.conditionStack.slice(0),done:this.done},this.options.ranges&&(je.yylloc.range=this.yylloc.range.slice(0))),Pe=xe[0].match(/(?:\r\n?|\n).*/g),Pe&&(this.yylineno+=Pe.length),this.yylloc={first_line:this.yylloc.last_line,last_line:this.yylineno+1,first_column:this.yylloc.last_column,last_column:Pe?Pe[Pe.length-1].length-Pe[Pe.length-1].match(/\r?\n?/)[0].length:this.yylloc.last_column+xe[0].length},this.yytext+=xe[0],this.match+=xe[0],this.matches=xe,this.yyleng=this.yytext.length,this.options.ranges&&(this.yylloc.range=[this.offset,this.offset+=this.yyleng]),this._more=!1,this._backtrack=!1,this._input=this._input.slice(xe[0].length),this.matched+=xe[0],Fe=this.performAction.call(this,this.yy,this,U,this.conditionStack[this.conditionStack.length-1]),this.done&&this._input&&(this.done=!1),Fe)return Fe;if(this._backtrack){for(var Ie in je)this[Ie]=je[Ie];return!1}return!1},next:function(){if(this.done)return this.EOF;this._input||(this.done=!0);var xe,U,Fe,Pe;this._more||(this.yytext="",this.match="");for(var je=this._currentRules(),Ie=0;Ie=6&&u.includes("weekends")||u.includes(i.format("dddd").toLowerCase())?!0:u.includes(i.format(s.trim()))},rnn=function(i){ive=i},inn=function(){return ive},tGe=function(i,s,u,d){if(!u.length||i.manualEndTime)return;let p;i.startTime instanceof Date?p=Lg(i.startTime):p=Lg(i.startTime,s,!0),p=p.add(1,"d");let v;i.endTime instanceof Date?v=Lg(i.endTime):v=Lg(i.endTime,s,!0);const[b,y]=snn(p,v,s,u,d);i.endTime=b.toDate(),i.renderEndTime=y},snn=function(i,s,u,d,p){let v=!1,b=null;for(;i<=s;)v||(b=s.toDate()),v=eGe(i,u,d,p),v&&(s=s.add(1,"d")),i=i.add(1,"d");return[s,b]},ave=function(i,s,u){u=u.trim();const p=/^after\s+(?=6&&u.includes("weekends")||u.includes(i.format("dddd").toLowerCase())?!0:u.includes(i.format(s.trim()))},rnn=function(i){ive=i},inn=function(){return ive},tGe=function(i,s,u,d){if(!u.length||i.manualEndTime)return;let p;i.startTime instanceof Date?p=Lg(i.startTime):p=Lg(i.startTime,s,!0),p=p.add(1,"d");let v;i.endTime instanceof Date?v=Lg(i.endTime):v=Lg(i.endTime,s,!0);const[b,y]=snn(p,v,s,u,d);i.endTime=b.toDate(),i.renderEndTime=y},snn=function(i,s,u,d,p){let v=!1,b=null;for(;i<=s;)v||(b=s.toDate()),v=eGe(i,u,d,p),v&&(s=s.add(1,"d")),i=i.add(1,"d");return[s,b]},ave=function(i,s,u){u=u.trim();const p=/^after\s+(?
");b=b.replace(/\n/g,"
");const y=b.split(li.lineBreakRegex);let T=1.25*qt().state.noteMargin;for(const _ of y){const A=_.trim();if(A.length>0){const P=v.append("tspan");if(P.text(A),T===0){const R=P.node().getBBox();T+=R.height}p+=T,P.attr("x",s+qt().state.noteMargin),P.attr("y",u+p+1.25*qt().state.noteMargin)}}return{textWidth:v.node().getBBox().width,textHeight:p}},Osn=(i,s)=>{s.attr("class","state-note");const u=s.append("rect").attr("x",0).attr("y",qt().state.padding),d=s.append("g"),{textWidth:p,textHeight:v}=Isn(i,0,0,d);return u.attr("height",v+2*qt().state.noteMargin),u.attr("width",p+qt().state.noteMargin*2),u},EKe=function(i,s){const u=s.id,d={id:u,label:s.id,width:0,height:0},p=i.append("g").attr("id",u).attr("class","stateGroup");s.type==="start"&&Csn(p),s.type==="end"&&Msn(p),(s.type==="fork"||s.type==="join")&&Dsn(p,s),s.type==="note"&&Osn(s.note.text,p),s.type==="divider"&&Ssn(p),s.type==="default"&&s.descriptions.length===0&&_sn(p,s),s.type==="default"&&s.descriptions.length>0&&Asn(p,s);const v=p.node().getBBox();return d.width=v.width+2*qt().state.padding,d.height=v.height+2*qt().state.padding,Tsn.set(u,d),d};let TKe=0;const Nsn=function(i,s,u){const d=function(T){switch(T){case G7.relationType.AGGREGATION:return"aggregation";case G7.relationType.EXTENSION:return"extension";case G7.relationType.COMPOSITION:return"composition";case G7.relationType.DEPENDENCY:return"dependency"}};s.points=s.points.filter(T=>!Number.isNaN(T.y));const p=s.points,v=k7().x(function(T){return T.x}).y(function(T){return T.y}).curve(FF),b=i.append("path").attr("d",v(p)).attr("id","edge"+TKe).attr("class","transition");let y="";if(qt().state.arrowMarkerAbsolute&&(y=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,y=y.replace(/\(/g,"\\("),y=y.replace(/\)/g,"\\)")),b.attr("marker-end","url("+y+"#"+d(G7.relationType.DEPENDENCY)+"End)"),u.title!==void 0){const T=i.append("g").attr("class","stateLabel"),{x:_,y:A}=Ao.calcLabelPosition(s.points),P=li.getRows(u.title);let R=0;const F=[];let j=0,K=0;for(let oe=0;oe<=P.length;oe++){const pe=T.append("text").attr("text-anchor","middle").text(P[oe]).attr("x",_).attr("y",A+R),be=pe.node().getBBox();j=Math.max(j,be.width),K=Math.min(K,be.x),Xe.info(be.x,_,A+R),R===0&&(R=pe.node().getBBox().height,Xe.info("Title height",R,A)),F.push(pe)}let ee=R*P.length;if(P.length>1){const oe=(P.length-1)*R*.5;F.forEach((pe,be)=>pe.attr("y",A+be*R-oe)),ee=R*P.length}const ie=T.node().getBBox();T.insert("rect",":first-child").attr("class","box").attr("x",_-j/2-qt().state.padding/2).attr("y",A-ee/2-qt().state.padding/2-3.5).attr("width",j+qt().state.padding).attr("height",ee+qt().state.padding),Xe.info(ie)}TKe++};let gm;const qve={},Psn=function(){},Bsn=function(i){i.append("defs").append("marker").attr("id","dependencyEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 19,7 L9,13 L14,7 L9,1 Z")},Fsn=function(i,s,u,d){gm=qt().state;const p=qt().securityLevel;let v;p==="sandbox"&&(v=Ir("#i"+s));const b=Ir(p==="sandbox"?v.nodes()[0].contentDocument.body:"body"),y=p==="sandbox"?v.nodes()[0].contentDocument:document;Xe.debug("Rendering diagram "+i);const T=b.select(`[id='${s}']`);Bsn(T);const _=d.db.getRootDoc();CKe(_,T,void 0,!1,b,y,d);const A=gm.padding,P=T.node().getBBox(),R=P.width+A*2,F=P.height+A*2,j=R*1.75;Ng(T,F,j,gm.useMaxWidth),T.attr("viewBox",`${P.x-gm.padding} ${P.y-gm.padding} `+R+" "+F)},Rsn=i=>i?i.length*gm.fontSizeFactor:1,CKe=(i,s,u,d,p,v,b)=>{const y=new B0({compound:!0,multigraph:!0});let T,_=!0;for(T=0;T
");b=b.replace(/\n/g,"
");const y=b.split(ci.lineBreakRegex);let T=1.25*qt().state.noteMargin;for(const _ of y){const A=_.trim();if(A.length>0){const P=v.append("tspan");if(P.text(A),T===0){const R=P.node().getBBox();T+=R.height}p+=T,P.attr("x",s+qt().state.noteMargin),P.attr("y",u+p+1.25*qt().state.noteMargin)}}return{textWidth:v.node().getBBox().width,textHeight:p}},Osn=(i,s)=>{s.attr("class","state-note");const u=s.append("rect").attr("x",0).attr("y",qt().state.padding),d=s.append("g"),{textWidth:p,textHeight:v}=Isn(i,0,0,d);return u.attr("height",v+2*qt().state.noteMargin),u.attr("width",p+qt().state.noteMargin*2),u},EKe=function(i,s){const u=s.id,d={id:u,label:s.id,width:0,height:0},p=i.append("g").attr("id",u).attr("class","stateGroup");s.type==="start"&&Csn(p),s.type==="end"&&Msn(p),(s.type==="fork"||s.type==="join")&&Dsn(p,s),s.type==="note"&&Osn(s.note.text,p),s.type==="divider"&&Ssn(p),s.type==="default"&&s.descriptions.length===0&&_sn(p,s),s.type==="default"&&s.descriptions.length>0&&Asn(p,s);const v=p.node().getBBox();return d.width=v.width+2*qt().state.padding,d.height=v.height+2*qt().state.padding,Tsn.set(u,d),d};let TKe=0;const Nsn=function(i,s,u){const d=function(T){switch(T){case G7.relationType.AGGREGATION:return"aggregation";case G7.relationType.EXTENSION:return"extension";case G7.relationType.COMPOSITION:return"composition";case G7.relationType.DEPENDENCY:return"dependency"}};s.points=s.points.filter(T=>!Number.isNaN(T.y));const p=s.points,v=k7().x(function(T){return T.x}).y(function(T){return T.y}).curve(FF),b=i.append("path").attr("d",v(p)).attr("id","edge"+TKe).attr("class","transition");let y="";if(qt().state.arrowMarkerAbsolute&&(y=window.location.protocol+"//"+window.location.host+window.location.pathname+window.location.search,y=y.replace(/\(/g,"\\("),y=y.replace(/\)/g,"\\)")),b.attr("marker-end","url("+y+"#"+d(G7.relationType.DEPENDENCY)+"End)"),u.title!==void 0){const T=i.append("g").attr("class","stateLabel"),{x:_,y:A}=Ao.calcLabelPosition(s.points),P=ci.getRows(u.title);let R=0;const F=[];let j=0,K=0;for(let oe=0;oe<=P.length;oe++){const pe=T.append("text").attr("text-anchor","middle").text(P[oe]).attr("x",_).attr("y",A+R),be=pe.node().getBBox();j=Math.max(j,be.width),K=Math.min(K,be.x),Xe.info(be.x,_,A+R),R===0&&(R=pe.node().getBBox().height,Xe.info("Title height",R,A)),F.push(pe)}let ee=R*P.length;if(P.length>1){const oe=(P.length-1)*R*.5;F.forEach((pe,be)=>pe.attr("y",A+be*R-oe)),ee=R*P.length}const ie=T.node().getBBox();T.insert("rect",":first-child").attr("class","box").attr("x",_-j/2-qt().state.padding/2).attr("y",A-ee/2-qt().state.padding/2-3.5).attr("width",j+qt().state.padding).attr("height",ee+qt().state.padding),Xe.info(ie)}TKe++};let gm;const qve={},Psn=function(){},Bsn=function(i){i.append("defs").append("marker").attr("id","dependencyEnd").attr("refX",19).attr("refY",7).attr("markerWidth",20).attr("markerHeight",28).attr("orient","auto").append("path").attr("d","M 19,7 L9,13 L14,7 L9,1 Z")},Fsn=function(i,s,u,d){gm=qt().state;const p=qt().securityLevel;let v;p==="sandbox"&&(v=Ir("#i"+s));const b=Ir(p==="sandbox"?v.nodes()[0].contentDocument.body:"body"),y=p==="sandbox"?v.nodes()[0].contentDocument:document;Xe.debug("Rendering diagram "+i);const T=b.select(`[id='${s}']`);Bsn(T);const _=d.db.getRootDoc();CKe(_,T,void 0,!1,b,y,d);const A=gm.padding,P=T.node().getBBox(),R=P.width+A*2,F=P.height+A*2,j=R*1.75;Ng(T,F,j,gm.useMaxWidth),T.attr("viewBox",`${P.x-gm.padding} ${P.y-gm.padding} `+R+" "+F)},Rsn=i=>i?i.length*gm.fontSizeFactor:1,CKe=(i,s,u,d,p,v,b)=>{const y=new B0({compound:!0,multigraph:!0});let T,_=!0;for(T=0;T
/gi);for(let ee=0;ee