diff options
Diffstat (limited to 'themes/blowfish/assets/lib/mermaid/mermaid-6dc72991.js')
| -rw-r--r-- | themes/blowfish/assets/lib/mermaid/mermaid-6dc72991.js | 6461 |
1 files changed, 6461 insertions, 0 deletions
diff --git a/themes/blowfish/assets/lib/mermaid/mermaid-6dc72991.js b/themes/blowfish/assets/lib/mermaid/mermaid-6dc72991.js new file mode 100644 index 0000000..38dfe84 --- /dev/null +++ b/themes/blowfish/assets/lib/mermaid/mermaid-6dc72991.js @@ -0,0 +1,6461 @@ +import { dedent } from "ts-dedent"; +import dayjs from "dayjs"; +import { sanitizeUrl } from "@braintree/sanitize-url"; +import { select, curveBasis, curveBasisClosed, curveBasisOpen, curveBumpX, curveBumpY, curveBundle, curveCardinalClosed, curveCardinalOpen, curveCardinal, curveCatmullRomClosed, curveCatmullRomOpen, curveCatmullRom, curveLinear, curveLinearClosed, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore } from "d3"; +import DOMPurify from "dompurify"; +import { adjust, invert, darken, lighten, isDark, rgba } from "khroma"; +import memoize from "lodash-es/memoize.js"; +import merge$1 from "lodash-es/merge.js"; +import { serialize, compile, stringify } from "stylis"; +import isEmpty from "lodash-es/isEmpty.js"; +const LEVELS = { + trace: 0, + debug: 1, + info: 2, + warn: 3, + error: 4, + fatal: 5 +}; +const log$1 = { + trace: (..._args) => { + }, + debug: (..._args) => { + }, + info: (..._args) => { + }, + warn: (..._args) => { + }, + error: (..._args) => { + }, + fatal: (..._args) => { + } +}; +const setLogLevel$1 = function(level = "fatal") { + let numericLevel = LEVELS.fatal; + if (typeof level === "string") { + level = level.toLowerCase(); + if (level in LEVELS) { + numericLevel = LEVELS[level]; + } + } else if (typeof level === "number") { + numericLevel = level; + } + log$1.trace = () => { + }; + log$1.debug = () => { + }; + log$1.info = () => { + }; + log$1.warn = () => { + }; + log$1.error = () => { + }; + log$1.fatal = () => { + }; + if (numericLevel <= LEVELS.fatal) { + log$1.fatal = console.error ? console.error.bind(console, format("FATAL"), "color: orange") : console.log.bind(console, "\x1B[35m", format("FATAL")); + } + if (numericLevel <= LEVELS.error) { + log$1.error = console.error ? console.error.bind(console, format("ERROR"), "color: orange") : console.log.bind(console, "\x1B[31m", format("ERROR")); + } + if (numericLevel <= LEVELS.warn) { + log$1.warn = console.warn ? console.warn.bind(console, format("WARN"), "color: orange") : console.log.bind(console, `\x1B[33m`, format("WARN")); + } + if (numericLevel <= LEVELS.info) { + log$1.info = console.info ? console.info.bind(console, format("INFO"), "color: lightblue") : console.log.bind(console, "\x1B[34m", format("INFO")); + } + if (numericLevel <= LEVELS.debug) { + log$1.debug = console.debug ? console.debug.bind(console, format("DEBUG"), "color: lightgreen") : console.log.bind(console, "\x1B[32m", format("DEBUG")); + } + if (numericLevel <= LEVELS.trace) { + log$1.trace = console.debug ? console.debug.bind(console, format("TRACE"), "color: lightgreen") : console.log.bind(console, "\x1B[32m", format("TRACE")); + } +}; +const format = (level) => { + const time = dayjs().format("ss.SSS"); + return `%c${time} : ${level} : `; +}; +const lineBreakRegex = /<br\s*\/?>/gi; +const getRows = (s) => { + if (!s) { + return [""]; + } + const str2 = breakToPlaceholder(s).replace(/\\n/g, "#br#"); + return str2.split("#br#"); +}; +const setupDompurifyHooksIfNotSetup = (() => { + let setup = false; + return () => { + if (!setup) { + setupDompurifyHooks(); + setup = true; + } + }; +})(); +function setupDompurifyHooks() { + const TEMPORARY_ATTRIBUTE = "data-temp-href-target"; + DOMPurify.addHook("beforeSanitizeAttributes", (node) => { + if (node.tagName === "A" && node.hasAttribute("target")) { + node.setAttribute(TEMPORARY_ATTRIBUTE, node.getAttribute("target") || ""); + } + }); + DOMPurify.addHook("afterSanitizeAttributes", (node) => { + if (node.tagName === "A" && node.hasAttribute(TEMPORARY_ATTRIBUTE)) { + node.setAttribute("target", node.getAttribute(TEMPORARY_ATTRIBUTE) || ""); + node.removeAttribute(TEMPORARY_ATTRIBUTE); + if (node.getAttribute("target") === "_blank") { + node.setAttribute("rel", "noopener"); + } + } + }); +} +const removeScript = (txt) => { + setupDompurifyHooksIfNotSetup(); + const sanitizedText = DOMPurify.sanitize(txt); + return sanitizedText; +}; +const sanitizeMore = (text, config2) => { + var _a; + if (((_a = config2.flowchart) == null ? void 0 : _a.htmlLabels) !== false) { + const level = config2.securityLevel; + if (level === "antiscript" || level === "strict") { + text = removeScript(text); + } else if (level !== "loose") { + text = breakToPlaceholder(text); + text = text.replace(/</g, "<").replace(/>/g, ">"); + text = text.replace(/=/g, "="); + text = placeholderToBreak(text); + } + } + return text; +}; +const sanitizeText$2 = (text, config2) => { + if (!text) { + return text; + } + if (config2.dompurifyConfig) { + text = DOMPurify.sanitize(sanitizeMore(text, config2), config2.dompurifyConfig).toString(); + } else { + text = DOMPurify.sanitize(sanitizeMore(text, config2), { + FORBID_TAGS: ["style"] + }).toString(); + } + return text; +}; +const sanitizeTextOrArray = (a, config2) => { + if (typeof a === "string") { + return sanitizeText$2(a, config2); + } + return a.flat().map((x) => sanitizeText$2(x, config2)); +}; +const hasBreaks = (text) => { + return lineBreakRegex.test(text); +}; +const splitBreaks = (text) => { + return text.split(lineBreakRegex); +}; +const placeholderToBreak = (s) => { + return s.replace(/#br#/g, "<br/>"); +}; +const breakToPlaceholder = (s) => { + return s.replace(lineBreakRegex, "#br#"); +}; +const getUrl = (useAbsolute) => { + let url = ""; + if (useAbsolute) { + url = window.location.protocol + "//" + window.location.host + window.location.pathname + window.location.search; + url = url.replaceAll(/\(/g, "\\("); + url = url.replaceAll(/\)/g, "\\)"); + } + return url; +}; +const evaluate = (val) => val === false || ["false", "null", "0"].includes(String(val).trim().toLowerCase()) ? false : true; +const getMax = function(...values) { + const newValues = values.filter((value) => { + return !isNaN(value); + }); + return Math.max(...newValues); +}; +const getMin = function(...values) { + const newValues = values.filter((value) => { + return !isNaN(value); + }); + return Math.min(...newValues); +}; +const parseGenericTypes = function(input) { + const inputSets = input.split(/(,)/); + const output = []; + for (let i = 0; i < inputSets.length; i++) { + let thisSet = inputSets[i]; + if (thisSet === "," && i > 0 && i + 1 < inputSets.length) { + const previousSet = inputSets[i - 1]; + const nextSet = inputSets[i + 1]; + if (shouldCombineSets(previousSet, nextSet)) { + thisSet = previousSet + "," + nextSet; + i++; + output.pop(); + } + } + output.push(processSet(thisSet)); + } + return output.join(""); +}; +const countOccurrence = (string, substring) => { + return Math.max(0, string.split(substring).length - 1); +}; +const shouldCombineSets = (previousSet, nextSet) => { + const prevCount = countOccurrence(previousSet, "~"); + const nextCount = countOccurrence(nextSet, "~"); + return prevCount === 1 && nextCount === 1; +}; +const processSet = (input) => { + const tildeCount = countOccurrence(input, "~"); + let hasStartingTilde = false; + if (tildeCount <= 1) { + return input; + } + if (tildeCount % 2 !== 0 && input.startsWith("~")) { + input = input.substring(1); + hasStartingTilde = true; + } + const chars = [...input]; + let first = chars.indexOf("~"); + let last = chars.lastIndexOf("~"); + while (first !== -1 && last !== -1 && first !== last) { + chars[first] = "<"; + chars[last] = ">"; + first = chars.indexOf("~"); + last = chars.lastIndexOf("~"); + } + if (hasStartingTilde) { + chars.unshift("~"); + } + return chars.join(""); +}; +const isMathMLSupported = () => window.MathMLElement !== void 0; +const katexRegex = /\$\$(.*)\$\$/g; +const hasKatex = (text) => { + var _a; + return (((_a = text.match(katexRegex)) == null ? void 0 : _a.length) ?? 0) > 0; +}; +const calculateMathMLDimensions = async (text, config2) => { + text = await renderKatex(text, config2); + const divElem = document.createElement("div"); + divElem.innerHTML = text; + divElem.id = "katex-temp"; + divElem.style.visibility = "hidden"; + divElem.style.position = "absolute"; + divElem.style.top = "0"; + const body = document.querySelector("body"); + body == null ? void 0 : body.insertAdjacentElement("beforeend", divElem); + const dim = { width: divElem.clientWidth, height: divElem.clientHeight }; + divElem.remove(); + return dim; +}; +const renderKatex = async (text, config2) => { + if (!hasKatex(text)) { + return text; + } + if (!isMathMLSupported() && !config2.legacyMathML) { + return text.replace(katexRegex, "MathML is unsupported in this environment."); + } + const { default: katex } = await import("katex"); + return text.split(lineBreakRegex).map( + (line) => hasKatex(line) ? ` + <div style="display: flex; align-items: center; justify-content: center; white-space: nowrap;"> + ${line} + </div> + ` : `<div>${line}</div>` + ).join("").replace( + katexRegex, + (_, c) => katex.renderToString(c, { + throwOnError: true, + displayMode: true, + output: isMathMLSupported() ? "mathml" : "htmlAndMathml" + }).replace(/\n/g, " ").replace(/<annotation.*<\/annotation>/g, "") + ); +}; +const common$1 = { + getRows, + sanitizeText: sanitizeText$2, + sanitizeTextOrArray, + hasBreaks, + splitBreaks, + lineBreakRegex, + removeScript, + getUrl, + evaluate, + getMax, + getMin +}; +const mkBorder = (col, darkMode) => darkMode ? adjust(col, { s: -40, l: 10 }) : adjust(col, { s: -40, l: -10 }); +const oldAttributeBackgroundColorOdd = "#ffffff"; +const oldAttributeBackgroundColorEven = "#f2f2f2"; +let Theme$4 = class Theme { + constructor() { + this.background = "#f4f4f4"; + this.primaryColor = "#fff4dd"; + this.noteBkgColor = "#fff5ad"; + this.noteTextColor = "#333"; + this.THEME_COLOR_LIMIT = 12; + this.fontFamily = '"trebuchet ms", verdana, arial, sans-serif'; + this.fontSize = "16px"; + } + updateColors() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; + this.primaryTextColor = this.primaryTextColor || (this.darkMode ? "#eee" : "#333"); + this.secondaryColor = this.secondaryColor || adjust(this.primaryColor, { h: -120 }); + this.tertiaryColor = this.tertiaryColor || adjust(this.primaryColor, { h: 180, l: 5 }); + this.primaryBorderColor = this.primaryBorderColor || mkBorder(this.primaryColor, this.darkMode); + this.secondaryBorderColor = this.secondaryBorderColor || mkBorder(this.secondaryColor, this.darkMode); + this.tertiaryBorderColor = this.tertiaryBorderColor || mkBorder(this.tertiaryColor, this.darkMode); + this.noteBorderColor = this.noteBorderColor || mkBorder(this.noteBkgColor, this.darkMode); + this.noteBkgColor = this.noteBkgColor || "#fff5ad"; + this.noteTextColor = this.noteTextColor || "#333"; + this.secondaryTextColor = this.secondaryTextColor || invert(this.secondaryColor); + this.tertiaryTextColor = this.tertiaryTextColor || invert(this.tertiaryColor); + this.lineColor = this.lineColor || invert(this.background); + this.arrowheadColor = this.arrowheadColor || invert(this.background); + this.textColor = this.textColor || this.primaryTextColor; + this.border2 = this.border2 || this.tertiaryBorderColor; + this.nodeBkg = this.nodeBkg || this.primaryColor; + this.mainBkg = this.mainBkg || this.primaryColor; + this.nodeBorder = this.nodeBorder || this.primaryBorderColor; + this.clusterBkg = this.clusterBkg || this.tertiaryColor; + this.clusterBorder = this.clusterBorder || this.tertiaryBorderColor; + this.defaultLinkColor = this.defaultLinkColor || this.lineColor; + this.titleColor = this.titleColor || this.tertiaryTextColor; + this.edgeLabelBackground = this.edgeLabelBackground || (this.darkMode ? darken(this.secondaryColor, 30) : this.secondaryColor); + this.nodeTextColor = this.nodeTextColor || this.primaryTextColor; + this.actorBorder = this.actorBorder || this.primaryBorderColor; + this.actorBkg = this.actorBkg || this.mainBkg; + this.actorTextColor = this.actorTextColor || this.primaryTextColor; + this.actorLineColor = this.actorLineColor || "grey"; + this.labelBoxBkgColor = this.labelBoxBkgColor || this.actorBkg; + this.signalColor = this.signalColor || this.textColor; + this.signalTextColor = this.signalTextColor || this.textColor; + this.labelBoxBorderColor = this.labelBoxBorderColor || this.actorBorder; + this.labelTextColor = this.labelTextColor || this.actorTextColor; + this.loopTextColor = this.loopTextColor || this.actorTextColor; + this.activationBorderColor = this.activationBorderColor || darken(this.secondaryColor, 10); + this.activationBkgColor = this.activationBkgColor || this.secondaryColor; + this.sequenceNumberColor = this.sequenceNumberColor || invert(this.lineColor); + this.sectionBkgColor = this.sectionBkgColor || this.tertiaryColor; + this.altSectionBkgColor = this.altSectionBkgColor || "white"; + this.sectionBkgColor = this.sectionBkgColor || this.secondaryColor; + this.sectionBkgColor2 = this.sectionBkgColor2 || this.primaryColor; + this.excludeBkgColor = this.excludeBkgColor || "#eeeeee"; + this.taskBorderColor = this.taskBorderColor || this.primaryBorderColor; + this.taskBkgColor = this.taskBkgColor || this.primaryColor; + this.activeTaskBorderColor = this.activeTaskBorderColor || this.primaryColor; + this.activeTaskBkgColor = this.activeTaskBkgColor || lighten(this.primaryColor, 23); + this.gridColor = this.gridColor || "lightgrey"; + this.doneTaskBkgColor = this.doneTaskBkgColor || "lightgrey"; + this.doneTaskBorderColor = this.doneTaskBorderColor || "grey"; + this.critBorderColor = this.critBorderColor || "#ff8888"; + this.critBkgColor = this.critBkgColor || "red"; + this.todayLineColor = this.todayLineColor || "red"; + this.taskTextColor = this.taskTextColor || this.textColor; + this.taskTextOutsideColor = this.taskTextOutsideColor || this.textColor; + this.taskTextLightColor = this.taskTextLightColor || this.textColor; + this.taskTextColor = this.taskTextColor || this.primaryTextColor; + this.taskTextDarkColor = this.taskTextDarkColor || this.textColor; + this.taskTextClickableColor = this.taskTextClickableColor || "#003163"; + this.personBorder = this.personBorder || this.primaryBorderColor; + this.personBkg = this.personBkg || this.mainBkg; + this.transitionColor = this.transitionColor || this.lineColor; + this.transitionLabelColor = this.transitionLabelColor || this.textColor; + this.stateLabelColor = this.stateLabelColor || this.stateBkg || this.primaryTextColor; + this.stateBkg = this.stateBkg || this.mainBkg; + this.labelBackgroundColor = this.labelBackgroundColor || this.stateBkg; + this.compositeBackground = this.compositeBackground || this.background || this.tertiaryColor; + this.altBackground = this.altBackground || this.tertiaryColor; + this.compositeTitleBackground = this.compositeTitleBackground || this.mainBkg; + this.compositeBorder = this.compositeBorder || this.nodeBorder; + this.innerEndBackground = this.nodeBorder; + this.errorBkgColor = this.errorBkgColor || this.tertiaryColor; + this.errorTextColor = this.errorTextColor || this.tertiaryTextColor; + this.transitionColor = this.transitionColor || this.lineColor; + this.specialStateColor = this.lineColor; + this.cScale0 = this.cScale0 || this.primaryColor; + this.cScale1 = this.cScale1 || this.secondaryColor; + this.cScale2 = this.cScale2 || this.tertiaryColor; + this.cScale3 = this.cScale3 || adjust(this.primaryColor, { h: 30 }); + this.cScale4 = this.cScale4 || adjust(this.primaryColor, { h: 60 }); + this.cScale5 = this.cScale5 || adjust(this.primaryColor, { h: 90 }); + this.cScale6 = this.cScale6 || adjust(this.primaryColor, { h: 120 }); + this.cScale7 = this.cScale7 || adjust(this.primaryColor, { h: 150 }); + this.cScale8 = this.cScale8 || adjust(this.primaryColor, { h: 210, l: 150 }); + this.cScale9 = this.cScale9 || adjust(this.primaryColor, { h: 270 }); + this.cScale10 = this.cScale10 || adjust(this.primaryColor, { h: 300 }); + this.cScale11 = this.cScale11 || adjust(this.primaryColor, { h: 330 }); + if (this.darkMode) { + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScale" + i] = darken(this["cScale" + i], 75); + } + } else { + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScale" + i] = darken(this["cScale" + i], 25); + } + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleInv" + i] = this["cScaleInv" + i] || invert(this["cScale" + i]); + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + if (this.darkMode) { + this["cScalePeer" + i] = this["cScalePeer" + i] || lighten(this["cScale" + i], 10); + } else { + this["cScalePeer" + i] = this["cScalePeer" + i] || darken(this["cScale" + i], 10); + } + } + this.scaleLabelColor = this.scaleLabelColor || this.labelTextColor; + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleLabel" + i] = this["cScaleLabel" + i] || this.scaleLabelColor; + } + const multiplier = this.darkMode ? -4 : -1; + for (let i = 0; i < 5; i++) { + this["surface" + i] = this["surface" + i] || adjust(this.mainBkg, { h: 180, s: -15, l: multiplier * (5 + i * 3) }); + this["surfacePeer" + i] = this["surfacePeer" + i] || adjust(this.mainBkg, { h: 180, s: -15, l: multiplier * (8 + i * 3) }); + } + this.classText = this.classText || this.textColor; + this.fillType0 = this.fillType0 || this.primaryColor; + this.fillType1 = this.fillType1 || this.secondaryColor; + this.fillType2 = this.fillType2 || adjust(this.primaryColor, { h: 64 }); + this.fillType3 = this.fillType3 || adjust(this.secondaryColor, { h: 64 }); + this.fillType4 = this.fillType4 || adjust(this.primaryColor, { h: -64 }); + this.fillType5 = this.fillType5 || adjust(this.secondaryColor, { h: -64 }); + this.fillType6 = this.fillType6 || adjust(this.primaryColor, { h: 128 }); + this.fillType7 = this.fillType7 || adjust(this.secondaryColor, { h: 128 }); + this.pie1 = this.pie1 || this.primaryColor; + this.pie2 = this.pie2 || this.secondaryColor; + this.pie3 = this.pie3 || this.tertiaryColor; + this.pie4 = this.pie4 || adjust(this.primaryColor, { l: -10 }); + this.pie5 = this.pie5 || adjust(this.secondaryColor, { l: -10 }); + this.pie6 = this.pie6 || adjust(this.tertiaryColor, { l: -10 }); + this.pie7 = this.pie7 || adjust(this.primaryColor, { h: 60, l: -10 }); + this.pie8 = this.pie8 || adjust(this.primaryColor, { h: -60, l: -10 }); + this.pie9 = this.pie9 || adjust(this.primaryColor, { h: 120, l: 0 }); + this.pie10 = this.pie10 || adjust(this.primaryColor, { h: 60, l: -20 }); + this.pie11 = this.pie11 || adjust(this.primaryColor, { h: -60, l: -20 }); + this.pie12 = this.pie12 || adjust(this.primaryColor, { h: 120, l: -10 }); + this.pieTitleTextSize = this.pieTitleTextSize || "25px"; + this.pieTitleTextColor = this.pieTitleTextColor || this.taskTextDarkColor; + this.pieSectionTextSize = this.pieSectionTextSize || "17px"; + this.pieSectionTextColor = this.pieSectionTextColor || this.textColor; + this.pieLegendTextSize = this.pieLegendTextSize || "17px"; + this.pieLegendTextColor = this.pieLegendTextColor || this.taskTextDarkColor; + this.pieStrokeColor = this.pieStrokeColor || "black"; + this.pieStrokeWidth = this.pieStrokeWidth || "2px"; + this.pieOuterStrokeWidth = this.pieOuterStrokeWidth || "2px"; + this.pieOuterStrokeColor = this.pieOuterStrokeColor || "black"; + this.pieOpacity = this.pieOpacity || "0.7"; + this.quadrant1Fill = this.quadrant1Fill || this.primaryColor; + this.quadrant2Fill = this.quadrant2Fill || adjust(this.primaryColor, { r: 5, g: 5, b: 5 }); + this.quadrant3Fill = this.quadrant3Fill || adjust(this.primaryColor, { r: 10, g: 10, b: 10 }); + this.quadrant4Fill = this.quadrant4Fill || adjust(this.primaryColor, { r: 15, g: 15, b: 15 }); + this.quadrant1TextFill = this.quadrant1TextFill || this.primaryTextColor; + this.quadrant2TextFill = this.quadrant2TextFill || adjust(this.primaryTextColor, { r: -5, g: -5, b: -5 }); + this.quadrant3TextFill = this.quadrant3TextFill || adjust(this.primaryTextColor, { r: -10, g: -10, b: -10 }); + this.quadrant4TextFill = this.quadrant4TextFill || adjust(this.primaryTextColor, { r: -15, g: -15, b: -15 }); + this.quadrantPointFill = this.quadrantPointFill || isDark(this.quadrant1Fill) ? lighten(this.quadrant1Fill) : darken(this.quadrant1Fill); + this.quadrantPointTextFill = this.quadrantPointTextFill || this.primaryTextColor; + this.quadrantXAxisTextFill = this.quadrantXAxisTextFill || this.primaryTextColor; + this.quadrantYAxisTextFill = this.quadrantYAxisTextFill || this.primaryTextColor; + this.quadrantInternalBorderStrokeFill = this.quadrantInternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantExternalBorderStrokeFill = this.quadrantExternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantTitleFill = this.quadrantTitleFill || this.primaryTextColor; + this.xyChart = { + backgroundColor: ((_a = this.xyChart) == null ? void 0 : _a.backgroundColor) || this.background, + titleColor: ((_b = this.xyChart) == null ? void 0 : _b.titleColor) || this.primaryTextColor, + xAxisTitleColor: ((_c = this.xyChart) == null ? void 0 : _c.xAxisTitleColor) || this.primaryTextColor, + xAxisLabelColor: ((_d = this.xyChart) == null ? void 0 : _d.xAxisLabelColor) || this.primaryTextColor, + xAxisTickColor: ((_e = this.xyChart) == null ? void 0 : _e.xAxisTickColor) || this.primaryTextColor, + xAxisLineColor: ((_f = this.xyChart) == null ? void 0 : _f.xAxisLineColor) || this.primaryTextColor, + yAxisTitleColor: ((_g = this.xyChart) == null ? void 0 : _g.yAxisTitleColor) || this.primaryTextColor, + yAxisLabelColor: ((_h = this.xyChart) == null ? void 0 : _h.yAxisLabelColor) || this.primaryTextColor, + yAxisTickColor: ((_i = this.xyChart) == null ? void 0 : _i.yAxisTickColor) || this.primaryTextColor, + yAxisLineColor: ((_j = this.xyChart) == null ? void 0 : _j.yAxisLineColor) || this.primaryTextColor, + plotColorPalette: ((_k = this.xyChart) == null ? void 0 : _k.plotColorPalette) || "#FFF4DD,#FFD8B1,#FFA07A,#ECEFF1,#D6DBDF,#C3E0A8,#FFB6A4,#FFD74D,#738FA7,#FFFFF0" + }; + this.requirementBackground = this.requirementBackground || this.primaryColor; + this.requirementBorderColor = this.requirementBorderColor || this.primaryBorderColor; + this.requirementBorderSize = this.requirementBorderSize || "1"; + this.requirementTextColor = this.requirementTextColor || this.primaryTextColor; + this.relationColor = this.relationColor || this.lineColor; + this.relationLabelBackground = this.relationLabelBackground || (this.darkMode ? darken(this.secondaryColor, 30) : this.secondaryColor); + this.relationLabelColor = this.relationLabelColor || this.actorTextColor; + this.git0 = this.git0 || this.primaryColor; + this.git1 = this.git1 || this.secondaryColor; + this.git2 = this.git2 || this.tertiaryColor; + this.git3 = this.git3 || adjust(this.primaryColor, { h: -30 }); + this.git4 = this.git4 || adjust(this.primaryColor, { h: -60 }); + this.git5 = this.git5 || adjust(this.primaryColor, { h: -90 }); + this.git6 = this.git6 || adjust(this.primaryColor, { h: 60 }); + this.git7 = this.git7 || adjust(this.primaryColor, { h: 120 }); + if (this.darkMode) { + this.git0 = lighten(this.git0, 25); + this.git1 = lighten(this.git1, 25); + this.git2 = lighten(this.git2, 25); + this.git3 = lighten(this.git3, 25); + this.git4 = lighten(this.git4, 25); + this.git5 = lighten(this.git5, 25); + this.git6 = lighten(this.git6, 25); + this.git7 = lighten(this.git7, 25); + } else { + this.git0 = darken(this.git0, 25); + this.git1 = darken(this.git1, 25); + this.git2 = darken(this.git2, 25); + this.git3 = darken(this.git3, 25); + this.git4 = darken(this.git4, 25); + this.git5 = darken(this.git5, 25); + this.git6 = darken(this.git6, 25); + this.git7 = darken(this.git7, 25); + } + this.gitInv0 = this.gitInv0 || invert(this.git0); + this.gitInv1 = this.gitInv1 || invert(this.git1); + this.gitInv2 = this.gitInv2 || invert(this.git2); + this.gitInv3 = this.gitInv3 || invert(this.git3); + this.gitInv4 = this.gitInv4 || invert(this.git4); + this.gitInv5 = this.gitInv5 || invert(this.git5); + this.gitInv6 = this.gitInv6 || invert(this.git6); + this.gitInv7 = this.gitInv7 || invert(this.git7); + this.branchLabelColor = this.branchLabelColor || (this.darkMode ? "black" : this.labelTextColor); + this.gitBranchLabel0 = this.gitBranchLabel0 || this.branchLabelColor; + this.gitBranchLabel1 = this.gitBranchLabel1 || this.branchLabelColor; + this.gitBranchLabel2 = this.gitBranchLabel2 || this.branchLabelColor; + this.gitBranchLabel3 = this.gitBranchLabel3 || this.branchLabelColor; + this.gitBranchLabel4 = this.gitBranchLabel4 || this.branchLabelColor; + this.gitBranchLabel5 = this.gitBranchLabel5 || this.branchLabelColor; + this.gitBranchLabel6 = this.gitBranchLabel6 || this.branchLabelColor; + this.gitBranchLabel7 = this.gitBranchLabel7 || this.branchLabelColor; + this.tagLabelColor = this.tagLabelColor || this.primaryTextColor; + this.tagLabelBackground = this.tagLabelBackground || this.primaryColor; + this.tagLabelBorder = this.tagBorder || this.primaryBorderColor; + this.tagLabelFontSize = this.tagLabelFontSize || "10px"; + this.commitLabelColor = this.commitLabelColor || this.secondaryTextColor; + this.commitLabelBackground = this.commitLabelBackground || this.secondaryColor; + this.commitLabelFontSize = this.commitLabelFontSize || "10px"; + this.attributeBackgroundColorOdd = this.attributeBackgroundColorOdd || oldAttributeBackgroundColorOdd; + this.attributeBackgroundColorEven = this.attributeBackgroundColorEven || oldAttributeBackgroundColorEven; + } + calculate(overrides) { + if (typeof overrides !== "object") { + this.updateColors(); + return; + } + const keys = Object.keys(overrides); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + this.updateColors(); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + } +}; +const getThemeVariables$4 = (userOverrides) => { + const theme2 = new Theme$4(); + theme2.calculate(userOverrides); + return theme2; +}; +let Theme$3 = class Theme2 { + constructor() { + this.background = "#333"; + this.primaryColor = "#1f2020"; + this.secondaryColor = lighten(this.primaryColor, 16); + this.tertiaryColor = adjust(this.primaryColor, { h: -160 }); + this.primaryBorderColor = invert(this.background); + this.secondaryBorderColor = mkBorder(this.secondaryColor, this.darkMode); + this.tertiaryBorderColor = mkBorder(this.tertiaryColor, this.darkMode); + this.primaryTextColor = invert(this.primaryColor); + this.secondaryTextColor = invert(this.secondaryColor); + this.tertiaryTextColor = invert(this.tertiaryColor); + this.lineColor = invert(this.background); + this.textColor = invert(this.background); + this.mainBkg = "#1f2020"; + this.secondBkg = "calculated"; + this.mainContrastColor = "lightgrey"; + this.darkTextColor = lighten(invert("#323D47"), 10); + this.lineColor = "calculated"; + this.border1 = "#81B1DB"; + this.border2 = rgba(255, 255, 255, 0.25); + this.arrowheadColor = "calculated"; + this.fontFamily = '"trebuchet ms", verdana, arial, sans-serif'; + this.fontSize = "16px"; + this.labelBackground = "#181818"; + this.textColor = "#ccc"; + this.THEME_COLOR_LIMIT = 12; + this.nodeBkg = "calculated"; + this.nodeBorder = "calculated"; + this.clusterBkg = "calculated"; + this.clusterBorder = "calculated"; + this.defaultLinkColor = "calculated"; + this.titleColor = "#F9FFFE"; + this.edgeLabelBackground = "calculated"; + this.actorBorder = "calculated"; + this.actorBkg = "calculated"; + this.actorTextColor = "calculated"; + this.actorLineColor = "calculated"; + this.signalColor = "calculated"; + this.signalTextColor = "calculated"; + this.labelBoxBkgColor = "calculated"; + this.labelBoxBorderColor = "calculated"; + this.labelTextColor = "calculated"; + this.loopTextColor = "calculated"; + this.noteBorderColor = "calculated"; + this.noteBkgColor = "#fff5ad"; + this.noteTextColor = "calculated"; + this.activationBorderColor = "calculated"; + this.activationBkgColor = "calculated"; + this.sequenceNumberColor = "black"; + this.sectionBkgColor = darken("#EAE8D9", 30); + this.altSectionBkgColor = "calculated"; + this.sectionBkgColor2 = "#EAE8D9"; + this.excludeBkgColor = darken(this.sectionBkgColor, 10); + this.taskBorderColor = rgba(255, 255, 255, 70); + this.taskBkgColor = "calculated"; + this.taskTextColor = "calculated"; + this.taskTextLightColor = "calculated"; + this.taskTextOutsideColor = "calculated"; + this.taskTextClickableColor = "#003163"; + this.activeTaskBorderColor = rgba(255, 255, 255, 50); + this.activeTaskBkgColor = "#81B1DB"; + this.gridColor = "calculated"; + this.doneTaskBkgColor = "calculated"; + this.doneTaskBorderColor = "grey"; + this.critBorderColor = "#E83737"; + this.critBkgColor = "#E83737"; + this.taskTextDarkColor = "calculated"; + this.todayLineColor = "#DB5757"; + this.personBorder = this.primaryBorderColor; + this.personBkg = this.mainBkg; + this.labelColor = "calculated"; + this.errorBkgColor = "#a44141"; + this.errorTextColor = "#ddd"; + } + updateColors() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; + this.secondBkg = lighten(this.mainBkg, 16); + this.lineColor = this.mainContrastColor; + this.arrowheadColor = this.mainContrastColor; + this.nodeBkg = this.mainBkg; + this.nodeBorder = this.border1; + this.clusterBkg = this.secondBkg; + this.clusterBorder = this.border2; + this.defaultLinkColor = this.lineColor; + this.edgeLabelBackground = lighten(this.labelBackground, 25); + this.actorBorder = this.border1; + this.actorBkg = this.mainBkg; + this.actorTextColor = this.mainContrastColor; + this.actorLineColor = this.mainContrastColor; + this.signalColor = this.mainContrastColor; + this.signalTextColor = this.mainContrastColor; + this.labelBoxBkgColor = this.actorBkg; + this.labelBoxBorderColor = this.actorBorder; + this.labelTextColor = this.mainContrastColor; + this.loopTextColor = this.mainContrastColor; + this.noteBorderColor = this.secondaryBorderColor; + this.noteBkgColor = this.secondBkg; + this.noteTextColor = this.secondaryTextColor; + this.activationBorderColor = this.border1; + this.activationBkgColor = this.secondBkg; + this.altSectionBkgColor = this.background; + this.taskBkgColor = lighten(this.mainBkg, 23); + this.taskTextColor = this.darkTextColor; + this.taskTextLightColor = this.mainContrastColor; + this.taskTextOutsideColor = this.taskTextLightColor; + this.gridColor = this.mainContrastColor; + this.doneTaskBkgColor = this.mainContrastColor; + this.taskTextDarkColor = this.darkTextColor; + this.transitionColor = this.transitionColor || this.lineColor; + this.transitionLabelColor = this.transitionLabelColor || this.textColor; + this.stateLabelColor = this.stateLabelColor || this.stateBkg || this.primaryTextColor; + this.stateBkg = this.stateBkg || this.mainBkg; + this.labelBackgroundColor = this.labelBackgroundColor || this.stateBkg; + this.compositeBackground = this.compositeBackground || this.background || this.tertiaryColor; + this.altBackground = this.altBackground || "#555"; + this.compositeTitleBackground = this.compositeTitleBackground || this.mainBkg; + this.compositeBorder = this.compositeBorder || this.nodeBorder; + this.innerEndBackground = this.primaryBorderColor; + this.specialStateColor = "#f4f4f4"; + this.errorBkgColor = this.errorBkgColor || this.tertiaryColor; + this.errorTextColor = this.errorTextColor || this.tertiaryTextColor; + this.fillType0 = this.primaryColor; + this.fillType1 = this.secondaryColor; + this.fillType2 = adjust(this.primaryColor, { h: 64 }); + this.fillType3 = adjust(this.secondaryColor, { h: 64 }); + this.fillType4 = adjust(this.primaryColor, { h: -64 }); + this.fillType5 = adjust(this.secondaryColor, { h: -64 }); + this.fillType6 = adjust(this.primaryColor, { h: 128 }); + this.fillType7 = adjust(this.secondaryColor, { h: 128 }); + this.cScale1 = this.cScale1 || "#0b0000"; + this.cScale2 = this.cScale2 || "#4d1037"; + this.cScale3 = this.cScale3 || "#3f5258"; + this.cScale4 = this.cScale4 || "#4f2f1b"; + this.cScale5 = this.cScale5 || "#6e0a0a"; + this.cScale6 = this.cScale6 || "#3b0048"; + this.cScale7 = this.cScale7 || "#995a01"; + this.cScale8 = this.cScale8 || "#154706"; + this.cScale9 = this.cScale9 || "#161722"; + this.cScale10 = this.cScale10 || "#00296f"; + this.cScale11 = this.cScale11 || "#01629c"; + this.cScale12 = this.cScale12 || "#010029"; + this.cScale0 = this.cScale0 || this.primaryColor; + this.cScale1 = this.cScale1 || this.secondaryColor; + this.cScale2 = this.cScale2 || this.tertiaryColor; + this.cScale3 = this.cScale3 || adjust(this.primaryColor, { h: 30 }); + this.cScale4 = this.cScale4 || adjust(this.primaryColor, { h: 60 }); + this.cScale5 = this.cScale5 || adjust(this.primaryColor, { h: 90 }); + this.cScale6 = this.cScale6 || adjust(this.primaryColor, { h: 120 }); + this.cScale7 = this.cScale7 || adjust(this.primaryColor, { h: 150 }); + this.cScale8 = this.cScale8 || adjust(this.primaryColor, { h: 210 }); + this.cScale9 = this.cScale9 || adjust(this.primaryColor, { h: 270 }); + this.cScale10 = this.cScale10 || adjust(this.primaryColor, { h: 300 }); + this.cScale11 = this.cScale11 || adjust(this.primaryColor, { h: 330 }); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleInv" + i] = this["cScaleInv" + i] || invert(this["cScale" + i]); + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScalePeer" + i] = this["cScalePeer" + i] || lighten(this["cScale" + i], 10); + } + for (let i = 0; i < 5; i++) { + this["surface" + i] = this["surface" + i] || adjust(this.mainBkg, { h: 30, s: -30, l: -(-10 + i * 4) }); + this["surfacePeer" + i] = this["surfacePeer" + i] || adjust(this.mainBkg, { h: 30, s: -30, l: -(-7 + i * 4) }); + } + this.scaleLabelColor = this.scaleLabelColor || (this.darkMode ? "black" : this.labelTextColor); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleLabel" + i] = this["cScaleLabel" + i] || this.scaleLabelColor; + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["pie" + i] = this["cScale" + i]; + } + this.pieTitleTextSize = this.pieTitleTextSize || "25px"; + this.pieTitleTextColor = this.pieTitleTextColor || this.taskTextDarkColor; + this.pieSectionTextSize = this.pieSectionTextSize || "17px"; + this.pieSectionTextColor = this.pieSectionTextColor || this.textColor; + this.pieLegendTextSize = this.pieLegendTextSize || "17px"; + this.pieLegendTextColor = this.pieLegendTextColor || this.taskTextDarkColor; + this.pieStrokeColor = this.pieStrokeColor || "black"; + this.pieStrokeWidth = this.pieStrokeWidth || "2px"; + this.pieOuterStrokeWidth = this.pieOuterStrokeWidth || "2px"; + this.pieOuterStrokeColor = this.pieOuterStrokeColor || "black"; + this.pieOpacity = this.pieOpacity || "0.7"; + this.quadrant1Fill = this.quadrant1Fill || this.primaryColor; + this.quadrant2Fill = this.quadrant2Fill || adjust(this.primaryColor, { r: 5, g: 5, b: 5 }); + this.quadrant3Fill = this.quadrant3Fill || adjust(this.primaryColor, { r: 10, g: 10, b: 10 }); + this.quadrant4Fill = this.quadrant4Fill || adjust(this.primaryColor, { r: 15, g: 15, b: 15 }); + this.quadrant1TextFill = this.quadrant1TextFill || this.primaryTextColor; + this.quadrant2TextFill = this.quadrant2TextFill || adjust(this.primaryTextColor, { r: -5, g: -5, b: -5 }); + this.quadrant3TextFill = this.quadrant3TextFill || adjust(this.primaryTextColor, { r: -10, g: -10, b: -10 }); + this.quadrant4TextFill = this.quadrant4TextFill || adjust(this.primaryTextColor, { r: -15, g: -15, b: -15 }); + this.quadrantPointFill = this.quadrantPointFill || isDark(this.quadrant1Fill) ? lighten(this.quadrant1Fill) : darken(this.quadrant1Fill); + this.quadrantPointTextFill = this.quadrantPointTextFill || this.primaryTextColor; + this.quadrantXAxisTextFill = this.quadrantXAxisTextFill || this.primaryTextColor; + this.quadrantYAxisTextFill = this.quadrantYAxisTextFill || this.primaryTextColor; + this.quadrantInternalBorderStrokeFill = this.quadrantInternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantExternalBorderStrokeFill = this.quadrantExternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantTitleFill = this.quadrantTitleFill || this.primaryTextColor; + this.xyChart = { + backgroundColor: ((_a = this.xyChart) == null ? void 0 : _a.backgroundColor) || this.background, + titleColor: ((_b = this.xyChart) == null ? void 0 : _b.titleColor) || this.primaryTextColor, + xAxisTitleColor: ((_c = this.xyChart) == null ? void 0 : _c.xAxisTitleColor) || this.primaryTextColor, + xAxisLabelColor: ((_d = this.xyChart) == null ? void 0 : _d.xAxisLabelColor) || this.primaryTextColor, + xAxisTickColor: ((_e = this.xyChart) == null ? void 0 : _e.xAxisTickColor) || this.primaryTextColor, + xAxisLineColor: ((_f = this.xyChart) == null ? void 0 : _f.xAxisLineColor) || this.primaryTextColor, + yAxisTitleColor: ((_g = this.xyChart) == null ? void 0 : _g.yAxisTitleColor) || this.primaryTextColor, + yAxisLabelColor: ((_h = this.xyChart) == null ? void 0 : _h.yAxisLabelColor) || this.primaryTextColor, + yAxisTickColor: ((_i = this.xyChart) == null ? void 0 : _i.yAxisTickColor) || this.primaryTextColor, + yAxisLineColor: ((_j = this.xyChart) == null ? void 0 : _j.yAxisLineColor) || this.primaryTextColor, + plotColorPalette: ((_k = this.xyChart) == null ? void 0 : _k.plotColorPalette) || "#3498db,#2ecc71,#e74c3c,#f1c40f,#bdc3c7,#ffffff,#34495e,#9b59b6,#1abc9c,#e67e22" + }; + this.classText = this.primaryTextColor; + this.requirementBackground = this.requirementBackground || this.primaryColor; + this.requirementBorderColor = this.requirementBorderColor || this.primaryBorderColor; + this.requirementBorderSize = this.requirementBorderSize || "1"; + this.requirementTextColor = this.requirementTextColor || this.primaryTextColor; + this.relationColor = this.relationColor || this.lineColor; + this.relationLabelBackground = this.relationLabelBackground || (this.darkMode ? darken(this.secondaryColor, 30) : this.secondaryColor); + this.relationLabelColor = this.relationLabelColor || this.actorTextColor; + this.git0 = lighten(this.secondaryColor, 20); + this.git1 = lighten(this.pie2 || this.secondaryColor, 20); + this.git2 = lighten(this.pie3 || this.tertiaryColor, 20); + this.git3 = lighten(this.pie4 || adjust(this.primaryColor, { h: -30 }), 20); + this.git4 = lighten(this.pie5 || adjust(this.primaryColor, { h: -60 }), 20); + this.git5 = lighten(this.pie6 || adjust(this.primaryColor, { h: -90 }), 10); + this.git6 = lighten(this.pie7 || adjust(this.primaryColor, { h: 60 }), 10); + this.git7 = lighten(this.pie8 || adjust(this.primaryColor, { h: 120 }), 20); + this.gitInv0 = this.gitInv0 || invert(this.git0); + this.gitInv1 = this.gitInv1 || invert(this.git1); + this.gitInv2 = this.gitInv2 || invert(this.git2); + this.gitInv3 = this.gitInv3 || invert(this.git3); + this.gitInv4 = this.gitInv4 || invert(this.git4); + this.gitInv5 = this.gitInv5 || invert(this.git5); + this.gitInv6 = this.gitInv6 || invert(this.git6); + this.gitInv7 = this.gitInv7 || invert(this.git7); + this.gitBranchLabel0 = this.gitBranchLabel0 || invert(this.labelTextColor); + this.gitBranchLabel1 = this.gitBranchLabel1 || this.labelTextColor; + this.gitBranchLabel2 = this.gitBranchLabel2 || this.labelTextColor; + this.gitBranchLabel3 = this.gitBranchLabel3 || invert(this.labelTextColor); + this.gitBranchLabel4 = this.gitBranchLabel4 || this.labelTextColor; + this.gitBranchLabel5 = this.gitBranchLabel5 || this.labelTextColor; + this.gitBranchLabel6 = this.gitBranchLabel6 || this.labelTextColor; + this.gitBranchLabel7 = this.gitBranchLabel7 || this.labelTextColor; + this.tagLabelColor = this.tagLabelColor || this.primaryTextColor; + this.tagLabelBackground = this.tagLabelBackground || this.primaryColor; + this.tagLabelBorder = this.tagBorder || this.primaryBorderColor; + this.tagLabelFontSize = this.tagLabelFontSize || "10px"; + this.commitLabelColor = this.commitLabelColor || this.secondaryTextColor; + this.commitLabelBackground = this.commitLabelBackground || this.secondaryColor; + this.commitLabelFontSize = this.commitLabelFontSize || "10px"; + this.attributeBackgroundColorOdd = this.attributeBackgroundColorOdd || lighten(this.background, 12); + this.attributeBackgroundColorEven = this.attributeBackgroundColorEven || lighten(this.background, 2); + } + calculate(overrides) { + if (typeof overrides !== "object") { + this.updateColors(); + return; + } + const keys = Object.keys(overrides); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + this.updateColors(); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + } +}; +const getThemeVariables$3 = (userOverrides) => { + const theme2 = new Theme$3(); + theme2.calculate(userOverrides); + return theme2; +}; +let Theme$2 = class Theme3 { + constructor() { + this.background = "#f4f4f4"; + this.primaryColor = "#ECECFF"; + this.secondaryColor = adjust(this.primaryColor, { h: 120 }); + this.secondaryColor = "#ffffde"; + this.tertiaryColor = adjust(this.primaryColor, { h: -160 }); + this.primaryBorderColor = mkBorder(this.primaryColor, this.darkMode); + this.secondaryBorderColor = mkBorder(this.secondaryColor, this.darkMode); + this.tertiaryBorderColor = mkBorder(this.tertiaryColor, this.darkMode); + this.primaryTextColor = invert(this.primaryColor); + this.secondaryTextColor = invert(this.secondaryColor); + this.tertiaryTextColor = invert(this.tertiaryColor); + this.lineColor = invert(this.background); + this.textColor = invert(this.background); + this.background = "white"; + this.mainBkg = "#ECECFF"; + this.secondBkg = "#ffffde"; + this.lineColor = "#333333"; + this.border1 = "#9370DB"; + this.border2 = "#aaaa33"; + this.arrowheadColor = "#333333"; + this.fontFamily = '"trebuchet ms", verdana, arial, sans-serif'; + this.fontSize = "16px"; + this.labelBackground = "#e8e8e8"; + this.textColor = "#333"; + this.THEME_COLOR_LIMIT = 12; + this.nodeBkg = "calculated"; + this.nodeBorder = "calculated"; + this.clusterBkg = "calculated"; + this.clusterBorder = "calculated"; + this.defaultLinkColor = "calculated"; + this.titleColor = "calculated"; + this.edgeLabelBackground = "calculated"; + this.actorBorder = "calculated"; + this.actorBkg = "calculated"; + this.actorTextColor = "black"; + this.actorLineColor = "grey"; + this.signalColor = "calculated"; + this.signalTextColor = "calculated"; + this.labelBoxBkgColor = "calculated"; + this.labelBoxBorderColor = "calculated"; + this.labelTextColor = "calculated"; + this.loopTextColor = "calculated"; + this.noteBorderColor = "calculated"; + this.noteBkgColor = "#fff5ad"; + this.noteTextColor = "calculated"; + this.activationBorderColor = "#666"; + this.activationBkgColor = "#f4f4f4"; + this.sequenceNumberColor = "white"; + this.sectionBkgColor = "calculated"; + this.altSectionBkgColor = "calculated"; + this.sectionBkgColor2 = "calculated"; + this.excludeBkgColor = "#eeeeee"; + this.taskBorderColor = "calculated"; + this.taskBkgColor = "calculated"; + this.taskTextLightColor = "calculated"; + this.taskTextColor = this.taskTextLightColor; + this.taskTextDarkColor = "calculated"; + this.taskTextOutsideColor = this.taskTextDarkColor; + this.taskTextClickableColor = "calculated"; + this.activeTaskBorderColor = "calculated"; + this.activeTaskBkgColor = "calculated"; + this.gridColor = "calculated"; + this.doneTaskBkgColor = "calculated"; + this.doneTaskBorderColor = "calculated"; + this.critBorderColor = "calculated"; + this.critBkgColor = "calculated"; + this.todayLineColor = "calculated"; + this.sectionBkgColor = rgba(102, 102, 255, 0.49); + this.altSectionBkgColor = "white"; + this.sectionBkgColor2 = "#fff400"; + this.taskBorderColor = "#534fbc"; + this.taskBkgColor = "#8a90dd"; + this.taskTextLightColor = "white"; + this.taskTextColor = "calculated"; + this.taskTextDarkColor = "black"; + this.taskTextOutsideColor = "calculated"; + this.taskTextClickableColor = "#003163"; + this.activeTaskBorderColor = "#534fbc"; + this.activeTaskBkgColor = "#bfc7ff"; + this.gridColor = "lightgrey"; + this.doneTaskBkgColor = "lightgrey"; + this.doneTaskBorderColor = "grey"; + this.critBorderColor = "#ff8888"; + this.critBkgColor = "red"; + this.todayLineColor = "red"; + this.personBorder = this.primaryBorderColor; + this.personBkg = this.mainBkg; + this.labelColor = "black"; + this.errorBkgColor = "#552222"; + this.errorTextColor = "#552222"; + this.updateColors(); + } + updateColors() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; + this.cScale0 = this.cScale0 || this.primaryColor; + this.cScale1 = this.cScale1 || this.secondaryColor; + this.cScale2 = this.cScale2 || this.tertiaryColor; + this.cScale3 = this.cScale3 || adjust(this.primaryColor, { h: 30 }); + this.cScale4 = this.cScale4 || adjust(this.primaryColor, { h: 60 }); + this.cScale5 = this.cScale5 || adjust(this.primaryColor, { h: 90 }); + this.cScale6 = this.cScale6 || adjust(this.primaryColor, { h: 120 }); + this.cScale7 = this.cScale7 || adjust(this.primaryColor, { h: 150 }); + this.cScale8 = this.cScale8 || adjust(this.primaryColor, { h: 210 }); + this.cScale9 = this.cScale9 || adjust(this.primaryColor, { h: 270 }); + this.cScale10 = this.cScale10 || adjust(this.primaryColor, { h: 300 }); + this.cScale11 = this.cScale11 || adjust(this.primaryColor, { h: 330 }); + this["cScalePeer1"] = this["cScalePeer1"] || darken(this.secondaryColor, 45); + this["cScalePeer2"] = this["cScalePeer2"] || darken(this.tertiaryColor, 40); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScale" + i] = darken(this["cScale" + i], 10); + this["cScalePeer" + i] = this["cScalePeer" + i] || darken(this["cScale" + i], 25); + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleInv" + i] = this["cScaleInv" + i] || adjust(this["cScale" + i], { h: 180 }); + } + for (let i = 0; i < 5; i++) { + this["surface" + i] = this["surface" + i] || adjust(this.mainBkg, { h: 30, l: -(5 + i * 5) }); + this["surfacePeer" + i] = this["surfacePeer" + i] || adjust(this.mainBkg, { h: 30, l: -(7 + i * 5) }); + } + this.scaleLabelColor = this.scaleLabelColor !== "calculated" && this.scaleLabelColor ? this.scaleLabelColor : this.labelTextColor; + if (this.labelTextColor !== "calculated") { + this.cScaleLabel0 = this.cScaleLabel0 || invert(this.labelTextColor); + this.cScaleLabel3 = this.cScaleLabel3 || invert(this.labelTextColor); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleLabel" + i] = this["cScaleLabel" + i] || this.labelTextColor; + } + } + this.nodeBkg = this.mainBkg; + this.nodeBorder = this.border1; + this.clusterBkg = this.secondBkg; + this.clusterBorder = this.border2; + this.defaultLinkColor = this.lineColor; + this.titleColor = this.textColor; + this.edgeLabelBackground = this.labelBackground; + this.actorBorder = lighten(this.border1, 23); + this.actorBkg = this.mainBkg; + this.labelBoxBkgColor = this.actorBkg; + this.signalColor = this.textColor; + this.signalTextColor = this.textColor; + this.labelBoxBorderColor = this.actorBorder; + this.labelTextColor = this.actorTextColor; + this.loopTextColor = this.actorTextColor; + this.noteBorderColor = this.border2; + this.noteTextColor = this.actorTextColor; + this.taskTextColor = this.taskTextLightColor; + this.taskTextOutsideColor = this.taskTextDarkColor; + this.transitionColor = this.transitionColor || this.lineColor; + this.transitionLabelColor = this.transitionLabelColor || this.textColor; + this.stateLabelColor = this.stateLabelColor || this.stateBkg || this.primaryTextColor; + this.stateBkg = this.stateBkg || this.mainBkg; + this.labelBackgroundColor = this.labelBackgroundColor || this.stateBkg; + this.compositeBackground = this.compositeBackground || this.background || this.tertiaryColor; + this.altBackground = this.altBackground || "#f0f0f0"; + this.compositeTitleBackground = this.compositeTitleBackground || this.mainBkg; + this.compositeBorder = this.compositeBorder || this.nodeBorder; + this.innerEndBackground = this.nodeBorder; + this.specialStateColor = this.lineColor; + this.errorBkgColor = this.errorBkgColor || this.tertiaryColor; + this.errorTextColor = this.errorTextColor || this.tertiaryTextColor; + this.transitionColor = this.transitionColor || this.lineColor; + this.classText = this.primaryTextColor; + this.fillType0 = this.primaryColor; + this.fillType1 = this.secondaryColor; + this.fillType2 = adjust(this.primaryColor, { h: 64 }); + this.fillType3 = adjust(this.secondaryColor, { h: 64 }); + this.fillType4 = adjust(this.primaryColor, { h: -64 }); + this.fillType5 = adjust(this.secondaryColor, { h: -64 }); + this.fillType6 = adjust(this.primaryColor, { h: 128 }); + this.fillType7 = adjust(this.secondaryColor, { h: 128 }); + this.pie1 = this.pie1 || this.primaryColor; + this.pie2 = this.pie2 || this.secondaryColor; + this.pie3 = this.pie3 || adjust(this.tertiaryColor, { l: -40 }); + this.pie4 = this.pie4 || adjust(this.primaryColor, { l: -10 }); + this.pie5 = this.pie5 || adjust(this.secondaryColor, { l: -30 }); + this.pie6 = this.pie6 || adjust(this.tertiaryColor, { l: -20 }); + this.pie7 = this.pie7 || adjust(this.primaryColor, { h: 60, l: -20 }); + this.pie8 = this.pie8 || adjust(this.primaryColor, { h: -60, l: -40 }); + this.pie9 = this.pie9 || adjust(this.primaryColor, { h: 120, l: -40 }); + this.pie10 = this.pie10 || adjust(this.primaryColor, { h: 60, l: -40 }); + this.pie11 = this.pie11 || adjust(this.primaryColor, { h: -90, l: -40 }); + this.pie12 = this.pie12 || adjust(this.primaryColor, { h: 120, l: -30 }); + this.pieTitleTextSize = this.pieTitleTextSize || "25px"; + this.pieTitleTextColor = this.pieTitleTextColor || this.taskTextDarkColor; + this.pieSectionTextSize = this.pieSectionTextSize || "17px"; + this.pieSectionTextColor = this.pieSectionTextColor || this.textColor; + this.pieLegendTextSize = this.pieLegendTextSize || "17px"; + this.pieLegendTextColor = this.pieLegendTextColor || this.taskTextDarkColor; + this.pieStrokeColor = this.pieStrokeColor || "black"; + this.pieStrokeWidth = this.pieStrokeWidth || "2px"; + this.pieOuterStrokeWidth = this.pieOuterStrokeWidth || "2px"; + this.pieOuterStrokeColor = this.pieOuterStrokeColor || "black"; + this.pieOpacity = this.pieOpacity || "0.7"; + this.quadrant1Fill = this.quadrant1Fill || this.primaryColor; + this.quadrant2Fill = this.quadrant2Fill || adjust(this.primaryColor, { r: 5, g: 5, b: 5 }); + this.quadrant3Fill = this.quadrant3Fill || adjust(this.primaryColor, { r: 10, g: 10, b: 10 }); + this.quadrant4Fill = this.quadrant4Fill || adjust(this.primaryColor, { r: 15, g: 15, b: 15 }); + this.quadrant1TextFill = this.quadrant1TextFill || this.primaryTextColor; + this.quadrant2TextFill = this.quadrant2TextFill || adjust(this.primaryTextColor, { r: -5, g: -5, b: -5 }); + this.quadrant3TextFill = this.quadrant3TextFill || adjust(this.primaryTextColor, { r: -10, g: -10, b: -10 }); + this.quadrant4TextFill = this.quadrant4TextFill || adjust(this.primaryTextColor, { r: -15, g: -15, b: -15 }); + this.quadrantPointFill = this.quadrantPointFill || isDark(this.quadrant1Fill) ? lighten(this.quadrant1Fill) : darken(this.quadrant1Fill); + this.quadrantPointTextFill = this.quadrantPointTextFill || this.primaryTextColor; + this.quadrantXAxisTextFill = this.quadrantXAxisTextFill || this.primaryTextColor; + this.quadrantYAxisTextFill = this.quadrantYAxisTextFill || this.primaryTextColor; + this.quadrantInternalBorderStrokeFill = this.quadrantInternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantExternalBorderStrokeFill = this.quadrantExternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantTitleFill = this.quadrantTitleFill || this.primaryTextColor; + this.xyChart = { + backgroundColor: ((_a = this.xyChart) == null ? void 0 : _a.backgroundColor) || this.background, + titleColor: ((_b = this.xyChart) == null ? void 0 : _b.titleColor) || this.primaryTextColor, + xAxisTitleColor: ((_c = this.xyChart) == null ? void 0 : _c.xAxisTitleColor) || this.primaryTextColor, + xAxisLabelColor: ((_d = this.xyChart) == null ? void 0 : _d.xAxisLabelColor) || this.primaryTextColor, + xAxisTickColor: ((_e = this.xyChart) == null ? void 0 : _e.xAxisTickColor) || this.primaryTextColor, + xAxisLineColor: ((_f = this.xyChart) == null ? void 0 : _f.xAxisLineColor) || this.primaryTextColor, + yAxisTitleColor: ((_g = this.xyChart) == null ? void 0 : _g.yAxisTitleColor) || this.primaryTextColor, + yAxisLabelColor: ((_h = this.xyChart) == null ? void 0 : _h.yAxisLabelColor) || this.primaryTextColor, + yAxisTickColor: ((_i = this.xyChart) == null ? void 0 : _i.yAxisTickColor) || this.primaryTextColor, + yAxisLineColor: ((_j = this.xyChart) == null ? void 0 : _j.yAxisLineColor) || this.primaryTextColor, + plotColorPalette: ((_k = this.xyChart) == null ? void 0 : _k.plotColorPalette) || "#ECECFF,#8493A6,#FFC3A0,#DCDDE1,#B8E994,#D1A36F,#C3CDE6,#FFB6C1,#496078,#F8F3E3" + }; + this.requirementBackground = this.requirementBackground || this.primaryColor; + this.requirementBorderColor = this.requirementBorderColor || this.primaryBorderColor; + this.requirementBorderSize = this.requirementBorderSize || "1"; + this.requirementTextColor = this.requirementTextColor || this.primaryTextColor; + this.relationColor = this.relationColor || this.lineColor; + this.relationLabelBackground = this.relationLabelBackground || this.labelBackground; + this.relationLabelColor = this.relationLabelColor || this.actorTextColor; + this.git0 = this.git0 || this.primaryColor; + this.git1 = this.git1 || this.secondaryColor; + this.git2 = this.git2 || this.tertiaryColor; + this.git3 = this.git3 || adjust(this.primaryColor, { h: -30 }); + this.git4 = this.git4 || adjust(this.primaryColor, { h: -60 }); + this.git5 = this.git5 || adjust(this.primaryColor, { h: -90 }); + this.git6 = this.git6 || adjust(this.primaryColor, { h: 60 }); + this.git7 = this.git7 || adjust(this.primaryColor, { h: 120 }); + if (this.darkMode) { + this.git0 = lighten(this.git0, 25); + this.git1 = lighten(this.git1, 25); + this.git2 = lighten(this.git2, 25); + this.git3 = lighten(this.git3, 25); + this.git4 = lighten(this.git4, 25); + this.git5 = lighten(this.git5, 25); + this.git6 = lighten(this.git6, 25); + this.git7 = lighten(this.git7, 25); + } else { + this.git0 = darken(this.git0, 25); + this.git1 = darken(this.git1, 25); + this.git2 = darken(this.git2, 25); + this.git3 = darken(this.git3, 25); + this.git4 = darken(this.git4, 25); + this.git5 = darken(this.git5, 25); + this.git6 = darken(this.git6, 25); + this.git7 = darken(this.git7, 25); + } + this.gitInv0 = this.gitInv0 || darken(invert(this.git0), 25); + this.gitInv1 = this.gitInv1 || invert(this.git1); + this.gitInv2 = this.gitInv2 || invert(this.git2); + this.gitInv3 = this.gitInv3 || invert(this.git3); + this.gitInv4 = this.gitInv4 || invert(this.git4); + this.gitInv5 = this.gitInv5 || invert(this.git5); + this.gitInv6 = this.gitInv6 || invert(this.git6); + this.gitInv7 = this.gitInv7 || invert(this.git7); + this.gitBranchLabel0 = this.gitBranchLabel0 || invert(this.labelTextColor); + this.gitBranchLabel1 = this.gitBranchLabel1 || this.labelTextColor; + this.gitBranchLabel2 = this.gitBranchLabel2 || this.labelTextColor; + this.gitBranchLabel3 = this.gitBranchLabel3 || invert(this.labelTextColor); + this.gitBranchLabel4 = this.gitBranchLabel4 || this.labelTextColor; + this.gitBranchLabel5 = this.gitBranchLabel5 || this.labelTextColor; + this.gitBranchLabel6 = this.gitBranchLabel6 || this.labelTextColor; + this.gitBranchLabel7 = this.gitBranchLabel7 || this.labelTextColor; + this.tagLabelColor = this.tagLabelColor || this.primaryTextColor; + this.tagLabelBackground = this.tagLabelBackground || this.primaryColor; + this.tagLabelBorder = this.tagBorder || this.primaryBorderColor; + this.tagLabelFontSize = this.tagLabelFontSize || "10px"; + this.commitLabelColor = this.commitLabelColor || this.secondaryTextColor; + this.commitLabelBackground = this.commitLabelBackground || this.secondaryColor; + this.commitLabelFontSize = this.commitLabelFontSize || "10px"; + this.attributeBackgroundColorOdd = this.attributeBackgroundColorOdd || oldAttributeBackgroundColorOdd; + this.attributeBackgroundColorEven = this.attributeBackgroundColorEven || oldAttributeBackgroundColorEven; + } + calculate(overrides) { + if (typeof overrides !== "object") { + this.updateColors(); + return; + } + const keys = Object.keys(overrides); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + this.updateColors(); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + } +}; +const getThemeVariables$2 = (userOverrides) => { + const theme2 = new Theme$2(); + theme2.calculate(userOverrides); + return theme2; +}; +let Theme$1 = class Theme4 { + constructor() { + this.background = "#f4f4f4"; + this.primaryColor = "#cde498"; + this.secondaryColor = "#cdffb2"; + this.background = "white"; + this.mainBkg = "#cde498"; + this.secondBkg = "#cdffb2"; + this.lineColor = "green"; + this.border1 = "#13540c"; + this.border2 = "#6eaa49"; + this.arrowheadColor = "green"; + this.fontFamily = '"trebuchet ms", verdana, arial, sans-serif'; + this.fontSize = "16px"; + this.tertiaryColor = lighten("#cde498", 10); + this.primaryBorderColor = mkBorder(this.primaryColor, this.darkMode); + this.secondaryBorderColor = mkBorder(this.secondaryColor, this.darkMode); + this.tertiaryBorderColor = mkBorder(this.tertiaryColor, this.darkMode); + this.primaryTextColor = invert(this.primaryColor); + this.secondaryTextColor = invert(this.secondaryColor); + this.tertiaryTextColor = invert(this.primaryColor); + this.lineColor = invert(this.background); + this.textColor = invert(this.background); + this.THEME_COLOR_LIMIT = 12; + this.nodeBkg = "calculated"; + this.nodeBorder = "calculated"; + this.clusterBkg = "calculated"; + this.clusterBorder = "calculated"; + this.defaultLinkColor = "calculated"; + this.titleColor = "#333"; + this.edgeLabelBackground = "#e8e8e8"; + this.actorBorder = "calculated"; + this.actorBkg = "calculated"; + this.actorTextColor = "black"; + this.actorLineColor = "grey"; + this.signalColor = "#333"; + this.signalTextColor = "#333"; + this.labelBoxBkgColor = "calculated"; + this.labelBoxBorderColor = "#326932"; + this.labelTextColor = "calculated"; + this.loopTextColor = "calculated"; + this.noteBorderColor = "calculated"; + this.noteBkgColor = "#fff5ad"; + this.noteTextColor = "calculated"; + this.activationBorderColor = "#666"; + this.activationBkgColor = "#f4f4f4"; + this.sequenceNumberColor = "white"; + this.sectionBkgColor = "#6eaa49"; + this.altSectionBkgColor = "white"; + this.sectionBkgColor2 = "#6eaa49"; + this.excludeBkgColor = "#eeeeee"; + this.taskBorderColor = "calculated"; + this.taskBkgColor = "#487e3a"; + this.taskTextLightColor = "white"; + this.taskTextColor = "calculated"; + this.taskTextDarkColor = "black"; + this.taskTextOutsideColor = "calculated"; + this.taskTextClickableColor = "#003163"; + this.activeTaskBorderColor = "calculated"; + this.activeTaskBkgColor = "calculated"; + this.gridColor = "lightgrey"; + this.doneTaskBkgColor = "lightgrey"; + this.doneTaskBorderColor = "grey"; + this.critBorderColor = "#ff8888"; + this.critBkgColor = "red"; + this.todayLineColor = "red"; + this.personBorder = this.primaryBorderColor; + this.personBkg = this.mainBkg; + this.labelColor = "black"; + this.errorBkgColor = "#552222"; + this.errorTextColor = "#552222"; + } + updateColors() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; + this.actorBorder = darken(this.mainBkg, 20); + this.actorBkg = this.mainBkg; + this.labelBoxBkgColor = this.actorBkg; + this.labelTextColor = this.actorTextColor; + this.loopTextColor = this.actorTextColor; + this.noteBorderColor = this.border2; + this.noteTextColor = this.actorTextColor; + this.cScale0 = this.cScale0 || this.primaryColor; + this.cScale1 = this.cScale1 || this.secondaryColor; + this.cScale2 = this.cScale2 || this.tertiaryColor; + this.cScale3 = this.cScale3 || adjust(this.primaryColor, { h: 30 }); + this.cScale4 = this.cScale4 || adjust(this.primaryColor, { h: 60 }); + this.cScale5 = this.cScale5 || adjust(this.primaryColor, { h: 90 }); + this.cScale6 = this.cScale6 || adjust(this.primaryColor, { h: 120 }); + this.cScale7 = this.cScale7 || adjust(this.primaryColor, { h: 150 }); + this.cScale8 = this.cScale8 || adjust(this.primaryColor, { h: 210 }); + this.cScale9 = this.cScale9 || adjust(this.primaryColor, { h: 270 }); + this.cScale10 = this.cScale10 || adjust(this.primaryColor, { h: 300 }); + this.cScale11 = this.cScale11 || adjust(this.primaryColor, { h: 330 }); + this["cScalePeer1"] = this["cScalePeer1"] || darken(this.secondaryColor, 45); + this["cScalePeer2"] = this["cScalePeer2"] || darken(this.tertiaryColor, 40); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScale" + i] = darken(this["cScale" + i], 10); + this["cScalePeer" + i] = this["cScalePeer" + i] || darken(this["cScale" + i], 25); + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleInv" + i] = this["cScaleInv" + i] || adjust(this["cScale" + i], { h: 180 }); + } + this.scaleLabelColor = this.scaleLabelColor !== "calculated" && this.scaleLabelColor ? this.scaleLabelColor : this.labelTextColor; + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleLabel" + i] = this["cScaleLabel" + i] || this.scaleLabelColor; + } + for (let i = 0; i < 5; i++) { + this["surface" + i] = this["surface" + i] || adjust(this.mainBkg, { h: 30, s: -30, l: -(5 + i * 5) }); + this["surfacePeer" + i] = this["surfacePeer" + i] || adjust(this.mainBkg, { h: 30, s: -30, l: -(8 + i * 5) }); + } + this.nodeBkg = this.mainBkg; + this.nodeBorder = this.border1; + this.clusterBkg = this.secondBkg; + this.clusterBorder = this.border2; + this.defaultLinkColor = this.lineColor; + this.taskBorderColor = this.border1; + this.taskTextColor = this.taskTextLightColor; + this.taskTextOutsideColor = this.taskTextDarkColor; + this.activeTaskBorderColor = this.taskBorderColor; + this.activeTaskBkgColor = this.mainBkg; + this.transitionColor = this.transitionColor || this.lineColor; + this.transitionLabelColor = this.transitionLabelColor || this.textColor; + this.stateLabelColor = this.stateLabelColor || this.stateBkg || this.primaryTextColor; + this.stateBkg = this.stateBkg || this.mainBkg; + this.labelBackgroundColor = this.labelBackgroundColor || this.stateBkg; + this.compositeBackground = this.compositeBackground || this.background || this.tertiaryColor; + this.altBackground = this.altBackground || "#f0f0f0"; + this.compositeTitleBackground = this.compositeTitleBackground || this.mainBkg; + this.compositeBorder = this.compositeBorder || this.nodeBorder; + this.innerEndBackground = this.primaryBorderColor; + this.specialStateColor = this.lineColor; + this.errorBkgColor = this.errorBkgColor || this.tertiaryColor; + this.errorTextColor = this.errorTextColor || this.tertiaryTextColor; + this.transitionColor = this.transitionColor || this.lineColor; + this.classText = this.primaryTextColor; + this.fillType0 = this.primaryColor; + this.fillType1 = this.secondaryColor; + this.fillType2 = adjust(this.primaryColor, { h: 64 }); + this.fillType3 = adjust(this.secondaryColor, { h: 64 }); + this.fillType4 = adjust(this.primaryColor, { h: -64 }); + this.fillType5 = adjust(this.secondaryColor, { h: -64 }); + this.fillType6 = adjust(this.primaryColor, { h: 128 }); + this.fillType7 = adjust(this.secondaryColor, { h: 128 }); + this.pie1 = this.pie1 || this.primaryColor; + this.pie2 = this.pie2 || this.secondaryColor; + this.pie3 = this.pie3 || this.tertiaryColor; + this.pie4 = this.pie4 || adjust(this.primaryColor, { l: -30 }); + this.pie5 = this.pie5 || adjust(this.secondaryColor, { l: -30 }); + this.pie6 = this.pie6 || adjust(this.tertiaryColor, { h: 40, l: -40 }); + this.pie7 = this.pie7 || adjust(this.primaryColor, { h: 60, l: -10 }); + this.pie8 = this.pie8 || adjust(this.primaryColor, { h: -60, l: -10 }); + this.pie9 = this.pie9 || adjust(this.primaryColor, { h: 120, l: 0 }); + this.pie10 = this.pie10 || adjust(this.primaryColor, { h: 60, l: -50 }); + this.pie11 = this.pie11 || adjust(this.primaryColor, { h: -60, l: -50 }); + this.pie12 = this.pie12 || adjust(this.primaryColor, { h: 120, l: -50 }); + this.pieTitleTextSize = this.pieTitleTextSize || "25px"; + this.pieTitleTextColor = this.pieTitleTextColor || this.taskTextDarkColor; + this.pieSectionTextSize = this.pieSectionTextSize || "17px"; + this.pieSectionTextColor = this.pieSectionTextColor || this.textColor; + this.pieLegendTextSize = this.pieLegendTextSize || "17px"; + this.pieLegendTextColor = this.pieLegendTextColor || this.taskTextDarkColor; + this.pieStrokeColor = this.pieStrokeColor || "black"; + this.pieStrokeWidth = this.pieStrokeWidth || "2px"; + this.pieOuterStrokeWidth = this.pieOuterStrokeWidth || "2px"; + this.pieOuterStrokeColor = this.pieOuterStrokeColor || "black"; + this.pieOpacity = this.pieOpacity || "0.7"; + this.quadrant1Fill = this.quadrant1Fill || this.primaryColor; + this.quadrant2Fill = this.quadrant2Fill || adjust(this.primaryColor, { r: 5, g: 5, b: 5 }); + this.quadrant3Fill = this.quadrant3Fill || adjust(this.primaryColor, { r: 10, g: 10, b: 10 }); + this.quadrant4Fill = this.quadrant4Fill || adjust(this.primaryColor, { r: 15, g: 15, b: 15 }); + this.quadrant1TextFill = this.quadrant1TextFill || this.primaryTextColor; + this.quadrant2TextFill = this.quadrant2TextFill || adjust(this.primaryTextColor, { r: -5, g: -5, b: -5 }); + this.quadrant3TextFill = this.quadrant3TextFill || adjust(this.primaryTextColor, { r: -10, g: -10, b: -10 }); + this.quadrant4TextFill = this.quadrant4TextFill || adjust(this.primaryTextColor, { r: -15, g: -15, b: -15 }); + this.quadrantPointFill = this.quadrantPointFill || isDark(this.quadrant1Fill) ? lighten(this.quadrant1Fill) : darken(this.quadrant1Fill); + this.quadrantPointTextFill = this.quadrantPointTextFill || this.primaryTextColor; + this.quadrantXAxisTextFill = this.quadrantXAxisTextFill || this.primaryTextColor; + this.quadrantYAxisTextFill = this.quadrantYAxisTextFill || this.primaryTextColor; + this.quadrantInternalBorderStrokeFill = this.quadrantInternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantExternalBorderStrokeFill = this.quadrantExternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantTitleFill = this.quadrantTitleFill || this.primaryTextColor; + this.xyChart = { + backgroundColor: ((_a = this.xyChart) == null ? void 0 : _a.backgroundColor) || this.background, + titleColor: ((_b = this.xyChart) == null ? void 0 : _b.titleColor) || this.primaryTextColor, + xAxisTitleColor: ((_c = this.xyChart) == null ? void 0 : _c.xAxisTitleColor) || this.primaryTextColor, + xAxisLabelColor: ((_d = this.xyChart) == null ? void 0 : _d.xAxisLabelColor) || this.primaryTextColor, + xAxisTickColor: ((_e = this.xyChart) == null ? void 0 : _e.xAxisTickColor) || this.primaryTextColor, + xAxisLineColor: ((_f = this.xyChart) == null ? void 0 : _f.xAxisLineColor) || this.primaryTextColor, + yAxisTitleColor: ((_g = this.xyChart) == null ? void 0 : _g.yAxisTitleColor) || this.primaryTextColor, + yAxisLabelColor: ((_h = this.xyChart) == null ? void 0 : _h.yAxisLabelColor) || this.primaryTextColor, + yAxisTickColor: ((_i = this.xyChart) == null ? void 0 : _i.yAxisTickColor) || this.primaryTextColor, + yAxisLineColor: ((_j = this.xyChart) == null ? void 0 : _j.yAxisLineColor) || this.primaryTextColor, + plotColorPalette: ((_k = this.xyChart) == null ? void 0 : _k.plotColorPalette) || "#CDE498,#FF6B6B,#A0D2DB,#D7BDE2,#F0F0F0,#FFC3A0,#7FD8BE,#FF9A8B,#FAF3E0,#FFF176" + }; + this.requirementBackground = this.requirementBackground || this.primaryColor; + this.requirementBorderColor = this.requirementBorderColor || this.primaryBorderColor; + this.requirementBorderSize = this.requirementBorderSize || "1"; + this.requirementTextColor = this.requirementTextColor || this.primaryTextColor; + this.relationColor = this.relationColor || this.lineColor; + this.relationLabelBackground = this.relationLabelBackground || this.edgeLabelBackground; + this.relationLabelColor = this.relationLabelColor || this.actorTextColor; + this.git0 = this.git0 || this.primaryColor; + this.git1 = this.git1 || this.secondaryColor; + this.git2 = this.git2 || this.tertiaryColor; + this.git3 = this.git3 || adjust(this.primaryColor, { h: -30 }); + this.git4 = this.git4 || adjust(this.primaryColor, { h: -60 }); + this.git5 = this.git5 || adjust(this.primaryColor, { h: -90 }); + this.git6 = this.git6 || adjust(this.primaryColor, { h: 60 }); + this.git7 = this.git7 || adjust(this.primaryColor, { h: 120 }); + if (this.darkMode) { + this.git0 = lighten(this.git0, 25); + this.git1 = lighten(this.git1, 25); + this.git2 = lighten(this.git2, 25); + this.git3 = lighten(this.git3, 25); + this.git4 = lighten(this.git4, 25); + this.git5 = lighten(this.git5, 25); + this.git6 = lighten(this.git6, 25); + this.git7 = lighten(this.git7, 25); + } else { + this.git0 = darken(this.git0, 25); + this.git1 = darken(this.git1, 25); + this.git2 = darken(this.git2, 25); + this.git3 = darken(this.git3, 25); + this.git4 = darken(this.git4, 25); + this.git5 = darken(this.git5, 25); + this.git6 = darken(this.git6, 25); + this.git7 = darken(this.git7, 25); + } + this.gitInv0 = this.gitInv0 || invert(this.git0); + this.gitInv1 = this.gitInv1 || invert(this.git1); + this.gitInv2 = this.gitInv2 || invert(this.git2); + this.gitInv3 = this.gitInv3 || invert(this.git3); + this.gitInv4 = this.gitInv4 || invert(this.git4); + this.gitInv5 = this.gitInv5 || invert(this.git5); + this.gitInv6 = this.gitInv6 || invert(this.git6); + this.gitInv7 = this.gitInv7 || invert(this.git7); + this.gitBranchLabel0 = this.gitBranchLabel0 || invert(this.labelTextColor); + this.gitBranchLabel1 = this.gitBranchLabel1 || this.labelTextColor; + this.gitBranchLabel2 = this.gitBranchLabel2 || this.labelTextColor; + this.gitBranchLabel3 = this.gitBranchLabel3 || invert(this.labelTextColor); + this.gitBranchLabel4 = this.gitBranchLabel4 || this.labelTextColor; + this.gitBranchLabel5 = this.gitBranchLabel5 || this.labelTextColor; + this.gitBranchLabel6 = this.gitBranchLabel6 || this.labelTextColor; + this.gitBranchLabel7 = this.gitBranchLabel7 || this.labelTextColor; + this.tagLabelColor = this.tagLabelColor || this.primaryTextColor; + this.tagLabelBackground = this.tagLabelBackground || this.primaryColor; + this.tagLabelBorder = this.tagBorder || this.primaryBorderColor; + this.tagLabelFontSize = this.tagLabelFontSize || "10px"; + this.commitLabelColor = this.commitLabelColor || this.secondaryTextColor; + this.commitLabelBackground = this.commitLabelBackground || this.secondaryColor; + this.commitLabelFontSize = this.commitLabelFontSize || "10px"; + this.attributeBackgroundColorOdd = this.attributeBackgroundColorOdd || oldAttributeBackgroundColorOdd; + this.attributeBackgroundColorEven = this.attributeBackgroundColorEven || oldAttributeBackgroundColorEven; + } + calculate(overrides) { + if (typeof overrides !== "object") { + this.updateColors(); + return; + } + const keys = Object.keys(overrides); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + this.updateColors(); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + } +}; +const getThemeVariables$1 = (userOverrides) => { + const theme2 = new Theme$1(); + theme2.calculate(userOverrides); + return theme2; +}; +class Theme5 { + constructor() { + this.primaryColor = "#eee"; + this.contrast = "#707070"; + this.secondaryColor = lighten(this.contrast, 55); + this.background = "#ffffff"; + this.tertiaryColor = adjust(this.primaryColor, { h: -160 }); + this.primaryBorderColor = mkBorder(this.primaryColor, this.darkMode); + this.secondaryBorderColor = mkBorder(this.secondaryColor, this.darkMode); + this.tertiaryBorderColor = mkBorder(this.tertiaryColor, this.darkMode); + this.primaryTextColor = invert(this.primaryColor); + this.secondaryTextColor = invert(this.secondaryColor); + this.tertiaryTextColor = invert(this.tertiaryColor); + this.lineColor = invert(this.background); + this.textColor = invert(this.background); + this.mainBkg = "#eee"; + this.secondBkg = "calculated"; + this.lineColor = "#666"; + this.border1 = "#999"; + this.border2 = "calculated"; + this.note = "#ffa"; + this.text = "#333"; + this.critical = "#d42"; + this.done = "#bbb"; + this.arrowheadColor = "#333333"; + this.fontFamily = '"trebuchet ms", verdana, arial, sans-serif'; + this.fontSize = "16px"; + this.THEME_COLOR_LIMIT = 12; + this.nodeBkg = "calculated"; + this.nodeBorder = "calculated"; + this.clusterBkg = "calculated"; + this.clusterBorder = "calculated"; + this.defaultLinkColor = "calculated"; + this.titleColor = "calculated"; + this.edgeLabelBackground = "white"; + this.actorBorder = "calculated"; + this.actorBkg = "calculated"; + this.actorTextColor = "calculated"; + this.actorLineColor = "calculated"; + this.signalColor = "calculated"; + this.signalTextColor = "calculated"; + this.labelBoxBkgColor = "calculated"; + this.labelBoxBorderColor = "calculated"; + this.labelTextColor = "calculated"; + this.loopTextColor = "calculated"; + this.noteBorderColor = "calculated"; + this.noteBkgColor = "calculated"; + this.noteTextColor = "calculated"; + this.activationBorderColor = "#666"; + this.activationBkgColor = "#f4f4f4"; + this.sequenceNumberColor = "white"; + this.sectionBkgColor = "calculated"; + this.altSectionBkgColor = "white"; + this.sectionBkgColor2 = "calculated"; + this.excludeBkgColor = "#eeeeee"; + this.taskBorderColor = "calculated"; + this.taskBkgColor = "calculated"; + this.taskTextLightColor = "white"; + this.taskTextColor = "calculated"; + this.taskTextDarkColor = "calculated"; + this.taskTextOutsideColor = "calculated"; + this.taskTextClickableColor = "#003163"; + this.activeTaskBorderColor = "calculated"; + this.activeTaskBkgColor = "calculated"; + this.gridColor = "calculated"; + this.doneTaskBkgColor = "calculated"; + this.doneTaskBorderColor = "calculated"; + this.critBkgColor = "calculated"; + this.critBorderColor = "calculated"; + this.todayLineColor = "calculated"; + this.personBorder = this.primaryBorderColor; + this.personBkg = this.mainBkg; + this.labelColor = "black"; + this.errorBkgColor = "#552222"; + this.errorTextColor = "#552222"; + } + updateColors() { + var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k; + this.secondBkg = lighten(this.contrast, 55); + this.border2 = this.contrast; + this.actorBorder = lighten(this.border1, 23); + this.actorBkg = this.mainBkg; + this.actorTextColor = this.text; + this.actorLineColor = this.lineColor; + this.signalColor = this.text; + this.signalTextColor = this.text; + this.labelBoxBkgColor = this.actorBkg; + this.labelBoxBorderColor = this.actorBorder; + this.labelTextColor = this.text; + this.loopTextColor = this.text; + this.noteBorderColor = "#999"; + this.noteBkgColor = "#666"; + this.noteTextColor = "#fff"; + this.cScale0 = this.cScale0 || "#555"; + this.cScale1 = this.cScale1 || "#F4F4F4"; + this.cScale2 = this.cScale2 || "#555"; + this.cScale3 = this.cScale3 || "#BBB"; + this.cScale4 = this.cScale4 || "#777"; + this.cScale5 = this.cScale5 || "#999"; + this.cScale6 = this.cScale6 || "#DDD"; + this.cScale7 = this.cScale7 || "#FFF"; + this.cScale8 = this.cScale8 || "#DDD"; + this.cScale9 = this.cScale9 || "#BBB"; + this.cScale10 = this.cScale10 || "#999"; + this.cScale11 = this.cScale11 || "#777"; + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleInv" + i] = this["cScaleInv" + i] || invert(this["cScale" + i]); + } + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + if (this.darkMode) { + this["cScalePeer" + i] = this["cScalePeer" + i] || lighten(this["cScale" + i], 10); + } else { + this["cScalePeer" + i] = this["cScalePeer" + i] || darken(this["cScale" + i], 10); + } + } + this.scaleLabelColor = this.scaleLabelColor || (this.darkMode ? "black" : this.labelTextColor); + this["cScaleLabel0"] = this["cScaleLabel0"] || this.cScale1; + this["cScaleLabel2"] = this["cScaleLabel2"] || this.cScale1; + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["cScaleLabel" + i] = this["cScaleLabel" + i] || this.scaleLabelColor; + } + for (let i = 0; i < 5; i++) { + this["surface" + i] = this["surface" + i] || adjust(this.mainBkg, { l: -(5 + i * 5) }); + this["surfacePeer" + i] = this["surfacePeer" + i] || adjust(this.mainBkg, { l: -(8 + i * 5) }); + } + this.nodeBkg = this.mainBkg; + this.nodeBorder = this.border1; + this.clusterBkg = this.secondBkg; + this.clusterBorder = this.border2; + this.defaultLinkColor = this.lineColor; + this.titleColor = this.text; + this.sectionBkgColor = lighten(this.contrast, 30); + this.sectionBkgColor2 = lighten(this.contrast, 30); + this.taskBorderColor = darken(this.contrast, 10); + this.taskBkgColor = this.contrast; + this.taskTextColor = this.taskTextLightColor; + this.taskTextDarkColor = this.text; + this.taskTextOutsideColor = this.taskTextDarkColor; + this.activeTaskBorderColor = this.taskBorderColor; + this.activeTaskBkgColor = this.mainBkg; + this.gridColor = lighten(this.border1, 30); + this.doneTaskBkgColor = this.done; + this.doneTaskBorderColor = this.lineColor; + this.critBkgColor = this.critical; + this.critBorderColor = darken(this.critBkgColor, 10); + this.todayLineColor = this.critBkgColor; + this.transitionColor = this.transitionColor || "#000"; + this.transitionLabelColor = this.transitionLabelColor || this.textColor; + this.stateLabelColor = this.stateLabelColor || this.stateBkg || this.primaryTextColor; + this.stateBkg = this.stateBkg || this.mainBkg; + this.labelBackgroundColor = this.labelBackgroundColor || this.stateBkg; + this.compositeBackground = this.compositeBackground || this.background || this.tertiaryColor; + this.altBackground = this.altBackground || "#f4f4f4"; + this.compositeTitleBackground = this.compositeTitleBackground || this.mainBkg; + this.stateBorder = this.stateBorder || "#000"; + this.innerEndBackground = this.primaryBorderColor; + this.specialStateColor = "#222"; + this.errorBkgColor = this.errorBkgColor || this.tertiaryColor; + this.errorTextColor = this.errorTextColor || this.tertiaryTextColor; + this.classText = this.primaryTextColor; + this.fillType0 = this.primaryColor; + this.fillType1 = this.secondaryColor; + this.fillType2 = adjust(this.primaryColor, { h: 64 }); + this.fillType3 = adjust(this.secondaryColor, { h: 64 }); + this.fillType4 = adjust(this.primaryColor, { h: -64 }); + this.fillType5 = adjust(this.secondaryColor, { h: -64 }); + this.fillType6 = adjust(this.primaryColor, { h: 128 }); + this.fillType7 = adjust(this.secondaryColor, { h: 128 }); + for (let i = 0; i < this.THEME_COLOR_LIMIT; i++) { + this["pie" + i] = this["cScale" + i]; + } + this.pie12 = this.pie0; + this.pieTitleTextSize = this.pieTitleTextSize || "25px"; + this.pieTitleTextColor = this.pieTitleTextColor || this.taskTextDarkColor; + this.pieSectionTextSize = this.pieSectionTextSize || "17px"; + this.pieSectionTextColor = this.pieSectionTextColor || this.textColor; + this.pieLegendTextSize = this.pieLegendTextSize || "17px"; + this.pieLegendTextColor = this.pieLegendTextColor || this.taskTextDarkColor; + this.pieStrokeColor = this.pieStrokeColor || "black"; + this.pieStrokeWidth = this.pieStrokeWidth || "2px"; + this.pieOuterStrokeWidth = this.pieOuterStrokeWidth || "2px"; + this.pieOuterStrokeColor = this.pieOuterStrokeColor || "black"; + this.pieOpacity = this.pieOpacity || "0.7"; + this.quadrant1Fill = this.quadrant1Fill || this.primaryColor; + this.quadrant2Fill = this.quadrant2Fill || adjust(this.primaryColor, { r: 5, g: 5, b: 5 }); + this.quadrant3Fill = this.quadrant3Fill || adjust(this.primaryColor, { r: 10, g: 10, b: 10 }); + this.quadrant4Fill = this.quadrant4Fill || adjust(this.primaryColor, { r: 15, g: 15, b: 15 }); + this.quadrant1TextFill = this.quadrant1TextFill || this.primaryTextColor; + this.quadrant2TextFill = this.quadrant2TextFill || adjust(this.primaryTextColor, { r: -5, g: -5, b: -5 }); + this.quadrant3TextFill = this.quadrant3TextFill || adjust(this.primaryTextColor, { r: -10, g: -10, b: -10 }); + this.quadrant4TextFill = this.quadrant4TextFill || adjust(this.primaryTextColor, { r: -15, g: -15, b: -15 }); + this.quadrantPointFill = this.quadrantPointFill || isDark(this.quadrant1Fill) ? lighten(this.quadrant1Fill) : darken(this.quadrant1Fill); + this.quadrantPointTextFill = this.quadrantPointTextFill || this.primaryTextColor; + this.quadrantXAxisTextFill = this.quadrantXAxisTextFill || this.primaryTextColor; + this.quadrantYAxisTextFill = this.quadrantYAxisTextFill || this.primaryTextColor; + this.quadrantInternalBorderStrokeFill = this.quadrantInternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantExternalBorderStrokeFill = this.quadrantExternalBorderStrokeFill || this.primaryBorderColor; + this.quadrantTitleFill = this.quadrantTitleFill || this.primaryTextColor; + this.xyChart = { + backgroundColor: ((_a = this.xyChart) == null ? void 0 : _a.backgroundColor) || this.background, + titleColor: ((_b = this.xyChart) == null ? void 0 : _b.titleColor) || this.primaryTextColor, + xAxisTitleColor: ((_c = this.xyChart) == null ? void 0 : _c.xAxisTitleColor) || this.primaryTextColor, + xAxisLabelColor: ((_d = this.xyChart) == null ? void 0 : _d.xAxisLabelColor) || this.primaryTextColor, + xAxisTickColor: ((_e = this.xyChart) == null ? void 0 : _e.xAxisTickColor) || this.primaryTextColor, + xAxisLineColor: ((_f = this.xyChart) == null ? void 0 : _f.xAxisLineColor) || this.primaryTextColor, + yAxisTitleColor: ((_g = this.xyChart) == null ? void 0 : _g.yAxisTitleColor) || this.primaryTextColor, + yAxisLabelColor: ((_h = this.xyChart) == null ? void 0 : _h.yAxisLabelColor) || this.primaryTextColor, + yAxisTickColor: ((_i = this.xyChart) == null ? void 0 : _i.yAxisTickColor) || this.primaryTextColor, + yAxisLineColor: ((_j = this.xyChart) == null ? void 0 : _j.yAxisLineColor) || this.primaryTextColor, + plotColorPalette: ((_k = this.xyChart) == null ? void 0 : _k.plotColorPalette) || "#EEE,#6BB8E4,#8ACB88,#C7ACD6,#E8DCC2,#FFB2A8,#FFF380,#7E8D91,#FFD8B1,#FAF3E0" + }; + this.requirementBackground = this.requirementBackground || this.primaryColor; + this.requirementBorderColor = this.requirementBorderColor || this.primaryBorderColor; + this.requirementBorderSize = this.requirementBorderSize || "1"; + this.requirementTextColor = this.requirementTextColor || this.primaryTextColor; + this.relationColor = this.relationColor || this.lineColor; + this.relationLabelBackground = this.relationLabelBackground || this.edgeLabelBackground; + this.relationLabelColor = this.relationLabelColor || this.actorTextColor; + this.git0 = darken(this.pie1, 25) || this.primaryColor; + this.git1 = this.pie2 || this.secondaryColor; + this.git2 = this.pie3 || this.tertiaryColor; + this.git3 = this.pie4 || adjust(this.primaryColor, { h: -30 }); + this.git4 = this.pie5 || adjust(this.primaryColor, { h: -60 }); + this.git5 = this.pie6 || adjust(this.primaryColor, { h: -90 }); + this.git6 = this.pie7 || adjust(this.primaryColor, { h: 60 }); + this.git7 = this.pie8 || adjust(this.primaryColor, { h: 120 }); + this.gitInv0 = this.gitInv0 || invert(this.git0); + this.gitInv1 = this.gitInv1 || invert(this.git1); + this.gitInv2 = this.gitInv2 || invert(this.git2); + this.gitInv3 = this.gitInv3 || invert(this.git3); + this.gitInv4 = this.gitInv4 || invert(this.git4); + this.gitInv5 = this.gitInv5 || invert(this.git5); + this.gitInv6 = this.gitInv6 || invert(this.git6); + this.gitInv7 = this.gitInv7 || invert(this.git7); + this.branchLabelColor = this.branchLabelColor || this.labelTextColor; + this.gitBranchLabel0 = this.branchLabelColor; + this.gitBranchLabel1 = "white"; + this.gitBranchLabel2 = this.branchLabelColor; + this.gitBranchLabel3 = "white"; + this.gitBranchLabel4 = this.branchLabelColor; + this.gitBranchLabel5 = this.branchLabelColor; + this.gitBranchLabel6 = this.branchLabelColor; + this.gitBranchLabel7 = this.branchLabelColor; + this.tagLabelColor = this.tagLabelColor || this.primaryTextColor; + this.tagLabelBackground = this.tagLabelBackground || this.primaryColor; + this.tagLabelBorder = this.tagBorder || this.primaryBorderColor; + this.tagLabelFontSize = this.tagLabelFontSize || "10px"; + this.commitLabelColor = this.commitLabelColor || this.secondaryTextColor; + this.commitLabelBackground = this.commitLabelBackground || this.secondaryColor; + this.commitLabelFontSize = this.commitLabelFontSize || "10px"; + this.attributeBackgroundColorOdd = this.attributeBackgroundColorOdd || oldAttributeBackgroundColorOdd; + this.attributeBackgroundColorEven = this.attributeBackgroundColorEven || oldAttributeBackgroundColorEven; + } + calculate(overrides) { + if (typeof overrides !== "object") { + this.updateColors(); + return; + } + const keys = Object.keys(overrides); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + this.updateColors(); + keys.forEach((k) => { + this[k] = overrides[k]; + }); + } +} +const getThemeVariables = (userOverrides) => { + const theme2 = new Theme5(); + theme2.calculate(userOverrides); + return theme2; +}; +const theme = { + base: { + getThemeVariables: getThemeVariables$4 + }, + dark: { + getThemeVariables: getThemeVariables$3 + }, + default: { + getThemeVariables: getThemeVariables$2 + }, + forest: { + getThemeVariables: getThemeVariables$1 + }, + neutral: { + getThemeVariables + } +}; +const defaultConfigJson = { + "flowchart": { + "useMaxWidth": true, + "titleTopMargin": 25, + "subGraphTitleMargin": { + "top": 0, + "bottom": 0 + }, + "diagramPadding": 8, + "htmlLabels": true, + "nodeSpacing": 50, + "rankSpacing": 50, + "curve": "basis", + "padding": 15, + "defaultRenderer": "dagre-wrapper", + "wrappingWidth": 200 + }, + "sequence": { + "useMaxWidth": true, + "hideUnusedParticipants": false, + "activationWidth": 10, + "diagramMarginX": 50, + "diagramMarginY": 10, + "actorMargin": 50, + "width": 150, + "height": 65, + "boxMargin": 10, + "boxTextMargin": 5, + "noteMargin": 10, + "messageMargin": 35, + "messageAlign": "center", + "mirrorActors": true, + "forceMenus": false, + "bottomMarginAdj": 1, + "rightAngles": false, + "showSequenceNumbers": false, + "actorFontSize": 14, + "actorFontFamily": '"Open Sans", sans-serif', + "actorFontWeight": 400, + "noteFontSize": 14, + "noteFontFamily": '"trebuchet ms", verdana, arial, sans-serif', + "noteFontWeight": 400, + "noteAlign": "center", + "messageFontSize": 16, + "messageFontFamily": '"trebuchet ms", verdana, arial, sans-serif', + "messageFontWeight": 400, + "wrap": false, + "wrapPadding": 10, + "labelBoxWidth": 50, + "labelBoxHeight": 20 + }, + "gantt": { + "useMaxWidth": true, + "titleTopMargin": 25, + "barHeight": 20, + "barGap": 4, + "topPadding": 50, + "rightPadding": 75, + "leftPadding": 75, + "gridLineStartPadding": 35, + "fontSize": 11, + "sectionFontSize": 11, + "numberSectionStyles": 4, + "axisFormat": "%Y-%m-%d", + "topAxis": false, + "displayMode": "", + "weekday": "sunday" + }, + "journey": { + "useMaxWidth": true, + "diagramMarginX": 50, + "diagramMarginY": 10, + "leftMargin": 150, + "width": 150, + "height": 50, + "boxMargin": 10, + "boxTextMargin": 5, + "noteMargin": 10, + "messageMargin": 35, + "messageAlign": "center", + "bottomMarginAdj": 1, + "rightAngles": false, + "taskFontSize": 14, + "taskFontFamily": '"Open Sans", sans-serif', + "taskMargin": 50, + "activationWidth": 10, + "textPlacement": "fo", + "actorColours": [ + "#8FBC8F", + "#7CFC00", + "#00FFFF", + "#20B2AA", + "#B0E0E6", + "#FFFFE0" + ], + "sectionFills": [ + "#191970", + "#8B008B", + "#4B0082", + "#2F4F4F", + "#800000", + "#8B4513", + "#00008B" + ], + "sectionColours": [ + "#fff" + ] + }, + "class": { + "useMaxWidth": true, + "titleTopMargin": 25, + "arrowMarkerAbsolute": false, + "dividerMargin": 10, + "padding": 5, + "textHeight": 10, + "defaultRenderer": "dagre-wrapper", + "htmlLabels": false + }, + "state": { + "useMaxWidth": true, + "titleTopMargin": 25, + "dividerMargin": 10, + "sizeUnit": 5, + "padding": 8, + "textHeight": 10, + "titleShift": -15, + "noteMargin": 10, + "forkWidth": 70, + "forkHeight": 7, + "miniPadding": 2, + "fontSizeFactor": 5.02, + "fontSize": 24, + "labelHeight": 16, + "edgeLengthFactor": "20", + "compositTitleSize": 35, + "radius": 5, + "defaultRenderer": "dagre-wrapper" + }, + "er": { + "useMaxWidth": true, + "titleTopMargin": 25, + "diagramPadding": 20, + "layoutDirection": "TB", + "minEntityWidth": 100, + "minEntityHeight": 75, + "entityPadding": 15, + "stroke": "gray", + "fill": "honeydew", + "fontSize": 12 + }, + "pie": { + "useMaxWidth": true, + "textPosition": 0.75 + }, + "quadrantChart": { + "useMaxWidth": true, + "chartWidth": 500, + "chartHeight": 500, + "titleFontSize": 20, + "titlePadding": 10, + "quadrantPadding": 5, + "xAxisLabelPadding": 5, + "yAxisLabelPadding": 5, + "xAxisLabelFontSize": 16, + "yAxisLabelFontSize": 16, + "quadrantLabelFontSize": 16, + "quadrantTextTopPadding": 5, + "pointTextPadding": 5, + "pointLabelFontSize": 12, + "pointRadius": 5, + "xAxisPosition": "top", + "yAxisPosition": "left", + "quadrantInternalBorderStrokeWidth": 1, + "quadrantExternalBorderStrokeWidth": 2 + }, + "xyChart": { + "useMaxWidth": true, + "width": 700, + "height": 500, + "titleFontSize": 20, + "titlePadding": 10, + "showTitle": true, + "xAxis": { + "$ref": "#/$defs/XYChartAxisConfig", + "showLabel": true, + "labelFontSize": 14, + "labelPadding": 5, + "showTitle": true, + "titleFontSize": 16, + "titlePadding": 5, + "showTick": true, + "tickLength": 5, + "tickWidth": 2, + "showAxisLine": true, + "axisLineWidth": 2 + }, + "yAxis": { + "$ref": "#/$defs/XYChartAxisConfig", + "showLabel": true, + "labelFontSize": 14, + "labelPadding": 5, + "showTitle": true, + "titleFontSize": 16, + "titlePadding": 5, + "showTick": true, + "tickLength": 5, + "tickWidth": 2, + "showAxisLine": true, + "axisLineWidth": 2 + }, + "chartOrientation": "vertical", + "plotReservedSpacePercent": 50 + }, + "requirement": { + "useMaxWidth": true, + "rect_fill": "#f9f9f9", + "text_color": "#333", + "rect_border_size": "0.5px", + "rect_border_color": "#bbb", + "rect_min_width": 200, + "rect_min_height": 200, + "fontSize": 14, + "rect_padding": 10, + "line_height": 20 + }, + "mindmap": { + "useMaxWidth": true, + "padding": 10, + "maxNodeWidth": 200 + }, + "timeline": { + "useMaxWidth": true, + "diagramMarginX": 50, + "diagramMarginY": 10, + "leftMargin": 150, + "width": 150, + "height": 50, + "boxMargin": 10, + "boxTextMargin": 5, + "noteMargin": 10, + "messageMargin": 35, + "messageAlign": "center", + "bottomMarginAdj": 1, + "rightAngles": false, + "taskFontSize": 14, + "taskFontFamily": '"Open Sans", sans-serif', + "taskMargin": 50, + "activationWidth": 10, + "textPlacement": "fo", + "actorColours": [ + "#8FBC8F", + "#7CFC00", + "#00FFFF", + "#20B2AA", + "#B0E0E6", + "#FFFFE0" + ], + "sectionFills": [ + "#191970", + "#8B008B", + "#4B0082", + "#2F4F4F", + "#800000", + "#8B4513", + "#00008B" + ], + "sectionColours": [ + "#fff" + ], + "disableMulticolor": false + }, + "gitGraph": { + "useMaxWidth": true, + "titleTopMargin": 25, + "diagramPadding": 8, + "nodeLabel": { + "width": 75, + "height": 100, + "x": -25, + "y": 0 + }, + "mainBranchName": "main", + "mainBranchOrder": 0, + "showCommitLabel": true, + "showBranches": true, + "rotateCommitLabel": true, + "parallelCommits": false, + "arrowMarkerAbsolute": false + }, + "c4": { + "useMaxWidth": true, + "diagramMarginX": 50, + "diagramMarginY": 10, + "c4ShapeMargin": 50, + "c4ShapePadding": 20, + "width": 216, + "height": 60, + "boxMargin": 10, + "c4ShapeInRow": 4, + "nextLinePaddingX": 0, + "c4BoundaryInRow": 2, + "personFontSize": 14, + "personFontFamily": '"Open Sans", sans-serif', + "personFontWeight": "normal", + "external_personFontSize": 14, + "external_personFontFamily": '"Open Sans", sans-serif', + "external_personFontWeight": "normal", + "systemFontSize": 14, + "systemFontFamily": '"Open Sans", sans-serif', + "systemFontWeight": "normal", + "external_systemFontSize": 14, + "external_systemFontFamily": '"Open Sans", sans-serif', + "external_systemFontWeight": "normal", + "system_dbFontSize": 14, + "system_dbFontFamily": '"Open Sans", sans-serif', + "system_dbFontWeight": "normal", + "external_system_dbFontSize": 14, + "external_system_dbFontFamily": '"Open Sans", sans-serif', + "external_system_dbFontWeight": "normal", + "system_queueFontSize": 14, + "system_queueFontFamily": '"Open Sans", sans-serif', + "system_queueFontWeight": "normal", + "external_system_queueFontSize": 14, + "external_system_queueFontFamily": '"Open Sans", sans-serif', + "external_system_queueFontWeight": "normal", + "boundaryFontSize": 14, + "boundaryFontFamily": '"Open Sans", sans-serif', + "boundaryFontWeight": "normal", + "messageFontSize": 12, + "messageFontFamily": '"Open Sans", sans-serif', + "messageFontWeight": "normal", + "containerFontSize": 14, + "containerFontFamily": '"Open Sans", sans-serif', + "containerFontWeight": "normal", + "external_containerFontSize": 14, + "external_containerFontFamily": '"Open Sans", sans-serif', + "external_containerFontWeight": "normal", + "container_dbFontSize": 14, + "container_dbFontFamily": '"Open Sans", sans-serif', + "container_dbFontWeight": "normal", + "external_container_dbFontSize": 14, + "external_container_dbFontFamily": '"Open Sans", sans-serif', + "external_container_dbFontWeight": "normal", + "container_queueFontSize": 14, + "container_queueFontFamily": '"Open Sans", sans-serif', + "container_queueFontWeight": "normal", + "external_container_queueFontSize": 14, + "external_container_queueFontFamily": '"Open Sans", sans-serif', + "external_container_queueFontWeight": "normal", + "componentFontSize": 14, + "componentFontFamily": '"Open Sans", sans-serif', + "componentFontWeight": "normal", + "external_componentFontSize": 14, + "external_componentFontFamily": '"Open Sans", sans-serif', + "external_componentFontWeight": "normal", + "component_dbFontSize": 14, + "component_dbFontFamily": '"Open Sans", sans-serif', + "component_dbFontWeight": "normal", + "external_component_dbFontSize": 14, + "external_component_dbFontFamily": '"Open Sans", sans-serif', + "external_component_dbFontWeight": "normal", + "component_queueFontSize": 14, + "component_queueFontFamily": '"Open Sans", sans-serif', + "component_queueFontWeight": "normal", + "external_component_queueFontSize": 14, + "external_component_queueFontFamily": '"Open Sans", sans-serif', + "external_component_queueFontWeight": "normal", + "wrap": true, + "wrapPadding": 10, + "person_bg_color": "#08427B", + "person_border_color": "#073B6F", + "external_person_bg_color": "#686868", + "external_person_border_color": "#8A8A8A", + "system_bg_color": "#1168BD", + "system_border_color": "#3C7FC0", + "system_db_bg_color": "#1168BD", + "system_db_border_color": "#3C7FC0", + "system_queue_bg_color": "#1168BD", + "system_queue_border_color": "#3C7FC0", + "external_system_bg_color": "#999999", + "external_system_border_color": "#8A8A8A", + "external_system_db_bg_color": "#999999", + "external_system_db_border_color": "#8A8A8A", + "external_system_queue_bg_color": "#999999", + "external_system_queue_border_color": "#8A8A8A", + "container_bg_color": "#438DD5", + "container_border_color": "#3C7FC0", + "container_db_bg_color": "#438DD5", + "container_db_border_color": "#3C7FC0", + "container_queue_bg_color": "#438DD5", + "container_queue_border_color": "#3C7FC0", + "external_container_bg_color": "#B3B3B3", + "external_container_border_color": "#A6A6A6", + "external_container_db_bg_color": "#B3B3B3", + "external_container_db_border_color": "#A6A6A6", + "external_container_queue_bg_color": "#B3B3B3", + "external_container_queue_border_color": "#A6A6A6", + "component_bg_color": "#85BBF0", + "component_border_color": "#78A8D8", + "component_db_bg_color": "#85BBF0", + "component_db_border_color": "#78A8D8", + "component_queue_bg_color": "#85BBF0", + "component_queue_border_color": "#78A8D8", + "external_component_bg_color": "#CCCCCC", + "external_component_border_color": "#BFBFBF", + "external_component_db_bg_color": "#CCCCCC", + "external_component_db_border_color": "#BFBFBF", + "external_component_queue_bg_color": "#CCCCCC", + "external_component_queue_border_color": "#BFBFBF" + }, + "sankey": { + "useMaxWidth": true, + "width": 600, + "height": 400, + "linkColor": "gradient", + "nodeAlignment": "justify", + "showValues": true, + "prefix": "", + "suffix": "" + }, + "block": { + "useMaxWidth": true, + "padding": 8 + }, + "theme": "default", + "maxTextSize": 5e4, + "maxEdges": 500, + "darkMode": false, + "fontFamily": '"trebuchet ms", verdana, arial, sans-serif;', + "logLevel": 5, + "securityLevel": "strict", + "startOnLoad": true, + "arrowMarkerAbsolute": false, + "secure": [ + "secure", + "securityLevel", + "startOnLoad", + "maxTextSize", + "maxEdges" + ], + "legacyMathML": false, + "deterministicIds": false, + "fontSize": 16 +}; +const config = { + ...defaultConfigJson, + // Set, even though they're `undefined` so that `configKeys` finds these keys + // TODO: Should we replace these with `null` so that they can go in the JSON Schema? + deterministicIDSeed: void 0, + themeCSS: void 0, + // add non-JSON default config values + themeVariables: theme["default"].getThemeVariables(), + sequence: { + ...defaultConfigJson.sequence, + messageFont: function() { + return { + fontFamily: this.messageFontFamily, + fontSize: this.messageFontSize, + fontWeight: this.messageFontWeight + }; + }, + noteFont: function() { + return { + fontFamily: this.noteFontFamily, + fontSize: this.noteFontSize, + fontWeight: this.noteFontWeight + }; + }, + actorFont: function() { + return { + fontFamily: this.actorFontFamily, + fontSize: this.actorFontSize, + fontWeight: this.actorFontWeight + }; + } + }, + gantt: { + ...defaultConfigJson.gantt, + tickInterval: void 0, + useWidth: void 0 + // can probably be removed since `configKeys` already includes this + }, + c4: { + ...defaultConfigJson.c4, + useWidth: void 0, + personFont: function() { + return { + fontFamily: this.personFontFamily, + fontSize: this.personFontSize, + fontWeight: this.personFontWeight + }; + }, + external_personFont: function() { + return { + fontFamily: this.external_personFontFamily, + fontSize: this.external_personFontSize, + fontWeight: this.external_personFontWeight + }; + }, + systemFont: function() { + return { + fontFamily: this.systemFontFamily, + fontSize: this.systemFontSize, + fontWeight: this.systemFontWeight + }; + }, + external_systemFont: function() { + return { + fontFamily: this.external_systemFontFamily, + fontSize: this.external_systemFontSize, + fontWeight: this.external_systemFontWeight + }; + }, + system_dbFont: function() { + return { + fontFamily: this.system_dbFontFamily, + fontSize: this.system_dbFontSize, + fontWeight: this.system_dbFontWeight + }; + }, + external_system_dbFont: function() { + return { + fontFamily: this.external_system_dbFontFamily, + fontSize: this.external_system_dbFontSize, + fontWeight: this.external_system_dbFontWeight + }; + }, + system_queueFont: function() { + return { + fontFamily: this.system_queueFontFamily, + fontSize: this.system_queueFontSize, + fontWeight: this.system_queueFontWeight + }; + }, + external_system_queueFont: function() { + return { + fontFamily: this.external_system_queueFontFamily, + fontSize: this.external_system_queueFontSize, + fontWeight: this.external_system_queueFontWeight + }; + }, + containerFont: function() { + return { + fontFamily: this.containerFontFamily, + fontSize: this.containerFontSize, + fontWeight: this.containerFontWeight + }; + }, + external_containerFont: function() { + return { + fontFamily: this.external_containerFontFamily, + fontSize: this.external_containerFontSize, + fontWeight: this.external_containerFontWeight + }; + }, + container_dbFont: function() { + return { + fontFamily: this.container_dbFontFamily, + fontSize: this.container_dbFontSize, + fontWeight: this.container_dbFontWeight + }; + }, + external_container_dbFont: function() { + return { + fontFamily: this.external_container_dbFontFamily, + fontSize: this.external_container_dbFontSize, + fontWeight: this.external_container_dbFontWeight + }; + }, + container_queueFont: function() { + return { + fontFamily: this.container_queueFontFamily, + fontSize: this.container_queueFontSize, + fontWeight: this.container_queueFontWeight + }; + }, + external_container_queueFont: function() { + return { + fontFamily: this.external_container_queueFontFamily, + fontSize: this.external_container_queueFontSize, + fontWeight: this.external_container_queueFontWeight + }; + }, + componentFont: function() { + return { + fontFamily: this.componentFontFamily, + fontSize: this.componentFontSize, + fontWeight: this.componentFontWeight + }; + }, + external_componentFont: function() { + return { + fontFamily: this.external_componentFontFamily, + fontSize: this.external_componentFontSize, + fontWeight: this.external_componentFontWeight + }; + }, + component_dbFont: function() { + return { + fontFamily: this.component_dbFontFamily, + fontSize: this.component_dbFontSize, + fontWeight: this.component_dbFontWeight + }; + }, + external_component_dbFont: function() { + return { + fontFamily: this.external_component_dbFontFamily, + fontSize: this.external_component_dbFontSize, + fontWeight: this.external_component_dbFontWeight + }; + }, + component_queueFont: function() { + return { + fontFamily: this.component_queueFontFamily, + fontSize: this.component_queueFontSize, + fontWeight: this.component_queueFontWeight + }; + }, + external_component_queueFont: function() { + return { + fontFamily: this.external_component_queueFontFamily, + fontSize: this.external_component_queueFontSize, + fontWeight: this.external_component_queueFontWeight + }; + }, + boundaryFont: function() { + return { + fontFamily: this.boundaryFontFamily, + fontSize: this.boundaryFontSize, + fontWeight: this.boundaryFontWeight + }; + }, + messageFont: function() { + return { + fontFamily: this.messageFontFamily, + fontSize: this.messageFontSize, + fontWeight: this.messageFontWeight + }; + } + }, + pie: { + ...defaultConfigJson.pie, + useWidth: 984 + }, + xyChart: { + ...defaultConfigJson.xyChart, + useWidth: void 0 + }, + requirement: { + ...defaultConfigJson.requirement, + useWidth: void 0 + }, + gitGraph: { + ...defaultConfigJson.gitGraph, + // TODO: This is a temporary override for `gitGraph`, since every other + // diagram does have `useMaxWidth`, but instead sets it to `true`. + // Should we set this to `true` instead? + useMaxWidth: false + }, + sankey: { + ...defaultConfigJson.sankey, + // this is false, unlike every other diagram (other than gitGraph) + // TODO: can we make this default to `true` instead? + useMaxWidth: false + } +}; +const keyify = (obj, prefix = "") => Object.keys(obj).reduce((res, el) => { + if (Array.isArray(obj[el])) { + return res; + } else if (typeof obj[el] === "object" && obj[el] !== null) { + return [...res, prefix + el, ...keyify(obj[el], "")]; + } + return [...res, prefix + el]; +}, []); +const configKeys = new Set(keyify(config, "")); +const defaultConfig$2 = config; +const sanitizeDirective = (args) => { + log$1.debug("sanitizeDirective called with", args); + if (typeof args !== "object" || args == null) { + return; + } + if (Array.isArray(args)) { + args.forEach((arg) => sanitizeDirective(arg)); + return; + } + for (const key of Object.keys(args)) { + log$1.debug("Checking key", key); + if (key.startsWith("__") || key.includes("proto") || key.includes("constr") || !configKeys.has(key) || args[key] == null) { + log$1.debug("sanitize deleting key: ", key); + delete args[key]; + continue; + } + if (typeof args[key] === "object") { + log$1.debug("sanitizing object", key); + sanitizeDirective(args[key]); + continue; + } + const cssMatchers = ["themeCSS", "fontFamily", "altFontFamily"]; + for (const cssKey of cssMatchers) { + if (key.includes(cssKey)) { + log$1.debug("sanitizing css option", key); + args[key] = sanitizeCss(args[key]); + } + } + } + if (args.themeVariables) { + for (const k of Object.keys(args.themeVariables)) { + const val = args.themeVariables[k]; + if ((val == null ? void 0 : val.match) && !val.match(/^[\d "#%(),.;A-Za-z]+$/)) { + args.themeVariables[k] = ""; + } + } + } + log$1.debug("After sanitization", args); +}; +const sanitizeCss = (str2) => { + let startCnt = 0; + let endCnt = 0; + for (const element of str2) { + if (startCnt < endCnt) { + return "{ /* ERROR: Unbalanced CSS */ }"; + } + if (element === "{") { + startCnt++; + } else if (element === "}") { + endCnt++; + } + } + if (startCnt !== endCnt) { + return "{ /* ERROR: Unbalanced CSS */ }"; + } + return str2; +}; +const frontMatterRegex = /^-{3}\s*[\n\r](.*?)[\n\r]-{3}\s*[\n\r]+/s; +const directiveRegex = /%{2}{\s*(?:(\w+)\s*:|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi; +const anyCommentRegex = /\s*%%.*\n/gm; +class UnknownDiagramError extends Error { + constructor(message) { + super(message); + this.name = "UnknownDiagramError"; + } +} +const detectors = {}; +const detectType = function(text, config2) { + text = text.replace(frontMatterRegex, "").replace(directiveRegex, "").replace(anyCommentRegex, "\n"); + for (const [key, { detector: detector2 }] of Object.entries(detectors)) { + const diagram2 = detector2(text, config2); + if (diagram2) { + return key; + } + } + throw new UnknownDiagramError( + `No diagram type detected matching given configuration for text: ${text}` + ); +}; +const registerLazyLoadedDiagrams = (...diagrams2) => { + for (const { id: id2, detector: detector2, loader: loader2 } of diagrams2) { + addDetector(id2, detector2, loader2); + } +}; +const addDetector = (key, detector2, loader2) => { + if (detectors[key]) { + log$1.error(`Detector with key ${key} already exists`); + } else { + detectors[key] = { detector: detector2, loader: loader2 }; + } + log$1.debug(`Detector with key ${key} added${loader2 ? " with loader" : ""}`); +}; +const getDiagramLoader = (key) => { + return detectors[key].loader; +}; +const assignWithDepth = (dst, src, { depth = 2, clobber = false } = {}) => { + const config2 = { depth, clobber }; + if (Array.isArray(src) && !Array.isArray(dst)) { + src.forEach((s) => assignWithDepth(dst, s, config2)); + return dst; + } else if (Array.isArray(src) && Array.isArray(dst)) { + src.forEach((s) => { + if (!dst.includes(s)) { + dst.push(s); + } + }); + return dst; + } + if (dst === void 0 || depth <= 0) { + if (dst !== void 0 && dst !== null && typeof dst === "object" && typeof src === "object") { + return Object.assign(dst, src); + } else { + return src; + } + } + if (src !== void 0 && typeof dst === "object" && typeof src === "object") { + Object.keys(src).forEach((key) => { + if (typeof src[key] === "object" && (dst[key] === void 0 || typeof dst[key] === "object")) { + if (dst[key] === void 0) { + dst[key] = Array.isArray(src[key]) ? [] : {}; + } + dst[key] = assignWithDepth(dst[key], src[key], { depth: depth - 1, clobber }); + } else if (clobber || typeof dst[key] !== "object" && typeof src[key] !== "object") { + dst[key] = src[key]; + } + }); + } + return dst; +}; +const assignWithDepth$1 = assignWithDepth; +const ZERO_WIDTH_SPACE = "​"; +const d3CurveTypes = { + curveBasis, + curveBasisClosed, + curveBasisOpen, + curveBumpX, + curveBumpY, + curveBundle, + curveCardinalClosed, + curveCardinalOpen, + curveCardinal, + curveCatmullRomClosed, + curveCatmullRomOpen, + curveCatmullRom, + curveLinear, + curveLinearClosed, + curveMonotoneX, + curveMonotoneY, + curveNatural, + curveStep, + curveStepAfter, + curveStepBefore +}; +const directiveWithoutOpen = /\s*(?:(\w+)(?=:):|(\w+))\s*(?:(\w+)|((?:(?!}%{2}).|\r?\n)*))?\s*(?:}%{2})?/gi; +const detectInit = function(text, config2) { + const inits = detectDirective(text, /(?:init\b)|(?:initialize\b)/); + let results = {}; + if (Array.isArray(inits)) { + const args = inits.map((init2) => init2.args); + sanitizeDirective(args); + results = assignWithDepth$1(results, [...args]); + } else { + results = inits.args; + } + if (!results) { + return; + } + let type2 = detectType(text, config2); + const prop = "config"; + if (results[prop] !== void 0) { + if (type2 === "flowchart-v2") { + type2 = "flowchart"; + } + results[type2] = results[prop]; + delete results[prop]; + } + return results; +}; +const detectDirective = function(text, type2 = null) { + try { + const commentWithoutDirectives = new RegExp( + `[%]{2}(?![{]${directiveWithoutOpen.source})(?=[}][%]{2}).* +`, + "ig" + ); + text = text.trim().replace(commentWithoutDirectives, "").replace(/'/gm, '"'); + log$1.debug( + `Detecting diagram directive${type2 !== null ? " type:" + type2 : ""} based on the text:${text}` + ); + let match; + const result = []; + while ((match = directiveRegex.exec(text)) !== null) { + if (match.index === directiveRegex.lastIndex) { + directiveRegex.lastIndex++; + } + if (match && !type2 || type2 && match[1] && match[1].match(type2) || type2 && match[2] && match[2].match(type2)) { + const type22 = match[1] ? match[1] : match[2]; + const args = match[3] ? match[3].trim() : match[4] ? JSON.parse(match[4].trim()) : null; + result.push({ type: type22, args }); + } + } + if (result.length === 0) { + return { type: text, args: null }; + } + return result.length === 1 ? result[0] : result; + } catch (error) { + log$1.error( + `ERROR: ${error.message} - Unable to parse directive type: '${type2}' based on the text: '${text}'` + ); + return { type: void 0, args: null }; + } +}; +const removeDirectives = function(text) { + return text.replace(directiveRegex, ""); +}; +const isSubstringInArray = function(str2, arr) { + for (const [i, element] of arr.entries()) { + if (element.match(str2)) { + return i; + } + } + return -1; +}; +function interpolateToCurve(interpolate, defaultCurve) { + if (!interpolate) { + return defaultCurve; + } + const curveName = `curve${interpolate.charAt(0).toUpperCase() + interpolate.slice(1)}`; + return d3CurveTypes[curveName] ?? defaultCurve; +} +function formatUrl(linkStr, config2) { + const url = linkStr.trim(); + if (!url) { + return void 0; + } + if (config2.securityLevel !== "loose") { + return sanitizeUrl(url); + } + return url; +} +const runFunc = (functionName, ...params) => { + const arrPaths = functionName.split("."); + const len = arrPaths.length - 1; + const fnName = arrPaths[len]; + let obj = window; + for (let i = 0; i < len; i++) { + obj = obj[arrPaths[i]]; + if (!obj) { + log$1.error(`Function name: ${functionName} not found in window`); + return; + } + } + obj[fnName](...params); +}; +function distance(p1, p2) { + if (!p1 || !p2) { + return 0; + } + return Math.sqrt(Math.pow(p2.x - p1.x, 2) + Math.pow(p2.y - p1.y, 2)); +} +function traverseEdge(points) { + let prevPoint; + let totalDistance = 0; + points.forEach((point) => { + totalDistance += distance(point, prevPoint); + prevPoint = point; + }); + const remainingDistance = totalDistance / 2; + return calculatePoint(points, remainingDistance); +} +function calcLabelPosition(points) { + if (points.length === 1) { + return points[0]; + } + return traverseEdge(points); +} +const roundNumber = (num, precision = 2) => { + const factor = Math.pow(10, precision); + return Math.round(num * factor) / factor; +}; +const calculatePoint = (points, distanceToTraverse) => { + let prevPoint = void 0; + let remainingDistance = distanceToTraverse; + for (const point of points) { + if (prevPoint) { + const vectorDistance = distance(point, prevPoint); + if (vectorDistance < remainingDistance) { + remainingDistance -= vectorDistance; + } else { + const distanceRatio = remainingDistance / vectorDistance; + if (distanceRatio <= 0) { + return prevPoint; + } + if (distanceRatio >= 1) { + return { x: point.x, y: point.y }; + } + if (distanceRatio > 0 && distanceRatio < 1) { + return { + x: roundNumber((1 - distanceRatio) * prevPoint.x + distanceRatio * point.x, 5), + y: roundNumber((1 - distanceRatio) * prevPoint.y + distanceRatio * point.y, 5) + }; + } + } + } + prevPoint = point; + } + throw new Error("Could not find a suitable point for the given distance"); +}; +const calcCardinalityPosition = (isRelationTypePresent, points, initialPosition) => { + log$1.info(`our points ${JSON.stringify(points)}`); + if (points[0] !== initialPosition) { + points = points.reverse(); + } + const distanceToCardinalityPoint = 25; + const center = calculatePoint(points, distanceToCardinalityPoint); + const d = isRelationTypePresent ? 10 : 5; + const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x); + const cardinalityPosition = { x: 0, y: 0 }; + cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2; + cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2; + return cardinalityPosition; +}; +function calcTerminalLabelPosition(terminalMarkerSize, position, _points) { + const points = structuredClone(_points); + log$1.info("our points", points); + if (position !== "start_left" && position !== "start_right") { + points.reverse(); + } + const distanceToCardinalityPoint = 25 + terminalMarkerSize; + const center = calculatePoint(points, distanceToCardinalityPoint); + const d = 10 + terminalMarkerSize * 0.5; + const angle = Math.atan2(points[0].y - center.y, points[0].x - center.x); + const cardinalityPosition = { x: 0, y: 0 }; + if (position === "start_left") { + cardinalityPosition.x = Math.sin(angle + Math.PI) * d + (points[0].x + center.x) / 2; + cardinalityPosition.y = -Math.cos(angle + Math.PI) * d + (points[0].y + center.y) / 2; + } else if (position === "end_right") { + cardinalityPosition.x = Math.sin(angle - Math.PI) * d + (points[0].x + center.x) / 2 - 5; + cardinalityPosition.y = -Math.cos(angle - Math.PI) * d + (points[0].y + center.y) / 2 - 5; + } else if (position === "end_left") { + cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2 - 5; + cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2 - 5; + } else { + cardinalityPosition.x = Math.sin(angle) * d + (points[0].x + center.x) / 2; + cardinalityPosition.y = -Math.cos(angle) * d + (points[0].y + center.y) / 2; + } + return cardinalityPosition; +} +function getStylesFromArray(arr) { + let style = ""; + let labelStyle = ""; + for (const element of arr) { + if (element !== void 0) { + if (element.startsWith("color:") || element.startsWith("text-align:")) { + labelStyle = labelStyle + element + ";"; + } else { + style = style + element + ";"; + } + } + } + return { style, labelStyle }; +} +let cnt = 0; +const generateId = () => { + cnt++; + return "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt; +}; +function makeRandomHex(length) { + let result = ""; + const characters = "0123456789abcdef"; + const charactersLength = characters.length; + for (let i = 0; i < length; i++) { + result += characters.charAt(Math.floor(Math.random() * charactersLength)); + } + return result; +} +const random = (options) => { + return makeRandomHex(options.length); +}; +const getTextObj = function() { + return { + x: 0, + y: 0, + fill: void 0, + anchor: "start", + style: "#666", + width: 100, + height: 100, + textMargin: 0, + rx: 0, + ry: 0, + valign: void 0, + text: "" + }; +}; +const drawSimpleText = function(elem, textData) { + const nText = textData.text.replace(common$1.lineBreakRegex, " "); + const [, _fontSizePx] = parseFontSize(textData.fontSize); + const textElem = elem.append("text"); + textElem.attr("x", textData.x); + textElem.attr("y", textData.y); + textElem.style("text-anchor", textData.anchor); + textElem.style("font-family", textData.fontFamily); + textElem.style("font-size", _fontSizePx); + textElem.style("font-weight", textData.fontWeight); + textElem.attr("fill", textData.fill); + if (textData.class !== void 0) { + textElem.attr("class", textData.class); + } + const span = textElem.append("tspan"); + span.attr("x", textData.x + textData.textMargin * 2); + span.attr("fill", textData.fill); + span.text(nText); + return textElem; +}; +const wrapLabel = memoize( + (label, maxWidth, config2) => { + if (!label) { + return label; + } + config2 = Object.assign( + { fontSize: 12, fontWeight: 400, fontFamily: "Arial", joinWith: "<br/>" }, + config2 + ); + if (common$1.lineBreakRegex.test(label)) { + return label; + } + const words = label.split(" "); + const completedLines = []; + let nextLine = ""; + words.forEach((word, index) => { + const wordLength = calculateTextWidth(`${word} `, config2); + const nextLineLength = calculateTextWidth(nextLine, config2); + if (wordLength > maxWidth) { + const { hyphenatedStrings, remainingWord } = breakString(word, maxWidth, "-", config2); + completedLines.push(nextLine, ...hyphenatedStrings); + nextLine = remainingWord; + } else if (nextLineLength + wordLength >= maxWidth) { + completedLines.push(nextLine); + nextLine = word; + } else { + nextLine = [nextLine, word].filter(Boolean).join(" "); + } + const currentWord = index + 1; + const isLastWord = currentWord === words.length; + if (isLastWord) { + completedLines.push(nextLine); + } + }); + return completedLines.filter((line) => line !== "").join(config2.joinWith); + }, + (label, maxWidth, config2) => `${label}${maxWidth}${config2.fontSize}${config2.fontWeight}${config2.fontFamily}${config2.joinWith}` +); +const breakString = memoize( + (word, maxWidth, hyphenCharacter = "-", config2) => { + config2 = Object.assign( + { fontSize: 12, fontWeight: 400, fontFamily: "Arial", margin: 0 }, + config2 + ); + const characters = [...word]; + const lines = []; + let currentLine = ""; + characters.forEach((character, index) => { + const nextLine = `${currentLine}${character}`; + const lineWidth = calculateTextWidth(nextLine, config2); + if (lineWidth >= maxWidth) { + const currentCharacter = index + 1; + const isLastLine = characters.length === currentCharacter; + const hyphenatedNextLine = `${nextLine}${hyphenCharacter}`; + lines.push(isLastLine ? nextLine : hyphenatedNextLine); + currentLine = ""; + } else { + currentLine = nextLine; + } + }); + return { hyphenatedStrings: lines, remainingWord: currentLine }; + }, + (word, maxWidth, hyphenCharacter = "-", config2) => `${word}${maxWidth}${hyphenCharacter}${config2.fontSize}${config2.fontWeight}${config2.fontFamily}` +); +function calculateTextHeight(text, config2) { + return calculateTextDimensions(text, config2).height; +} +function calculateTextWidth(text, config2) { + return calculateTextDimensions(text, config2).width; +} +const calculateTextDimensions = memoize( + (text, config2) => { + const { fontSize = 12, fontFamily = "Arial", fontWeight = 400 } = config2; + if (!text) { + return { width: 0, height: 0 }; + } + const [, _fontSizePx] = parseFontSize(fontSize); + const fontFamilies = ["sans-serif", fontFamily]; + const lines = text.split(common$1.lineBreakRegex); + const dims = []; + const body = select("body"); + if (!body.remove) { + return { width: 0, height: 0, lineHeight: 0 }; + } + const g = body.append("svg"); + for (const fontFamily2 of fontFamilies) { + let cHeight = 0; + const dim = { width: 0, height: 0, lineHeight: 0 }; + for (const line of lines) { + const textObj = getTextObj(); + textObj.text = line || ZERO_WIDTH_SPACE; + const textElem = drawSimpleText(g, textObj).style("font-size", _fontSizePx).style("font-weight", fontWeight).style("font-family", fontFamily2); + const bBox = (textElem._groups || textElem)[0][0].getBBox(); + if (bBox.width === 0 && bBox.height === 0) { + throw new Error("svg element not in render tree"); + } + dim.width = Math.round(Math.max(dim.width, bBox.width)); + cHeight = Math.round(bBox.height); + dim.height += cHeight; + dim.lineHeight = Math.round(Math.max(dim.lineHeight, cHeight)); + } + dims.push(dim); + } + g.remove(); + const index = isNaN(dims[1].height) || isNaN(dims[1].width) || isNaN(dims[1].lineHeight) || dims[0].height > dims[1].height && dims[0].width > dims[1].width && dims[0].lineHeight > dims[1].lineHeight ? 0 : 1; + return dims[index]; + }, + (text, config2) => `${text}${config2.fontSize}${config2.fontWeight}${config2.fontFamily}` +); +class InitIDGenerator { + constructor(deterministic = false, seed) { + this.count = 0; + this.count = seed ? seed.length : 0; + this.next = deterministic ? () => this.count++ : () => Date.now(); + } +} +let decoder; +const entityDecode = function(html) { + decoder = decoder || document.createElement("div"); + html = escape(html).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";"); + decoder.innerHTML = html; + return unescape(decoder.textContent); +}; +function isDetailedError(error) { + return "str" in error; +} +const insertTitle = (parent, cssClass, titleTopMargin, title) => { + var _a; + if (!title) { + return; + } + const bounds = (_a = parent.node()) == null ? void 0 : _a.getBBox(); + if (!bounds) { + return; + } + parent.append("text").text(title).attr("x", bounds.x + bounds.width / 2).attr("y", -titleTopMargin).attr("class", cssClass); +}; +const parseFontSize = (fontSize) => { + if (typeof fontSize === "number") { + return [fontSize, fontSize + "px"]; + } + const fontSizeNumber = parseInt(fontSize ?? "", 10); + if (Number.isNaN(fontSizeNumber)) { + return [void 0, void 0]; + } else if (fontSize === String(fontSizeNumber)) { + return [fontSizeNumber, fontSize + "px"]; + } else { + return [fontSizeNumber, fontSize]; + } +}; +function cleanAndMerge(defaultData, data) { + return merge$1({}, defaultData, data); +} +const utils = { + assignWithDepth: assignWithDepth$1, + wrapLabel, + calculateTextHeight, + calculateTextWidth, + calculateTextDimensions, + cleanAndMerge, + detectInit, + detectDirective, + isSubstringInArray, + interpolateToCurve, + calcLabelPosition, + calcCardinalityPosition, + calcTerminalLabelPosition, + formatUrl, + getStylesFromArray, + generateId, + random, + runFunc, + entityDecode, + insertTitle, + parseFontSize, + InitIDGenerator +}; +const encodeEntities = function(text) { + let txt = text; + txt = txt.replace(/style.*:\S*#.*;/g, function(s) { + return s.substring(0, s.length - 1); + }); + txt = txt.replace(/classDef.*:\S*#.*;/g, function(s) { + return s.substring(0, s.length - 1); + }); + txt = txt.replace(/#\w+;/g, function(s) { + const innerTxt = s.substring(1, s.length - 1); + const isInt = /^\+?\d+$/.test(innerTxt); + if (isInt) { + return "fl°°" + innerTxt + "¶ß"; + } else { + return "fl°" + innerTxt + "¶ß"; + } + }); + return txt; +}; +const decodeEntities = function(text) { + return text.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";"); +}; +const version = "10.9.1"; +const defaultConfig$1 = Object.freeze(defaultConfig$2); +let siteConfig = assignWithDepth$1({}, defaultConfig$1); +let configFromInitialize; +let directives = []; +let currentConfig = assignWithDepth$1({}, defaultConfig$1); +const updateCurrentConfig = (siteCfg, _directives) => { + let cfg = assignWithDepth$1({}, siteCfg); + let sumOfDirectives = {}; + for (const d of _directives) { + sanitize(d); + sumOfDirectives = assignWithDepth$1(sumOfDirectives, d); + } + cfg = assignWithDepth$1(cfg, sumOfDirectives); + if (sumOfDirectives.theme && sumOfDirectives.theme in theme) { + const tmpConfigFromInitialize = assignWithDepth$1({}, configFromInitialize); + const themeVariables = assignWithDepth$1( + tmpConfigFromInitialize.themeVariables || {}, + sumOfDirectives.themeVariables + ); + if (cfg.theme && cfg.theme in theme) { + cfg.themeVariables = theme[cfg.theme].getThemeVariables(themeVariables); + } + } + currentConfig = cfg; + checkConfig(currentConfig); + return currentConfig; +}; +const setSiteConfig = (conf) => { + siteConfig = assignWithDepth$1({}, defaultConfig$1); + siteConfig = assignWithDepth$1(siteConfig, conf); + if (conf.theme && theme[conf.theme]) { + siteConfig.themeVariables = theme[conf.theme].getThemeVariables(conf.themeVariables); + } + updateCurrentConfig(siteConfig, directives); + return siteConfig; +}; +const saveConfigFromInitialize = (conf) => { + configFromInitialize = assignWithDepth$1({}, conf); +}; +const updateSiteConfig = (conf) => { + siteConfig = assignWithDepth$1(siteConfig, conf); + updateCurrentConfig(siteConfig, directives); + return siteConfig; +}; +const getSiteConfig = () => { + return assignWithDepth$1({}, siteConfig); +}; +const setConfig$1 = (conf) => { + checkConfig(conf); + assignWithDepth$1(currentConfig, conf); + return getConfig$1(); +}; +const getConfig$1 = () => { + return assignWithDepth$1({}, currentConfig); +}; +const sanitize = (options) => { + if (!options) { + return; + } + ["secure", ...siteConfig.secure ?? []].forEach((key) => { + if (Object.hasOwn(options, key)) { + log$1.debug(`Denied attempt to modify a secure key ${key}`, options[key]); + delete options[key]; + } + }); + Object.keys(options).forEach((key) => { + if (key.startsWith("__")) { + delete options[key]; + } + }); + Object.keys(options).forEach((key) => { + if (typeof options[key] === "string" && (options[key].includes("<") || options[key].includes(">") || options[key].includes("url(data:"))) { + delete options[key]; + } + if (typeof options[key] === "object") { + sanitize(options[key]); + } + }); +}; +const addDirective = (directive) => { + sanitizeDirective(directive); + if (directive.fontFamily && (!directive.themeVariables || !directive.themeVariables.fontFamily)) { + directive.themeVariables = { fontFamily: directive.fontFamily }; + } + directives.push(directive); + updateCurrentConfig(siteConfig, directives); +}; +const reset = (config2 = siteConfig) => { + directives = []; + updateCurrentConfig(config2, directives); +}; +const ConfigWarning = { + LAZY_LOAD_DEPRECATED: "The configuration options lazyLoadedDiagrams and loadExternalDiagramsAtStartup are deprecated. Please use registerExternalDiagrams instead." +}; +const issuedWarnings = {}; +const issueWarning = (warning) => { + if (issuedWarnings[warning]) { + return; + } + log$1.warn(ConfigWarning[warning]); + issuedWarnings[warning] = true; +}; +const checkConfig = (config2) => { + if (!config2) { + return; + } + if (config2.lazyLoadedDiagrams || config2.loadExternalDiagramsAtStartup) { + issueWarning("LAZY_LOAD_DEPRECATED"); + } +}; +const id$l = "c4"; +const detector$l = (txt) => { + return /^\s*C4Context|C4Container|C4Component|C4Dynamic|C4Deployment/.test(txt); +}; +const loader$m = async () => { + const { diagram: diagram2 } = await import("./c4Diagram-ae766693.js"); + return { id: id$l, diagram: diagram2 }; +}; +const plugin$j = { + id: id$l, + detector: detector$l, + loader: loader$m +}; +const c4 = plugin$j; +const id$k = "flowchart"; +const detector$k = (txt, config2) => { + var _a, _b; + if (((_a = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _a.defaultRenderer) === "dagre-wrapper" || ((_b = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _b.defaultRenderer) === "elk") { + return false; + } + return /^\s*graph/.test(txt); +}; +const loader$l = async () => { + const { diagram: diagram2 } = await import("./flowDiagram-b222e15a.js"); + return { id: id$k, diagram: diagram2 }; +}; +const plugin$i = { + id: id$k, + detector: detector$k, + loader: loader$l +}; +const flowchart = plugin$i; +const id$j = "flowchart-v2"; +const detector$j = (txt, config2) => { + var _a, _b, _c; + if (((_a = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _a.defaultRenderer) === "dagre-d3" || ((_b = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _b.defaultRenderer) === "elk") { + return false; + } + if (/^\s*graph/.test(txt) && ((_c = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _c.defaultRenderer) === "dagre-wrapper") { + return true; + } + return /^\s*flowchart/.test(txt); +}; +const loader$k = async () => { + const { diagram: diagram2 } = await import("./flowDiagram-v2-13329dc7.js"); + return { id: id$j, diagram: diagram2 }; +}; +const plugin$h = { + id: id$j, + detector: detector$j, + loader: loader$k +}; +const flowchartV2 = plugin$h; +const id$i = "er"; +const detector$i = (txt) => { + return /^\s*erDiagram/.test(txt); +}; +const loader$j = async () => { + const { diagram: diagram2 } = await import("./erDiagram-09d1c15f.js"); + return { id: id$i, diagram: diagram2 }; +}; +const plugin$g = { + id: id$i, + detector: detector$i, + loader: loader$j +}; +const er = plugin$g; +const id$h = "gitGraph"; +const detector$h = (txt) => { + return /^\s*gitGraph/.test(txt); +}; +const loader$i = async () => { + const { diagram: diagram2 } = await import("./gitGraphDiagram-942e62fe.js"); + return { id: id$h, diagram: diagram2 }; +}; +const plugin$f = { + id: id$h, + detector: detector$h, + loader: loader$i +}; +const git = plugin$f; +const id$g = "gantt"; +const detector$g = (txt) => { + return /^\s*gantt/.test(txt); +}; +const loader$h = async () => { + const { diagram: diagram2 } = await import("./ganttDiagram-b62c793e.js"); + return { id: id$g, diagram: diagram2 }; +}; +const plugin$e = { + id: id$g, + detector: detector$g, + loader: loader$h +}; +const gantt = plugin$e; +const id$f = "info"; +const detector$f = (txt) => { + return /^\s*info/.test(txt); +}; +const loader$g = async () => { + const { diagram: diagram2 } = await import("./infoDiagram-94cd232f.js"); + return { id: id$f, diagram: diagram2 }; +}; +const info = { + id: id$f, + detector: detector$f, + loader: loader$g +}; +const id$e = "pie"; +const detector$e = (txt) => { + return /^\s*pie/.test(txt); +}; +const loader$f = async () => { + const { diagram: diagram2 } = await import("./pieDiagram-bb1d19e5.js"); + return { id: id$e, diagram: diagram2 }; +}; +const pie = { + id: id$e, + detector: detector$e, + loader: loader$f +}; +const id$d = "quadrantChart"; +const detector$d = (txt) => { + return /^\s*quadrantChart/.test(txt); +}; +const loader$e = async () => { + const { diagram: diagram2 } = await import("./quadrantDiagram-c759a472.js"); + return { id: id$d, diagram: diagram2 }; +}; +const plugin$d = { + id: id$d, + detector: detector$d, + loader: loader$e +}; +const quadrantChart = plugin$d; +const id$c = "xychart"; +const detector$c = (txt) => { + return /^\s*xychart-beta/.test(txt); +}; +const loader$d = async () => { + const { diagram: diagram2 } = await import("./xychartDiagram-f11f50a6.js"); + return { id: id$c, diagram: diagram2 }; +}; +const plugin$c = { + id: id$c, + detector: detector$c, + loader: loader$d +}; +const xychart = plugin$c; +const id$b = "requirement"; +const detector$b = (txt) => { + return /^\s*requirement(Diagram)?/.test(txt); +}; +const loader$c = async () => { + const { diagram: diagram2 } = await import("./requirementDiagram-87253d64.js"); + return { id: id$b, diagram: diagram2 }; +}; +const plugin$b = { + id: id$b, + detector: detector$b, + loader: loader$c +}; +const requirement = plugin$b; +const id$a = "sequence"; +const detector$a = (txt) => { + return /^\s*sequenceDiagram/.test(txt); +}; +const loader$b = async () => { + const { diagram: diagram2 } = await import("./sequenceDiagram-6894f283.js"); + return { id: id$a, diagram: diagram2 }; +}; +const plugin$a = { + id: id$a, + detector: detector$a, + loader: loader$b +}; +const sequence = plugin$a; +const id$9 = "class"; +const detector$9 = (txt, config2) => { + var _a; + if (((_a = config2 == null ? void 0 : config2.class) == null ? void 0 : _a.defaultRenderer) === "dagre-wrapper") { + return false; + } + return /^\s*classDiagram/.test(txt); +}; +const loader$a = async () => { + const { diagram: diagram2 } = await import("./classDiagram-fb54d2a0.js"); + return { id: id$9, diagram: diagram2 }; +}; +const plugin$9 = { + id: id$9, + detector: detector$9, + loader: loader$a +}; +const classDiagram = plugin$9; +const id$8 = "classDiagram"; +const detector$8 = (txt, config2) => { + var _a; + if (/^\s*classDiagram/.test(txt) && ((_a = config2 == null ? void 0 : config2.class) == null ? void 0 : _a.defaultRenderer) === "dagre-wrapper") { + return true; + } + return /^\s*classDiagram-v2/.test(txt); +}; +const loader$9 = async () => { + const { diagram: diagram2 } = await import("./classDiagram-v2-a2b738ad.js"); + return { id: id$8, diagram: diagram2 }; +}; +const plugin$8 = { + id: id$8, + detector: detector$8, + loader: loader$9 +}; +const classDiagramV2 = plugin$8; +const id$7 = "state"; +const detector$7 = (txt, config2) => { + var _a; + if (((_a = config2 == null ? void 0 : config2.state) == null ? void 0 : _a.defaultRenderer) === "dagre-wrapper") { + return false; + } + return /^\s*stateDiagram/.test(txt); +}; +const loader$8 = async () => { + const { diagram: diagram2 } = await import("./stateDiagram-5dee940d.js"); + return { id: id$7, diagram: diagram2 }; +}; +const plugin$7 = { + id: id$7, + detector: detector$7, + loader: loader$8 +}; +const state = plugin$7; +const id$6 = "stateDiagram"; +const detector$6 = (txt, config2) => { + var _a; + if (/^\s*stateDiagram-v2/.test(txt)) { + return true; + } + if (/^\s*stateDiagram/.test(txt) && ((_a = config2 == null ? void 0 : config2.state) == null ? void 0 : _a.defaultRenderer) === "dagre-wrapper") { + return true; + } + return false; +}; +const loader$7 = async () => { + const { diagram: diagram2 } = await import("./stateDiagram-v2-1992cada.js"); + return { id: id$6, diagram: diagram2 }; +}; +const plugin$6 = { + id: id$6, + detector: detector$6, + loader: loader$7 +}; +const stateV2 = plugin$6; +const id$5 = "journey"; +const detector$5 = (txt) => { + return /^\s*journey/.test(txt); +}; +const loader$6 = async () => { + const { diagram: diagram2 } = await import("./journeyDiagram-6625b456.js"); + return { id: id$5, diagram: diagram2 }; +}; +const plugin$5 = { + id: id$5, + detector: detector$5, + loader: loader$6 +}; +const journey = plugin$5; +const d3Attrs = function(d3Elem, attrs) { + for (let attr of attrs) { + d3Elem.attr(attr[0], attr[1]); + } +}; +const calculateSvgSizeAttrs = function(height, width, useMaxWidth) { + let attrs = /* @__PURE__ */ new Map(); + if (useMaxWidth) { + attrs.set("width", "100%"); + attrs.set("style", `max-width: ${width}px;`); + } else { + attrs.set("height", height); + attrs.set("width", width); + } + return attrs; +}; +const configureSvgSize = function(svgElem, height, width, useMaxWidth) { + const attrs = calculateSvgSizeAttrs(height, width, useMaxWidth); + d3Attrs(svgElem, attrs); +}; +const setupGraphViewbox$1 = function(graph, svgElem, padding, useMaxWidth) { + const svgBounds = svgElem.node().getBBox(); + const sWidth = svgBounds.width; + const sHeight = svgBounds.height; + log$1.info(`SVG bounds: ${sWidth}x${sHeight}`, svgBounds); + let width = 0; + let height = 0; + log$1.info(`Graph bounds: ${width}x${height}`, graph); + width = sWidth + padding * 2; + height = sHeight + padding * 2; + log$1.info(`Calculated bounds: ${width}x${height}`); + configureSvgSize(svgElem, height, width, useMaxWidth); + const vBox = `${svgBounds.x - padding} ${svgBounds.y - padding} ${svgBounds.width + 2 * padding} ${svgBounds.height + 2 * padding}`; + svgElem.attr("viewBox", vBox); +}; +const themes = {}; +const getStyles = (type2, userStyles, options) => { + let diagramStyles = ""; + if (type2 in themes && themes[type2]) { + diagramStyles = themes[type2](options); + } else { + log$1.warn(`No theme found for ${type2}`); + } + return ` & { + font-family: ${options.fontFamily}; + font-size: ${options.fontSize}; + fill: ${options.textColor} + } + + /* Classes common for multiple diagrams */ + + & .error-icon { + fill: ${options.errorBkgColor}; + } + & .error-text { + fill: ${options.errorTextColor}; + stroke: ${options.errorTextColor}; + } + + & .edge-thickness-normal { + stroke-width: 2px; + } + & .edge-thickness-thick { + stroke-width: 3.5px + } + & .edge-pattern-solid { + stroke-dasharray: 0; + } + + & .edge-pattern-dashed{ + stroke-dasharray: 3; + } + .edge-pattern-dotted { + stroke-dasharray: 2; + } + + & .marker { + fill: ${options.lineColor}; + stroke: ${options.lineColor}; + } + & .marker.cross { + stroke: ${options.lineColor}; + } + + & svg { + font-family: ${options.fontFamily}; + font-size: ${options.fontSize}; + } + + ${diagramStyles} + + ${userStyles} +`; +}; +const addStylesForDiagram = (type2, diagramTheme) => { + if (diagramTheme !== void 0) { + themes[type2] = diagramTheme; + } +}; +const getStyles$1 = getStyles; +let accTitle = ""; +let diagramTitle = ""; +let accDescription = ""; +const sanitizeText$1 = (txt) => sanitizeText$2(txt, getConfig$1()); +const clear = () => { + accTitle = ""; + accDescription = ""; + diagramTitle = ""; +}; +const setAccTitle = (txt) => { + accTitle = sanitizeText$1(txt).replace(/^\s+/g, ""); +}; +const getAccTitle = () => accTitle; +const setAccDescription = (txt) => { + accDescription = sanitizeText$1(txt).replace(/\n\s+/g, "\n"); +}; +const getAccDescription = () => accDescription; +const setDiagramTitle = (txt) => { + diagramTitle = sanitizeText$1(txt); +}; +const getDiagramTitle = () => diagramTitle; +const commonDb = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({ + __proto__: null, + clear, + getAccDescription, + getAccTitle, + getDiagramTitle, + setAccDescription, + setAccTitle, + setDiagramTitle +}, Symbol.toStringTag, { value: "Module" })); +const log = log$1; +const setLogLevel = setLogLevel$1; +const getConfig = getConfig$1; +const setConfig = setConfig$1; +const defaultConfig = defaultConfig$1; +const sanitizeText = (text) => sanitizeText$2(text, getConfig()); +const setupGraphViewbox = setupGraphViewbox$1; +const getCommonDb = () => { + return commonDb; +}; +const diagrams = {}; +const registerDiagram = (id2, diagram2, detector2) => { + var _a; + if (diagrams[id2]) { + throw new Error(`Diagram ${id2} already registered.`); + } + diagrams[id2] = diagram2; + if (detector2) { + addDetector(id2, detector2); + } + addStylesForDiagram(id2, diagram2.styles); + (_a = diagram2.injectUtils) == null ? void 0 : _a.call( + diagram2, + log, + setLogLevel, + getConfig, + sanitizeText, + setupGraphViewbox, + getCommonDb(), + () => { + } + ); +}; +const getDiagram = (name) => { + if (name in diagrams) { + return diagrams[name]; + } + throw new DiagramNotFoundError(name); +}; +class DiagramNotFoundError extends Error { + constructor(name) { + super(`Diagram ${name} not found.`); + } +} +const selectSvgElement = (id2) => { + var _a; + const { securityLevel } = getConfig(); + let root = select("body"); + if (securityLevel === "sandbox") { + const sandboxElement = select(`#i${id2}`); + const doc = ((_a = sandboxElement.node()) == null ? void 0 : _a.contentDocument) ?? document; + root = select(doc.body); + } + const svg = root.select(`#${id2}`); + return svg; +}; +const draw = (_text, id2, version2) => { + log$1.debug("rendering svg for syntax error\n"); + const svg = selectSvgElement(id2); + const g = svg.append("g"); + svg.attr("viewBox", "0 0 2412 512"); + configureSvgSize(svg, 100, 512, true); + g.append("path").attr("class", "error-icon").attr( + "d", + "m411.313,123.313c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32-9.375,9.375-20.688-20.688c-12.484-12.5-32.766-12.5-45.25,0l-16,16c-1.261,1.261-2.304,2.648-3.31,4.051-21.739-8.561-45.324-13.426-70.065-13.426-105.867,0-192,86.133-192,192s86.133,192 192,192 192-86.133 192-192c0-24.741-4.864-48.327-13.426-70.065 1.402-1.007 2.79-2.049 4.051-3.31l16-16c12.5-12.492 12.5-32.758 0-45.25l-20.688-20.688 9.375-9.375 32.001-31.999zm-219.313,100.687c-52.938,0-96,43.063-96,96 0,8.836-7.164,16-16,16s-16-7.164-16-16c0-70.578 57.422-128 128-128 8.836,0 16,7.164 16,16s-7.164,16-16,16z" + ); + g.append("path").attr("class", "error-icon").attr( + "d", + "m459.02,148.98c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l16,16c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16.001-16z" + ); + g.append("path").attr("class", "error-icon").attr( + "d", + "m340.395,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688 6.25-6.25 6.25-16.375 0-22.625l-16-16c-6.25-6.25-16.375-6.25-22.625,0s-6.25,16.375 0,22.625l15.999,16z" + ); + g.append("path").attr("class", "error-icon").attr( + "d", + "m400,64c8.844,0 16-7.164 16-16v-32c0-8.836-7.156-16-16-16-8.844,0-16,7.164-16,16v32c0,8.836 7.156,16 16,16z" + ); + g.append("path").attr("class", "error-icon").attr( + "d", + "m496,96.586h-32c-8.844,0-16,7.164-16,16 0,8.836 7.156,16 16,16h32c8.844,0 16-7.164 16-16 0-8.836-7.156-16-16-16z" + ); + g.append("path").attr("class", "error-icon").attr( + "d", + "m436.98,75.605c3.125,3.125 7.219,4.688 11.313,4.688 4.094,0 8.188-1.563 11.313-4.688l32-32c6.25-6.25 6.25-16.375 0-22.625s-16.375-6.25-22.625,0l-32,32c-6.251,6.25-6.251,16.375-0.001,22.625z" + ); + g.append("text").attr("class", "error-text").attr("x", 1440).attr("y", 250).attr("font-size", "150px").style("text-anchor", "middle").text("Syntax error in text"); + g.append("text").attr("class", "error-text").attr("x", 1250).attr("y", 400).attr("font-size", "100px").style("text-anchor", "middle").text(`mermaid version ${version2}`); +}; +const renderer = { draw }; +const errorRenderer = renderer; +const diagram = { + db: {}, + renderer, + parser: { + parser: { yy: {} }, + parse: () => { + return; + } + } +}; +const errorDiagram = diagram; +const id$4 = "flowchart-elk"; +const detector$4 = (txt, config2) => { + var _a; + if ( + // If diagram explicitly states flowchart-elk + /^\s*flowchart-elk/.test(txt) || // If a flowchart/graph diagram has their default renderer set to elk + /^\s*flowchart|graph/.test(txt) && ((_a = config2 == null ? void 0 : config2.flowchart) == null ? void 0 : _a.defaultRenderer) === "elk" + ) { + return true; + } + return false; +}; +const loader$5 = async () => { + const { diagram: diagram2 } = await import("./flowchart-elk-definition-ae0efee6.js"); + return { id: id$4, diagram: diagram2 }; +}; +const plugin$4 = { + id: id$4, + detector: detector$4, + loader: loader$5 +}; +const flowchartElk = plugin$4; +const id$3 = "timeline"; +const detector$3 = (txt) => { + return /^\s*timeline/.test(txt); +}; +const loader$4 = async () => { + const { diagram: diagram2 } = await import("./timeline-definition-bf702344.js"); + return { id: id$3, diagram: diagram2 }; +}; +const plugin$3 = { + id: id$3, + detector: detector$3, + loader: loader$4 +}; +const timeline = plugin$3; +const id$2 = "mindmap"; +const detector$2 = (txt) => { + return /^\s*mindmap/.test(txt); +}; +const loader$3 = async () => { + const { diagram: diagram2 } = await import("./mindmap-definition-307c710a.js"); + return { id: id$2, diagram: diagram2 }; +}; +const plugin$2 = { + id: id$2, + detector: detector$2, + loader: loader$3 +}; +const mindmap = plugin$2; +const id$1 = "sankey"; +const detector$1 = (txt) => { + return /^\s*sankey-beta/.test(txt); +}; +const loader$2 = async () => { + const { diagram: diagram2 } = await import("./sankeyDiagram-707fac0f.js"); + return { id: id$1, diagram: diagram2 }; +}; +const plugin$1 = { + id: id$1, + detector: detector$1, + loader: loader$2 +}; +const sankey = plugin$1; +const id = "block"; +const detector = (txt) => { + return /^\s*block-beta/.test(txt); +}; +const loader$1 = async () => { + const { diagram: diagram2 } = await import("./blockDiagram-9f4a6865.js"); + return { id, diagram: diagram2 }; +}; +const plugin = { + id, + detector, + loader: loader$1 +}; +const block = plugin; +let hasLoadedDiagrams = false; +const addDiagrams = () => { + if (hasLoadedDiagrams) { + return; + } + hasLoadedDiagrams = true; + registerDiagram("error", errorDiagram, (text) => { + return text.toLowerCase().trim() === "error"; + }); + registerDiagram( + "---", + // --- diagram type may appear if YAML front-matter is not parsed correctly + { + db: { + clear: () => { + } + }, + styles: {}, + // should never be used + renderer: { + draw: () => { + } + }, + parser: { + parser: { yy: {} }, + parse: () => { + throw new Error( + "Diagrams beginning with --- are not valid. If you were trying to use a YAML front-matter, please ensure that you've correctly opened and closed the YAML front-matter with un-indented `---` blocks" + ); + } + }, + init: () => null + // no op + }, + (text) => { + return text.toLowerCase().trimStart().startsWith("---"); + } + ); + registerLazyLoadedDiagrams( + c4, + classDiagramV2, + classDiagram, + er, + gantt, + info, + pie, + requirement, + sequence, + flowchartElk, + flowchartV2, + flowchart, + mindmap, + timeline, + git, + stateV2, + state, + journey, + quadrantChart, + sankey, + xychart, + block + ); +}; +class Diagram { + constructor(text, metadata = {}) { + this.text = text; + this.metadata = metadata; + this.type = "graph"; + this.text = encodeEntities(text); + this.text += "\n"; + const cnf = getConfig$1(); + try { + this.type = detectType(text, cnf); + } catch (e) { + this.type = "error"; + this.detectError = e; + } + const diagram2 = getDiagram(this.type); + log$1.debug("Type " + this.type); + this.db = diagram2.db; + this.renderer = diagram2.renderer; + this.parser = diagram2.parser; + this.parser.parser.yy = this.db; + this.init = diagram2.init; + this.parse(); + } + parse() { + var _a, _b, _c, _d, _e; + if (this.detectError) { + throw this.detectError; + } + (_b = (_a = this.db).clear) == null ? void 0 : _b.call(_a); + const config2 = getConfig$1(); + (_c = this.init) == null ? void 0 : _c.call(this, config2); + if (this.metadata.title) { + (_e = (_d = this.db).setDiagramTitle) == null ? void 0 : _e.call(_d, this.metadata.title); + } + this.parser.parse(this.text); + } + async render(id2, version2) { + await this.renderer.draw(this.text, id2, version2, this); + } + getParser() { + return this.parser; + } + getType() { + return this.type; + } +} +const getDiagramFromText$1 = async (text, metadata = {}) => { + const type2 = detectType(text, getConfig$1()); + try { + getDiagram(type2); + } catch (error) { + const loader2 = getDiagramLoader(type2); + if (!loader2) { + throw new UnknownDiagramError(`Diagram ${type2} not found.`); + } + const { id: id2, diagram: diagram2 } = await loader2(); + registerDiagram(id2, diagram2); + } + return new Diagram(text, metadata); +}; +let interactionFunctions = []; +const attachFunctions = () => { + interactionFunctions.forEach((f) => { + f(); + }); + interactionFunctions = []; +}; +const SVG_ROLE = "graphics-document document"; +function setA11yDiagramInfo(svg, diagramType) { + svg.attr("role", SVG_ROLE); + if (diagramType !== "") { + svg.attr("aria-roledescription", diagramType); + } +} +function addSVGa11yTitleDescription(svg, a11yTitle, a11yDesc, baseId) { + if (svg.insert === void 0) { + return; + } + if (a11yDesc) { + const descId = `chart-desc-${baseId}`; + svg.attr("aria-describedby", descId); + svg.insert("desc", ":first-child").attr("id", descId).text(a11yDesc); + } + if (a11yTitle) { + const titleId = `chart-title-${baseId}`; + svg.attr("aria-labelledby", titleId); + svg.insert("title", ":first-child").attr("id", titleId).text(a11yTitle); + } +} +const cleanupComments = (text) => { + return text.replace(/^\s*%%(?!{)[^\n]+\n?/gm, "").trimStart(); +}; +/*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT */ +function isNothing(subject) { + return typeof subject === "undefined" || subject === null; +} +function isObject(subject) { + return typeof subject === "object" && subject !== null; +} +function toArray(sequence2) { + if (Array.isArray(sequence2)) + return sequence2; + else if (isNothing(sequence2)) + return []; + return [sequence2]; +} +function extend(target, source) { + var index, length, key, sourceKeys; + if (source) { + sourceKeys = Object.keys(source); + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + return target; +} +function repeat(string, count) { + var result = "", cycle; + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + return result; +} +function isNegativeZero(number) { + return number === 0 && Number.NEGATIVE_INFINITY === 1 / number; +} +var isNothing_1 = isNothing; +var isObject_1 = isObject; +var toArray_1 = toArray; +var repeat_1 = repeat; +var isNegativeZero_1 = isNegativeZero; +var extend_1 = extend; +var common = { + isNothing: isNothing_1, + isObject: isObject_1, + toArray: toArray_1, + repeat: repeat_1, + isNegativeZero: isNegativeZero_1, + extend: extend_1 +}; +function formatError(exception2, compact) { + var where = "", message = exception2.reason || "(unknown reason)"; + if (!exception2.mark) + return message; + if (exception2.mark.name) { + where += 'in "' + exception2.mark.name + '" '; + } + where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")"; + if (!compact && exception2.mark.snippet) { + where += "\n\n" + exception2.mark.snippet; + } + return message + " " + where; +} +function YAMLException$1(reason, mark) { + Error.call(this); + this.name = "YAMLException"; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } else { + this.stack = new Error().stack || ""; + } +} +YAMLException$1.prototype = Object.create(Error.prototype); +YAMLException$1.prototype.constructor = YAMLException$1; +YAMLException$1.prototype.toString = function toString(compact) { + return this.name + ": " + formatError(this, compact); +}; +var exception = YAMLException$1; +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ""; + var tail = ""; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + if (position - lineStart > maxHalfLength) { + head = " ... "; + lineStart = position - maxHalfLength + head.length; + } + if (lineEnd - position > maxHalfLength) { + tail = " ..."; + lineEnd = position + maxHalfLength - tail.length; + } + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail, + pos: position - lineStart + head.length + // relative position + }; +} +function padStart(string, max) { + return common.repeat(" ", max - string.length) + string; +} +function makeSnippet(mark, options) { + options = Object.create(options || null); + if (!mark.buffer) + return null; + if (!options.maxLength) + options.maxLength = 79; + if (typeof options.indent !== "number") + options.indent = 1; + if (typeof options.linesBefore !== "number") + options.linesBefore = 3; + if (typeof options.linesAfter !== "number") + options.linesAfter = 2; + var re = /\r?\n|\r|\0/g; + var lineStarts = [0]; + var lineEnds = []; + var match; + var foundLineNo = -1; + while (match = re.exec(mark.buffer)) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + if (foundLineNo < 0) + foundLineNo = lineStarts.length - 1; + var result = "", i, line; + var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); + for (i = 1; i <= options.linesBefore; i++) { + if (foundLineNo - i < 0) + break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo - i], + lineEnds[foundLineNo - i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), + maxLineLength + ); + result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result; + } + line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n"; + for (i = 1; i <= options.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) + break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n"; + } + return result.replace(/\n$/, ""); +} +var snippet = makeSnippet; +var TYPE_CONSTRUCTOR_OPTIONS = [ + "kind", + "multi", + "resolve", + "construct", + "instanceOf", + "predicate", + "represent", + "representName", + "defaultStyle", + "styleAliases" +]; +var YAML_NODE_KINDS = [ + "scalar", + "sequence", + "mapping" +]; +function compileStyleAliases(map2) { + var result = {}; + if (map2 !== null) { + Object.keys(map2).forEach(function(style) { + map2[style].forEach(function(alias) { + result[String(alias)] = style; + }); + }); + } + return result; +} +function Type$1(tag, options) { + options = options || {}; + Object.keys(options).forEach(function(name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + this.options = options; + this.tag = tag; + this.kind = options["kind"] || null; + this.resolve = options["resolve"] || function() { + return true; + }; + this.construct = options["construct"] || function(data) { + return data; + }; + this.instanceOf = options["instanceOf"] || null; + this.predicate = options["predicate"] || null; + this.represent = options["represent"] || null; + this.representName = options["representName"] || null; + this.defaultStyle = options["defaultStyle"] || null; + this.multi = options["multi"] || false; + this.styleAliases = compileStyleAliases(options["styleAliases"] || null); + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} +var type = Type$1; +function compileList(schema2, name) { + var result = []; + schema2[name].forEach(function(currentType) { + var newIndex = result.length; + result.forEach(function(previousType, previousIndex) { + if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) { + newIndex = previousIndex; + } + }); + result[newIndex] = currentType; + }); + return result; +} +function compileMap() { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] + } + }, index, length; + function collectType(type2) { + if (type2.multi) { + result.multi[type2.kind].push(type2); + result.multi["fallback"].push(type2); + } else { + result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2; + } + } + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} +function Schema$1(definition) { + return this.extend(definition); +} +Schema$1.prototype.extend = function extend2(definition) { + var implicit = []; + var explicit = []; + if (definition instanceof type) { + explicit.push(definition); + } else if (Array.isArray(definition)) { + explicit = explicit.concat(definition); + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + if (definition.implicit) + implicit = implicit.concat(definition.implicit); + if (definition.explicit) + explicit = explicit.concat(definition.explicit); + } else { + throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })"); + } + implicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + if (type$1.loadKind && type$1.loadKind !== "scalar") { + throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported."); + } + if (type$1.multi) { + throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit."); + } + }); + explicit.forEach(function(type$1) { + if (!(type$1 instanceof type)) { + throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object."); + } + }); + var result = Object.create(Schema$1.prototype); + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); + result.compiledImplicit = compileList(result, "implicit"); + result.compiledExplicit = compileList(result, "explicit"); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); + return result; +}; +var schema = Schema$1; +var str = new type("tag:yaml.org,2002:str", { + kind: "scalar", + construct: function(data) { + return data !== null ? data : ""; + } +}); +var seq = new type("tag:yaml.org,2002:seq", { + kind: "sequence", + construct: function(data) { + return data !== null ? data : []; + } +}); +var map = new type("tag:yaml.org,2002:map", { + kind: "mapping", + construct: function(data) { + return data !== null ? data : {}; + } +}); +var failsafe = new schema({ + explicit: [ + str, + seq, + map + ] +}); +function resolveYamlNull(data) { + if (data === null) + return true; + var max = data.length; + return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL"); +} +function constructYamlNull() { + return null; +} +function isNull(object) { + return object === null; +} +var _null = new type("tag:yaml.org,2002:null", { + kind: "scalar", + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function() { + return "~"; + }, + lowercase: function() { + return "null"; + }, + uppercase: function() { + return "NULL"; + }, + camelcase: function() { + return "Null"; + }, + empty: function() { + return ""; + } + }, + defaultStyle: "lowercase" +}); +function resolveYamlBoolean(data) { + if (data === null) + return false; + var max = data.length; + return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE"); +} +function constructYamlBoolean(data) { + return data === "true" || data === "True" || data === "TRUE"; +} +function isBoolean(object) { + return Object.prototype.toString.call(object) === "[object Boolean]"; +} +var bool = new type("tag:yaml.org,2002:bool", { + kind: "scalar", + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function(object) { + return object ? "true" : "false"; + }, + uppercase: function(object) { + return object ? "TRUE" : "FALSE"; + }, + camelcase: function(object) { + return object ? "True" : "False"; + } + }, + defaultStyle: "lowercase" +}); +function isHexCode(c) { + return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102; +} +function isOctCode(c) { + return 48 <= c && c <= 55; +} +function isDecCode(c) { + return 48 <= c && c <= 57; +} +function resolveYamlInteger(data) { + if (data === null) + return false; + var max = data.length, index = 0, hasDigits = false, ch; + if (!max) + return false; + ch = data[index]; + if (ch === "-" || ch === "+") { + ch = data[++index]; + } + if (ch === "0") { + if (index + 1 === max) + return true; + ch = data[++index]; + if (ch === "b") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (ch !== "0" && ch !== "1") + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "x") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isHexCode(data.charCodeAt(index))) + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "o") { + index++; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isOctCode(data.charCodeAt(index))) + return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + } + if (ch === "_") + return false; + for (; index < max; index++) { + ch = data[index]; + if (ch === "_") + continue; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + if (!hasDigits || ch === "_") + return false; + return true; +} +function constructYamlInteger(data) { + var value = data, sign = 1, ch; + if (value.indexOf("_") !== -1) { + value = value.replace(/_/g, ""); + } + ch = value[0]; + if (ch === "-" || ch === "+") { + if (ch === "-") + sign = -1; + value = value.slice(1); + ch = value[0]; + } + if (value === "0") + return 0; + if (ch === "0") { + if (value[1] === "b") + return sign * parseInt(value.slice(2), 2); + if (value[1] === "x") + return sign * parseInt(value.slice(2), 16); + if (value[1] === "o") + return sign * parseInt(value.slice(2), 8); + } + return sign * parseInt(value, 10); +} +function isInteger(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 === 0 && !common.isNegativeZero(object)); +} +var int = new type("tag:yaml.org,2002:int", { + kind: "scalar", + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function(obj) { + return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); + }, + octal: function(obj) { + return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1); + }, + decimal: function(obj) { + return obj.toString(10); + }, + /* eslint-disable max-len */ + hexadecimal: function(obj) { + return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); + } + }, + defaultStyle: "decimal", + styleAliases: { + binary: [2, "bin"], + octal: [8, "oct"], + decimal: [10, "dec"], + hexadecimal: [16, "hex"] + } +}); +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$" +); +function resolveYamlFloat(data) { + if (data === null) + return false; + if (!YAML_FLOAT_PATTERN.test(data) || // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === "_") { + return false; + } + return true; +} +function constructYamlFloat(data) { + var value, sign; + value = data.replace(/_/g, "").toLowerCase(); + sign = value[0] === "-" ? -1 : 1; + if ("+-".indexOf(value[0]) >= 0) { + value = value.slice(1); + } + if (value === ".inf") { + return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + } else if (value === ".nan") { + return NaN; + } + return sign * parseFloat(value, 10); +} +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; +function representYamlFloat(object, style) { + var res; + if (isNaN(object)) { + switch (style) { + case "lowercase": + return ".nan"; + case "uppercase": + return ".NAN"; + case "camelcase": + return ".NaN"; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return ".inf"; + case "uppercase": + return ".INF"; + case "camelcase": + return ".Inf"; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case "lowercase": + return "-.inf"; + case "uppercase": + return "-.INF"; + case "camelcase": + return "-.Inf"; + } + } else if (common.isNegativeZero(object)) { + return "-0.0"; + } + res = object.toString(10); + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res; +} +function isFloat(object) { + return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object)); +} +var float = new type("tag:yaml.org,2002:float", { + kind: "scalar", + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: "lowercase" +}); +var json = failsafe.extend({ + implicit: [ + _null, + bool, + int, + float + ] +}); +var core = json; +var YAML_DATE_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$" +); +var YAML_TIMESTAMP_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$" +); +function resolveYamlTimestamp(data) { + if (data === null) + return false; + if (YAML_DATE_REGEXP.exec(data) !== null) + return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) + return true; + return false; +} +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date; + match = YAML_DATE_REGEXP.exec(data); + if (match === null) + match = YAML_TIMESTAMP_REGEXP.exec(data); + if (match === null) + throw new Error("Date resolve error"); + year = +match[1]; + month = +match[2] - 1; + day = +match[3]; + if (!match[4]) { + return new Date(Date.UTC(year, month, day)); + } + hour = +match[4]; + minute = +match[5]; + second = +match[6]; + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { + fraction += "0"; + } + fraction = +fraction; + } + if (match[9]) { + tz_hour = +match[10]; + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 6e4; + if (match[9] === "-") + delta = -delta; + } + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + if (delta) + date.setTime(date.getTime() - delta); + return date; +} +function representYamlTimestamp(object) { + return object.toISOString(); +} +var timestamp = new type("tag:yaml.org,2002:timestamp", { + kind: "scalar", + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); +function resolveYamlMerge(data) { + return data === "<<" || data === null; +} +var merge = new type("tag:yaml.org,2002:merge", { + kind: "scalar", + resolve: resolveYamlMerge +}); +var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r"; +function resolveYamlBinary(data) { + if (data === null) + return false; + var code, idx, bitlen = 0, max = data.length, map2 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + code = map2.indexOf(data.charAt(idx)); + if (code > 64) + continue; + if (code < 0) + return false; + bitlen += 6; + } + return bitlen % 8 === 0; +} +function constructYamlBinary(data) { + var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = []; + for (idx = 0; idx < max; idx++) { + if (idx % 4 === 0 && idx) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } + bits = bits << 6 | map2.indexOf(input.charAt(idx)); + } + tailbits = max % 4 * 6; + if (tailbits === 0) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } else if (tailbits === 18) { + result.push(bits >> 10 & 255); + result.push(bits >> 2 & 255); + } else if (tailbits === 12) { + result.push(bits >> 4 & 255); + } + return new Uint8Array(result); +} +function representYamlBinary(object) { + var result = "", bits = 0, idx, tail, max = object.length, map2 = BASE64_MAP; + for (idx = 0; idx < max; idx++) { + if (idx % 3 === 0 && idx) { + result += map2[bits >> 18 & 63]; + result += map2[bits >> 12 & 63]; + result += map2[bits >> 6 & 63]; + result += map2[bits & 63]; + } + bits = (bits << 8) + object[idx]; + } + tail = max % 3; + if (tail === 0) { + result += map2[bits >> 18 & 63]; + result += map2[bits >> 12 & 63]; + result += map2[bits >> 6 & 63]; + result += map2[bits & 63]; + } else if (tail === 2) { + result += map2[bits >> 10 & 63]; + result += map2[bits >> 4 & 63]; + result += map2[bits << 2 & 63]; + result += map2[64]; + } else if (tail === 1) { + result += map2[bits >> 2 & 63]; + result += map2[bits << 4 & 63]; + result += map2[64]; + result += map2[64]; + } + return result; +} +function isBinary(obj) { + return Object.prototype.toString.call(obj) === "[object Uint8Array]"; +} +var binary = new type("tag:yaml.org,2002:binary", { + kind: "scalar", + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); +var _hasOwnProperty$3 = Object.prototype.hasOwnProperty; +var _toString$2 = Object.prototype.toString; +function resolveYamlOmap(data) { + if (data === null) + return true; + var objectKeys = [], index, length, pair, pairKey, pairHasKey, object = data; + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + if (_toString$2.call(pair) !== "[object Object]") + return false; + for (pairKey in pair) { + if (_hasOwnProperty$3.call(pair, pairKey)) { + if (!pairHasKey) + pairHasKey = true; + else + return false; + } + } + if (!pairHasKey) + return false; + if (objectKeys.indexOf(pairKey) === -1) + objectKeys.push(pairKey); + else + return false; + } + return true; +} +function constructYamlOmap(data) { + return data !== null ? data : []; +} +var omap = new type("tag:yaml.org,2002:omap", { + kind: "sequence", + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); +var _toString$1 = Object.prototype.toString; +function resolveYamlPairs(data) { + if (data === null) + return true; + var index, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + if (_toString$1.call(pair) !== "[object Object]") + return false; + keys = Object.keys(pair); + if (keys.length !== 1) + return false; + result[index] = [keys[0], pair[keys[0]]]; + } + return true; +} +function constructYamlPairs(data) { + if (data === null) + return []; + var index, length, pair, keys, result, object = data; + result = new Array(object.length); + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + keys = Object.keys(pair); + result[index] = [keys[0], pair[keys[0]]]; + } + return result; +} +var pairs = new type("tag:yaml.org,2002:pairs", { + kind: "sequence", + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); +var _hasOwnProperty$2 = Object.prototype.hasOwnProperty; +function resolveYamlSet(data) { + if (data === null) + return true; + var key, object = data; + for (key in object) { + if (_hasOwnProperty$2.call(object, key)) { + if (object[key] !== null) + return false; + } + } + return true; +} +function constructYamlSet(data) { + return data !== null ? data : {}; +} +var set = new type("tag:yaml.org,2002:set", { + kind: "mapping", + resolve: resolveYamlSet, + construct: constructYamlSet +}); +var _default = core.extend({ + implicit: [ + timestamp, + merge + ], + explicit: [ + binary, + omap, + pairs, + set + ] +}); +var _hasOwnProperty$1 = Object.prototype.hasOwnProperty; +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; +function _class(obj) { + return Object.prototype.toString.call(obj); +} +function is_EOL(c) { + return c === 10 || c === 13; +} +function is_WHITE_SPACE(c) { + return c === 9 || c === 32; +} +function is_WS_OR_EOL(c) { + return c === 9 || c === 32 || c === 10 || c === 13; +} +function is_FLOW_INDICATOR(c) { + return c === 44 || c === 91 || c === 93 || c === 123 || c === 125; +} +function fromHexCode(c) { + var lc; + if (48 <= c && c <= 57) { + return c - 48; + } + lc = c | 32; + if (97 <= lc && lc <= 102) { + return lc - 97 + 10; + } + return -1; +} +function escapedHexLen(c) { + if (c === 120) { + return 2; + } + if (c === 117) { + return 4; + } + if (c === 85) { + return 8; + } + return 0; +} +function fromDecimalCode(c) { + if (48 <= c && c <= 57) { + return c - 48; + } + return -1; +} +function simpleEscapeSequence(c) { + return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? " " : c === 9 ? " " : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "…" : c === 95 ? " " : c === 76 ? "\u2028" : c === 80 ? "\u2029" : ""; +} +function charFromCodepoint(c) { + if (c <= 65535) { + return String.fromCharCode(c); + } + return String.fromCharCode( + (c - 65536 >> 10) + 55296, + (c - 65536 & 1023) + 56320 + ); +} +var simpleEscapeCheck = new Array(256); +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} +function State$1(input, options) { + this.input = input; + this.filename = options["filename"] || null; + this.schema = options["schema"] || _default; + this.onWarning = options["onWarning"] || null; + this.legacy = options["legacy"] || false; + this.json = options["json"] || false; + this.listener = options["listener"] || null; + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + this.firstTabInLine = -1; + this.documents = []; +} +function generateError(state2, message) { + var mark = { + name: state2.filename, + buffer: state2.input.slice(0, -1), + // omit trailing \0 + position: state2.position, + line: state2.line, + column: state2.position - state2.lineStart + }; + mark.snippet = snippet(mark); + return new exception(message, mark); +} +function throwError(state2, message) { + throw generateError(state2, message); +} +function throwWarning(state2, message) { + if (state2.onWarning) { + state2.onWarning.call(null, generateError(state2, message)); + } +} +var directiveHandlers = { + YAML: function handleYamlDirective(state2, name, args) { + var match, major, minor; + if (state2.version !== null) { + throwError(state2, "duplication of %YAML directive"); + } + if (args.length !== 1) { + throwError(state2, "YAML directive accepts exactly one argument"); + } + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + if (match === null) { + throwError(state2, "ill-formed argument of the YAML directive"); + } + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + if (major !== 1) { + throwError(state2, "unacceptable YAML version of the document"); + } + state2.version = args[0]; + state2.checkLineBreaks = minor < 2; + if (minor !== 1 && minor !== 2) { + throwWarning(state2, "unsupported YAML version of the document"); + } + }, + TAG: function handleTagDirective(state2, name, args) { + var handle, prefix; + if (args.length !== 2) { + throwError(state2, "TAG directive accepts exactly two arguments"); + } + handle = args[0]; + prefix = args[1]; + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state2, "ill-formed tag handle (first argument) of the TAG directive"); + } + if (_hasOwnProperty$1.call(state2.tagMap, handle)) { + throwError(state2, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state2, "ill-formed tag prefix (second argument) of the TAG directive"); + } + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state2, "tag prefix is malformed: " + prefix); + } + state2.tagMap[handle] = prefix; + } +}; +function captureSegment(state2, start, end, checkJson) { + var _position, _length, _character, _result; + if (start < end) { + _result = state2.input.slice(start, end); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 9 || 32 <= _character && _character <= 1114111)) { + throwError(state2, "expected valid JSON character"); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state2, "the stream contains non-printable characters"); + } + state2.result += _result; + } +} +function mergeMappings(state2, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + if (!common.isObject(source)) { + throwError(state2, "cannot merge mappings; the provided source object is unacceptable"); + } + sourceKeys = Object.keys(source); + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + if (!_hasOwnProperty$1.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} +function storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) { + var index, quantity; + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state2, "nested arrays are not supported inside keys"); + } + if (typeof keyNode === "object" && _class(keyNode[index]) === "[object Object]") { + keyNode[index] = "[object Object]"; + } + } + } + if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") { + keyNode = "[object Object]"; + } + keyNode = String(keyNode); + if (_result === null) { + _result = {}; + } + if (keyTag === "tag:yaml.org,2002:merge") { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state2, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state2, _result, valueNode, overridableKeys); + } + } else { + if (!state2.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) { + state2.line = startLine || state2.line; + state2.lineStart = startLineStart || state2.lineStart; + state2.position = startPos || state2.position; + throwError(state2, "duplicated mapping key"); + } + if (keyNode === "__proto__") { + Object.defineProperty(_result, keyNode, { + configurable: true, + enumerable: true, + writable: true, + value: valueNode + }); + } else { + _result[keyNode] = valueNode; + } + delete overridableKeys[keyNode]; + } + return _result; +} +function readLineBreak(state2) { + var ch; + ch = state2.input.charCodeAt(state2.position); + if (ch === 10) { + state2.position++; + } else if (ch === 13) { + state2.position++; + if (state2.input.charCodeAt(state2.position) === 10) { + state2.position++; + } + } else { + throwError(state2, "a line break is expected"); + } + state2.line += 1; + state2.lineStart = state2.position; + state2.firstTabInLine = -1; +} +function skipSeparationSpace(state2, allowComments, checkIndent) { + var lineBreaks = 0, ch = state2.input.charCodeAt(state2.position); + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 9 && state2.firstTabInLine === -1) { + state2.firstTabInLine = state2.position; + } + ch = state2.input.charCodeAt(++state2.position); + } + if (allowComments && ch === 35) { + do { + ch = state2.input.charCodeAt(++state2.position); + } while (ch !== 10 && ch !== 13 && ch !== 0); + } + if (is_EOL(ch)) { + readLineBreak(state2); + ch = state2.input.charCodeAt(state2.position); + lineBreaks++; + state2.lineIndent = 0; + while (ch === 32) { + state2.lineIndent++; + ch = state2.input.charCodeAt(++state2.position); + } + } else { + break; + } + } + if (checkIndent !== -1 && lineBreaks !== 0 && state2.lineIndent < checkIndent) { + throwWarning(state2, "deficient indentation"); + } + return lineBreaks; +} +function testDocumentSeparator(state2) { + var _position = state2.position, ch; + ch = state2.input.charCodeAt(_position); + if ((ch === 45 || ch === 46) && ch === state2.input.charCodeAt(_position + 1) && ch === state2.input.charCodeAt(_position + 2)) { + _position += 3; + ch = state2.input.charCodeAt(_position); + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + return false; +} +function writeFoldedLines(state2, count) { + if (count === 1) { + state2.result += " "; + } else if (count > 1) { + state2.result += common.repeat("\n", count - 1); + } +} +function readPlainScalar(state2, nodeIndent, withinFlowCollection) { + var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state2.kind, _result = state2.result, ch; + ch = state2.input.charCodeAt(state2.position); + if (is_WS_OR_EOL(ch) || is_FLOW_INDICATOR(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) { + return false; + } + if (ch === 63 || ch === 45) { + following = state2.input.charCodeAt(state2.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + state2.kind = "scalar"; + state2.result = ""; + captureStart = captureEnd = state2.position; + hasPendingContent = false; + while (ch !== 0) { + if (ch === 58) { + following = state2.input.charCodeAt(state2.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + } else if (ch === 35) { + preceding = state2.input.charCodeAt(state2.position - 1); + if (is_WS_OR_EOL(preceding)) { + break; + } + } else if (state2.position === state2.lineStart && testDocumentSeparator(state2) || withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + } else if (is_EOL(ch)) { + _line = state2.line; + _lineStart = state2.lineStart; + _lineIndent = state2.lineIndent; + skipSeparationSpace(state2, false, -1); + if (state2.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state2.input.charCodeAt(state2.position); + continue; + } else { + state2.position = captureEnd; + state2.line = _line; + state2.lineStart = _lineStart; + state2.lineIndent = _lineIndent; + break; + } + } + if (hasPendingContent) { + captureSegment(state2, captureStart, captureEnd, false); + writeFoldedLines(state2, state2.line - _line); + captureStart = captureEnd = state2.position; + hasPendingContent = false; + } + if (!is_WHITE_SPACE(ch)) { + captureEnd = state2.position + 1; + } + ch = state2.input.charCodeAt(++state2.position); + } + captureSegment(state2, captureStart, captureEnd, false); + if (state2.result) { + return true; + } + state2.kind = _kind; + state2.result = _result; + return false; +} +function readSingleQuotedScalar(state2, nodeIndent) { + var ch, captureStart, captureEnd; + ch = state2.input.charCodeAt(state2.position); + if (ch !== 39) { + return false; + } + state2.kind = "scalar"; + state2.result = ""; + state2.position++; + captureStart = captureEnd = state2.position; + while ((ch = state2.input.charCodeAt(state2.position)) !== 0) { + if (ch === 39) { + captureSegment(state2, captureStart, state2.position, true); + ch = state2.input.charCodeAt(++state2.position); + if (ch === 39) { + captureStart = state2.position; + state2.position++; + captureEnd = state2.position; + } else { + return true; + } + } else if (is_EOL(ch)) { + captureSegment(state2, captureStart, captureEnd, true); + writeFoldedLines(state2, skipSeparationSpace(state2, false, nodeIndent)); + captureStart = captureEnd = state2.position; + } else if (state2.position === state2.lineStart && testDocumentSeparator(state2)) { + throwError(state2, "unexpected end of the document within a single quoted scalar"); + } else { + state2.position++; + captureEnd = state2.position; + } + } + throwError(state2, "unexpected end of the stream within a single quoted scalar"); +} +function readDoubleQuotedScalar(state2, nodeIndent) { + var captureStart, captureEnd, hexLength, hexResult, tmp, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch !== 34) { + return false; + } + state2.kind = "scalar"; + state2.result = ""; + state2.position++; + captureStart = captureEnd = state2.position; + while ((ch = state2.input.charCodeAt(state2.position)) !== 0) { + if (ch === 34) { + captureSegment(state2, captureStart, state2.position, true); + state2.position++; + return true; + } else if (ch === 92) { + captureSegment(state2, captureStart, state2.position, true); + ch = state2.input.charCodeAt(++state2.position); + if (is_EOL(ch)) { + skipSeparationSpace(state2, false, nodeIndent); + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state2.result += simpleEscapeMap[ch]; + state2.position++; + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + for (; hexLength > 0; hexLength--) { + ch = state2.input.charCodeAt(++state2.position); + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + } else { + throwError(state2, "expected hexadecimal character"); + } + } + state2.result += charFromCodepoint(hexResult); + state2.position++; + } else { + throwError(state2, "unknown escape sequence"); + } + captureStart = captureEnd = state2.position; + } else if (is_EOL(ch)) { + captureSegment(state2, captureStart, captureEnd, true); + writeFoldedLines(state2, skipSeparationSpace(state2, false, nodeIndent)); + captureStart = captureEnd = state2.position; + } else if (state2.position === state2.lineStart && testDocumentSeparator(state2)) { + throwError(state2, "unexpected end of the document within a double quoted scalar"); + } else { + state2.position++; + captureEnd = state2.position; + } + } + throwError(state2, "unexpected end of the stream within a double quoted scalar"); +} +function readFlowCollection(state2, nodeIndent) { + var readNext = true, _line, _lineStart, _pos, _tag = state2.tag, _result, _anchor = state2.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch === 91) { + terminator = 93; + isMapping = false; + _result = []; + } else if (ch === 123) { + terminator = 125; + isMapping = true; + _result = {}; + } else { + return false; + } + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = _result; + } + ch = state2.input.charCodeAt(++state2.position); + while (ch !== 0) { + skipSeparationSpace(state2, true, nodeIndent); + ch = state2.input.charCodeAt(state2.position); + if (ch === terminator) { + state2.position++; + state2.tag = _tag; + state2.anchor = _anchor; + state2.kind = isMapping ? "mapping" : "sequence"; + state2.result = _result; + return true; + } else if (!readNext) { + throwError(state2, "missed comma between flow collection entries"); + } else if (ch === 44) { + throwError(state2, "expected the node content, but found ','"); + } + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + if (ch === 63) { + following = state2.input.charCodeAt(state2.position + 1); + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state2.position++; + skipSeparationSpace(state2, true, nodeIndent); + } + } + _line = state2.line; + _lineStart = state2.lineStart; + _pos = state2.position; + composeNode(state2, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state2.tag; + keyNode = state2.result; + skipSeparationSpace(state2, true, nodeIndent); + ch = state2.input.charCodeAt(state2.position); + if ((isExplicitPair || state2.line === _line) && ch === 58) { + isPair = true; + ch = state2.input.charCodeAt(++state2.position); + skipSeparationSpace(state2, true, nodeIndent); + composeNode(state2, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state2.result; + } + if (isMapping) { + storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state2, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + skipSeparationSpace(state2, true, nodeIndent); + ch = state2.input.charCodeAt(state2.position); + if (ch === 44) { + readNext = true; + ch = state2.input.charCodeAt(++state2.position); + } else { + readNext = false; + } + } + throwError(state2, "unexpected end of the stream within a flow collection"); +} +function readBlockScalar(state2, nodeIndent) { + var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch === 124) { + folding = false; + } else if (ch === 62) { + folding = true; + } else { + return false; + } + state2.kind = "scalar"; + state2.result = ""; + while (ch !== 0) { + ch = state2.input.charCodeAt(++state2.position); + if (ch === 43 || ch === 45) { + if (CHOMPING_CLIP === chomping) { + chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state2, "repeat of a chomping mode identifier"); + } + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state2, "bad explicit indentation width of a block scalar; it cannot be less than one"); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state2, "repeat of an indentation width identifier"); + } + } else { + break; + } + } + if (is_WHITE_SPACE(ch)) { + do { + ch = state2.input.charCodeAt(++state2.position); + } while (is_WHITE_SPACE(ch)); + if (ch === 35) { + do { + ch = state2.input.charCodeAt(++state2.position); + } while (!is_EOL(ch) && ch !== 0); + } + } + while (ch !== 0) { + readLineBreak(state2); + state2.lineIndent = 0; + ch = state2.input.charCodeAt(state2.position); + while ((!detectedIndent || state2.lineIndent < textIndent) && ch === 32) { + state2.lineIndent++; + ch = state2.input.charCodeAt(++state2.position); + } + if (!detectedIndent && state2.lineIndent > textIndent) { + textIndent = state2.lineIndent; + } + if (is_EOL(ch)) { + emptyLines++; + continue; + } + if (state2.lineIndent < textIndent) { + if (chomping === CHOMPING_KEEP) { + state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { + state2.result += "\n"; + } + } + break; + } + if (folding) { + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + state2.result += common.repeat("\n", emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) { + state2.result += " "; + } + } else { + state2.result += common.repeat("\n", emptyLines); + } + } else { + state2.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state2.position; + while (!is_EOL(ch) && ch !== 0) { + ch = state2.input.charCodeAt(++state2.position); + } + captureSegment(state2, captureStart, state2.position, false); + } + return true; +} +function readBlockSequence(state2, nodeIndent) { + var _line, _tag = state2.tag, _anchor = state2.anchor, _result = [], following, detected = false, ch; + if (state2.firstTabInLine !== -1) + return false; + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = _result; + } + ch = state2.input.charCodeAt(state2.position); + while (ch !== 0) { + if (state2.firstTabInLine !== -1) { + state2.position = state2.firstTabInLine; + throwError(state2, "tab characters must not be used in indentation"); + } + if (ch !== 45) { + break; + } + following = state2.input.charCodeAt(state2.position + 1); + if (!is_WS_OR_EOL(following)) { + break; + } + detected = true; + state2.position++; + if (skipSeparationSpace(state2, true, -1)) { + if (state2.lineIndent <= nodeIndent) { + _result.push(null); + ch = state2.input.charCodeAt(state2.position); + continue; + } + } + _line = state2.line; + composeNode(state2, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state2.result); + skipSeparationSpace(state2, true, -1); + ch = state2.input.charCodeAt(state2.position); + if ((state2.line === _line || state2.lineIndent > nodeIndent) && ch !== 0) { + throwError(state2, "bad indentation of a sequence entry"); + } else if (state2.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state2.tag = _tag; + state2.anchor = _anchor; + state2.kind = "sequence"; + state2.result = _result; + return true; + } + return false; +} +function readBlockMapping(state2, nodeIndent, flowIndent) { + var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state2.tag, _anchor = state2.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; + if (state2.firstTabInLine !== -1) + return false; + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = _result; + } + ch = state2.input.charCodeAt(state2.position); + while (ch !== 0) { + if (!atExplicitKey && state2.firstTabInLine !== -1) { + state2.position = state2.firstTabInLine; + throwError(state2, "tab characters must not be used in indentation"); + } + following = state2.input.charCodeAt(state2.position + 1); + _line = state2.line; + if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) { + if (ch === 63) { + if (atExplicitKey) { + storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = true; + allowCompact = true; + } else if (atExplicitKey) { + atExplicitKey = false; + allowCompact = true; + } else { + throwError(state2, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); + } + state2.position += 1; + ch = following; + } else { + _keyLine = state2.line; + _keyLineStart = state2.lineStart; + _keyPos = state2.position; + if (!composeNode(state2, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + break; + } + if (state2.line === _line) { + ch = state2.input.charCodeAt(state2.position); + while (is_WHITE_SPACE(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + if (ch === 58) { + ch = state2.input.charCodeAt(++state2.position); + if (!is_WS_OR_EOL(ch)) { + throwError(state2, "a whitespace character is expected after the key-value separator within a block mapping"); + } + if (atExplicitKey) { + storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state2.tag; + keyNode = state2.result; + } else if (detected) { + throwError(state2, "can not read an implicit mapping pair; a colon is missed"); + } else { + state2.tag = _tag; + state2.anchor = _anchor; + return true; + } + } else if (detected) { + throwError(state2, "can not read a block mapping entry; a multiline key may not be an implicit key"); + } else { + state2.tag = _tag; + state2.anchor = _anchor; + return true; + } + } + if (state2.line === _line || state2.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state2.line; + _keyLineStart = state2.lineStart; + _keyPos = state2.position; + } + if (composeNode(state2, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state2.result; + } else { + valueNode = state2.result; + } + } + if (!atExplicitKey) { + storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + skipSeparationSpace(state2, true, -1); + ch = state2.input.charCodeAt(state2.position); + } + if ((state2.line === _line || state2.lineIndent > nodeIndent) && ch !== 0) { + throwError(state2, "bad indentation of a mapping entry"); + } else if (state2.lineIndent < nodeIndent) { + break; + } + } + if (atExplicitKey) { + storeMappingPair(state2, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + if (detected) { + state2.tag = _tag; + state2.anchor = _anchor; + state2.kind = "mapping"; + state2.result = _result; + } + return detected; +} +function readTagProperty(state2) { + var _position, isVerbatim = false, isNamed = false, tagHandle, tagName, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch !== 33) + return false; + if (state2.tag !== null) { + throwError(state2, "duplication of a tag property"); + } + ch = state2.input.charCodeAt(++state2.position); + if (ch === 60) { + isVerbatim = true; + ch = state2.input.charCodeAt(++state2.position); + } else if (ch === 33) { + isNamed = true; + tagHandle = "!!"; + ch = state2.input.charCodeAt(++state2.position); + } else { + tagHandle = "!"; + } + _position = state2.position; + if (isVerbatim) { + do { + ch = state2.input.charCodeAt(++state2.position); + } while (ch !== 0 && ch !== 62); + if (state2.position < state2.length) { + tagName = state2.input.slice(_position, state2.position); + ch = state2.input.charCodeAt(++state2.position); + } else { + throwError(state2, "unexpected end of the stream within a verbatim tag"); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + if (ch === 33) { + if (!isNamed) { + tagHandle = state2.input.slice(_position - 1, state2.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state2, "named tag handle cannot contain such characters"); + } + isNamed = true; + _position = state2.position + 1; + } else { + throwError(state2, "tag suffix cannot contain exclamation marks"); + } + } + ch = state2.input.charCodeAt(++state2.position); + } + tagName = state2.input.slice(_position, state2.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state2, "tag suffix cannot contain flow indicator characters"); + } + } + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state2, "tag name cannot contain such characters: " + tagName); + } + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state2, "tag name is malformed: " + tagName); + } + if (isVerbatim) { + state2.tag = tagName; + } else if (_hasOwnProperty$1.call(state2.tagMap, tagHandle)) { + state2.tag = state2.tagMap[tagHandle] + tagName; + } else if (tagHandle === "!") { + state2.tag = "!" + tagName; + } else if (tagHandle === "!!") { + state2.tag = "tag:yaml.org,2002:" + tagName; + } else { + throwError(state2, 'undeclared tag handle "' + tagHandle + '"'); + } + return true; +} +function readAnchorProperty(state2) { + var _position, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch !== 38) + return false; + if (state2.anchor !== null) { + throwError(state2, "duplication of an anchor property"); + } + ch = state2.input.charCodeAt(++state2.position); + _position = state2.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + if (state2.position === _position) { + throwError(state2, "name of an anchor node must contain at least one character"); + } + state2.anchor = state2.input.slice(_position, state2.position); + return true; +} +function readAlias(state2) { + var _position, alias, ch; + ch = state2.input.charCodeAt(state2.position); + if (ch !== 42) + return false; + ch = state2.input.charCodeAt(++state2.position); + _position = state2.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + if (state2.position === _position) { + throwError(state2, "name of an alias node must contain at least one character"); + } + alias = state2.input.slice(_position, state2.position); + if (!_hasOwnProperty$1.call(state2.anchorMap, alias)) { + throwError(state2, 'unidentified alias "' + alias + '"'); + } + state2.result = state2.anchorMap[alias]; + skipSeparationSpace(state2, true, -1); + return true; +} +function composeNode(state2, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type2, flowIndent, blockIndent; + if (state2.listener !== null) { + state2.listener("open", state2); + } + state2.tag = null; + state2.anchor = null; + state2.kind = null; + state2.result = null; + allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; + if (allowToSeek) { + if (skipSeparationSpace(state2, true, -1)) { + atNewLine = true; + if (state2.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state2.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state2.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + if (indentStatus === 1) { + while (readTagProperty(state2) || readAnchorProperty(state2)) { + if (skipSeparationSpace(state2, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state2.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state2.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state2.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + blockIndent = state2.position - state2.lineStart; + if (indentStatus === 1) { + if (allowBlockCollections && (readBlockSequence(state2, blockIndent) || readBlockMapping(state2, blockIndent, flowIndent)) || readFlowCollection(state2, flowIndent)) { + hasContent = true; + } else { + if (allowBlockScalars && readBlockScalar(state2, flowIndent) || readSingleQuotedScalar(state2, flowIndent) || readDoubleQuotedScalar(state2, flowIndent)) { + hasContent = true; + } else if (readAlias(state2)) { + hasContent = true; + if (state2.tag !== null || state2.anchor !== null) { + throwError(state2, "alias node should not have any properties"); + } + } else if (readPlainScalar(state2, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + if (state2.tag === null) { + state2.tag = "?"; + } + } + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = state2.result; + } + } + } else if (indentStatus === 0) { + hasContent = allowBlockCollections && readBlockSequence(state2, blockIndent); + } + } + if (state2.tag === null) { + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = state2.result; + } + } else if (state2.tag === "?") { + if (state2.result !== null && state2.kind !== "scalar") { + throwError(state2, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state2.kind + '"'); + } + for (typeIndex = 0, typeQuantity = state2.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type2 = state2.implicitTypes[typeIndex]; + if (type2.resolve(state2.result)) { + state2.result = type2.construct(state2.result); + state2.tag = type2.tag; + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = state2.result; + } + break; + } + } + } else if (state2.tag !== "!") { + if (_hasOwnProperty$1.call(state2.typeMap[state2.kind || "fallback"], state2.tag)) { + type2 = state2.typeMap[state2.kind || "fallback"][state2.tag]; + } else { + type2 = null; + typeList = state2.typeMap.multi[state2.kind || "fallback"]; + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state2.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type2 = typeList[typeIndex]; + break; + } + } + } + if (!type2) { + throwError(state2, "unknown tag !<" + state2.tag + ">"); + } + if (state2.result !== null && type2.kind !== state2.kind) { + throwError(state2, "unacceptable node kind for !<" + state2.tag + '> tag; it should be "' + type2.kind + '", not "' + state2.kind + '"'); + } + if (!type2.resolve(state2.result, state2.tag)) { + throwError(state2, "cannot resolve a node with !<" + state2.tag + "> explicit tag"); + } else { + state2.result = type2.construct(state2.result, state2.tag); + if (state2.anchor !== null) { + state2.anchorMap[state2.anchor] = state2.result; + } + } + } + if (state2.listener !== null) { + state2.listener("close", state2); + } + return state2.tag !== null || state2.anchor !== null || hasContent; +} +function readDocument(state2) { + var documentStart = state2.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; + state2.version = null; + state2.checkLineBreaks = state2.legacy; + state2.tagMap = /* @__PURE__ */ Object.create(null); + state2.anchorMap = /* @__PURE__ */ Object.create(null); + while ((ch = state2.input.charCodeAt(state2.position)) !== 0) { + skipSeparationSpace(state2, true, -1); + ch = state2.input.charCodeAt(state2.position); + if (state2.lineIndent > 0 || ch !== 37) { + break; + } + hasDirectives = true; + ch = state2.input.charCodeAt(++state2.position); + _position = state2.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + directiveName = state2.input.slice(_position, state2.position); + directiveArgs = []; + if (directiveName.length < 1) { + throwError(state2, "directive name must not be less than one character in length"); + } + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + if (ch === 35) { + do { + ch = state2.input.charCodeAt(++state2.position); + } while (ch !== 0 && !is_EOL(ch)); + break; + } + if (is_EOL(ch)) + break; + _position = state2.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state2.input.charCodeAt(++state2.position); + } + directiveArgs.push(state2.input.slice(_position, state2.position)); + } + if (ch !== 0) + readLineBreak(state2); + if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state2, directiveName, directiveArgs); + } else { + throwWarning(state2, 'unknown document directive "' + directiveName + '"'); + } + } + skipSeparationSpace(state2, true, -1); + if (state2.lineIndent === 0 && state2.input.charCodeAt(state2.position) === 45 && state2.input.charCodeAt(state2.position + 1) === 45 && state2.input.charCodeAt(state2.position + 2) === 45) { + state2.position += 3; + skipSeparationSpace(state2, true, -1); + } else if (hasDirectives) { + throwError(state2, "directives end mark is expected"); + } + composeNode(state2, state2.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state2, true, -1); + if (state2.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state2.input.slice(documentStart, state2.position))) { + throwWarning(state2, "non-ASCII line breaks are interpreted as content"); + } + state2.documents.push(state2.result); + if (state2.position === state2.lineStart && testDocumentSeparator(state2)) { + if (state2.input.charCodeAt(state2.position) === 46) { + state2.position += 3; + skipSeparationSpace(state2, true, -1); + } + return; + } + if (state2.position < state2.length - 1) { + throwError(state2, "end of the stream or a document separator is expected"); + } else { + return; + } +} +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + if (input.length !== 0) { + if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) { + input += "\n"; + } + if (input.charCodeAt(0) === 65279) { + input = input.slice(1); + } + } + var state2 = new State$1(input, options); + var nullpos = input.indexOf("\0"); + if (nullpos !== -1) { + state2.position = nullpos; + throwError(state2, "null byte is not allowed in input"); + } + state2.input += "\0"; + while (state2.input.charCodeAt(state2.position) === 32) { + state2.lineIndent += 1; + state2.position += 1; + } + while (state2.position < state2.length - 1) { + readDocument(state2); + } + return state2.documents; +} +function loadAll$1(input, iterator, options) { + if (iterator !== null && typeof iterator === "object" && typeof options === "undefined") { + options = iterator; + iterator = null; + } + var documents = loadDocuments(input, options); + if (typeof iterator !== "function") { + return documents; + } + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} +function load$1(input, options) { + var documents = loadDocuments(input, options); + if (documents.length === 0) { + return void 0; + } else if (documents.length === 1) { + return documents[0]; + } + throw new exception("expected a single document in the stream, but found more"); +} +var loadAll_1 = loadAll$1; +var load_1 = load$1; +var loader = { + loadAll: loadAll_1, + load: load_1 +}; +var JSON_SCHEMA = json; +var load = loader.load; +function extractFrontMatter(text) { + const matches = text.match(frontMatterRegex); + if (!matches) { + return { + text, + metadata: {} + }; + } + let parsed = load(matches[1], { + // To support config, we need JSON schema. + // https://www.yaml.org/spec/1.2/spec.html#id2803231 + schema: JSON_SCHEMA + }) ?? {}; + parsed = typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {}; + const metadata = {}; + if (parsed.displayMode) { + metadata.displayMode = parsed.displayMode.toString(); + } + if (parsed.title) { + metadata.title = parsed.title.toString(); + } + if (parsed.config) { + metadata.config = parsed.config; + } + return { + text: text.slice(matches[0].length), + metadata + }; +} +const cleanupText = (code) => { + return code.replace(/\r\n?/g, "\n").replace( + /<(\w+)([^>]*)>/g, + (match, tag, attributes) => "<" + tag + attributes.replace(/="([^"]*)"/g, "='$1'") + ">" + ); +}; +const processFrontmatter = (code) => { + const { text, metadata } = extractFrontMatter(code); + const { displayMode, title, config: config2 = {} } = metadata; + if (displayMode) { + if (!config2.gantt) { + config2.gantt = {}; + } + config2.gantt.displayMode = displayMode; + } + return { title, config: config2, text }; +}; +const processDirectives = (code) => { + const initDirective = utils.detectInit(code) ?? {}; + const wrapDirectives = utils.detectDirective(code, "wrap"); + if (Array.isArray(wrapDirectives)) { + initDirective.wrap = wrapDirectives.some(({ type: type2 }) => { + }); + } else if ((wrapDirectives == null ? void 0 : wrapDirectives.type) === "wrap") { + initDirective.wrap = true; + } + return { + text: removeDirectives(code), + directive: initDirective + }; +}; +function preprocessDiagram(code) { + const cleanedCode = cleanupText(code); + const frontMatterResult = processFrontmatter(cleanedCode); + const directiveResult = processDirectives(frontMatterResult.text); + const config2 = cleanAndMerge(frontMatterResult.config, directiveResult.directive); + code = cleanupComments(directiveResult.text); + return { + code, + title: frontMatterResult.title, + config: config2 + }; +} +const MAX_TEXTLENGTH = 5e4; +const MAX_TEXTLENGTH_EXCEEDED_MSG = "graph TB;a[Maximum text size in diagram exceeded];style a fill:#faa"; +const SECURITY_LVL_SANDBOX = "sandbox"; +const SECURITY_LVL_LOOSE = "loose"; +const XMLNS_SVG_STD = "http://www.w3.org/2000/svg"; +const XMLNS_XLINK_STD = "http://www.w3.org/1999/xlink"; +const XMLNS_XHTML_STD = "http://www.w3.org/1999/xhtml"; +const IFRAME_WIDTH = "100%"; +const IFRAME_HEIGHT = "100%"; +const IFRAME_STYLES = "border:0;margin:0;"; +const IFRAME_BODY_STYLE = "margin:0"; +const IFRAME_SANDBOX_OPTS = "allow-top-navigation-by-user-activation allow-popups"; +const IFRAME_NOT_SUPPORTED_MSG = 'The "iframe" tag is not supported by your browser.'; +const DOMPURIFY_TAGS = ["foreignobject"]; +const DOMPURIFY_ATTR = ["dominant-baseline"]; +function processAndSetConfigs(text) { + const processed = preprocessDiagram(text); + reset(); + addDirective(processed.config ?? {}); + return processed; +} +async function parse$1(text, parseOptions) { + addDiagrams(); + text = processAndSetConfigs(text).code; + try { + await getDiagramFromText(text); + } catch (error) { + if (parseOptions == null ? void 0 : parseOptions.suppressErrors) { + return false; + } + throw error; + } + return true; +} +const cssImportantStyles = (cssClass, element, cssClasses = []) => { + return ` +.${cssClass} ${element} { ${cssClasses.join(" !important; ")} !important; }`; +}; +const createCssStyles = (config2, classDefs = {}) => { + var _a; + let cssStyles = ""; + if (config2.themeCSS !== void 0) { + cssStyles += ` +${config2.themeCSS}`; + } + if (config2.fontFamily !== void 0) { + cssStyles += ` +:root { --mermaid-font-family: ${config2.fontFamily}}`; + } + if (config2.altFontFamily !== void 0) { + cssStyles += ` +:root { --mermaid-alt-font-family: ${config2.altFontFamily}}`; + } + if (!isEmpty(classDefs)) { + const htmlLabels = config2.htmlLabels || ((_a = config2.flowchart) == null ? void 0 : _a.htmlLabels); + const cssHtmlElements = ["> *", "span"]; + const cssShapeElements = ["rect", "polygon", "ellipse", "circle", "path"]; + const cssElements = htmlLabels ? cssHtmlElements : cssShapeElements; + for (const classId in classDefs) { + const styleClassDef = classDefs[classId]; + if (!isEmpty(styleClassDef.styles)) { + cssElements.forEach((cssElement) => { + cssStyles += cssImportantStyles(styleClassDef.id, cssElement, styleClassDef.styles); + }); + } + if (!isEmpty(styleClassDef.textStyles)) { + cssStyles += cssImportantStyles(styleClassDef.id, "tspan", styleClassDef.textStyles); + } + } + } + return cssStyles; +}; +const createUserStyles = (config2, graphType, classDefs, svgId) => { + const userCSSstyles = createCssStyles(config2, classDefs); + const allStyles = getStyles$1(graphType, userCSSstyles, config2.themeVariables); + return serialize(compile(`${svgId}{${allStyles}}`), stringify); +}; +const cleanUpSvgCode = (svgCode = "", inSandboxMode, useArrowMarkerUrls) => { + let cleanedUpSvg = svgCode; + if (!useArrowMarkerUrls && !inSandboxMode) { + cleanedUpSvg = cleanedUpSvg.replace( + /marker-end="url\([\d+./:=?A-Za-z-]*?#/g, + 'marker-end="url(#' + ); + } + cleanedUpSvg = decodeEntities(cleanedUpSvg); + cleanedUpSvg = cleanedUpSvg.replace(/<br>/g, "<br/>"); + return cleanedUpSvg; +}; +const putIntoIFrame = (svgCode = "", svgElement) => { + var _a, _b; + const height = ((_b = (_a = svgElement == null ? void 0 : svgElement.viewBox) == null ? void 0 : _a.baseVal) == null ? void 0 : _b.height) ? svgElement.viewBox.baseVal.height + "px" : IFRAME_HEIGHT; + const base64encodedSrc = btoa('<body style="' + IFRAME_BODY_STYLE + '">' + svgCode + "</body>"); + return `<iframe style="width:${IFRAME_WIDTH};height:${height};${IFRAME_STYLES}" src="data:text/html;base64,${base64encodedSrc}" sandbox="${IFRAME_SANDBOX_OPTS}"> + ${IFRAME_NOT_SUPPORTED_MSG} +</iframe>`; +}; +const appendDivSvgG = (parentRoot, id2, enclosingDivId, divStyle, svgXlink) => { + const enclosingDiv = parentRoot.append("div"); + enclosingDiv.attr("id", enclosingDivId); + if (divStyle) { + enclosingDiv.attr("style", divStyle); + } + const svgNode = enclosingDiv.append("svg").attr("id", id2).attr("width", "100%").attr("xmlns", XMLNS_SVG_STD); + if (svgXlink) { + svgNode.attr("xmlns:xlink", svgXlink); + } + svgNode.append("g"); + return parentRoot; +}; +function sandboxedIframe(parentNode, iFrameId) { + return parentNode.append("iframe").attr("id", iFrameId).attr("style", "width: 100%; height: 100%;").attr("sandbox", ""); +} +const removeExistingElements = (doc, id2, divId, iFrameId) => { + var _a, _b, _c; + (_a = doc.getElementById(id2)) == null ? void 0 : _a.remove(); + (_b = doc.getElementById(divId)) == null ? void 0 : _b.remove(); + (_c = doc.getElementById(iFrameId)) == null ? void 0 : _c.remove(); +}; +const render$1 = async function(id2, text, svgContainingElement) { + var _a, _b, _c, _d, _e, _f; + addDiagrams(); + const processed = processAndSetConfigs(text); + text = processed.code; + const config2 = getConfig$1(); + log$1.debug(config2); + if (text.length > ((config2 == null ? void 0 : config2.maxTextSize) ?? MAX_TEXTLENGTH)) { + text = MAX_TEXTLENGTH_EXCEEDED_MSG; + } + const idSelector = "#" + id2; + const iFrameID = "i" + id2; + const iFrameID_selector = "#" + iFrameID; + const enclosingDivID = "d" + id2; + const enclosingDivID_selector = "#" + enclosingDivID; + let root = select("body"); + const isSandboxed = config2.securityLevel === SECURITY_LVL_SANDBOX; + const isLooseSecurityLevel = config2.securityLevel === SECURITY_LVL_LOOSE; + const fontFamily = config2.fontFamily; + if (svgContainingElement !== void 0) { + if (svgContainingElement) { + svgContainingElement.innerHTML = ""; + } + if (isSandboxed) { + const iframe = sandboxedIframe(select(svgContainingElement), iFrameID); + root = select(iframe.nodes()[0].contentDocument.body); + root.node().style.margin = 0; + } else { + root = select(svgContainingElement); + } + appendDivSvgG(root, id2, enclosingDivID, `font-family: ${fontFamily}`, XMLNS_XLINK_STD); + } else { + removeExistingElements(document, id2, enclosingDivID, iFrameID); + if (isSandboxed) { + const iframe = sandboxedIframe(select("body"), iFrameID); + root = select(iframe.nodes()[0].contentDocument.body); + root.node().style.margin = 0; + } else { + root = select("body"); + } + appendDivSvgG(root, id2, enclosingDivID); + } + let diag; + let parseEncounteredException; + try { + diag = await getDiagramFromText(text, { title: processed.title }); + } catch (error) { + diag = new Diagram("error"); + parseEncounteredException = error; + } + const element = root.select(enclosingDivID_selector).node(); + const diagramType = diag.type; + const svg = element.firstChild; + const firstChild = svg.firstChild; + const diagramClassDefs = (_b = (_a = diag.renderer).getClasses) == null ? void 0 : _b.call(_a, text, diag); + const rules = createUserStyles(config2, diagramType, diagramClassDefs, idSelector); + const style1 = document.createElement("style"); + style1.innerHTML = rules; + svg.insertBefore(style1, firstChild); + try { + await diag.renderer.draw(text, id2, version, diag); + } catch (e) { + errorRenderer.draw(text, id2, version); + throw e; + } + const svgNode = root.select(`${enclosingDivID_selector} svg`); + const a11yTitle = (_d = (_c = diag.db).getAccTitle) == null ? void 0 : _d.call(_c); + const a11yDescr = (_f = (_e = diag.db).getAccDescription) == null ? void 0 : _f.call(_e); + addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr); + root.select(`[id="${id2}"]`).selectAll("foreignobject > *").attr("xmlns", XMLNS_XHTML_STD); + let svgCode = root.select(enclosingDivID_selector).node().innerHTML; + log$1.debug("config.arrowMarkerAbsolute", config2.arrowMarkerAbsolute); + svgCode = cleanUpSvgCode(svgCode, isSandboxed, evaluate(config2.arrowMarkerAbsolute)); + if (isSandboxed) { + const svgEl = root.select(enclosingDivID_selector + " svg").node(); + svgCode = putIntoIFrame(svgCode, svgEl); + } else if (!isLooseSecurityLevel) { + svgCode = DOMPurify.sanitize(svgCode, { + ADD_TAGS: DOMPURIFY_TAGS, + ADD_ATTR: DOMPURIFY_ATTR + }); + } + attachFunctions(); + if (parseEncounteredException) { + throw parseEncounteredException; + } + const tmpElementSelector = isSandboxed ? iFrameID_selector : enclosingDivID_selector; + const node = select(tmpElementSelector).node(); + if (node && "remove" in node) { + node.remove(); + } + return { + svg: svgCode, + bindFunctions: diag.db.bindFunctions + }; +}; +function initialize$1(options = {}) { + var _a; + if ((options == null ? void 0 : options.fontFamily) && !((_a = options.themeVariables) == null ? void 0 : _a.fontFamily)) { + if (!options.themeVariables) { + options.themeVariables = {}; + } + options.themeVariables.fontFamily = options.fontFamily; + } + saveConfigFromInitialize(options); + if ((options == null ? void 0 : options.theme) && options.theme in theme) { + options.themeVariables = theme[options.theme].getThemeVariables( + options.themeVariables + ); + } else if (options) { + options.themeVariables = theme.default.getThemeVariables(options.themeVariables); + } + const config2 = typeof options === "object" ? setSiteConfig(options) : getSiteConfig(); + setLogLevel$1(config2.logLevel); + addDiagrams(); +} +const getDiagramFromText = (text, metadata = {}) => { + const { code } = preprocessDiagram(text); + return getDiagramFromText$1(code, metadata); +}; +function addA11yInfo(diagramType, svgNode, a11yTitle, a11yDescr) { + setA11yDiagramInfo(svgNode, diagramType); + addSVGa11yTitleDescription(svgNode, a11yTitle, a11yDescr, svgNode.attr("id")); +} +const mermaidAPI = Object.freeze({ + render: render$1, + parse: parse$1, + getDiagramFromText, + initialize: initialize$1, + getConfig: getConfig$1, + setConfig: setConfig$1, + getSiteConfig, + updateSiteConfig, + reset: () => { + reset(); + }, + globalReset: () => { + reset(defaultConfig$1); + }, + defaultConfig: defaultConfig$1 +}); +setLogLevel$1(getConfig$1().logLevel); +reset(getConfig$1()); +const loadRegisteredDiagrams = async () => { + log$1.debug(`Loading registered diagrams`); + const results = await Promise.allSettled( + Object.entries(detectors).map(async ([key, { detector: detector2, loader: loader2 }]) => { + if (loader2) { + try { + getDiagram(key); + } catch (error) { + try { + const { diagram: diagram2, id: id2 } = await loader2(); + registerDiagram(id2, diagram2, detector2); + } catch (err) { + log$1.error(`Failed to load external diagram with key ${key}. Removing from detectors.`); + delete detectors[key]; + throw err; + } + } + } + }) + ); + const failed = results.filter((result) => result.status === "rejected"); + if (failed.length > 0) { + log$1.error(`Failed to load ${failed.length} external diagrams`); + for (const res of failed) { + log$1.error(res); + } + throw new Error(`Failed to load ${failed.length} external diagrams`); + } +}; +const handleError = (error, errors, parseError) => { + log$1.warn(error); + if (isDetailedError(error)) { + if (parseError) { + parseError(error.str, error.hash); + } + errors.push({ ...error, message: error.str, error }); + } else { + if (parseError) { + parseError(error); + } + if (error instanceof Error) { + errors.push({ + str: error.message, + message: error.message, + hash: error.name, + error + }); + } + } +}; +const run = async function(options = { + querySelector: ".mermaid" +}) { + try { + await runThrowsErrors(options); + } catch (e) { + if (isDetailedError(e)) { + log$1.error(e.str); + } + if (mermaid.parseError) { + mermaid.parseError(e); + } + if (!options.suppressErrors) { + log$1.error("Use the suppressErrors option to suppress these errors"); + throw e; + } + } +}; +const runThrowsErrors = async function({ postRenderCallback, querySelector, nodes } = { + querySelector: ".mermaid" +}) { + const conf = mermaidAPI.getConfig(); + log$1.debug(`${!postRenderCallback ? "No " : ""}Callback function found`); + let nodesToProcess; + if (nodes) { + nodesToProcess = nodes; + } else if (querySelector) { + nodesToProcess = document.querySelectorAll(querySelector); + } else { + throw new Error("Nodes and querySelector are both undefined"); + } + log$1.debug(`Found ${nodesToProcess.length} diagrams`); + if ((conf == null ? void 0 : conf.startOnLoad) !== void 0) { + log$1.debug("Start On Load: " + (conf == null ? void 0 : conf.startOnLoad)); + mermaidAPI.updateSiteConfig({ startOnLoad: conf == null ? void 0 : conf.startOnLoad }); + } + const idGenerator = new utils.InitIDGenerator(conf.deterministicIds, conf.deterministicIDSeed); + let txt; + const errors = []; + for (const element of Array.from(nodesToProcess)) { + log$1.info("Rendering diagram: " + element.id); + /*! Check if previously processed */ + if (element.getAttribute("data-processed")) { + continue; + } + element.setAttribute("data-processed", "true"); + const id2 = `mermaid-${idGenerator.next()}`; + txt = element.innerHTML; + txt = dedent(utils.entityDecode(txt)).trim().replace(/<br\s*\/?>/gi, "<br/>"); + const init2 = utils.detectInit(txt); + if (init2) { + log$1.debug("Detected early reinit: ", init2); + } + try { + const { svg, bindFunctions } = await render(id2, txt, element); + element.innerHTML = svg; + if (postRenderCallback) { + await postRenderCallback(id2); + } + if (bindFunctions) { + bindFunctions(element); + } + } catch (error) { + handleError(error, errors, mermaid.parseError); + } + } + if (errors.length > 0) { + throw errors[0]; + } +}; +const initialize = function(config2) { + mermaidAPI.initialize(config2); +}; +const init = async function(config2, nodes, callback) { + log$1.warn("mermaid.init is deprecated. Please use run instead."); + if (config2) { + initialize(config2); + } + const runOptions = { postRenderCallback: callback, querySelector: ".mermaid" }; + if (typeof nodes === "string") { + runOptions.querySelector = nodes; + } else if (nodes) { + if (nodes instanceof HTMLElement) { + runOptions.nodes = [nodes]; + } else { + runOptions.nodes = nodes; + } + } + await run(runOptions); +}; +const registerExternalDiagrams = async (diagrams2, { + lazyLoad = true +} = {}) => { + registerLazyLoadedDiagrams(...diagrams2); + if (lazyLoad === false) { + await loadRegisteredDiagrams(); + } +}; +const contentLoaded = function() { + if (mermaid.startOnLoad) { + const { startOnLoad } = mermaidAPI.getConfig(); + if (startOnLoad) { + mermaid.run().catch((err) => log$1.error("Mermaid failed to initialize", err)); + } + } +}; +if (typeof document !== "undefined") { + /*! + * Wait for document loaded before starting the execution + */ + window.addEventListener("load", contentLoaded, false); +} +const setParseErrorHandler = function(parseErrorHandler) { + mermaid.parseError = parseErrorHandler; +}; +const executionQueue = []; +let executionQueueRunning = false; +const executeQueue = async () => { + if (executionQueueRunning) { + return; + } + executionQueueRunning = true; + while (executionQueue.length > 0) { + const f = executionQueue.shift(); + if (f) { + try { + await f(); + } catch (e) { + log$1.error("Error executing queue", e); + } + } + } + executionQueueRunning = false; +}; +const parse = async (text, parseOptions) => { + return new Promise((resolve, reject) => { + const performCall = () => new Promise((res, rej) => { + mermaidAPI.parse(text, parseOptions).then( + (r) => { + res(r); + resolve(r); + }, + (e) => { + var _a; + log$1.error("Error parsing", e); + (_a = mermaid.parseError) == null ? void 0 : _a.call(mermaid, e); + rej(e); + reject(e); + } + ); + }); + executionQueue.push(performCall); + executeQueue().catch(reject); + }); +}; +const render = (id2, text, container) => { + return new Promise((resolve, reject) => { + const performCall = () => new Promise((res, rej) => { + mermaidAPI.render(id2, text, container).then( + (r) => { + res(r); + resolve(r); + }, + (e) => { + var _a; + log$1.error("Error parsing", e); + (_a = mermaid.parseError) == null ? void 0 : _a.call(mermaid, e); + rej(e); + reject(e); + } + ); + }); + executionQueue.push(performCall); + executeQueue().catch(reject); + }); +}; +const mermaid = { + startOnLoad: true, + mermaidAPI, + parse, + render, + init, + run, + registerExternalDiagrams, + initialize, + parseError: void 0, + contentLoaded, + setParseErrorHandler, + detectType +}; +export { + selectSvgElement as A, + defaultConfig$2 as B, + cleanAndMerge as C, + parseFontSize as D, + getThemeVariables$2 as E, + getConfig$1 as F, + hasKatex as G, + calculateMathMLDimensions as H, + generateId as I, + lineBreakRegex as J, + defaultConfig as K, + commonDb as L, + decodeEntities as M, + mermaid as N, + ZERO_WIDTH_SPACE as Z, + getAccDescription as a, + setAccDescription as b, + getConfig as c, + sanitizeText$2 as d, + common$1 as e, + assignWithDepth$1 as f, + getAccTitle as g, + calculateTextWidth as h, + configureSvgSize as i, + calculateTextHeight as j, + getStylesFromArray as k, + log$1 as l, + evaluate as m, + interpolateToCurve as n, + setupGraphViewbox$1 as o, + setConfig as p, + setDiagramTitle as q, + renderKatex as r, + setAccTitle as s, + getDiagramTitle as t, + utils as u, + clear as v, + wrapLabel as w, + parseGenericTypes as x, + random as y, + setupGraphViewbox as z +}; |