"); + }, "placeholderToBreak"); + breakToPlaceholder = /* @__PURE__ */ __name((s2) => { + return s2.replace(lineBreakRegex, "#br#"); + }, "breakToPlaceholder"); + getUrl = /* @__PURE__ */ __name((useAbsolute) => { + let url = ""; + if (useAbsolute) { + url = window.location.protocol + "//" + window.location.host + window.location.pathname + window.location.search; + url = CSS.escape(url); + } + return url; + }, "getUrl"); + evaluate = /* @__PURE__ */ __name((val) => val === false || ["false", "null", "0"].includes(String(val).trim().toLowerCase()) ? false : true, "evaluate"); + getMax = /* @__PURE__ */ __name(function(...values2) { + const newValues = values2.filter((value2) => { + return !isNaN(value2); + }); + return Math.max(...newValues); + }, "getMax"); + getMin = /* @__PURE__ */ __name(function(...values2) { + const newValues = values2.filter((value2) => { + return !isNaN(value2); + }); + return Math.min(...newValues); + }, "getMin"); + parseGenericTypes = /* @__PURE__ */ __name(function(input) { + const inputSets = input.split(/(,)/); + const output2 = []; + for (let i2 = 0; i2 < inputSets.length; i2++) { + let thisSet = inputSets[i2]; + if (thisSet === "," && i2 > 0 && i2 + 1 < inputSets.length) { + const previousSet = inputSets[i2 - 1]; + const nextSet = inputSets[i2 + 1]; + if (shouldCombineSets(previousSet, nextSet)) { + thisSet = previousSet + "," + nextSet; + i2++; + output2.pop(); + } + } + output2.push(processSet(thisSet)); + } + return output2.join(""); + }, "parseGenericTypes"); + countOccurrence = /* @__PURE__ */ __name((string3, substring) => { + return Math.max(0, string3.split(substring).length - 1); + }, "countOccurrence"); + shouldCombineSets = /* @__PURE__ */ __name((previousSet, nextSet) => { + const prevCount = countOccurrence(previousSet, "~"); + const nextCount = countOccurrence(nextSet, "~"); + return prevCount === 1 && nextCount === 1; + }, "shouldCombineSets"); + processSet = /* @__PURE__ */ __name((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 first3 = chars.indexOf("~"); + let last3 = chars.lastIndexOf("~"); + while (first3 !== -1 && last3 !== -1 && first3 !== last3) { + chars[first3] = "<"; + chars[last3] = ">"; + first3 = chars.indexOf("~"); + last3 = chars.lastIndexOf("~"); + } + if (hasStartingTilde) { + chars.unshift("~"); + } + return chars.join(""); + }, "processSet"); + isMathMLSupported = /* @__PURE__ */ __name(() => window.MathMLElement !== void 0, "isMathMLSupported"); + katexRegex = /\$\$(.*)\$\$/g; + hasKatex = /* @__PURE__ */ __name((text4) => (text4.match(katexRegex)?.length ?? 0) > 0, "hasKatex"); + calculateMathMLDimensions = /* @__PURE__ */ __name(async (text4, config5) => { + const divElem = document.createElement("div"); + divElem.innerHTML = await renderKatexSanitized(text4, config5); + divElem.id = "katex-temp"; + divElem.style.visibility = "hidden"; + divElem.style.position = "absolute"; + divElem.style.top = "0"; + const body = document.querySelector("body"); + body?.insertAdjacentElement("beforeend", divElem); + const dim = { width: divElem.clientWidth, height: divElem.clientHeight }; + divElem.remove(); + return dim; + }, "calculateMathMLDimensions"); + renderKatexUnsanitized = /* @__PURE__ */ __name(async (text4, config5) => { + if (!hasKatex(text4)) { + return text4; + } + if (!(isMathMLSupported() || config5.legacyMathML || config5.forceLegacyMathML)) { + return text4.replace(katexRegex, "MathML is unsupported in this environment."); + } + if (true) { + const { default: katex2 } = await Promise.resolve().then(() => (init_katex(), katex_exports)); + const outputMode = config5.forceLegacyMathML || !isMathMLSupported() && config5.legacyMathML ? "htmlAndMathml" : "mathml"; + return text4.split(lineBreakRegex).map( + (line2) => hasKatex(line2) ? `
${line2}
` : `${line2}
`
+ ).join("").replace(
+ katexRegex,
+ (_3, c3) => katex2.renderToString(c3, {
+ throwOnError: true,
+ displayMode: true,
+ output: outputMode
+ }).replace(/\n/g, " ").replace(/" }, + config5 + ); + if (common_default.lineBreakRegex.test(label)) { + return label; + } + const words = label.split(" ").filter(Boolean); + const completedLines = []; + let nextLine = ""; + words.forEach((word, index) => { + const wordLength = calculateTextWidth(`${word} `, config5); + const nextLineLength = calculateTextWidth(nextLine, config5); + if (wordLength > maxWidth2) { + const { hyphenatedStrings, remainingWord } = breakString(word, maxWidth2, "-", config5); + completedLines.push(nextLine, ...hyphenatedStrings); + nextLine = remainingWord; + } else if (nextLineLength + wordLength >= maxWidth2) { + 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((line2) => line2 !== "").join(config5.joinWith); + }, + (label, maxWidth2, config5) => `${label}${maxWidth2}${config5.fontSize}${config5.fontWeight}${config5.fontFamily}${config5.joinWith}` + ); + breakString = memoize_default( + (word, maxWidth2, hyphenCharacter = "-", config5) => { + config5 = Object.assign( + { fontSize: 12, fontWeight: 400, fontFamily: "Arial", margin: 0 }, + config5 + ); + const characters2 = [...word]; + const lines = []; + let currentLine = ""; + characters2.forEach((character2, index) => { + const nextLine = `${currentLine}${character2}`; + const lineWidth = calculateTextWidth(nextLine, config5); + if (lineWidth >= maxWidth2) { + const currentCharacter = index + 1; + const isLastLine = characters2.length === currentCharacter; + const hyphenatedNextLine = `${nextLine}${hyphenCharacter}`; + lines.push(isLastLine ? nextLine : hyphenatedNextLine); + currentLine = ""; + } else { + currentLine = nextLine; + } + }); + return { hyphenatedStrings: lines, remainingWord: currentLine }; + }, + (word, maxWidth2, hyphenCharacter = "-", config5) => `${word}${maxWidth2}${hyphenCharacter}${config5.fontSize}${config5.fontWeight}${config5.fontFamily}` + ); + __name(calculateTextHeight, "calculateTextHeight"); + __name(calculateTextWidth, "calculateTextWidth"); + calculateTextDimensions = memoize_default( + (text4, config5) => { + const { fontSize = 12, fontFamily = "Arial", fontWeight = 400 } = config5; + if (!text4) { + return { width: 0, height: 0 }; + } + const [, _fontSizePx] = parseFontSize(fontSize); + const fontFamilies = ["sans-serif", fontFamily]; + const lines = text4.split(common_default.lineBreakRegex); + const dims = []; + const body = select_default2("body"); + if (!body.remove) { + return { width: 0, height: 0, lineHeight: 0 }; + } + const g2 = body.append("svg"); + for (const fontFamily2 of fontFamilies) { + let cHeight = 0; + const dim = { width: 0, height: 0, lineHeight: 0 }; + for (const line2 of lines) { + const textObj = getTextObj2(); + textObj.text = line2 || ZERO_WIDTH_SPACE; + const textElem = drawSimpleText(g2, 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); + } + g2.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]; + }, + (text4, config5) => `${text4}${config5.fontSize}${config5.fontWeight}${config5.fontFamily}` + ); + InitIDGenerator = class { + constructor(deterministic = false, seed) { + this.count = 0; + this.count = seed ? seed.length : 0; + this.next = deterministic ? () => this.count++ : () => Date.now(); + } + static { + __name(this, "InitIDGenerator"); + } + }; + entityDecode = /* @__PURE__ */ __name(function(html2) { + decoder = decoder || document.createElement("div"); + html2 = escape(html2).replace(/%26/g, "&").replace(/%23/g, "#").replace(/%3B/g, ";"); + decoder.innerHTML = html2; + return unescape(decoder.textContent); + }, "entityDecode"); + __name(isDetailedError, "isDetailedError"); + insertTitle = /* @__PURE__ */ __name((parent4, cssClass, titleTopMargin, title2) => { + if (!title2) { + return; + } + const bounds4 = parent4.node()?.getBBox(); + if (!bounds4) { + return; + } + parent4.append("text").text(title2).attr("text-anchor", "middle").attr("x", bounds4.x + bounds4.width / 2).attr("y", -titleTopMargin).attr("class", cssClass); + }, "insertTitle"); + parseFontSize = /* @__PURE__ */ __name((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]; + } + }, "parseFontSize"); + __name(cleanAndMerge, "cleanAndMerge"); + utils_default2 = { + assignWithDepth: assignWithDepth_default, + wrapLabel, + calculateTextHeight, + calculateTextWidth, + calculateTextDimensions, + cleanAndMerge, + detectInit, + detectDirective, + isSubstringInArray, + interpolateToCurve, + calcLabelPosition, + calcCardinalityPosition, + calcTerminalLabelPosition, + formatUrl, + getStylesFromArray, + generateId, + random, + runFunc, + entityDecode, + insertTitle, + isLabelCoordinateInPath, + parseFontSize, + InitIDGenerator + }; + encodeEntities = /* @__PURE__ */ __name(function(text4) { + let txt = text4; + txt = txt.replace(/style.*:\S*#.*;/g, function(s2) { + return s2.substring(0, s2.length - 1); + }); + txt = txt.replace(/classDef.*:\S*#.*;/g, function(s2) { + return s2.substring(0, s2.length - 1); + }); + txt = txt.replace(/#\w+;/g, function(s2) { + const innerTxt = s2.substring(1, s2.length - 1); + const isInt = /^\+?\d+$/.test(innerTxt); + if (isInt) { + return "\uFB02\xB0\xB0" + innerTxt + "\xB6\xDF"; + } else { + return "\uFB02\xB0" + innerTxt + "\xB6\xDF"; + } + }); + return txt; + }, "encodeEntities"); + decodeEntities = /* @__PURE__ */ __name(function(text4) { + return text4.replace(/fl°°/g, "&#").replace(/fl°/g, "&").replace(/¶ß/g, ";"); + }, "decodeEntities"); + getEdgeId = /* @__PURE__ */ __name((from2, to, { + counter: counter2 = 0, + prefix, + suffix + }, id30) => { + if (id30) { + return id30; + } + return `${prefix ? `${prefix}_` : ""}${from2}_${to}_${counter2}${suffix ? `_${suffix}` : ""}`; + }, "getEdgeId"); + __name(handleUndefinedAttr, "handleUndefinedAttr"); + __name(isLabelCoordinateInPath, "isLabelCoordinateInPath"); + } + }); + + // src/diagrams/c4/c4Renderer.js + function calcC4ShapeTextWH(textType, c4Shape, c4ShapeTextWrap, textConf, textLimitWidth) { + if (!c4Shape[textType].width) { + if (c4ShapeTextWrap) { + c4Shape[textType].text = wrapLabel(c4Shape[textType].text, textLimitWidth, textConf); + c4Shape[textType].textLines = c4Shape[textType].text.split(common_default.lineBreakRegex).length; + c4Shape[textType].width = textLimitWidth; + c4Shape[textType].height = calculateTextHeight(c4Shape[textType].text, textConf); + } else { + let lines = c4Shape[textType].text.split(common_default.lineBreakRegex); + c4Shape[textType].textLines = lines.length; + let lineHeight = 0; + c4Shape[textType].height = 0; + c4Shape[textType].width = 0; + for (const line2 of lines) { + c4Shape[textType].width = Math.max( + calculateTextWidth(line2, textConf), + c4Shape[textType].width + ); + lineHeight = calculateTextHeight(line2, textConf); + c4Shape[textType].height = c4Shape[textType].height + lineHeight; + } + } + } + } + function drawInsideBoundary(diagram27, parentBoundaryAlias, parentBounds, currentBoundaries, diagObj) { + let currentBounds = new Bounds(diagObj); + currentBounds.data.widthLimit = parentBounds.data.widthLimit / Math.min(c4BoundaryInRow2, currentBoundaries.length); + for (let [i2, currentBoundary] of currentBoundaries.entries()) { + let Y3 = 0; + currentBoundary.image = { width: 0, height: 0, Y: 0 }; + if (currentBoundary.sprite) { + currentBoundary.image.width = 48; + currentBoundary.image.height = 48; + currentBoundary.image.Y = Y3; + Y3 = currentBoundary.image.Y + currentBoundary.image.height; + } + let currentBoundaryTextWrap = currentBoundary.wrap && conf.wrap; + let currentBoundaryLabelConf = boundaryFont(conf); + currentBoundaryLabelConf.fontSize = currentBoundaryLabelConf.fontSize + 2; + currentBoundaryLabelConf.fontWeight = "bold"; + calcC4ShapeTextWH( + "label", + currentBoundary, + currentBoundaryTextWrap, + currentBoundaryLabelConf, + currentBounds.data.widthLimit + ); + currentBoundary.label.Y = Y3 + 8; + Y3 = currentBoundary.label.Y + currentBoundary.label.height; + if (currentBoundary.type && currentBoundary.type.text !== "") { + currentBoundary.type.text = "[" + currentBoundary.type.text + "]"; + let currentBoundaryTypeConf = boundaryFont(conf); + calcC4ShapeTextWH( + "type", + currentBoundary, + currentBoundaryTextWrap, + currentBoundaryTypeConf, + currentBounds.data.widthLimit + ); + currentBoundary.type.Y = Y3 + 5; + Y3 = currentBoundary.type.Y + currentBoundary.type.height; + } + if (currentBoundary.descr && currentBoundary.descr.text !== "") { + let currentBoundaryDescrConf = boundaryFont(conf); + currentBoundaryDescrConf.fontSize = currentBoundaryDescrConf.fontSize - 2; + calcC4ShapeTextWH( + "descr", + currentBoundary, + currentBoundaryTextWrap, + currentBoundaryDescrConf, + currentBounds.data.widthLimit + ); + currentBoundary.descr.Y = Y3 + 20; + Y3 = currentBoundary.descr.Y + currentBoundary.descr.height; + } + if (i2 == 0 || i2 % c4BoundaryInRow2 === 0) { + let _x = parentBounds.data.startx + conf.diagramMarginX; + let _y = parentBounds.data.stopy + conf.diagramMarginY + Y3; + currentBounds.setData(_x, _x, _y, _y); + } else { + let _x = currentBounds.data.stopx !== currentBounds.data.startx ? currentBounds.data.stopx + conf.diagramMarginX : currentBounds.data.startx; + let _y = currentBounds.data.starty; + currentBounds.setData(_x, _x, _y, _y); + } + currentBounds.name = currentBoundary.alias; + let currentPersonOrSystemArray = diagObj.db.getC4ShapeArray(currentBoundary.alias); + let currentPersonOrSystemKeys = diagObj.db.getC4ShapeKeys(currentBoundary.alias); + if (currentPersonOrSystemKeys.length > 0) { + drawC4ShapeArray( + currentBounds, + diagram27, + currentPersonOrSystemArray, + currentPersonOrSystemKeys + ); + } + parentBoundaryAlias = currentBoundary.alias; + let nextCurrentBoundaries = diagObj.db.getBoundaries(parentBoundaryAlias); + if (nextCurrentBoundaries.length > 0) { + drawInsideBoundary( + diagram27, + parentBoundaryAlias, + currentBounds, + nextCurrentBoundaries, + diagObj + ); + } + if (currentBoundary.alias !== "global") { + drawBoundary2(diagram27, currentBoundary, currentBounds); + } + parentBounds.data.stopy = Math.max( + currentBounds.data.stopy + conf.c4ShapeMargin, + parentBounds.data.stopy + ); + parentBounds.data.stopx = Math.max( + currentBounds.data.stopx + conf.c4ShapeMargin, + parentBounds.data.stopx + ); + globalBoundaryMaxX = Math.max(globalBoundaryMaxX, parentBounds.data.stopx); + globalBoundaryMaxY = Math.max(globalBoundaryMaxY, parentBounds.data.stopy); + } + } + var globalBoundaryMaxX, globalBoundaryMaxY, c4ShapeInRow2, c4BoundaryInRow2, conf, Bounds, setConf, c4ShapeFont, boundaryFont, messageFont, drawBoundary2, drawC4ShapeArray, Point2, getIntersectPoint, getIntersectPoints, drawRels2, draw, c4Renderer_default; + var init_c4Renderer = __esm({ + "src/diagrams/c4/c4Renderer.js"() { + "use strict"; + init_src32(); + init_svgDraw(); + init_logger(); + init_c4Diagram(); + init_common(); + init_c4Db(); + init_diagramAPI(); + init_assignWithDepth(); + init_utils2(); + init_setupGraphViewbox(); + globalBoundaryMaxX = 0; + globalBoundaryMaxY = 0; + c4ShapeInRow2 = 4; + c4BoundaryInRow2 = 2; + parser.yy = c4Db_default; + conf = {}; + Bounds = class { + static { + __name(this, "Bounds"); + } + constructor(diagObj) { + this.name = ""; + this.data = {}; + this.data.startx = void 0; + this.data.stopx = void 0; + this.data.starty = void 0; + this.data.stopy = void 0; + this.data.widthLimit = void 0; + this.nextData = {}; + this.nextData.startx = void 0; + this.nextData.stopx = void 0; + this.nextData.starty = void 0; + this.nextData.stopy = void 0; + this.nextData.cnt = 0; + setConf(diagObj.db.getConfig()); + } + setData(startx, stopx, starty, stopy) { + this.nextData.startx = this.data.startx = startx; + this.nextData.stopx = this.data.stopx = stopx; + this.nextData.starty = this.data.starty = starty; + this.nextData.stopy = this.data.stopy = stopy; + } + updateVal(obj, key, val, fun) { + if (obj[key] === void 0) { + obj[key] = val; + } else { + obj[key] = fun(val, obj[key]); + } + } + insert(c4Shape) { + this.nextData.cnt = this.nextData.cnt + 1; + let _startx = this.nextData.startx === this.nextData.stopx ? this.nextData.stopx + c4Shape.margin : this.nextData.stopx + c4Shape.margin * 2; + let _stopx = _startx + c4Shape.width; + let _starty = this.nextData.starty + c4Shape.margin * 2; + let _stopy = _starty + c4Shape.height; + if (_startx >= this.data.widthLimit || _stopx >= this.data.widthLimit || this.nextData.cnt > c4ShapeInRow2) { + _startx = this.nextData.startx + c4Shape.margin + conf.nextLinePaddingX; + _starty = this.nextData.stopy + c4Shape.margin * 2; + this.nextData.stopx = _stopx = _startx + c4Shape.width; + this.nextData.starty = this.nextData.stopy; + this.nextData.stopy = _stopy = _starty + c4Shape.height; + this.nextData.cnt = 1; + } + c4Shape.x = _startx; + c4Shape.y = _starty; + this.updateVal(this.data, "startx", _startx, Math.min); + this.updateVal(this.data, "starty", _starty, Math.min); + this.updateVal(this.data, "stopx", _stopx, Math.max); + this.updateVal(this.data, "stopy", _stopy, Math.max); + this.updateVal(this.nextData, "startx", _startx, Math.min); + this.updateVal(this.nextData, "starty", _starty, Math.min); + this.updateVal(this.nextData, "stopx", _stopx, Math.max); + this.updateVal(this.nextData, "stopy", _stopy, Math.max); + } + init(diagObj) { + this.name = ""; + this.data = { + startx: void 0, + stopx: void 0, + starty: void 0, + stopy: void 0, + widthLimit: void 0 + }; + this.nextData = { + startx: void 0, + stopx: void 0, + starty: void 0, + stopy: void 0, + cnt: 0 + }; + setConf(diagObj.db.getConfig()); + } + bumpLastMargin(margin) { + this.data.stopx += margin; + this.data.stopy += margin; + } + }; + setConf = /* @__PURE__ */ __name(function(cnf) { + assignWithDepth_default(conf, cnf); + if (cnf.fontFamily) { + conf.personFontFamily = conf.systemFontFamily = conf.messageFontFamily = cnf.fontFamily; + } + if (cnf.fontSize) { + conf.personFontSize = conf.systemFontSize = conf.messageFontSize = cnf.fontSize; + } + if (cnf.fontWeight) { + conf.personFontWeight = conf.systemFontWeight = conf.messageFontWeight = cnf.fontWeight; + } + }, "setConf"); + c4ShapeFont = /* @__PURE__ */ __name((cnf, typeC4Shape) => { + return { + fontFamily: cnf[typeC4Shape + "FontFamily"], + fontSize: cnf[typeC4Shape + "FontSize"], + fontWeight: cnf[typeC4Shape + "FontWeight"] + }; + }, "c4ShapeFont"); + boundaryFont = /* @__PURE__ */ __name((cnf) => { + return { + fontFamily: cnf.boundaryFontFamily, + fontSize: cnf.boundaryFontSize, + fontWeight: cnf.boundaryFontWeight + }; + }, "boundaryFont"); + messageFont = /* @__PURE__ */ __name((cnf) => { + return { + fontFamily: cnf.messageFontFamily, + fontSize: cnf.messageFontSize, + fontWeight: cnf.messageFontWeight + }; + }, "messageFont"); + __name(calcC4ShapeTextWH, "calcC4ShapeTextWH"); + drawBoundary2 = /* @__PURE__ */ __name(function(diagram27, boundary, bounds4) { + boundary.x = bounds4.data.startx; + boundary.y = bounds4.data.starty; + boundary.width = bounds4.data.stopx - bounds4.data.startx; + boundary.height = bounds4.data.stopy - bounds4.data.starty; + boundary.label.y = conf.c4ShapeMargin - 35; + let boundaryTextWrap = boundary.wrap && conf.wrap; + let boundaryLabelConf = boundaryFont(conf); + boundaryLabelConf.fontSize = boundaryLabelConf.fontSize + 2; + boundaryLabelConf.fontWeight = "bold"; + let textLimitWidth = calculateTextWidth(boundary.label.text, boundaryLabelConf); + calcC4ShapeTextWH("label", boundary, boundaryTextWrap, boundaryLabelConf, textLimitWidth); + svgDraw_default.drawBoundary(diagram27, boundary, conf); + }, "drawBoundary"); + drawC4ShapeArray = /* @__PURE__ */ __name(function(currentBounds, diagram27, c4ShapeArray2, c4ShapeKeys) { + let Y3 = 0; + for (const c4ShapeKey of c4ShapeKeys) { + Y3 = 0; + const c4Shape = c4ShapeArray2[c4ShapeKey]; + let c4ShapeTypeConf = c4ShapeFont(conf, c4Shape.typeC4Shape.text); + c4ShapeTypeConf.fontSize = c4ShapeTypeConf.fontSize - 2; + c4Shape.typeC4Shape.width = calculateTextWidth( + "\xAB" + c4Shape.typeC4Shape.text + "\xBB", + c4ShapeTypeConf + ); + c4Shape.typeC4Shape.height = c4ShapeTypeConf.fontSize + 2; + c4Shape.typeC4Shape.Y = conf.c4ShapePadding; + Y3 = c4Shape.typeC4Shape.Y + c4Shape.typeC4Shape.height - 4; + c4Shape.image = { width: 0, height: 0, Y: 0 }; + switch (c4Shape.typeC4Shape.text) { + case "person": + case "external_person": + c4Shape.image.width = 48; + c4Shape.image.height = 48; + c4Shape.image.Y = Y3; + Y3 = c4Shape.image.Y + c4Shape.image.height; + break; + } + if (c4Shape.sprite) { + c4Shape.image.width = 48; + c4Shape.image.height = 48; + c4Shape.image.Y = Y3; + Y3 = c4Shape.image.Y + c4Shape.image.height; + } + let c4ShapeTextWrap = c4Shape.wrap && conf.wrap; + let textLimitWidth = conf.width - conf.c4ShapePadding * 2; + let c4ShapeLabelConf = c4ShapeFont(conf, c4Shape.typeC4Shape.text); + c4ShapeLabelConf.fontSize = c4ShapeLabelConf.fontSize + 2; + c4ShapeLabelConf.fontWeight = "bold"; + calcC4ShapeTextWH("label", c4Shape, c4ShapeTextWrap, c4ShapeLabelConf, textLimitWidth); + c4Shape.label.Y = Y3 + 8; + Y3 = c4Shape.label.Y + c4Shape.label.height; + if (c4Shape.type && c4Shape.type.text !== "") { + c4Shape.type.text = "[" + c4Shape.type.text + "]"; + let c4ShapeTypeConf2 = c4ShapeFont(conf, c4Shape.typeC4Shape.text); + calcC4ShapeTextWH("type", c4Shape, c4ShapeTextWrap, c4ShapeTypeConf2, textLimitWidth); + c4Shape.type.Y = Y3 + 5; + Y3 = c4Shape.type.Y + c4Shape.type.height; + } else if (c4Shape.techn && c4Shape.techn.text !== "") { + c4Shape.techn.text = "[" + c4Shape.techn.text + "]"; + let c4ShapeTechnConf = c4ShapeFont(conf, c4Shape.techn.text); + calcC4ShapeTextWH("techn", c4Shape, c4ShapeTextWrap, c4ShapeTechnConf, textLimitWidth); + c4Shape.techn.Y = Y3 + 5; + Y3 = c4Shape.techn.Y + c4Shape.techn.height; + } + let rectHeight = Y3; + let rectWidth = c4Shape.label.width; + if (c4Shape.descr && c4Shape.descr.text !== "") { + let c4ShapeDescrConf = c4ShapeFont(conf, c4Shape.typeC4Shape.text); + calcC4ShapeTextWH("descr", c4Shape, c4ShapeTextWrap, c4ShapeDescrConf, textLimitWidth); + c4Shape.descr.Y = Y3 + 20; + Y3 = c4Shape.descr.Y + c4Shape.descr.height; + rectWidth = Math.max(c4Shape.label.width, c4Shape.descr.width); + rectHeight = Y3 - c4Shape.descr.textLines * 5; + } + rectWidth = rectWidth + conf.c4ShapePadding; + c4Shape.width = Math.max(c4Shape.width || conf.width, rectWidth, conf.width); + c4Shape.height = Math.max(c4Shape.height || conf.height, rectHeight, conf.height); + c4Shape.margin = c4Shape.margin || conf.c4ShapeMargin; + currentBounds.insert(c4Shape); + svgDraw_default.drawC4Shape(diagram27, c4Shape, conf); + } + currentBounds.bumpLastMargin(conf.c4ShapeMargin); + }, "drawC4ShapeArray"); + Point2 = class { + static { + __name(this, "Point"); + } + constructor(x5, y6) { + this.x = x5; + this.y = y6; + } + }; + getIntersectPoint = /* @__PURE__ */ __name(function(fromNode, endPoint) { + let x1 = fromNode.x; + let y1 = fromNode.y; + let x22 = endPoint.x; + let y22 = endPoint.y; + let fromCenterX = x1 + fromNode.width / 2; + let fromCenterY = y1 + fromNode.height / 2; + let dx = Math.abs(x1 - x22); + let dy = Math.abs(y1 - y22); + let tanDYX = dy / dx; + let fromDYX = fromNode.height / fromNode.width; + let returnPoint = null; + if (y1 == y22 && x1 < x22) { + returnPoint = new Point2(x1 + fromNode.width, fromCenterY); + } else if (y1 == y22 && x1 > x22) { + returnPoint = new Point2(x1, fromCenterY); + } else if (x1 == x22 && y1 < y22) { + returnPoint = new Point2(fromCenterX, y1 + fromNode.height); + } else if (x1 == x22 && y1 > y22) { + returnPoint = new Point2(fromCenterX, y1); + } + if (x1 > x22 && y1 < y22) { + if (fromDYX >= tanDYX) { + returnPoint = new Point2(x1, fromCenterY + tanDYX * fromNode.width / 2); + } else { + returnPoint = new Point2( + fromCenterX - dx / dy * fromNode.height / 2, + y1 + fromNode.height + ); + } + } else if (x1 < x22 && y1 < y22) { + if (fromDYX >= tanDYX) { + returnPoint = new Point2(x1 + fromNode.width, fromCenterY + tanDYX * fromNode.width / 2); + } else { + returnPoint = new Point2( + fromCenterX + dx / dy * fromNode.height / 2, + y1 + fromNode.height + ); + } + } else if (x1 < x22 && y1 > y22) { + if (fromDYX >= tanDYX) { + returnPoint = new Point2(x1 + fromNode.width, fromCenterY - tanDYX * fromNode.width / 2); + } else { + returnPoint = new Point2(fromCenterX + fromNode.height / 2 * dx / dy, y1); + } + } else if (x1 > x22 && y1 > y22) { + if (fromDYX >= tanDYX) { + returnPoint = new Point2(x1, fromCenterY - fromNode.width / 2 * tanDYX); + } else { + returnPoint = new Point2(fromCenterX - fromNode.height / 2 * dx / dy, y1); + } + } + return returnPoint; + }, "getIntersectPoint"); + getIntersectPoints = /* @__PURE__ */ __name(function(fromNode, endNode) { + let endIntersectPoint = { x: 0, y: 0 }; + endIntersectPoint.x = endNode.x + endNode.width / 2; + endIntersectPoint.y = endNode.y + endNode.height / 2; + let startPoint = getIntersectPoint(fromNode, endIntersectPoint); + endIntersectPoint.x = fromNode.x + fromNode.width / 2; + endIntersectPoint.y = fromNode.y + fromNode.height / 2; + let endPoint = getIntersectPoint(endNode, endIntersectPoint); + return { startPoint, endPoint }; + }, "getIntersectPoints"); + drawRels2 = /* @__PURE__ */ __name(function(diagram27, rels2, getC4ShapeObj, diagObj) { + let i2 = 0; + for (let rel2 of rels2) { + i2 = i2 + 1; + let relTextWrap = rel2.wrap && conf.wrap; + let relConf = messageFont(conf); + let diagramType = diagObj.db.getC4Type(); + if (diagramType === "C4Dynamic") { + rel2.label.text = i2 + ": " + rel2.label.text; + } + let textLimitWidth = calculateTextWidth(rel2.label.text, relConf); + calcC4ShapeTextWH("label", rel2, relTextWrap, relConf, textLimitWidth); + if (rel2.techn && rel2.techn.text !== "") { + textLimitWidth = calculateTextWidth(rel2.techn.text, relConf); + calcC4ShapeTextWH("techn", rel2, relTextWrap, relConf, textLimitWidth); + } + if (rel2.descr && rel2.descr.text !== "") { + textLimitWidth = calculateTextWidth(rel2.descr.text, relConf); + calcC4ShapeTextWH("descr", rel2, relTextWrap, relConf, textLimitWidth); + } + let fromNode = getC4ShapeObj(rel2.from); + let endNode = getC4ShapeObj(rel2.to); + let points = getIntersectPoints(fromNode, endNode); + rel2.startPoint = points.startPoint; + rel2.endPoint = points.endPoint; + } + svgDraw_default.drawRels(diagram27, rels2, conf); + }, "drawRels"); + __name(drawInsideBoundary, "drawInsideBoundary"); + draw = /* @__PURE__ */ __name(function(_text, id30, _version, diagObj) { + conf = getConfig2().c4; + const securityLevel = getConfig2().securityLevel; + let sandboxElement; + if (securityLevel === "sandbox") { + sandboxElement = select_default2("#i" + id30); + } + const root3 = securityLevel === "sandbox" ? select_default2(sandboxElement.nodes()[0].contentDocument.body) : select_default2("body"); + let db7 = diagObj.db; + diagObj.db.setWrap(conf.wrap); + c4ShapeInRow2 = db7.getC4ShapeInRow(); + c4BoundaryInRow2 = db7.getC4BoundaryInRow(); + log.debug(`C:${JSON.stringify(conf, null, 2)}`); + const diagram27 = securityLevel === "sandbox" ? root3.select(`[id="${id30}"]`) : select_default2(`[id="${id30}"]`); + svgDraw_default.insertComputerIcon(diagram27); + svgDraw_default.insertDatabaseIcon(diagram27); + svgDraw_default.insertClockIcon(diagram27); + let screenBounds = new Bounds(diagObj); + screenBounds.setData( + conf.diagramMarginX, + conf.diagramMarginX, + conf.diagramMarginY, + conf.diagramMarginY + ); + screenBounds.data.widthLimit = screen.availWidth; + globalBoundaryMaxX = conf.diagramMarginX; + globalBoundaryMaxY = conf.diagramMarginY; + const title2 = diagObj.db.getTitle(); + let currentBoundaries = diagObj.db.getBoundaries(""); + drawInsideBoundary(diagram27, "", screenBounds, currentBoundaries, diagObj); + svgDraw_default.insertArrowHead(diagram27); + svgDraw_default.insertArrowEnd(diagram27); + svgDraw_default.insertArrowCrossHead(diagram27); + svgDraw_default.insertArrowFilledHead(diagram27); + drawRels2(diagram27, diagObj.db.getRels(), diagObj.db.getC4Shape, diagObj); + screenBounds.data.stopx = globalBoundaryMaxX; + screenBounds.data.stopy = globalBoundaryMaxY; + const box = screenBounds.data; + let boxHeight = box.stopy - box.starty; + let height2 = boxHeight + 2 * conf.diagramMarginY; + let boxWidth = box.stopx - box.startx; + const width3 = boxWidth + 2 * conf.diagramMarginX; + if (title2) { + diagram27.append("text").text(title2).attr("x", (box.stopx - box.startx) / 2 - 4 * conf.diagramMarginX).attr("y", box.starty + conf.diagramMarginY); + } + configureSvgSize(diagram27, height2, width3, conf.useMaxWidth); + const extraVertForTitle = title2 ? 60 : 0; + diagram27.attr( + "viewBox", + box.startx - conf.diagramMarginX + " -" + (conf.diagramMarginY + extraVertForTitle) + " " + width3 + " " + (height2 + extraVertForTitle) + ); + log.debug(`models:`, box); + }, "draw"); + c4Renderer_default = { + drawPersonOrSystemArray: drawC4ShapeArray, + drawBoundary: drawBoundary2, + setConf, + draw + }; + } + }); + + // src/diagrams/c4/styles.js + var getStyles2, styles_default2; + var init_styles2 = __esm({ + "src/diagrams/c4/styles.js"() { + "use strict"; + getStyles2 = /* @__PURE__ */ __name((options2) => `.person { + stroke: ${options2.personBorder}; + fill: ${options2.personBkg}; + } +`, "getStyles"); + styles_default2 = getStyles2; + } + }); + + // src/diagrams/c4/c4Diagram.ts + var c4Diagram_exports = {}; + __export(c4Diagram_exports, { + diagram: () => diagram + }); + var diagram; + var init_c4Diagram2 = __esm({ + "src/diagrams/c4/c4Diagram.ts"() { + "use strict"; + init_c4Diagram(); + init_c4Db(); + init_c4Renderer(); + init_styles2(); + diagram = { + parser: c4Diagram_default, + db: c4Db_default, + renderer: c4Renderer_default, + styles: styles_default2, + init: /* @__PURE__ */ __name(({ c4, wrap: wrap3 }) => { + c4Renderer_default.setConf(c4); + c4Db_default.setWrap(wrap3); + }, "init") + }; + } + }); + + // ../../node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/dist/js-yaml.mjs + function isNothing(subject) { + return typeof subject === "undefined" || subject === null; + } + function isObject2(subject) { + return typeof subject === "object" && subject !== null; + } + function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + return [sequence]; + } + function extend2(target, source) { + var index, length2, key, sourceKeys; + if (source) { + sourceKeys = Object.keys(source); + for (index = 0, length2 = sourceKeys.length; index < length2; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + return target; + } + function repeat(string3, count2) { + var result = "", cycle; + for (cycle = 0; cycle < count2; cycle += 1) { + result += string3; + } + return result; + } + function isNegativeZero(number7) { + return number7 === 0 && Number.NEGATIVE_INFINITY === 1 / number7; + } + function formatError(exception2, compact2) { + 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 (!compact2 && 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 || ""; + } + } + function getLine(buffer, lineStart, lineEnd, position5, maxLineLength) { + var head2 = ""; + var tail = ""; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + if (position5 - lineStart > maxHalfLength) { + head2 = " ... "; + lineStart = position5 - maxHalfLength + head2.length; + } + if (lineEnd - position5 > maxHalfLength) { + tail = " ..."; + lineEnd = position5 + maxHalfLength - tail.length; + } + return { + str: head2 + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail, + pos: position5 - lineStart + head2.length + // relative position + }; + } + function padStart(string3, max10) { + return common.repeat(" ", max10 - string3.length) + string3; + } + function makeSnippet(mark, options2) { + options2 = Object.create(options2 || null); + if (!mark.buffer) return null; + if (!options2.maxLength) options2.maxLength = 79; + if (typeof options2.indent !== "number") options2.indent = 1; + if (typeof options2.linesBefore !== "number") options2.linesBefore = 3; + if (typeof options2.linesAfter !== "number") options2.linesAfter = 2; + var re3 = /\r?\n|\r|\0/g; + var lineStarts = [0]; + var lineEnds = []; + var match2; + var foundLineNo = -1; + while (match2 = re3.exec(mark.buffer)) { + lineEnds.push(match2.index); + lineStarts.push(match2.index + match2[0].length); + if (mark.position <= match2.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; + var result = "", i2, line2; + var lineNoLength = Math.min(mark.line + options2.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options2.maxLength - (options2.indent + lineNoLength + 3); + for (i2 = 1; i2 <= options2.linesBefore; i2++) { + if (foundLineNo - i2 < 0) break; + line2 = getLine( + mark.buffer, + lineStarts[foundLineNo - i2], + lineEnds[foundLineNo - i2], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i2]), + maxLineLength + ); + result = common.repeat(" ", options2.indent) + padStart((mark.line - i2 + 1).toString(), lineNoLength) + " | " + line2.str + "\n" + result; + } + line2 = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(" ", options2.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line2.str + "\n"; + result += common.repeat("-", options2.indent + lineNoLength + 3 + line2.pos) + "^\n"; + for (i2 = 1; i2 <= options2.linesAfter; i2++) { + if (foundLineNo + i2 >= lineEnds.length) break; + line2 = getLine( + mark.buffer, + lineStarts[foundLineNo + i2], + lineEnds[foundLineNo + i2], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i2]), + maxLineLength + ); + result += common.repeat(" ", options2.indent) + padStart((mark.line + i2 + 1).toString(), lineNoLength) + " | " + line2.str + "\n"; + } + return result.replace(/\n$/, ""); + } + function compileStyleAliases(map5) { + var result = {}; + if (map5 !== null) { + Object.keys(map5).forEach(function(style3) { + map5[style3].forEach(function(alias) { + result[String(alias)] = style3; + }); + }); + } + return result; + } + function Type$1(tag, options2) { + options2 = options2 || {}; + Object.keys(options2).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 = options2; + this.tag = tag; + this.kind = options2["kind"] || null; + this.resolve = options2["resolve"] || function() { + return true; + }; + this.construct = options2["construct"] || function(data5) { + return data5; + }; + this.instanceOf = options2["instanceOf"] || null; + this.predicate = options2["predicate"] || null; + this.represent = options2["represent"] || null; + this.representName = options2["representName"] || null; + this.defaultStyle = options2["defaultStyle"] || null; + this.multi = options2["multi"] || false; + this.styleAliases = compileStyleAliases(options2["styleAliases"] || null); + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } + } + 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, length2; + function collectType(type3) { + if (type3.multi) { + result.multi[type3.kind].push(type3); + result.multi["fallback"].push(type3); + } else { + result[type3.kind][type3.tag] = result["fallback"][type3.tag] = type3; + } + } + __name(collectType, "collectType"); + for (index = 0, length2 = arguments.length; index < length2; index += 1) { + arguments[index].forEach(collectType); + } + return result; + } + function Schema$1(definition) { + return this.extend(definition); + } + function resolveYamlNull(data5) { + if (data5 === null) return true; + var max10 = data5.length; + return max10 === 1 && data5 === "~" || max10 === 4 && (data5 === "null" || data5 === "Null" || data5 === "NULL"); + } + function constructYamlNull() { + return null; + } + function isNull(object3) { + return object3 === null; + } + function resolveYamlBoolean(data5) { + if (data5 === null) return false; + var max10 = data5.length; + return max10 === 4 && (data5 === "true" || data5 === "True" || data5 === "TRUE") || max10 === 5 && (data5 === "false" || data5 === "False" || data5 === "FALSE"); + } + function constructYamlBoolean(data5) { + return data5 === "true" || data5 === "True" || data5 === "TRUE"; + } + function isBoolean(object3) { + return Object.prototype.toString.call(object3) === "[object Boolean]"; + } + function isHexCode(c3) { + return 48 <= c3 && c3 <= 57 || 65 <= c3 && c3 <= 70 || 97 <= c3 && c3 <= 102; + } + function isOctCode(c3) { + return 48 <= c3 && c3 <= 55; + } + function isDecCode(c3) { + return 48 <= c3 && c3 <= 57; + } + function resolveYamlInteger(data5) { + if (data5 === null) return false; + var max10 = data5.length, index = 0, hasDigits = false, ch; + if (!max10) return false; + ch = data5[index]; + if (ch === "-" || ch === "+") { + ch = data5[++index]; + } + if (ch === "0") { + if (index + 1 === max10) return true; + ch = data5[++index]; + if (ch === "b") { + index++; + for (; index < max10; index++) { + ch = data5[index]; + if (ch === "_") continue; + if (ch !== "0" && ch !== "1") return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "x") { + index++; + for (; index < max10; index++) { + ch = data5[index]; + if (ch === "_") continue; + if (!isHexCode(data5.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + if (ch === "o") { + index++; + for (; index < max10; index++) { + ch = data5[index]; + if (ch === "_") continue; + if (!isOctCode(data5.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== "_"; + } + } + if (ch === "_") return false; + for (; index < max10; index++) { + ch = data5[index]; + if (ch === "_") continue; + if (!isDecCode(data5.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + if (!hasDigits || ch === "_") return false; + return true; + } + function constructYamlInteger(data5) { + var value2 = data5, sign2 = 1, ch; + if (value2.indexOf("_") !== -1) { + value2 = value2.replace(/_/g, ""); + } + ch = value2[0]; + if (ch === "-" || ch === "+") { + if (ch === "-") sign2 = -1; + value2 = value2.slice(1); + ch = value2[0]; + } + if (value2 === "0") return 0; + if (ch === "0") { + if (value2[1] === "b") return sign2 * parseInt(value2.slice(2), 2); + if (value2[1] === "x") return sign2 * parseInt(value2.slice(2), 16); + if (value2[1] === "o") return sign2 * parseInt(value2.slice(2), 8); + } + return sign2 * parseInt(value2, 10); + } + function isInteger(object3) { + return Object.prototype.toString.call(object3) === "[object Number]" && (object3 % 1 === 0 && !common.isNegativeZero(object3)); + } + function resolveYamlFloat(data5) { + if (data5 === null) return false; + if (!YAML_FLOAT_PATTERN.test(data5) || // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data5[data5.length - 1] === "_") { + return false; + } + return true; + } + function constructYamlFloat(data5) { + var value2, sign2; + value2 = data5.replace(/_/g, "").toLowerCase(); + sign2 = value2[0] === "-" ? -1 : 1; + if ("+-".indexOf(value2[0]) >= 0) { + value2 = value2.slice(1); + } + if (value2 === ".inf") { + return sign2 === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + } else if (value2 === ".nan") { + return NaN; + } + return sign2 * parseFloat(value2, 10); + } + function representYamlFloat(object3, style3) { + var res; + if (isNaN(object3)) { + switch (style3) { + case "lowercase": + return ".nan"; + case "uppercase": + return ".NAN"; + case "camelcase": + return ".NaN"; + } + } else if (Number.POSITIVE_INFINITY === object3) { + switch (style3) { + case "lowercase": + return ".inf"; + case "uppercase": + return ".INF"; + case "camelcase": + return ".Inf"; + } + } else if (Number.NEGATIVE_INFINITY === object3) { + switch (style3) { + case "lowercase": + return "-.inf"; + case "uppercase": + return "-.INF"; + case "camelcase": + return "-.Inf"; + } + } else if (common.isNegativeZero(object3)) { + return "-0.0"; + } + res = object3.toString(10); + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res; + } + function isFloat(object3) { + return Object.prototype.toString.call(object3) === "[object Number]" && (object3 % 1 !== 0 || common.isNegativeZero(object3)); + } + function resolveYamlTimestamp(data5) { + if (data5 === null) return false; + if (YAML_DATE_REGEXP.exec(data5) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data5) !== null) return true; + return false; + } + function constructYamlTimestamp(data5) { + var match2, year, month, day, hour, minute, second2, fraction = 0, delta = null, tz_hour, tz_minute, date2; + match2 = YAML_DATE_REGEXP.exec(data5); + if (match2 === null) match2 = YAML_TIMESTAMP_REGEXP.exec(data5); + if (match2 === null) throw new Error("Date resolve error"); + year = +match2[1]; + month = +match2[2] - 1; + day = +match2[3]; + if (!match2[4]) { + return new Date(Date.UTC(year, month, day)); + } + hour = +match2[4]; + minute = +match2[5]; + second2 = +match2[6]; + if (match2[7]) { + fraction = match2[7].slice(0, 3); + while (fraction.length < 3) { + fraction += "0"; + } + fraction = +fraction; + } + if (match2[9]) { + tz_hour = +match2[10]; + tz_minute = +(match2[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 6e4; + if (match2[9] === "-") delta = -delta; + } + date2 = new Date(Date.UTC(year, month, day, hour, minute, second2, fraction)); + if (delta) date2.setTime(date2.getTime() - delta); + return date2; + } + function representYamlTimestamp(object3) { + return object3.toISOString(); + } + function resolveYamlMerge(data5) { + return data5 === "<<" || data5 === null; + } + function resolveYamlBinary(data5) { + if (data5 === null) return false; + var code, idx, bitlen = 0, max10 = data5.length, map5 = BASE64_MAP; + for (idx = 0; idx < max10; idx++) { + code = map5.indexOf(data5.charAt(idx)); + if (code > 64) continue; + if (code < 0) return false; + bitlen += 6; + } + return bitlen % 8 === 0; + } + function constructYamlBinary(data5) { + var idx, tailbits, input = data5.replace(/[\r\n=]/g, ""), max10 = input.length, map5 = BASE64_MAP, bits = 0, result = []; + for (idx = 0; idx < max10; idx++) { + if (idx % 4 === 0 && idx) { + result.push(bits >> 16 & 255); + result.push(bits >> 8 & 255); + result.push(bits & 255); + } + bits = bits << 6 | map5.indexOf(input.charAt(idx)); + } + tailbits = max10 % 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(object3) { + var result = "", bits = 0, idx, tail, max10 = object3.length, map5 = BASE64_MAP; + for (idx = 0; idx < max10; idx++) { + if (idx % 3 === 0 && idx) { + result += map5[bits >> 18 & 63]; + result += map5[bits >> 12 & 63]; + result += map5[bits >> 6 & 63]; + result += map5[bits & 63]; + } + bits = (bits << 8) + object3[idx]; + } + tail = max10 % 3; + if (tail === 0) { + result += map5[bits >> 18 & 63]; + result += map5[bits >> 12 & 63]; + result += map5[bits >> 6 & 63]; + result += map5[bits & 63]; + } else if (tail === 2) { + result += map5[bits >> 10 & 63]; + result += map5[bits >> 4 & 63]; + result += map5[bits << 2 & 63]; + result += map5[64]; + } else if (tail === 1) { + result += map5[bits >> 2 & 63]; + result += map5[bits << 4 & 63]; + result += map5[64]; + result += map5[64]; + } + return result; + } + function isBinary(obj) { + return Object.prototype.toString.call(obj) === "[object Uint8Array]"; + } + function resolveYamlOmap(data5) { + if (data5 === null) return true; + var objectKeys = [], index, length2, pair, pairKey, pairHasKey, object3 = data5; + for (index = 0, length2 = object3.length; index < length2; index += 1) { + pair = object3[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(data5) { + return data5 !== null ? data5 : []; + } + function resolveYamlPairs(data5) { + if (data5 === null) return true; + var index, length2, pair, keys2, result, object3 = data5; + result = new Array(object3.length); + for (index = 0, length2 = object3.length; index < length2; index += 1) { + pair = object3[index]; + if (_toString$1.call(pair) !== "[object Object]") return false; + keys2 = Object.keys(pair); + if (keys2.length !== 1) return false; + result[index] = [keys2[0], pair[keys2[0]]]; + } + return true; + } + function constructYamlPairs(data5) { + if (data5 === null) return []; + var index, length2, pair, keys2, result, object3 = data5; + result = new Array(object3.length); + for (index = 0, length2 = object3.length; index < length2; index += 1) { + pair = object3[index]; + keys2 = Object.keys(pair); + result[index] = [keys2[0], pair[keys2[0]]]; + } + return result; + } + function resolveYamlSet(data5) { + if (data5 === null) return true; + var key, object3 = data5; + for (key in object3) { + if (_hasOwnProperty$2.call(object3, key)) { + if (object3[key] !== null) return false; + } + } + return true; + } + function constructYamlSet(data5) { + return data5 !== null ? data5 : {}; + } + function _class(obj) { + return Object.prototype.toString.call(obj); + } + function is_EOL(c3) { + return c3 === 10 || c3 === 13; + } + function is_WHITE_SPACE(c3) { + return c3 === 9 || c3 === 32; + } + function is_WS_OR_EOL(c3) { + return c3 === 9 || c3 === 32 || c3 === 10 || c3 === 13; + } + function is_FLOW_INDICATOR(c3) { + return c3 === 44 || c3 === 91 || c3 === 93 || c3 === 123 || c3 === 125; + } + function fromHexCode(c3) { + var lc; + if (48 <= c3 && c3 <= 57) { + return c3 - 48; + } + lc = c3 | 32; + if (97 <= lc && lc <= 102) { + return lc - 97 + 10; + } + return -1; + } + function escapedHexLen(c3) { + if (c3 === 120) { + return 2; + } + if (c3 === 117) { + return 4; + } + if (c3 === 85) { + return 8; + } + return 0; + } + function fromDecimalCode(c3) { + if (48 <= c3 && c3 <= 57) { + return c3 - 48; + } + return -1; + } + function simpleEscapeSequence(c3) { + return c3 === 48 ? "\0" : c3 === 97 ? "\x07" : c3 === 98 ? "\b" : c3 === 116 ? " " : c3 === 9 ? " " : c3 === 110 ? "\n" : c3 === 118 ? "\v" : c3 === 102 ? "\f" : c3 === 114 ? "\r" : c3 === 101 ? "\x1B" : c3 === 32 ? " " : c3 === 34 ? '"' : c3 === 47 ? "/" : c3 === 92 ? "\\" : c3 === 78 ? "\x85" : c3 === 95 ? "\xA0" : c3 === 76 ? "\u2028" : c3 === 80 ? "\u2029" : ""; + } + function charFromCodepoint(c3) { + if (c3 <= 65535) { + return String.fromCharCode(c3); + } + return String.fromCharCode( + (c3 - 65536 >> 10) + 55296, + (c3 - 65536 & 1023) + 56320 + ); + } + function State$1(input, options2) { + this.input = input; + this.filename = options2["filename"] || null; + this.schema = options2["schema"] || _default; + this.onWarning = options2["onWarning"] || null; + this.legacy = options2["legacy"] || false; + this.json = options2["json"] || false; + this.listener = options2["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(state3, message) { + var mark = { + name: state3.filename, + buffer: state3.input.slice(0, -1), + // omit trailing \0 + position: state3.position, + line: state3.line, + column: state3.position - state3.lineStart + }; + mark.snippet = snippet(mark); + return new exception(message, mark); + } + function throwError(state3, message) { + throw generateError(state3, message); + } + function throwWarning(state3, message) { + if (state3.onWarning) { + state3.onWarning.call(null, generateError(state3, message)); + } + } + function captureSegment(state3, start3, end2, checkJson) { + var _position, _length, _character, _result; + if (start3 < end2) { + _result = state3.input.slice(start3, end2); + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 9 || 32 <= _character && _character <= 1114111)) { + throwError(state3, "expected valid JSON character"); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state3, "the stream contains non-printable characters"); + } + state3.result += _result; + } + } + function mergeMappings(state3, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + if (!common.isObject(source)) { + throwError(state3, "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(state3, _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(state3, "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(state3, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state3, _result, valueNode, overridableKeys); + } + } else { + if (!state3.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) { + state3.line = startLine || state3.line; + state3.lineStart = startLineStart || state3.lineStart; + state3.position = startPos || state3.position; + throwError(state3, "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(state3) { + var ch; + ch = state3.input.charCodeAt(state3.position); + if (ch === 10) { + state3.position++; + } else if (ch === 13) { + state3.position++; + if (state3.input.charCodeAt(state3.position) === 10) { + state3.position++; + } + } else { + throwError(state3, "a line break is expected"); + } + state3.line += 1; + state3.lineStart = state3.position; + state3.firstTabInLine = -1; + } + function skipSeparationSpace(state3, allowComments, checkIndent) { + var lineBreaks = 0, ch = state3.input.charCodeAt(state3.position); + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 9 && state3.firstTabInLine === -1) { + state3.firstTabInLine = state3.position; + } + ch = state3.input.charCodeAt(++state3.position); + } + if (allowComments && ch === 35) { + do { + ch = state3.input.charCodeAt(++state3.position); + } while (ch !== 10 && ch !== 13 && ch !== 0); + } + if (is_EOL(ch)) { + readLineBreak(state3); + ch = state3.input.charCodeAt(state3.position); + lineBreaks++; + state3.lineIndent = 0; + while (ch === 32) { + state3.lineIndent++; + ch = state3.input.charCodeAt(++state3.position); + } + } else { + break; + } + } + if (checkIndent !== -1 && lineBreaks !== 0 && state3.lineIndent < checkIndent) { + throwWarning(state3, "deficient indentation"); + } + return lineBreaks; + } + function testDocumentSeparator(state3) { + var _position = state3.position, ch; + ch = state3.input.charCodeAt(_position); + if ((ch === 45 || ch === 46) && ch === state3.input.charCodeAt(_position + 1) && ch === state3.input.charCodeAt(_position + 2)) { + _position += 3; + ch = state3.input.charCodeAt(_position); + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + return false; + } + function writeFoldedLines(state3, count2) { + if (count2 === 1) { + state3.result += " "; + } else if (count2 > 1) { + state3.result += common.repeat("\n", count2 - 1); + } + } + function readPlainScalar(state3, nodeIndent, withinFlowCollection) { + var preceding, following, captureStart, captureEnd, hasPendingContent, _line, _lineStart, _lineIndent, _kind = state3.kind, _result = state3.result, ch; + ch = state3.input.charCodeAt(state3.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 = state3.input.charCodeAt(state3.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + state3.kind = "scalar"; + state3.result = ""; + captureStart = captureEnd = state3.position; + hasPendingContent = false; + while (ch !== 0) { + if (ch === 58) { + following = state3.input.charCodeAt(state3.position + 1); + if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + } else if (ch === 35) { + preceding = state3.input.charCodeAt(state3.position - 1); + if (is_WS_OR_EOL(preceding)) { + break; + } + } else if (state3.position === state3.lineStart && testDocumentSeparator(state3) || withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + } else if (is_EOL(ch)) { + _line = state3.line; + _lineStart = state3.lineStart; + _lineIndent = state3.lineIndent; + skipSeparationSpace(state3, false, -1); + if (state3.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state3.input.charCodeAt(state3.position); + continue; + } else { + state3.position = captureEnd; + state3.line = _line; + state3.lineStart = _lineStart; + state3.lineIndent = _lineIndent; + break; + } + } + if (hasPendingContent) { + captureSegment(state3, captureStart, captureEnd, false); + writeFoldedLines(state3, state3.line - _line); + captureStart = captureEnd = state3.position; + hasPendingContent = false; + } + if (!is_WHITE_SPACE(ch)) { + captureEnd = state3.position + 1; + } + ch = state3.input.charCodeAt(++state3.position); + } + captureSegment(state3, captureStart, captureEnd, false); + if (state3.result) { + return true; + } + state3.kind = _kind; + state3.result = _result; + return false; + } + function readSingleQuotedScalar(state3, nodeIndent) { + var ch, captureStart, captureEnd; + ch = state3.input.charCodeAt(state3.position); + if (ch !== 39) { + return false; + } + state3.kind = "scalar"; + state3.result = ""; + state3.position++; + captureStart = captureEnd = state3.position; + while ((ch = state3.input.charCodeAt(state3.position)) !== 0) { + if (ch === 39) { + captureSegment(state3, captureStart, state3.position, true); + ch = state3.input.charCodeAt(++state3.position); + if (ch === 39) { + captureStart = state3.position; + state3.position++; + captureEnd = state3.position; + } else { + return true; + } + } else if (is_EOL(ch)) { + captureSegment(state3, captureStart, captureEnd, true); + writeFoldedLines(state3, skipSeparationSpace(state3, false, nodeIndent)); + captureStart = captureEnd = state3.position; + } else if (state3.position === state3.lineStart && testDocumentSeparator(state3)) { + throwError(state3, "unexpected end of the document within a single quoted scalar"); + } else { + state3.position++; + captureEnd = state3.position; + } + } + throwError(state3, "unexpected end of the stream within a single quoted scalar"); + } + function readDoubleQuotedScalar(state3, nodeIndent) { + var captureStart, captureEnd, hexLength, hexResult, tmp, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch !== 34) { + return false; + } + state3.kind = "scalar"; + state3.result = ""; + state3.position++; + captureStart = captureEnd = state3.position; + while ((ch = state3.input.charCodeAt(state3.position)) !== 0) { + if (ch === 34) { + captureSegment(state3, captureStart, state3.position, true); + state3.position++; + return true; + } else if (ch === 92) { + captureSegment(state3, captureStart, state3.position, true); + ch = state3.input.charCodeAt(++state3.position); + if (is_EOL(ch)) { + skipSeparationSpace(state3, false, nodeIndent); + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state3.result += simpleEscapeMap[ch]; + state3.position++; + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + for (; hexLength > 0; hexLength--) { + ch = state3.input.charCodeAt(++state3.position); + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + } else { + throwError(state3, "expected hexadecimal character"); + } + } + state3.result += charFromCodepoint(hexResult); + state3.position++; + } else { + throwError(state3, "unknown escape sequence"); + } + captureStart = captureEnd = state3.position; + } else if (is_EOL(ch)) { + captureSegment(state3, captureStart, captureEnd, true); + writeFoldedLines(state3, skipSeparationSpace(state3, false, nodeIndent)); + captureStart = captureEnd = state3.position; + } else if (state3.position === state3.lineStart && testDocumentSeparator(state3)) { + throwError(state3, "unexpected end of the document within a double quoted scalar"); + } else { + state3.position++; + captureEnd = state3.position; + } + } + throwError(state3, "unexpected end of the stream within a double quoted scalar"); + } + function readFlowCollection(state3, nodeIndent) { + var readNext = true, _line, _lineStart, _pos, _tag = state3.tag, _result, _anchor = state3.anchor, following, terminator, isPair, isExplicitPair, isMapping, overridableKeys = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch === 91) { + terminator = 93; + isMapping = false; + _result = []; + } else if (ch === 123) { + terminator = 125; + isMapping = true; + _result = {}; + } else { + return false; + } + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = _result; + } + ch = state3.input.charCodeAt(++state3.position); + while (ch !== 0) { + skipSeparationSpace(state3, true, nodeIndent); + ch = state3.input.charCodeAt(state3.position); + if (ch === terminator) { + state3.position++; + state3.tag = _tag; + state3.anchor = _anchor; + state3.kind = isMapping ? "mapping" : "sequence"; + state3.result = _result; + return true; + } else if (!readNext) { + throwError(state3, "missed comma between flow collection entries"); + } else if (ch === 44) { + throwError(state3, "expected the node content, but found ','"); + } + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + if (ch === 63) { + following = state3.input.charCodeAt(state3.position + 1); + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state3.position++; + skipSeparationSpace(state3, true, nodeIndent); + } + } + _line = state3.line; + _lineStart = state3.lineStart; + _pos = state3.position; + composeNode(state3, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state3.tag; + keyNode = state3.result; + skipSeparationSpace(state3, true, nodeIndent); + ch = state3.input.charCodeAt(state3.position); + if ((isExplicitPair || state3.line === _line) && ch === 58) { + isPair = true; + ch = state3.input.charCodeAt(++state3.position); + skipSeparationSpace(state3, true, nodeIndent); + composeNode(state3, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state3.result; + } + if (isMapping) { + storeMappingPair(state3, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state3, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + skipSeparationSpace(state3, true, nodeIndent); + ch = state3.input.charCodeAt(state3.position); + if (ch === 44) { + readNext = true; + ch = state3.input.charCodeAt(++state3.position); + } else { + readNext = false; + } + } + throwError(state3, "unexpected end of the stream within a flow collection"); + } + function readBlockScalar(state3, nodeIndent) { + var captureStart, folding, chomping = CHOMPING_CLIP, didReadContent = false, detectedIndent = false, textIndent = nodeIndent, emptyLines = 0, atMoreIndented = false, tmp, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch === 124) { + folding = false; + } else if (ch === 62) { + folding = true; + } else { + return false; + } + state3.kind = "scalar"; + state3.result = ""; + while (ch !== 0) { + ch = state3.input.charCodeAt(++state3.position); + if (ch === 43 || ch === 45) { + if (CHOMPING_CLIP === chomping) { + chomping = ch === 43 ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state3, "repeat of a chomping mode identifier"); + } + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state3, "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(state3, "repeat of an indentation width identifier"); + } + } else { + break; + } + } + if (is_WHITE_SPACE(ch)) { + do { + ch = state3.input.charCodeAt(++state3.position); + } while (is_WHITE_SPACE(ch)); + if (ch === 35) { + do { + ch = state3.input.charCodeAt(++state3.position); + } while (!is_EOL(ch) && ch !== 0); + } + } + while (ch !== 0) { + readLineBreak(state3); + state3.lineIndent = 0; + ch = state3.input.charCodeAt(state3.position); + while ((!detectedIndent || state3.lineIndent < textIndent) && ch === 32) { + state3.lineIndent++; + ch = state3.input.charCodeAt(++state3.position); + } + if (!detectedIndent && state3.lineIndent > textIndent) { + textIndent = state3.lineIndent; + } + if (is_EOL(ch)) { + emptyLines++; + continue; + } + if (state3.lineIndent < textIndent) { + if (chomping === CHOMPING_KEEP) { + state3.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { + state3.result += "\n"; + } + } + break; + } + if (folding) { + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + state3.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } else if (atMoreIndented) { + atMoreIndented = false; + state3.result += common.repeat("\n", emptyLines + 1); + } else if (emptyLines === 0) { + if (didReadContent) { + state3.result += " "; + } + } else { + state3.result += common.repeat("\n", emptyLines); + } + } else { + state3.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines); + } + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state3.position; + while (!is_EOL(ch) && ch !== 0) { + ch = state3.input.charCodeAt(++state3.position); + } + captureSegment(state3, captureStart, state3.position, false); + } + return true; + } + function readBlockSequence(state3, nodeIndent) { + var _line, _tag = state3.tag, _anchor = state3.anchor, _result = [], following, detected = false, ch; + if (state3.firstTabInLine !== -1) return false; + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = _result; + } + ch = state3.input.charCodeAt(state3.position); + while (ch !== 0) { + if (state3.firstTabInLine !== -1) { + state3.position = state3.firstTabInLine; + throwError(state3, "tab characters must not be used in indentation"); + } + if (ch !== 45) { + break; + } + following = state3.input.charCodeAt(state3.position + 1); + if (!is_WS_OR_EOL(following)) { + break; + } + detected = true; + state3.position++; + if (skipSeparationSpace(state3, true, -1)) { + if (state3.lineIndent <= nodeIndent) { + _result.push(null); + ch = state3.input.charCodeAt(state3.position); + continue; + } + } + _line = state3.line; + composeNode(state3, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state3.result); + skipSeparationSpace(state3, true, -1); + ch = state3.input.charCodeAt(state3.position); + if ((state3.line === _line || state3.lineIndent > nodeIndent) && ch !== 0) { + throwError(state3, "bad indentation of a sequence entry"); + } else if (state3.lineIndent < nodeIndent) { + break; + } + } + if (detected) { + state3.tag = _tag; + state3.anchor = _anchor; + state3.kind = "sequence"; + state3.result = _result; + return true; + } + return false; + } + function readBlockMapping(state3, nodeIndent, flowIndent) { + var following, allowCompact, _line, _keyLine, _keyLineStart, _keyPos, _tag = state3.tag, _anchor = state3.anchor, _result = {}, overridableKeys = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch; + if (state3.firstTabInLine !== -1) return false; + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = _result; + } + ch = state3.input.charCodeAt(state3.position); + while (ch !== 0) { + if (!atExplicitKey && state3.firstTabInLine !== -1) { + state3.position = state3.firstTabInLine; + throwError(state3, "tab characters must not be used in indentation"); + } + following = state3.input.charCodeAt(state3.position + 1); + _line = state3.line; + if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) { + if (ch === 63) { + if (atExplicitKey) { + storeMappingPair(state3, _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(state3, "incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line"); + } + state3.position += 1; + ch = following; + } else { + _keyLine = state3.line; + _keyLineStart = state3.lineStart; + _keyPos = state3.position; + if (!composeNode(state3, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + break; + } + if (state3.line === _line) { + ch = state3.input.charCodeAt(state3.position); + while (is_WHITE_SPACE(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + if (ch === 58) { + ch = state3.input.charCodeAt(++state3.position); + if (!is_WS_OR_EOL(ch)) { + throwError(state3, "a whitespace character is expected after the key-value separator within a block mapping"); + } + if (atExplicitKey) { + storeMappingPair(state3, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state3.tag; + keyNode = state3.result; + } else if (detected) { + throwError(state3, "can not read an implicit mapping pair; a colon is missed"); + } else { + state3.tag = _tag; + state3.anchor = _anchor; + return true; + } + } else if (detected) { + throwError(state3, "can not read a block mapping entry; a multiline key may not be an implicit key"); + } else { + state3.tag = _tag; + state3.anchor = _anchor; + return true; + } + } + if (state3.line === _line || state3.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state3.line; + _keyLineStart = state3.lineStart; + _keyPos = state3.position; + } + if (composeNode(state3, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state3.result; + } else { + valueNode = state3.result; + } + } + if (!atExplicitKey) { + storeMappingPair(state3, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + skipSeparationSpace(state3, true, -1); + ch = state3.input.charCodeAt(state3.position); + } + if ((state3.line === _line || state3.lineIndent > nodeIndent) && ch !== 0) { + throwError(state3, "bad indentation of a mapping entry"); + } else if (state3.lineIndent < nodeIndent) { + break; + } + } + if (atExplicitKey) { + storeMappingPair(state3, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + if (detected) { + state3.tag = _tag; + state3.anchor = _anchor; + state3.kind = "mapping"; + state3.result = _result; + } + return detected; + } + function readTagProperty(state3) { + var _position, isVerbatim = false, isNamed2 = false, tagHandle, tagName, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch !== 33) return false; + if (state3.tag !== null) { + throwError(state3, "duplication of a tag property"); + } + ch = state3.input.charCodeAt(++state3.position); + if (ch === 60) { + isVerbatim = true; + ch = state3.input.charCodeAt(++state3.position); + } else if (ch === 33) { + isNamed2 = true; + tagHandle = "!!"; + ch = state3.input.charCodeAt(++state3.position); + } else { + tagHandle = "!"; + } + _position = state3.position; + if (isVerbatim) { + do { + ch = state3.input.charCodeAt(++state3.position); + } while (ch !== 0 && ch !== 62); + if (state3.position < state3.length) { + tagName = state3.input.slice(_position, state3.position); + ch = state3.input.charCodeAt(++state3.position); + } else { + throwError(state3, "unexpected end of the stream within a verbatim tag"); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + if (ch === 33) { + if (!isNamed2) { + tagHandle = state3.input.slice(_position - 1, state3.position + 1); + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state3, "named tag handle cannot contain such characters"); + } + isNamed2 = true; + _position = state3.position + 1; + } else { + throwError(state3, "tag suffix cannot contain exclamation marks"); + } + } + ch = state3.input.charCodeAt(++state3.position); + } + tagName = state3.input.slice(_position, state3.position); + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state3, "tag suffix cannot contain flow indicator characters"); + } + } + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state3, "tag name cannot contain such characters: " + tagName); + } + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state3, "tag name is malformed: " + tagName); + } + if (isVerbatim) { + state3.tag = tagName; + } else if (_hasOwnProperty$1.call(state3.tagMap, tagHandle)) { + state3.tag = state3.tagMap[tagHandle] + tagName; + } else if (tagHandle === "!") { + state3.tag = "!" + tagName; + } else if (tagHandle === "!!") { + state3.tag = "tag:yaml.org,2002:" + tagName; + } else { + throwError(state3, 'undeclared tag handle "' + tagHandle + '"'); + } + return true; + } + function readAnchorProperty(state3) { + var _position, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch !== 38) return false; + if (state3.anchor !== null) { + throwError(state3, "duplication of an anchor property"); + } + ch = state3.input.charCodeAt(++state3.position); + _position = state3.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + if (state3.position === _position) { + throwError(state3, "name of an anchor node must contain at least one character"); + } + state3.anchor = state3.input.slice(_position, state3.position); + return true; + } + function readAlias(state3) { + var _position, alias, ch; + ch = state3.input.charCodeAt(state3.position); + if (ch !== 42) return false; + ch = state3.input.charCodeAt(++state3.position); + _position = state3.position; + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + if (state3.position === _position) { + throwError(state3, "name of an alias node must contain at least one character"); + } + alias = state3.input.slice(_position, state3.position); + if (!_hasOwnProperty$1.call(state3.anchorMap, alias)) { + throwError(state3, 'unidentified alias "' + alias + '"'); + } + state3.result = state3.anchorMap[alias]; + skipSeparationSpace(state3, true, -1); + return true; + } + function composeNode(state3, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type3, flowIndent, blockIndent; + if (state3.listener !== null) { + state3.listener("open", state3); + } + state3.tag = null; + state3.anchor = null; + state3.kind = null; + state3.result = null; + allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext; + if (allowToSeek) { + if (skipSeparationSpace(state3, true, -1)) { + atNewLine = true; + if (state3.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state3.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state3.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + if (indentStatus === 1) { + while (readTagProperty(state3) || readAnchorProperty(state3)) { + if (skipSeparationSpace(state3, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + if (state3.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state3.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state3.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 = state3.position - state3.lineStart; + if (indentStatus === 1) { + if (allowBlockCollections && (readBlockSequence(state3, blockIndent) || readBlockMapping(state3, blockIndent, flowIndent)) || readFlowCollection(state3, flowIndent)) { + hasContent = true; + } else { + if (allowBlockScalars && readBlockScalar(state3, flowIndent) || readSingleQuotedScalar(state3, flowIndent) || readDoubleQuotedScalar(state3, flowIndent)) { + hasContent = true; + } else if (readAlias(state3)) { + hasContent = true; + if (state3.tag !== null || state3.anchor !== null) { + throwError(state3, "alias node should not have any properties"); + } + } else if (readPlainScalar(state3, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + if (state3.tag === null) { + state3.tag = "?"; + } + } + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = state3.result; + } + } + } else if (indentStatus === 0) { + hasContent = allowBlockCollections && readBlockSequence(state3, blockIndent); + } + } + if (state3.tag === null) { + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = state3.result; + } + } else if (state3.tag === "?") { + if (state3.result !== null && state3.kind !== "scalar") { + throwError(state3, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state3.kind + '"'); + } + for (typeIndex = 0, typeQuantity = state3.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type3 = state3.implicitTypes[typeIndex]; + if (type3.resolve(state3.result)) { + state3.result = type3.construct(state3.result); + state3.tag = type3.tag; + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = state3.result; + } + break; + } + } + } else if (state3.tag !== "!") { + if (_hasOwnProperty$1.call(state3.typeMap[state3.kind || "fallback"], state3.tag)) { + type3 = state3.typeMap[state3.kind || "fallback"][state3.tag]; + } else { + type3 = null; + typeList = state3.typeMap.multi[state3.kind || "fallback"]; + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state3.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type3 = typeList[typeIndex]; + break; + } + } + } + if (!type3) { + throwError(state3, "unknown tag !<" + state3.tag + ">"); + } + if (state3.result !== null && type3.kind !== state3.kind) { + throwError(state3, "unacceptable node kind for !<" + state3.tag + '> tag; it should be "' + type3.kind + '", not "' + state3.kind + '"'); + } + if (!type3.resolve(state3.result, state3.tag)) { + throwError(state3, "cannot resolve a node with !<" + state3.tag + "> explicit tag"); + } else { + state3.result = type3.construct(state3.result, state3.tag); + if (state3.anchor !== null) { + state3.anchorMap[state3.anchor] = state3.result; + } + } + } + if (state3.listener !== null) { + state3.listener("close", state3); + } + return state3.tag !== null || state3.anchor !== null || hasContent; + } + function readDocument(state3) { + var documentStart = state3.position, _position, directiveName, directiveArgs, hasDirectives = false, ch; + state3.version = null; + state3.checkLineBreaks = state3.legacy; + state3.tagMap = /* @__PURE__ */ Object.create(null); + state3.anchorMap = /* @__PURE__ */ Object.create(null); + while ((ch = state3.input.charCodeAt(state3.position)) !== 0) { + skipSeparationSpace(state3, true, -1); + ch = state3.input.charCodeAt(state3.position); + if (state3.lineIndent > 0 || ch !== 37) { + break; + } + hasDirectives = true; + ch = state3.input.charCodeAt(++state3.position); + _position = state3.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + directiveName = state3.input.slice(_position, state3.position); + directiveArgs = []; + if (directiveName.length < 1) { + throwError(state3, "directive name must not be less than one character in length"); + } + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + if (ch === 35) { + do { + ch = state3.input.charCodeAt(++state3.position); + } while (ch !== 0 && !is_EOL(ch)); + break; + } + if (is_EOL(ch)) break; + _position = state3.position; + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state3.input.charCodeAt(++state3.position); + } + directiveArgs.push(state3.input.slice(_position, state3.position)); + } + if (ch !== 0) readLineBreak(state3); + if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state3, directiveName, directiveArgs); + } else { + throwWarning(state3, 'unknown document directive "' + directiveName + '"'); + } + } + skipSeparationSpace(state3, true, -1); + if (state3.lineIndent === 0 && state3.input.charCodeAt(state3.position) === 45 && state3.input.charCodeAt(state3.position + 1) === 45 && state3.input.charCodeAt(state3.position + 2) === 45) { + state3.position += 3; + skipSeparationSpace(state3, true, -1); + } else if (hasDirectives) { + throwError(state3, "directives end mark is expected"); + } + composeNode(state3, state3.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state3, true, -1); + if (state3.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(state3.input.slice(documentStart, state3.position))) { + throwWarning(state3, "non-ASCII line breaks are interpreted as content"); + } + state3.documents.push(state3.result); + if (state3.position === state3.lineStart && testDocumentSeparator(state3)) { + if (state3.input.charCodeAt(state3.position) === 46) { + state3.position += 3; + skipSeparationSpace(state3, true, -1); + } + return; + } + if (state3.position < state3.length - 1) { + throwError(state3, "end of the stream or a document separator is expected"); + } else { + return; + } + } + function loadDocuments(input, options2) { + input = String(input); + options2 = options2 || {}; + 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 state3 = new State$1(input, options2); + var nullpos = input.indexOf("\0"); + if (nullpos !== -1) { + state3.position = nullpos; + throwError(state3, "null byte is not allowed in input"); + } + state3.input += "\0"; + while (state3.input.charCodeAt(state3.position) === 32) { + state3.lineIndent += 1; + state3.position += 1; + } + while (state3.position < state3.length - 1) { + readDocument(state3); + } + return state3.documents; + } + function loadAll$1(input, iterator, options2) { + if (iterator !== null && typeof iterator === "object" && typeof options2 === "undefined") { + options2 = iterator; + iterator = null; + } + var documents = loadDocuments(input, options2); + if (typeof iterator !== "function") { + return documents; + } + for (var index = 0, length2 = documents.length; index < length2; index += 1) { + iterator(documents[index]); + } + } + function load$1(input, options2) { + var documents = loadDocuments(input, options2); + 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"); + } + function compileStyleMap(schema2, map5) { + var result, keys2, index, length2, tag, style3, type3; + if (map5 === null) return {}; + result = {}; + keys2 = Object.keys(map5); + for (index = 0, length2 = keys2.length; index < length2; index += 1) { + tag = keys2[index]; + style3 = String(map5[tag]); + if (tag.slice(0, 2) === "!!") { + tag = "tag:yaml.org,2002:" + tag.slice(2); + } + type3 = schema2.compiledTypeMap["fallback"][tag]; + if (type3 && _hasOwnProperty.call(type3.styleAliases, style3)) { + style3 = type3.styleAliases[style3]; + } + result[tag] = style3; + } + return result; + } + function encodeHex(character2) { + var string3, handle, length2; + string3 = character2.toString(16).toUpperCase(); + if (character2 <= 255) { + handle = "x"; + length2 = 2; + } else if (character2 <= 65535) { + handle = "u"; + length2 = 4; + } else if (character2 <= 4294967295) { + handle = "U"; + length2 = 8; + } else { + throw new exception("code point within a string may not be greater than 0xFFFFFFFF"); + } + return "\\" + handle + common.repeat("0", length2 - string3.length) + string3; + } + function State(options2) { + this.schema = options2["schema"] || _default; + this.indent = Math.max(1, options2["indent"] || 2); + this.noArrayIndent = options2["noArrayIndent"] || false; + this.skipInvalid = options2["skipInvalid"] || false; + this.flowLevel = common.isNothing(options2["flowLevel"]) ? -1 : options2["flowLevel"]; + this.styleMap = compileStyleMap(this.schema, options2["styles"] || null); + this.sortKeys = options2["sortKeys"] || false; + this.lineWidth = options2["lineWidth"] || 80; + this.noRefs = options2["noRefs"] || false; + this.noCompatMode = options2["noCompatMode"] || false; + this.condenseFlow = options2["condenseFlow"] || false; + this.quotingType = options2["quotingType"] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options2["forceQuotes"] || false; + this.replacer = typeof options2["replacer"] === "function" ? options2["replacer"] : null; + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + this.tag = null; + this.result = ""; + this.duplicates = []; + this.usedDuplicates = null; + } + function indentString(string3, spaces) { + var ind = common.repeat(" ", spaces), position5 = 0, next3 = -1, result = "", line2, length2 = string3.length; + while (position5 < length2) { + next3 = string3.indexOf("\n", position5); + if (next3 === -1) { + line2 = string3.slice(position5); + position5 = length2; + } else { + line2 = string3.slice(position5, next3 + 1); + position5 = next3 + 1; + } + if (line2.length && line2 !== "\n") result += ind; + result += line2; + } + return result; + } + function generateNextLine(state3, level) { + return "\n" + common.repeat(" ", state3.indent * level); + } + function testImplicitResolving(state3, str2) { + var index, length2, type3; + for (index = 0, length2 = state3.implicitTypes.length; index < length2; index += 1) { + type3 = state3.implicitTypes[index]; + if (type3.resolve(str2)) { + return true; + } + } + return false; + } + function isWhitespace(c3) { + return c3 === CHAR_SPACE || c3 === CHAR_TAB; + } + function isPrintable(c3) { + return 32 <= c3 && c3 <= 126 || 161 <= c3 && c3 <= 55295 && c3 !== 8232 && c3 !== 8233 || 57344 <= c3 && c3 <= 65533 && c3 !== CHAR_BOM || 65536 <= c3 && c3 <= 1114111; + } + function isNsCharOrWhitespace(c3) { + return isPrintable(c3) && c3 !== CHAR_BOM && c3 !== CHAR_CARRIAGE_RETURN && c3 !== CHAR_LINE_FEED; + } + function isPlainSafe(c3, prev2, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c3); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c3); + return ( + // ns-plain-safe + (inblock ? ( + // c = flow-in + cIsNsCharOrWhitespace + ) : cIsNsCharOrWhitespace && c3 !== CHAR_COMMA && c3 !== CHAR_LEFT_SQUARE_BRACKET && c3 !== CHAR_RIGHT_SQUARE_BRACKET && c3 !== CHAR_LEFT_CURLY_BRACKET && c3 !== CHAR_RIGHT_CURLY_BRACKET) && c3 !== CHAR_SHARP && !(prev2 === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev2) && !isWhitespace(prev2) && c3 === CHAR_SHARP || prev2 === CHAR_COLON && cIsNsChar + ); + } + function isPlainSafeFirst(c3) { + return isPrintable(c3) && c3 !== CHAR_BOM && !isWhitespace(c3) && c3 !== CHAR_MINUS && c3 !== CHAR_QUESTION && c3 !== CHAR_COLON && c3 !== CHAR_COMMA && c3 !== CHAR_LEFT_SQUARE_BRACKET && c3 !== CHAR_RIGHT_SQUARE_BRACKET && c3 !== CHAR_LEFT_CURLY_BRACKET && c3 !== CHAR_RIGHT_CURLY_BRACKET && c3 !== CHAR_SHARP && c3 !== CHAR_AMPERSAND && c3 !== CHAR_ASTERISK && c3 !== CHAR_EXCLAMATION && c3 !== CHAR_VERTICAL_LINE && c3 !== CHAR_EQUALS && c3 !== CHAR_GREATER_THAN && c3 !== CHAR_SINGLE_QUOTE && c3 !== CHAR_DOUBLE_QUOTE && c3 !== CHAR_PERCENT && c3 !== CHAR_COMMERCIAL_AT && c3 !== CHAR_GRAVE_ACCENT; + } + function isPlainSafeLast(c3) { + return !isWhitespace(c3) && c3 !== CHAR_COLON; + } + function codePointAt(string3, pos) { + var first3 = string3.charCodeAt(pos), second2; + if (first3 >= 55296 && first3 <= 56319 && pos + 1 < string3.length) { + second2 = string3.charCodeAt(pos + 1); + if (second2 >= 56320 && second2 <= 57343) { + return (first3 - 55296) * 1024 + second2 - 56320 + 65536; + } + } + return first3; + } + function needIndentIndicator(string3) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string3); + } + function chooseScalarStyle(string3, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) { + var i2; + var char2 = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; + var plain = isPlainSafeFirst(codePointAt(string3, 0)) && isPlainSafeLast(codePointAt(string3, string3.length - 1)); + if (singleLineOnly || forceQuotes) { + for (i2 = 0; i2 < string3.length; char2 >= 65536 ? i2 += 2 : i2++) { + char2 = codePointAt(string3, i2); + if (!isPrintable(char2)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char2, prevChar, inblock); + prevChar = char2; + } + } else { + for (i2 = 0; i2 < string3.length; char2 >= 65536 ? i2 += 2 : i2++) { + char2 = codePointAt(string3, i2); + if (char2 === CHAR_LINE_FEED) { + hasLineBreak = true; + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented. + i2 - previousLineBreak - 1 > lineWidth && string3[previousLineBreak + 1] !== " "; + previousLineBreak = i2; + } + } else if (!isPrintable(char2)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char2, prevChar, inblock); + prevChar = char2; + } + hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i2 - previousLineBreak - 1 > lineWidth && string3[previousLineBreak + 1] !== " "); + } + if (!hasLineBreak && !hasFoldableLine) { + if (plain && !forceQuotes && !testAmbiguousType(string3)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + if (indentPerLevel > 9 && needIndentIndicator(string3)) { + return STYLE_DOUBLE; + } + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + function writeScalar(state3, string3, level, iskey, inblock) { + state3.dump = (function() { + if (string3.length === 0) { + return state3.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state3.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string3) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string3)) { + return state3.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string3 + '"' : "'" + string3 + "'"; + } + } + var indent = state3.indent * Math.max(1, level); + var lineWidth = state3.lineWidth === -1 ? -1 : Math.max(Math.min(state3.lineWidth, 40), state3.lineWidth - indent); + var singleLineOnly = iskey || state3.flowLevel > -1 && level >= state3.flowLevel; + function testAmbiguity(string4) { + return testImplicitResolving(state3, string4); + } + __name(testAmbiguity, "testAmbiguity"); + switch (chooseScalarStyle( + string3, + singleLineOnly, + state3.indent, + lineWidth, + testAmbiguity, + state3.quotingType, + state3.forceQuotes && !iskey, + inblock + )) { + case STYLE_PLAIN: + return string3; + case STYLE_SINGLE: + return "'" + string3.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return "|" + blockHeader(string3, state3.indent) + dropEndingNewline(indentString(string3, indent)); + case STYLE_FOLDED: + return ">" + blockHeader(string3, state3.indent) + dropEndingNewline(indentString(foldString(string3, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string3) + '"'; + default: + throw new exception("impossible error: invalid scalar style"); + } + })(); + } + function blockHeader(string3, indentPerLevel) { + var indentIndicator = needIndentIndicator(string3) ? String(indentPerLevel) : ""; + var clip = string3[string3.length - 1] === "\n"; + var keep = clip && (string3[string3.length - 2] === "\n" || string3 === "\n"); + var chomp = keep ? "+" : clip ? "" : "-"; + return indentIndicator + chomp + "\n"; + } + function dropEndingNewline(string3) { + return string3[string3.length - 1] === "\n" ? string3.slice(0, -1) : string3; + } + function foldString(string3, width3) { + var lineRe = /(\n+)([^\n]*)/g; + var result = (function() { + var nextLF = string3.indexOf("\n"); + nextLF = nextLF !== -1 ? nextLF : string3.length; + lineRe.lastIndex = nextLF; + return foldLine(string3.slice(0, nextLF), width3); + })(); + var prevMoreIndented = string3[0] === "\n" || string3[0] === " "; + var moreIndented; + var match2; + while (match2 = lineRe.exec(string3)) { + var prefix = match2[1], line2 = match2[2]; + moreIndented = line2[0] === " "; + result += prefix + (!prevMoreIndented && !moreIndented && line2 !== "" ? "\n" : "") + foldLine(line2, width3); + prevMoreIndented = moreIndented; + } + return result; + } + function foldLine(line2, width3) { + if (line2 === "" || line2[0] === " ") return line2; + var breakRe = / [^ ]/g; + var match2; + var start3 = 0, end2, curr = 0, next3 = 0; + var result = ""; + while (match2 = breakRe.exec(line2)) { + next3 = match2.index; + if (next3 - start3 > width3) { + end2 = curr > start3 ? curr : next3; + result += "\n" + line2.slice(start3, end2); + start3 = end2 + 1; + } + curr = next3; + } + result += "\n"; + if (line2.length - start3 > width3 && curr > start3) { + result += line2.slice(start3, curr) + "\n" + line2.slice(curr + 1); + } else { + result += line2.slice(start3); + } + return result.slice(1); + } + function escapeString(string3) { + var result = ""; + var char2 = 0; + var escapeSeq; + for (var i2 = 0; i2 < string3.length; char2 >= 65536 ? i2 += 2 : i2++) { + char2 = codePointAt(string3, i2); + escapeSeq = ESCAPE_SEQUENCES[char2]; + if (!escapeSeq && isPrintable(char2)) { + result += string3[i2]; + if (char2 >= 65536) result += string3[i2 + 1]; + } else { + result += escapeSeq || encodeHex(char2); + } + } + return result; + } + function writeFlowSequence(state3, level, object3) { + var _result = "", _tag = state3.tag, index, length2, value2; + for (index = 0, length2 = object3.length; index < length2; index += 1) { + value2 = object3[index]; + if (state3.replacer) { + value2 = state3.replacer.call(object3, String(index), value2); + } + if (writeNode(state3, level, value2, false, false) || typeof value2 === "undefined" && writeNode(state3, level, null, false, false)) { + if (_result !== "") _result += "," + (!state3.condenseFlow ? " " : ""); + _result += state3.dump; + } + } + state3.tag = _tag; + state3.dump = "[" + _result + "]"; + } + function writeBlockSequence(state3, level, object3, compact2) { + var _result = "", _tag = state3.tag, index, length2, value2; + for (index = 0, length2 = object3.length; index < length2; index += 1) { + value2 = object3[index]; + if (state3.replacer) { + value2 = state3.replacer.call(object3, String(index), value2); + } + if (writeNode(state3, level + 1, value2, true, true, false, true) || typeof value2 === "undefined" && writeNode(state3, level + 1, null, true, true, false, true)) { + if (!compact2 || _result !== "") { + _result += generateNextLine(state3, level); + } + if (state3.dump && CHAR_LINE_FEED === state3.dump.charCodeAt(0)) { + _result += "-"; + } else { + _result += "- "; + } + _result += state3.dump; + } + } + state3.tag = _tag; + state3.dump = _result || "[]"; + } + function writeFlowMapping(state3, level, object3) { + var _result = "", _tag = state3.tag, objectKeyList = Object.keys(object3), index, length2, objectKey, objectValue, pairBuffer; + for (index = 0, length2 = objectKeyList.length; index < length2; index += 1) { + pairBuffer = ""; + if (_result !== "") pairBuffer += ", "; + if (state3.condenseFlow) pairBuffer += '"'; + objectKey = objectKeyList[index]; + objectValue = object3[objectKey]; + if (state3.replacer) { + objectValue = state3.replacer.call(object3, objectKey, objectValue); + } + if (!writeNode(state3, level, objectKey, false, false)) { + continue; + } + if (state3.dump.length > 1024) pairBuffer += "? "; + pairBuffer += state3.dump + (state3.condenseFlow ? '"' : "") + ":" + (state3.condenseFlow ? "" : " "); + if (!writeNode(state3, level, objectValue, false, false)) { + continue; + } + pairBuffer += state3.dump; + _result += pairBuffer; + } + state3.tag = _tag; + state3.dump = "{" + _result + "}"; + } + function writeBlockMapping(state3, level, object3, compact2) { + var _result = "", _tag = state3.tag, objectKeyList = Object.keys(object3), index, length2, objectKey, objectValue, explicitPair, pairBuffer; + if (state3.sortKeys === true) { + objectKeyList.sort(); + } else if (typeof state3.sortKeys === "function") { + objectKeyList.sort(state3.sortKeys); + } else if (state3.sortKeys) { + throw new exception("sortKeys must be a boolean or a function"); + } + for (index = 0, length2 = objectKeyList.length; index < length2; index += 1) { + pairBuffer = ""; + if (!compact2 || _result !== "") { + pairBuffer += generateNextLine(state3, level); + } + objectKey = objectKeyList[index]; + objectValue = object3[objectKey]; + if (state3.replacer) { + objectValue = state3.replacer.call(object3, objectKey, objectValue); + } + if (!writeNode(state3, level + 1, objectKey, true, true, true)) { + continue; + } + explicitPair = state3.tag !== null && state3.tag !== "?" || state3.dump && state3.dump.length > 1024; + if (explicitPair) { + if (state3.dump && CHAR_LINE_FEED === state3.dump.charCodeAt(0)) { + pairBuffer += "?"; + } else { + pairBuffer += "? "; + } + } + pairBuffer += state3.dump; + if (explicitPair) { + pairBuffer += generateNextLine(state3, level); + } + if (!writeNode(state3, level + 1, objectValue, true, explicitPair)) { + continue; + } + if (state3.dump && CHAR_LINE_FEED === state3.dump.charCodeAt(0)) { + pairBuffer += ":"; + } else { + pairBuffer += ": "; + } + pairBuffer += state3.dump; + _result += pairBuffer; + } + state3.tag = _tag; + state3.dump = _result || "{}"; + } + function detectType2(state3, object3, explicit) { + var _result, typeList, index, length2, type3, style3; + typeList = explicit ? state3.explicitTypes : state3.implicitTypes; + for (index = 0, length2 = typeList.length; index < length2; index += 1) { + type3 = typeList[index]; + if ((type3.instanceOf || type3.predicate) && (!type3.instanceOf || typeof object3 === "object" && object3 instanceof type3.instanceOf) && (!type3.predicate || type3.predicate(object3))) { + if (explicit) { + if (type3.multi && type3.representName) { + state3.tag = type3.representName(object3); + } else { + state3.tag = type3.tag; + } + } else { + state3.tag = "?"; + } + if (type3.represent) { + style3 = state3.styleMap[type3.tag] || type3.defaultStyle; + if (_toString.call(type3.represent) === "[object Function]") { + _result = type3.represent(object3, style3); + } else if (_hasOwnProperty.call(type3.represent, style3)) { + _result = type3.represent[style3](object3, style3); + } else { + throw new exception("!<" + type3.tag + '> tag resolver accepts not "' + style3 + '" style'); + } + state3.dump = _result; + } + return true; + } + } + return false; + } + function writeNode(state3, level, object3, block2, compact2, iskey, isblockseq) { + state3.tag = null; + state3.dump = object3; + if (!detectType2(state3, object3, false)) { + detectType2(state3, object3, true); + } + var type3 = _toString.call(state3.dump); + var inblock = block2; + var tagStr; + if (block2) { + block2 = state3.flowLevel < 0 || state3.flowLevel > level; + } + var objectOrArray = type3 === "[object Object]" || type3 === "[object Array]", duplicateIndex, duplicate; + if (objectOrArray) { + duplicateIndex = state3.duplicates.indexOf(object3); + duplicate = duplicateIndex !== -1; + } + if (state3.tag !== null && state3.tag !== "?" || duplicate || state3.indent !== 2 && level > 0) { + compact2 = false; + } + if (duplicate && state3.usedDuplicates[duplicateIndex]) { + state3.dump = "*ref_" + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state3.usedDuplicates[duplicateIndex]) { + state3.usedDuplicates[duplicateIndex] = true; + } + if (type3 === "[object Object]") { + if (block2 && Object.keys(state3.dump).length !== 0) { + writeBlockMapping(state3, level, state3.dump, compact2); + if (duplicate) { + state3.dump = "&ref_" + duplicateIndex + state3.dump; + } + } else { + writeFlowMapping(state3, level, state3.dump); + if (duplicate) { + state3.dump = "&ref_" + duplicateIndex + " " + state3.dump; + } + } + } else if (type3 === "[object Array]") { + if (block2 && state3.dump.length !== 0) { + if (state3.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state3, level - 1, state3.dump, compact2); + } else { + writeBlockSequence(state3, level, state3.dump, compact2); + } + if (duplicate) { + state3.dump = "&ref_" + duplicateIndex + state3.dump; + } + } else { + writeFlowSequence(state3, level, state3.dump); + if (duplicate) { + state3.dump = "&ref_" + duplicateIndex + " " + state3.dump; + } + } + } else if (type3 === "[object String]") { + if (state3.tag !== "?") { + writeScalar(state3, state3.dump, level, iskey, inblock); + } + } else if (type3 === "[object Undefined]") { + return false; + } else { + if (state3.skipInvalid) return false; + throw new exception("unacceptable kind of an object to dump " + type3); + } + if (state3.tag !== null && state3.tag !== "?") { + tagStr = encodeURI( + state3.tag[0] === "!" ? state3.tag.slice(1) : state3.tag + ).replace(/!/g, "%21"); + if (state3.tag[0] === "!") { + tagStr = "!" + tagStr; + } else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") { + tagStr = "!!" + tagStr.slice(18); + } else { + tagStr = "!<" + tagStr + ">"; + } + state3.dump = tagStr + " " + state3.dump; + } + } + return true; + } + function getDuplicateReferences(object3, state3) { + var objects = [], duplicatesIndexes = [], index, length2; + inspectNode(object3, objects, duplicatesIndexes); + for (index = 0, length2 = duplicatesIndexes.length; index < length2; index += 1) { + state3.duplicates.push(objects[duplicatesIndexes[index]]); + } + state3.usedDuplicates = new Array(length2); + } + function inspectNode(object3, objects, duplicatesIndexes) { + var objectKeyList, index, length2; + if (object3 !== null && typeof object3 === "object") { + index = objects.indexOf(object3); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object3); + if (Array.isArray(object3)) { + for (index = 0, length2 = object3.length; index < length2; index += 1) { + inspectNode(object3[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object3); + for (index = 0, length2 = objectKeyList.length; index < length2; index += 1) { + inspectNode(object3[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } + } + function dump$1(input, options2) { + options2 = options2 || {}; + var state3 = new State(options2); + if (!state3.noRefs) getDuplicateReferences(input, state3); + var value2 = input; + if (state3.replacer) { + value2 = state3.replacer.call({ "": value2 }, "", value2); + } + if (writeNode(state3, 0, value2, true, true)) return state3.dump + "\n"; + return ""; + } + function renamed(from2, to) { + return function() { + throw new Error("Function yaml." + from2 + " is removed in js-yaml 4. Use yaml." + to + " instead, which is now safe by default."); + }; + } + var isNothing_1, isObject_1, toArray_1, repeat_1, isNegativeZero_1, extend_1, common, exception, snippet, TYPE_CONSTRUCTOR_OPTIONS, YAML_NODE_KINDS, type2, schema, str, seq, map2, failsafe, _null, bool, int, YAML_FLOAT_PATTERN, SCIENTIFIC_WITHOUT_DOT, float, json, core, YAML_DATE_REGEXP, YAML_TIMESTAMP_REGEXP, timestamp, merge2, BASE64_MAP, binary, _hasOwnProperty$3, _toString$2, omap, _toString$1, pairs, _hasOwnProperty$2, set3, _default, _hasOwnProperty$1, CONTEXT_FLOW_IN, CONTEXT_FLOW_OUT, CONTEXT_BLOCK_IN, CONTEXT_BLOCK_OUT, CHOMPING_CLIP, CHOMPING_STRIP, CHOMPING_KEEP, PATTERN_NON_PRINTABLE, PATTERN_NON_ASCII_LINE_BREAKS, PATTERN_FLOW_INDICATORS, PATTERN_TAG_HANDLE, PATTERN_TAG_URI, simpleEscapeCheck, simpleEscapeMap, i2, directiveHandlers, loadAll_1, load_1, loader2, _toString, _hasOwnProperty, CHAR_BOM, CHAR_TAB, CHAR_LINE_FEED, CHAR_CARRIAGE_RETURN, CHAR_SPACE, CHAR_EXCLAMATION, CHAR_DOUBLE_QUOTE, CHAR_SHARP, CHAR_PERCENT, CHAR_AMPERSAND, CHAR_SINGLE_QUOTE, CHAR_ASTERISK, CHAR_COMMA, CHAR_MINUS, CHAR_COLON, CHAR_EQUALS, CHAR_GREATER_THAN, CHAR_QUESTION, CHAR_COMMERCIAL_AT, CHAR_LEFT_SQUARE_BRACKET, CHAR_RIGHT_SQUARE_BRACKET, CHAR_GRAVE_ACCENT, CHAR_LEFT_CURLY_BRACKET, CHAR_VERTICAL_LINE, CHAR_RIGHT_CURLY_BRACKET, ESCAPE_SEQUENCES, DEPRECATED_BOOLEANS_SYNTAX, DEPRECATED_BASE60_SYNTAX, QUOTING_TYPE_SINGLE, QUOTING_TYPE_DOUBLE, STYLE_PLAIN, STYLE_SINGLE, STYLE_LITERAL, STYLE_FOLDED, STYLE_DOUBLE, dump_1, dumper, JSON_SCHEMA, load, loadAll, dump, safeLoad, safeLoadAll, safeDump; + var init_js_yaml = __esm({ + "../../node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/dist/js-yaml.mjs"() { + "use strict"; + __name(isNothing, "isNothing"); + __name(isObject2, "isObject"); + __name(toArray, "toArray"); + __name(extend2, "extend"); + __name(repeat, "repeat"); + __name(isNegativeZero, "isNegativeZero"); + isNothing_1 = isNothing; + isObject_1 = isObject2; + toArray_1 = toArray; + repeat_1 = repeat; + isNegativeZero_1 = isNegativeZero; + extend_1 = extend2; + common = { + isNothing: isNothing_1, + isObject: isObject_1, + toArray: toArray_1, + repeat: repeat_1, + isNegativeZero: isNegativeZero_1, + extend: extend_1 + }; + __name(formatError, "formatError"); + __name(YAMLException$1, "YAMLException$1"); + YAMLException$1.prototype = Object.create(Error.prototype); + YAMLException$1.prototype.constructor = YAMLException$1; + YAMLException$1.prototype.toString = /* @__PURE__ */ __name(function toString(compact2) { + return this.name + ": " + formatError(this, compact2); + }, "toString"); + exception = YAMLException$1; + __name(getLine, "getLine"); + __name(padStart, "padStart"); + __name(makeSnippet, "makeSnippet"); + snippet = makeSnippet; + TYPE_CONSTRUCTOR_OPTIONS = [ + "kind", + "multi", + "resolve", + "construct", + "instanceOf", + "predicate", + "represent", + "representName", + "defaultStyle", + "styleAliases" + ]; + YAML_NODE_KINDS = [ + "scalar", + "sequence", + "mapping" + ]; + __name(compileStyleAliases, "compileStyleAliases"); + __name(Type$1, "Type$1"); + type2 = Type$1; + __name(compileList, "compileList"); + __name(compileMap, "compileMap"); + __name(Schema$1, "Schema$1"); + Schema$1.prototype.extend = /* @__PURE__ */ __name(function extend3(definition) { + var implicit2 = []; + var explicit = []; + if (definition instanceof type2) { + 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) implicit2 = implicit2.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: [...] })"); + } + implicit2.forEach(function(type$1) { + if (!(type$1 instanceof type2)) { + 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 type2)) { + 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(implicit2); + 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; + }, "extend"); + schema = Schema$1; + str = new type2("tag:yaml.org,2002:str", { + kind: "scalar", + construct: /* @__PURE__ */ __name(function(data5) { + return data5 !== null ? data5 : ""; + }, "construct") + }); + seq = new type2("tag:yaml.org,2002:seq", { + kind: "sequence", + construct: /* @__PURE__ */ __name(function(data5) { + return data5 !== null ? data5 : []; + }, "construct") + }); + map2 = new type2("tag:yaml.org,2002:map", { + kind: "mapping", + construct: /* @__PURE__ */ __name(function(data5) { + return data5 !== null ? data5 : {}; + }, "construct") + }); + failsafe = new schema({ + explicit: [ + str, + seq, + map2 + ] + }); + __name(resolveYamlNull, "resolveYamlNull"); + __name(constructYamlNull, "constructYamlNull"); + __name(isNull, "isNull"); + _null = new type2("tag:yaml.org,2002:null", { + kind: "scalar", + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: /* @__PURE__ */ __name(function() { + return "~"; + }, "canonical"), + lowercase: /* @__PURE__ */ __name(function() { + return "null"; + }, "lowercase"), + uppercase: /* @__PURE__ */ __name(function() { + return "NULL"; + }, "uppercase"), + camelcase: /* @__PURE__ */ __name(function() { + return "Null"; + }, "camelcase"), + empty: /* @__PURE__ */ __name(function() { + return ""; + }, "empty") + }, + defaultStyle: "lowercase" + }); + __name(resolveYamlBoolean, "resolveYamlBoolean"); + __name(constructYamlBoolean, "constructYamlBoolean"); + __name(isBoolean, "isBoolean"); + bool = new type2("tag:yaml.org,2002:bool", { + kind: "scalar", + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: /* @__PURE__ */ __name(function(object3) { + return object3 ? "true" : "false"; + }, "lowercase"), + uppercase: /* @__PURE__ */ __name(function(object3) { + return object3 ? "TRUE" : "FALSE"; + }, "uppercase"), + camelcase: /* @__PURE__ */ __name(function(object3) { + return object3 ? "True" : "False"; + }, "camelcase") + }, + defaultStyle: "lowercase" + }); + __name(isHexCode, "isHexCode"); + __name(isOctCode, "isOctCode"); + __name(isDecCode, "isDecCode"); + __name(resolveYamlInteger, "resolveYamlInteger"); + __name(constructYamlInteger, "constructYamlInteger"); + __name(isInteger, "isInteger"); + int = new type2("tag:yaml.org,2002:int", { + kind: "scalar", + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: /* @__PURE__ */ __name(function(obj) { + return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1); + }, "binary"), + octal: /* @__PURE__ */ __name(function(obj) { + return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1); + }, "octal"), + decimal: /* @__PURE__ */ __name(function(obj) { + return obj.toString(10); + }, "decimal"), + /* eslint-disable max-len */ + hexadecimal: /* @__PURE__ */ __name(function(obj) { + return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1); + }, "hexadecimal") + }, + defaultStyle: "decimal", + styleAliases: { + binary: [2, "bin"], + octal: [8, "oct"], + decimal: [10, "dec"], + hexadecimal: [16, "hex"] + } + }); + 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))$" + ); + __name(resolveYamlFloat, "resolveYamlFloat"); + __name(constructYamlFloat, "constructYamlFloat"); + SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + __name(representYamlFloat, "representYamlFloat"); + __name(isFloat, "isFloat"); + float = new type2("tag:yaml.org,2002:float", { + kind: "scalar", + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: "lowercase" + }); + json = failsafe.extend({ + implicit: [ + _null, + bool, + int, + float + ] + }); + core = json; + YAML_DATE_REGEXP = new RegExp( + "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$" + ); + 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]))?))?$" + ); + __name(resolveYamlTimestamp, "resolveYamlTimestamp"); + __name(constructYamlTimestamp, "constructYamlTimestamp"); + __name(representYamlTimestamp, "representYamlTimestamp"); + timestamp = new type2("tag:yaml.org,2002:timestamp", { + kind: "scalar", + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp + }); + __name(resolveYamlMerge, "resolveYamlMerge"); + merge2 = new type2("tag:yaml.org,2002:merge", { + kind: "scalar", + resolve: resolveYamlMerge + }); + BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r"; + __name(resolveYamlBinary, "resolveYamlBinary"); + __name(constructYamlBinary, "constructYamlBinary"); + __name(representYamlBinary, "representYamlBinary"); + __name(isBinary, "isBinary"); + binary = new type2("tag:yaml.org,2002:binary", { + kind: "scalar", + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary + }); + _hasOwnProperty$3 = Object.prototype.hasOwnProperty; + _toString$2 = Object.prototype.toString; + __name(resolveYamlOmap, "resolveYamlOmap"); + __name(constructYamlOmap, "constructYamlOmap"); + omap = new type2("tag:yaml.org,2002:omap", { + kind: "sequence", + resolve: resolveYamlOmap, + construct: constructYamlOmap + }); + _toString$1 = Object.prototype.toString; + __name(resolveYamlPairs, "resolveYamlPairs"); + __name(constructYamlPairs, "constructYamlPairs"); + pairs = new type2("tag:yaml.org,2002:pairs", { + kind: "sequence", + resolve: resolveYamlPairs, + construct: constructYamlPairs + }); + _hasOwnProperty$2 = Object.prototype.hasOwnProperty; + __name(resolveYamlSet, "resolveYamlSet"); + __name(constructYamlSet, "constructYamlSet"); + set3 = new type2("tag:yaml.org,2002:set", { + kind: "mapping", + resolve: resolveYamlSet, + construct: constructYamlSet + }); + _default = core.extend({ + implicit: [ + timestamp, + merge2 + ], + explicit: [ + binary, + omap, + pairs, + set3 + ] + }); + _hasOwnProperty$1 = Object.prototype.hasOwnProperty; + CONTEXT_FLOW_IN = 1; + CONTEXT_FLOW_OUT = 2; + CONTEXT_BLOCK_IN = 3; + CONTEXT_BLOCK_OUT = 4; + CHOMPING_CLIP = 1; + CHOMPING_STRIP = 2; + CHOMPING_KEEP = 3; + PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; + PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; + PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; + PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; + PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + __name(_class, "_class"); + __name(is_EOL, "is_EOL"); + __name(is_WHITE_SPACE, "is_WHITE_SPACE"); + __name(is_WS_OR_EOL, "is_WS_OR_EOL"); + __name(is_FLOW_INDICATOR, "is_FLOW_INDICATOR"); + __name(fromHexCode, "fromHexCode"); + __name(escapedHexLen, "escapedHexLen"); + __name(fromDecimalCode, "fromDecimalCode"); + __name(simpleEscapeSequence, "simpleEscapeSequence"); + __name(charFromCodepoint, "charFromCodepoint"); + simpleEscapeCheck = new Array(256); + simpleEscapeMap = new Array(256); + for (i2 = 0; i2 < 256; i2++) { + simpleEscapeCheck[i2] = simpleEscapeSequence(i2) ? 1 : 0; + simpleEscapeMap[i2] = simpleEscapeSequence(i2); + } + __name(State$1, "State$1"); + __name(generateError, "generateError"); + __name(throwError, "throwError"); + __name(throwWarning, "throwWarning"); + directiveHandlers = { + YAML: /* @__PURE__ */ __name(function handleYamlDirective(state3, name, args) { + var match2, major, minor; + if (state3.version !== null) { + throwError(state3, "duplication of %YAML directive"); + } + if (args.length !== 1) { + throwError(state3, "YAML directive accepts exactly one argument"); + } + match2 = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + if (match2 === null) { + throwError(state3, "ill-formed argument of the YAML directive"); + } + major = parseInt(match2[1], 10); + minor = parseInt(match2[2], 10); + if (major !== 1) { + throwError(state3, "unacceptable YAML version of the document"); + } + state3.version = args[0]; + state3.checkLineBreaks = minor < 2; + if (minor !== 1 && minor !== 2) { + throwWarning(state3, "unsupported YAML version of the document"); + } + }, "handleYamlDirective"), + TAG: /* @__PURE__ */ __name(function handleTagDirective(state3, name, args) { + var handle, prefix; + if (args.length !== 2) { + throwError(state3, "TAG directive accepts exactly two arguments"); + } + handle = args[0]; + prefix = args[1]; + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state3, "ill-formed tag handle (first argument) of the TAG directive"); + } + if (_hasOwnProperty$1.call(state3.tagMap, handle)) { + throwError(state3, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state3, "ill-formed tag prefix (second argument) of the TAG directive"); + } + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state3, "tag prefix is malformed: " + prefix); + } + state3.tagMap[handle] = prefix; + }, "handleTagDirective") + }; + __name(captureSegment, "captureSegment"); + __name(mergeMappings, "mergeMappings"); + __name(storeMappingPair, "storeMappingPair"); + __name(readLineBreak, "readLineBreak"); + __name(skipSeparationSpace, "skipSeparationSpace"); + __name(testDocumentSeparator, "testDocumentSeparator"); + __name(writeFoldedLines, "writeFoldedLines"); + __name(readPlainScalar, "readPlainScalar"); + __name(readSingleQuotedScalar, "readSingleQuotedScalar"); + __name(readDoubleQuotedScalar, "readDoubleQuotedScalar"); + __name(readFlowCollection, "readFlowCollection"); + __name(readBlockScalar, "readBlockScalar"); + __name(readBlockSequence, "readBlockSequence"); + __name(readBlockMapping, "readBlockMapping"); + __name(readTagProperty, "readTagProperty"); + __name(readAnchorProperty, "readAnchorProperty"); + __name(readAlias, "readAlias"); + __name(composeNode, "composeNode"); + __name(readDocument, "readDocument"); + __name(loadDocuments, "loadDocuments"); + __name(loadAll$1, "loadAll$1"); + __name(load$1, "load$1"); + loadAll_1 = loadAll$1; + load_1 = load$1; + loader2 = { + loadAll: loadAll_1, + load: load_1 + }; + _toString = Object.prototype.toString; + _hasOwnProperty = Object.prototype.hasOwnProperty; + CHAR_BOM = 65279; + CHAR_TAB = 9; + CHAR_LINE_FEED = 10; + CHAR_CARRIAGE_RETURN = 13; + CHAR_SPACE = 32; + CHAR_EXCLAMATION = 33; + CHAR_DOUBLE_QUOTE = 34; + CHAR_SHARP = 35; + CHAR_PERCENT = 37; + CHAR_AMPERSAND = 38; + CHAR_SINGLE_QUOTE = 39; + CHAR_ASTERISK = 42; + CHAR_COMMA = 44; + CHAR_MINUS = 45; + CHAR_COLON = 58; + CHAR_EQUALS = 61; + CHAR_GREATER_THAN = 62; + CHAR_QUESTION = 63; + CHAR_COMMERCIAL_AT = 64; + CHAR_LEFT_SQUARE_BRACKET = 91; + CHAR_RIGHT_SQUARE_BRACKET = 93; + CHAR_GRAVE_ACCENT = 96; + CHAR_LEFT_CURLY_BRACKET = 123; + CHAR_VERTICAL_LINE = 124; + CHAR_RIGHT_CURLY_BRACKET = 125; + ESCAPE_SEQUENCES = {}; + ESCAPE_SEQUENCES[0] = "\\0"; + ESCAPE_SEQUENCES[7] = "\\a"; + ESCAPE_SEQUENCES[8] = "\\b"; + ESCAPE_SEQUENCES[9] = "\\t"; + ESCAPE_SEQUENCES[10] = "\\n"; + ESCAPE_SEQUENCES[11] = "\\v"; + ESCAPE_SEQUENCES[12] = "\\f"; + ESCAPE_SEQUENCES[13] = "\\r"; + ESCAPE_SEQUENCES[27] = "\\e"; + ESCAPE_SEQUENCES[34] = '\\"'; + ESCAPE_SEQUENCES[92] = "\\\\"; + ESCAPE_SEQUENCES[133] = "\\N"; + ESCAPE_SEQUENCES[160] = "\\_"; + ESCAPE_SEQUENCES[8232] = "\\L"; + ESCAPE_SEQUENCES[8233] = "\\P"; + DEPRECATED_BOOLEANS_SYNTAX = [ + "y", + "Y", + "yes", + "Yes", + "YES", + "on", + "On", + "ON", + "n", + "N", + "no", + "No", + "NO", + "off", + "Off", + "OFF" + ]; + DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; + __name(compileStyleMap, "compileStyleMap"); + __name(encodeHex, "encodeHex"); + QUOTING_TYPE_SINGLE = 1; + QUOTING_TYPE_DOUBLE = 2; + __name(State, "State"); + __name(indentString, "indentString"); + __name(generateNextLine, "generateNextLine"); + __name(testImplicitResolving, "testImplicitResolving"); + __name(isWhitespace, "isWhitespace"); + __name(isPrintable, "isPrintable"); + __name(isNsCharOrWhitespace, "isNsCharOrWhitespace"); + __name(isPlainSafe, "isPlainSafe"); + __name(isPlainSafeFirst, "isPlainSafeFirst"); + __name(isPlainSafeLast, "isPlainSafeLast"); + __name(codePointAt, "codePointAt"); + __name(needIndentIndicator, "needIndentIndicator"); + STYLE_PLAIN = 1; + STYLE_SINGLE = 2; + STYLE_LITERAL = 3; + STYLE_FOLDED = 4; + STYLE_DOUBLE = 5; + __name(chooseScalarStyle, "chooseScalarStyle"); + __name(writeScalar, "writeScalar"); + __name(blockHeader, "blockHeader"); + __name(dropEndingNewline, "dropEndingNewline"); + __name(foldString, "foldString"); + __name(foldLine, "foldLine"); + __name(escapeString, "escapeString"); + __name(writeFlowSequence, "writeFlowSequence"); + __name(writeBlockSequence, "writeBlockSequence"); + __name(writeFlowMapping, "writeFlowMapping"); + __name(writeBlockMapping, "writeBlockMapping"); + __name(detectType2, "detectType"); + __name(writeNode, "writeNode"); + __name(getDuplicateReferences, "getDuplicateReferences"); + __name(inspectNode, "inspectNode"); + __name(dump$1, "dump$1"); + dump_1 = dump$1; + dumper = { + dump: dump_1 + }; + __name(renamed, "renamed"); + JSON_SCHEMA = json; + load = loader2.load; + loadAll = loader2.loadAll; + dump = dumper.dump; + safeLoad = renamed("safeLoad", "load"); + safeLoadAll = renamed("safeLoadAll", "loadAll"); + safeDump = renamed("safeDump", "dump"); + } + }); + + // ../../node_modules/.pnpm/marked@16.3.0/node_modules/marked/lib/marked.esm.js + function L() { + return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null }; + } + function G(l4) { + O = l4; + } + function h(l4, e3 = "") { + let t4 = typeof l4 == "string" ? l4 : l4.source, n2 = { replace: /* @__PURE__ */ __name((r2, i2) => { + let s2 = typeof i2 == "string" ? i2 : i2.source; + return s2 = s2.replace(m.caret, "$1"), t4 = t4.replace(r2, s2), n2; + }, "replace"), getRegex: /* @__PURE__ */ __name(() => new RegExp(t4, e3), "getRegex") }; + return n2; + } + function w(l4, e3) { + if (e3) { + if (m.escapeTest.test(l4)) return l4.replace(m.escapeReplace, ke); + } else if (m.escapeTestNoEncode.test(l4)) return l4.replace(m.escapeReplaceNoEncode, ke); + return l4; + } + function J(l4) { + try { + l4 = encodeURI(l4).replace(m.percentDecode, "%"); + } catch { + return null; + } + return l4; + } + function V(l4, e3) { + let t4 = l4.replace(m.findPipe, (i2, s2, o2) => { + let a2 = false, u2 = s2; + for (; --u2 >= 0 && o2[u2] === "\\"; ) a2 = !a2; + return a2 ? "|" : " |"; + }), n2 = t4.split(m.splitPipe), r2 = 0; + if (n2[0].trim() || n2.shift(), n2.length > 0 && !n2.at(-1)?.trim() && n2.pop(), e3) if (n2.length > e3) n2.splice(e3); + else for (; n2.length < e3; ) n2.push(""); + for (; r2 < n2.length; r2++) n2[r2] = n2[r2].trim().replace(m.slashPipe, "|"); + return n2; + } + function z(l4, e3, t4) { + let n2 = l4.length; + if (n2 === 0) return ""; + let r2 = 0; + for (; r2 < n2; ) { + let i2 = l4.charAt(n2 - r2 - 1); + if (i2 === e3 && !t4) r2++; + else if (i2 !== e3 && t4) r2++; + else break; + } + return l4.slice(0, n2 - r2); + } + function ge(l4, e3) { + if (l4.indexOf(e3[1]) === -1) return -1; + let t4 = 0; + for (let n2 = 0; n2 < l4.length; n2++) if (l4[n2] === "\\") n2++; + else if (l4[n2] === e3[0]) t4++; + else if (l4[n2] === e3[1] && (t4--, t4 < 0)) return n2; + return t4 > 0 ? -2 : -1; + } + function fe(l4, e3, t4, n2, r2) { + let i2 = e3.href, s2 = e3.title || null, o2 = l4[1].replace(r2.other.outputLinkReplace, "$1"); + n2.state.inLink = true; + let a2 = { type: l4[0].charAt(0) === "!" ? "image" : "link", raw: t4, href: i2, title: s2, text: o2, tokens: n2.inlineTokens(o2) }; + return n2.state.inLink = false, a2; + } + function Je(l4, e3, t4) { + let n2 = l4.match(t4.other.indentCodeCompensation); + if (n2 === null) return e3; + let r2 = n2[1]; + return e3.split(` +`).map((i2) => { + let s2 = i2.match(t4.other.beginningSpace); + if (s2 === null) return i2; + let [o2] = s2; + return o2.length >= r2.length ? i2.slice(r2.length) : i2; + }).join(` +`); + } + function d(l4, e3) { + return _.parse(l4, e3); + } + var O, E, m, xe, be, Re, C, Oe, j, se, ie, Te, F, we, Q, ye, Pe, v, U, Se, oe, $e, K2, re2, _e, Le, Me, ze, ae, Ae, D2, W, le, Ee, ue, Ce, Ie, Be, pe, qe, ve, ce, De, He, Ze, Ge, Ne, je, Fe, q, Qe, he, de, Ue, X2, Ke, N, We, I, M, Xe, ke, y2, b, P, $, R, S2, B, _, Dt, Ht, Zt, Gt, Nt, Ft, Qt; + var init_marked_esm = __esm({ + "../../node_modules/.pnpm/marked@16.3.0/node_modules/marked/lib/marked.esm.js"() { + "use strict"; + __name(L, "L"); + O = L(); + __name(G, "G"); + E = { exec: /* @__PURE__ */ __name(() => null, "exec") }; + __name(h, "h"); + m = { codeRemoveIndent: /^(?: {1,4}| {0,3}\t)/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceTabs: /^\t+/, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] /, listReplaceTask: /^\[[ xX]\] +/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, unescapeTest: /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^( {0,3}${l4})((?:[ ][^\\n]*)?(?:\\n|$))`), "listItemRegex"), nextBulletRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}(?:[*+-]|\\d{1,9}[.)])((?:[ ][^\\n]*)?(?:\\n|$))`), "nextBulletRegex"), hrRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`), "hrRegex"), fencesBeginRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}(?:\`\`\`|~~~)`), "fencesBeginRegex"), headingBeginRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}#`), "headingBeginRegex"), htmlBeginRegex: /* @__PURE__ */ __name((l4) => new RegExp(`^ {0,${Math.min(3, l4 - 1)}}<(?:[a-z].*>|!--)`, "i"), "htmlBeginRegex") }; + xe = /^(?:[ \t]*(?:\n|$))+/; + be = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/; + Re = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/; + C = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/; + Oe = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/; + j = /(?:[*+-]|\d{1,9}[.)])/; + se = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |blockCode|fences|blockquote|heading|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/; + ie = h(se).replace(/bull/g, j).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex(); + Te = h(se).replace(/bull/g, j).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex(); + F = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table| +\n)[^\n]+)*)/; + we = /^[^\n]+/; + Q = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/; + ye = h(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", Q).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex(); + Pe = h(/^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/).replace(/bull/g, j).getRegex(); + v = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul"; + U = /|$))/; + Se = h("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:[^\\n]*\\n+|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>\\n*|$)|\\n*|$)|\\n*|$)|)[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][\\w-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$)|(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ ]*)+\\n|$))", "i").replace("comment", U).replace("tag", v).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex(); + oe = h(F).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex(); + $e = h(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", oe).getRegex(); + K2 = { blockquote: $e, code: be, def: ye, fences: Re, heading: Oe, hr: C, html: Se, lheading: ie, list: Pe, newline: xe, paragraph: oe, table: E, text: we }; + re2 = h("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3} )[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex(); + _e = { ...K2, lheading: Te, table: re2, paragraph: h(F).replace("hr", C).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", re2).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*\\n)|~{3,})[^\\n]*\\n").replace("list", " {0,3}(?:[*+-]|1[.)]) ").replace("html", ")|<(?:script|pre|style|textarea|!--)").replace("tag", v).getRegex() }; + Le = { ...K2, html: h(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+? *(?:\\n{2,}|\\s*$)|
' + (n2 ? i2 : w(i2, true)) + `" + (n2 ? i2 : w(i2, true)) + `+${this.parser.parse(e3)}+`; + } + html({ text: e3 }) { + return e3; + } + def(e3) { + return ""; + } + heading({ tokens: e3, depth: t4 }) { + return `
+`; + } + list(e3) { + let t4 = e3.ordered, n2 = e3.start, r2 = ""; + for (let o2 = 0; o2 < e3.items.length; o2++) { + let a2 = e3.items[o2]; + r2 += this.listitem(a2); + } + let i2 = t4 ? "ol" : "ul", s2 = t4 && n2 !== 1 ? ' start="' + n2 + '"' : ""; + return "<" + i2 + s2 + `> +` + r2 + " +`; + } + listitem(e3) { + let t4 = ""; + if (e3.task) { + let n2 = this.checkbox({ checked: !!e3.checked }); + e3.loose ? e3.tokens[0]?.type === "paragraph" ? (e3.tokens[0].text = n2 + " " + e3.tokens[0].text, e3.tokens[0].tokens && e3.tokens[0].tokens.length > 0 && e3.tokens[0].tokens[0].type === "text" && (e3.tokens[0].tokens[0].text = n2 + " " + w(e3.tokens[0].tokens[0].text), e3.tokens[0].tokens[0].escaped = true)) : e3.tokens.unshift({ type: "text", raw: n2 + " ", text: n2 + " ", escaped: true }) : t4 += n2 + " "; + } + return t4 += this.parser.parse(e3.tokens, !!e3.loose), `
${this.parser.parseInline(e3)}
+`; + } + table(e3) { + let t4 = "", n2 = ""; + for (let i2 = 0; i2 < e3.header.length; i2++) n2 += this.tablecell(e3.header[i2]); + t4 += this.tablerow({ text: n2 }); + let r2 = ""; + for (let i2 = 0; i2 < e3.rows.length; i2++) { + let s2 = e3.rows[i2]; + n2 = ""; + for (let o2 = 0; o2 < s2.length; o2++) n2 += this.tablecell(s2[o2]); + r2 += this.tablerow({ text: n2 }); + } + return r2 && (r2 = `${r2}`), `${w(e3, true)}`;
+ }
+ br(e3) {
+ return ""; + } + del({ tokens: e3 }) { + return `
An error occurred:
" + w(n2.message + "", true) + ""; + return t4 ? Promise.resolve(r2) : r2; + } + if (t4) return Promise.reject(n2); + throw n2; + }; + } + }; + _ = new B(); + __name(d, "d"); + d.options = d.setOptions = function(l4) { + return _.setOptions(l4), d.defaults = _.defaults, G(d.defaults), d; + }; + d.getDefaults = L; + d.defaults = O; + d.use = function(...l4) { + return _.use(...l4), d.defaults = _.defaults, G(d.defaults), d; + }; + d.walkTokens = function(l4, e3) { + return _.walkTokens(l4, e3); + }; + d.parseInline = _.parseInline; + d.Parser = R; + d.parser = R.parse; + d.Renderer = P; + d.TextRenderer = $; + d.Lexer = b; + d.lexer = b.lex; + d.Tokenizer = y2; + d.Hooks = S2; + d.parse = d; + Dt = d.options; + Ht = d.setOptions; + Zt = d.use; + Gt = d.walkTokens; + Nt = d.parseInline; + Ft = R.parse; + Qt = b.lex; + } + }); + + // src/rendering-util/handle-markdown-text.ts + function preprocessMarkdown(markdown, { markdownAutoWrap }) { + const withoutBR = markdown.replace(/
").replace(/ /g, " "); + } + return node2.text.replace(/\n */g, "
"); + } else if (node2.type === "strong") { + return `${node2.tokens?.map(output2).join("")}`; + } else if (node2.type === "em") { + return `${node2.tokens?.map(output2).join("")}`; + } else if (node2.type === "paragraph") { + return `
${node2.tokens?.map(output2).join("")}
`; + } else if (node2.type === "space") { + return ""; + } else if (node2.type === "html") { + return `${node2.text}`; + } else if (node2.type === "escape") { + return node2.text; + } + log.warn(`Unsupported markdown: ${node2.type}`); + return node2.raw; + } + __name(output2, "output"); + return nodes5.map(output2).join(""); + } + var init_handle_markdown_text = __esm({ + "src/rendering-util/handle-markdown-text.ts"() { + "use strict"; + init_marked_esm(); + init_esm(); + init_logger(); + __name(preprocessMarkdown, "preprocessMarkdown"); + __name(markdownToLines, "markdownToLines"); + __name(markdownToHTML, "markdownToHTML"); + } + }); + + // src/rendering-util/splitText.ts + function splitTextToChars(text4) { + if (Intl.Segmenter) { + return [...new Intl.Segmenter().segment(text4)].map((s2) => s2.segment); + } + return [...text4]; + } + function splitWordToFitWidth(checkFit, word) { + const characters2 = splitTextToChars(word.content); + return splitWordToFitWidthRecursion(checkFit, [], characters2, word.type); + } + function splitWordToFitWidthRecursion(checkFit, usedChars, remainingChars, type3) { + if (remainingChars.length === 0) { + return [ + { content: usedChars.join(""), type: type3 }, + { content: "", type: type3 } + ]; + } + const [nextChar, ...rest] = remainingChars; + const newWord = [...usedChars, nextChar]; + if (checkFit([{ content: newWord.join(""), type: type3 }])) { + return splitWordToFitWidthRecursion(checkFit, newWord, rest, type3); + } + if (usedChars.length === 0 && nextChar) { + usedChars.push(nextChar); + remainingChars.shift(); + } + return [ + { content: usedChars.join(""), type: type3 }, + { content: remainingChars.join(""), type: type3 } + ]; + } + function splitLineToFitWidth(line2, checkFit) { + if (line2.some(({ content }) => content.includes("\n"))) { + throw new Error("splitLineToFitWidth does not support newlines in the line"); + } + return splitLineToFitWidthRecursion(line2, checkFit); + } + function splitLineToFitWidthRecursion(words, checkFit, lines = [], newLine = []) { + if (words.length === 0) { + if (newLine.length > 0) { + lines.push(newLine); + } + return lines.length > 0 ? lines : []; + } + let joiner = ""; + if (words[0].content === " ") { + joiner = " "; + words.shift(); + } + const nextWord = words.shift() ?? { content: " ", type: "normal" }; + const lineWithNextWord = [...newLine]; + if (joiner !== "") { + lineWithNextWord.push({ content: joiner, type: "normal" }); + } + lineWithNextWord.push(nextWord); + if (checkFit(lineWithNextWord)) { + return splitLineToFitWidthRecursion(words, checkFit, lines, lineWithNextWord); + } + if (newLine.length > 0) { + lines.push(newLine); + words.unshift(nextWord); + } else if (nextWord.content) { + const [line2, rest] = splitWordToFitWidth(checkFit, nextWord); + lines.push([line2]); + if (rest.content) { + words.unshift(rest); + } + } + return splitLineToFitWidthRecursion(words, checkFit, lines); + } + var init_splitText = __esm({ + "src/rendering-util/splitText.ts"() { + "use strict"; + __name(splitTextToChars, "splitTextToChars"); + __name(splitWordToFitWidth, "splitWordToFitWidth"); + __name(splitWordToFitWidthRecursion, "splitWordToFitWidthRecursion"); + __name(splitLineToFitWidth, "splitLineToFitWidth"); + __name(splitLineToFitWidthRecursion, "splitLineToFitWidthRecursion"); + } + }); + + // src/rendering-util/createText.ts + function applyStyle(dom, styleFn) { + if (styleFn) { + dom.attr("style", styleFn); + } + } + async function addHtmlSpan(element3, node2, width3, classes3, addBackground = false, config5 = getConfig()) { + const fo = element3.append("foreignObject"); + fo.attr("width", `${10 * width3}px`); + fo.attr("height", `${10 * width3}px`); + const div = fo.append("xhtml:div"); + const sanitizedLabel = hasKatex(node2.label) ? await renderKatexSanitized(node2.label.replace(common_default.lineBreakRegex, "\n"), config5) : sanitizeText(node2.label, config5); + const labelClass = node2.isNode ? "nodeLabel" : "edgeLabel"; + const span = div.append("span"); + span.html(sanitizedLabel); + applyStyle(span, node2.labelStyle); + span.attr("class", `${labelClass} ${classes3}`); + applyStyle(div, node2.labelStyle); + div.style("display", "table-cell"); + div.style("white-space", "nowrap"); + div.style("line-height", "1.5"); + div.style("max-width", width3 + "px"); + div.style("text-align", "center"); + div.attr("xmlns", "http://www.w3.org/1999/xhtml"); + if (addBackground) { + div.attr("class", "labelBkg"); + } + let bbox = div.node().getBoundingClientRect(); + if (bbox.width === width3) { + div.style("display", "table"); + div.style("white-space", "break-spaces"); + div.style("width", width3 + "px"); + bbox = div.node().getBoundingClientRect(); + } + return fo.node(); + } + function createTspan(textElement, lineIndex, lineHeight) { + return textElement.append("tspan").attr("class", "text-outer-tspan").attr("x", 0).attr("y", lineIndex * lineHeight - 0.1 + "em").attr("dy", lineHeight + "em"); + } + function computeWidthOfText(parentNode, lineHeight, line2) { + const testElement = parentNode.append("text"); + const testSpan = createTspan(testElement, 1, lineHeight); + updateTextContentAndStyles(testSpan, line2); + const textLength = testSpan.node().getComputedTextLength(); + testElement.remove(); + return textLength; + } + function computeDimensionOfText(parentNode, lineHeight, text4) { + const testElement = parentNode.append("text"); + const testSpan = createTspan(testElement, 1, lineHeight); + updateTextContentAndStyles(testSpan, [{ content: text4, type: "normal" }]); + const textDimension = testSpan.node()?.getBoundingClientRect(); + if (textDimension) { + testElement.remove(); + } + return textDimension; + } + function createFormattedText(width3, g2, structuredText, addBackground = false) { + const lineHeight = 1.1; + const labelGroup = g2.append("g"); + const bkg = labelGroup.insert("rect").attr("class", "background").attr("style", "stroke: none"); + const textElement = labelGroup.append("text").attr("y", "-10.1"); + let lineIndex = 0; + for (const line2 of structuredText) { + const checkWidth = /* @__PURE__ */ __name((line3) => computeWidthOfText(labelGroup, lineHeight, line3) <= width3, "checkWidth"); + const linesUnderWidth = checkWidth(line2) ? [line2] : splitLineToFitWidth(line2, checkWidth); + for (const preparedLine of linesUnderWidth) { + const tspan = createTspan(textElement, lineIndex, lineHeight); + updateTextContentAndStyles(tspan, preparedLine); + lineIndex++; + } + } + if (addBackground) { + const bbox = textElement.node().getBBox(); + const padding2 = 2; + bkg.attr("x", bbox.x - padding2).attr("y", bbox.y - padding2).attr("width", bbox.width + 2 * padding2).attr("height", bbox.height + 2 * padding2); + return labelGroup.node(); + } else { + return textElement.node(); + } + } + function updateTextContentAndStyles(tspan, wrappedLine) { + tspan.text(""); + wrappedLine.forEach((word, index) => { + const innerTspan = tspan.append("tspan").attr("font-style", word.type === "em" ? "italic" : "normal").attr("class", "text-inner-tspan").attr("font-weight", word.type === "strong" ? "bold" : "normal"); + if (index === 0) { + innerTspan.text(word.content); + } else { + innerTspan.text(" " + word.content); + } + }); + } + async function replaceIconSubstring(text4, config5 = {}) { + const pendingReplacements = []; + text4.replace(/(fa[bklrs]?):fa-([\w-]+)/g, (fullMatch, prefix, iconName) => { + pendingReplacements.push( + (async () => { + const registeredIconName = `${prefix}:${iconName}`; + if (await isIconAvailable(registeredIconName)) { + return await getIconSVG(registeredIconName, void 0, { class: "label-icon" }); + } else { + return ``; + } + })() + ); + return fullMatch; + }); + const replacements = await Promise.all(pendingReplacements); + return text4.replace(/(fa[bklrs]?):fa-([\w-]+)/g, () => replacements.shift() ?? ""); + } + var createText; + var init_createText = __esm({ + "src/rendering-util/createText.ts"() { + "use strict"; + init_src32(); + init_common(); + init_logger(); + init_handle_markdown_text(); + init_utils2(); + init_icons(); + init_splitText(); + init_config(); + __name(applyStyle, "applyStyle"); + __name(addHtmlSpan, "addHtmlSpan"); + __name(createTspan, "createTspan"); + __name(computeWidthOfText, "computeWidthOfText"); + __name(computeDimensionOfText, "computeDimensionOfText"); + __name(createFormattedText, "createFormattedText"); + __name(updateTextContentAndStyles, "updateTextContentAndStyles"); + __name(replaceIconSubstring, "replaceIconSubstring"); + createText = /* @__PURE__ */ __name(async (el, text4 = "", { + style: style3 = "", + isTitle = false, + classes: classes3 = "", + useHtmlLabels = true, + isNode: isNode2 = true, + width: width3 = 200, + addSvgBackground = false + } = {}, config5) => { + log.debug( + "XYZ createText", + text4, + style3, + isTitle, + classes3, + useHtmlLabels, + isNode2, + "addSvgBackground: ", + addSvgBackground + ); + if (useHtmlLabels) { + const htmlText = markdownToHTML(text4, config5); + const decodedReplacedText = await replaceIconSubstring(decodeEntities(htmlText), config5); + const inputForKatex = text4.replace(/\\\\/g, "\\"); + const node2 = { + isNode: isNode2, + label: hasKatex(text4) ? inputForKatex : decodedReplacedText, + labelStyle: style3.replace("fill:", "color:") + }; + const vertexNode = await addHtmlSpan(el, node2, width3, classes3, addSvgBackground, config5); + return vertexNode; + } else { + const sanitizeBR = text4.replace(/"); + const structuredText = markdownToLines(sanitizeBR.replace("
", "
"), config5); + const svgLabel = createFormattedText( + width3, + el, + structuredText, + text4 ? addSvgBackground : false + ); + if (isNode2) { + if (/stroke:/.exec(style3)) { + style3 = style3.replace("stroke:", "lineColor:"); + } + const nodeLabelTextStyle = style3.replace(/stroke:[^;]+;?/g, "").replace(/stroke-width:[^;]+;?/g, "").replace(/fill:[^;]+;?/g, "").replace(/color:/g, "fill:"); + select_default2(svgLabel).attr("style", nodeLabelTextStyle); + } else { + const edgeLabelRectStyle = style3.replace(/stroke:[^;]+;?/g, "").replace(/stroke-width:[^;]+;?/g, "").replace(/fill:[^;]+;?/g, "").replace(/background:/g, "fill:"); + select_default2(svgLabel).select("rect").attr("style", edgeLabelRectStyle.replace(/background:/g, "fill:")); + const edgeLabelTextStyle = style3.replace(/stroke:[^;]+;?/g, "").replace(/stroke-width:[^;]+;?/g, "").replace(/fill:[^;]+;?/g, "").replace(/color:/g, "fill:"); + select_default2(svgLabel).select("text").attr("style", edgeLabelTextStyle); + } + return svgLabel; + } + }, "createText"); + } + }); + + // src/rendering-util/rendering-elements/shapes/util.ts + function createPathFromPoints(points) { + const pointStrings = points.map((p3, i2) => `${i2 === 0 ? "M" : "L"}${p3.x},${p3.y}`); + pointStrings.push("Z"); + return pointStrings.join(" "); + } + function generateFullSineWavePoints(x1, y1, x22, y22, amplitude, numCycles) { + const points = []; + const steps = 50; + const deltaX = x22 - x1; + const deltaY = y22 - y1; + const cycleLength = deltaX / numCycles; + const frequency = 2 * Math.PI / cycleLength; + const midY = y1 + deltaY / 2; + for (let i2 = 0; i2 <= steps; i2++) { + const t4 = i2 / steps; + const x5 = x1 + t4 * deltaX; + const y6 = midY + amplitude * Math.sin(frequency * (x5 - x1)); + points.push({ x: x5, y: y6 }); + } + return points; + } + function generateCirclePoints(centerX, centerY, radius2, numPoints, startAngle, endAngle) { + const points = []; + const startAngleRad = startAngle * Math.PI / 180; + const endAngleRad = endAngle * Math.PI / 180; + const angleRange = endAngleRad - startAngleRad; + const angleStep = angleRange / (numPoints - 1); + for (let i2 = 0; i2 < numPoints; i2++) { + const angle2 = startAngleRad + i2 * angleStep; + const x5 = centerX + radius2 * Math.cos(angle2); + const y6 = centerY + radius2 * Math.sin(angle2); + points.push({ x: -x5, y: -y6 }); + } + return points; + } + var labelHelper, insertLabel, updateNodeBounds, getNodeClasses; + var init_util = __esm({ + "src/rendering-util/rendering-elements/shapes/util.ts"() { + "use strict"; + init_createText(); + init_diagramAPI(); + init_src32(); + init_defaultConfig(); + init_common(); + init_utils2(); + labelHelper = /* @__PURE__ */ __name(async (parent4, node2, _classes) => { + let cssClasses; + const useHtmlLabels = node2.useHtmlLabels || evaluate(getConfig2()?.htmlLabels); + if (!_classes) { + cssClasses = "node default"; + } else { + cssClasses = _classes; + } + const shapeSvg = parent4.insert("g").attr("class", cssClasses).attr("id", node2.domId || node2.id); + const labelEl = shapeSvg.insert("g").attr("class", "label").attr("style", handleUndefinedAttr(node2.labelStyle)); + let label; + if (node2.label === void 0) { + label = ""; + } else { + label = typeof node2.label === "string" ? node2.label : node2.label[0]; + } + const text4 = await createText(labelEl, sanitizeText(decodeEntities(label), getConfig2()), { + useHtmlLabels, + width: node2.width || getConfig2().flowchart?.wrappingWidth, + // @ts-expect-error -- This is currently not used. Should this be `classes` instead? + cssClasses: "markdown-node-label", + style: node2.labelStyle, + addSvgBackground: !!node2.icon || !!node2.img + }); + let bbox = text4.getBBox(); + const halfPadding = (node2?.padding ?? 0) / 2; + if (useHtmlLabels) { + const div = text4.children[0]; + const dv = select_default2(text4); + const images = div.getElementsByTagName("img"); + if (images) { + const noImgText = label.replace(/
"); + log.info("vertexText" + vertexText); + const node2 = { + isNode: isNode2, + label: decodeEntities(vertexText).replace( + /fa[blrs]?:fa-[\w-]+/g, + (s2) => `` + ), + labelStyle: style3 ? style3.replace("fill:", "color:") : style3 + }; + let vertexNode = await addHtmlLabel(node2); + return vertexNode; + } else { + const svgLabel = document.createElementNS("http://www.w3.org/2000/svg", "text"); + svgLabel.setAttribute("style", style3.replace("color:", "fill:")); + let rows = []; + if (typeof vertexText === "string") { + rows = vertexText.split(/\\n|\n|
") : textRows, + node2.labelStyle, + true, + true + ) + ); + const div = descr.children[0]; + const dv = select_default2(descr); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + const halfPadding = (node2.padding || 0) / 2; + select_default2(descr).attr( + "transform", + "translate( " + (bbox.width > titleBox.width ? 0 : (titleBox.width - bbox.width) / 2) + ", " + (titleBox.height + halfPadding + 5) + ")" + ); + select_default2(text4).attr( + "transform", + "translate( " + (bbox.width < titleBox.width ? 0 : -(titleBox.width - bbox.width) / 2) + ", 0)" + ); + bbox = label.node().getBBox(); + label.attr( + "transform", + "translate(" + -bbox.width / 2 + ", " + (-bbox.height / 2 - halfPadding + 3) + ")" + ); + const totalWidth = bbox.width + (node2.padding || 0); + const totalHeight = bbox.height + (node2.padding || 0); + const x5 = -bbox.width / 2 - halfPadding; + const y6 = -bbox.height / 2 - halfPadding; + let rect3; + let innerLine; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + const roughNode = rc.path( + createRoundedRectPathD(x5, y6, totalWidth, totalHeight, node2.rx || 0), + options2 + ); + const roughLine = rc.line( + -bbox.width / 2 - halfPadding, + -bbox.height / 2 - halfPadding + titleBox.height + halfPadding, + bbox.width / 2 + halfPadding, + -bbox.height / 2 - halfPadding + titleBox.height + halfPadding, + options2 + ); + innerLine = shapeSvg.insert(() => { + log.debug("Rough node insert CXC", roughNode); + return roughLine; + }, ":first-child"); + rect3 = shapeSvg.insert(() => { + log.debug("Rough node insert CXC", roughNode); + return roughNode; + }, ":first-child"); + } else { + rect3 = g2.insert("rect", ":first-child"); + innerLine = g2.insert("line"); + rect3.attr("class", "outer title-state").attr("style", nodeStyles).attr("x", -bbox.width / 2 - halfPadding).attr("y", -bbox.height / 2 - halfPadding).attr("width", bbox.width + (node2.padding || 0)).attr("height", bbox.height + (node2.padding || 0)); + innerLine.attr("class", "divider").attr("x1", -bbox.width / 2 - halfPadding).attr("x2", bbox.width / 2 + halfPadding).attr("y1", -bbox.height / 2 - halfPadding + titleBox.height + halfPadding).attr("y2", -bbox.height / 2 - halfPadding + titleBox.height + halfPadding); + } + updateNodeBounds(node2, rect3); + node2.intersect = function(point8) { + return intersect_default.rect(node2, point8); + }; + return shapeSvg; + } + var init_rectWithTitle = __esm({ + "src/rendering-util/rendering-elements/shapes/rectWithTitle.ts"() { + "use strict"; + init_src32(); + init_common(); + init_util(); + init_createLabel(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_diagramAPI(); + init_roundedRectPath(); + init_logger(); + __name(rectWithTitle, "rectWithTitle"); + } + }); + + // src/rendering-util/rendering-elements/shapes/roundedRect.ts + function generateArcPoints2(x1, y1, x22, y22, rx, ry, clockwise) { + const numPoints = 20; + const midX = (x1 + x22) / 2; + const midY = (y1 + y22) / 2; + const angle2 = Math.atan2(y22 - y1, x22 - x1); + const dx = (x22 - x1) / 2; + const dy = (y22 - y1) / 2; + const transformedX = dx / rx; + const transformedY = dy / ry; + const distance2 = Math.sqrt(transformedX ** 2 + transformedY ** 2); + if (distance2 > 1) { + throw new Error("The given radii are too small to create an arc between the points."); + } + const scaledCenterDistance = Math.sqrt(1 - distance2 ** 2); + const centerX = midX + scaledCenterDistance * ry * Math.sin(angle2) * (clockwise ? -1 : 1); + const centerY = midY - scaledCenterDistance * rx * Math.cos(angle2) * (clockwise ? -1 : 1); + const startAngle = Math.atan2((y1 - centerY) / ry, (x1 - centerX) / rx); + const endAngle = Math.atan2((y22 - centerY) / ry, (x22 - centerX) / rx); + let angleRange = endAngle - startAngle; + if (clockwise && angleRange < 0) { + angleRange += 2 * Math.PI; + } + if (!clockwise && angleRange > 0) { + angleRange -= 2 * Math.PI; + } + const points = []; + for (let i2 = 0; i2 < numPoints; i2++) { + const t4 = i2 / (numPoints - 1); + const angle3 = startAngle + t4 * angleRange; + const x5 = centerX + rx * Math.cos(angle3); + const y6 = centerY + ry * Math.sin(angle3); + points.push({ x: x5, y: y6 }); + } + return points; + } + async function roundedRect(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const labelPaddingX = node2?.padding ?? 0; + const labelPaddingY = node2?.padding ?? 0; + const w4 = (node2?.width ? node2?.width : bbox.width) + labelPaddingX * 2; + const h3 = (node2?.height ? node2?.height : bbox.height) + labelPaddingY * 2; + const radius2 = node2.radius || 5; + const taper = node2.taper || 5; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.stroke) { + options2.stroke = node2.stroke; + } + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + // Top edge (left to right) + { x: -w4 / 2 + taper, y: -h3 / 2 }, + // Top-left corner start (1) + { x: w4 / 2 - taper, y: -h3 / 2 }, + // Top-right corner start (2) + ...generateArcPoints2(w4 / 2 - taper, -h3 / 2, w4 / 2, -h3 / 2 + taper, radius2, radius2, true), + // Top-left arc (2 to 3) + // Right edge (top to bottom) + { x: w4 / 2, y: -h3 / 2 + taper }, + // Top-right taper point (3) + { x: w4 / 2, y: h3 / 2 - taper }, + // Bottom-right taper point (4) + ...generateArcPoints2(w4 / 2, h3 / 2 - taper, w4 / 2 - taper, h3 / 2, radius2, radius2, true), + // Top-left arc (4 to 5) + // Bottom edge (right to left) + { x: w4 / 2 - taper, y: h3 / 2 }, + // Bottom-right corner start (5) + { x: -w4 / 2 + taper, y: h3 / 2 }, + // Bottom-left corner start (6) + ...generateArcPoints2(-w4 / 2 + taper, h3 / 2, -w4 / 2, h3 / 2 - taper, radius2, radius2, true), + // Top-left arc (4 to 5) + // Left edge (bottom to top) + { x: -w4 / 2, y: h3 / 2 - taper }, + // Bottom-left taper point (7) + { x: -w4 / 2, y: -h3 / 2 + taper }, + // Top-left taper point (8) + ...generateArcPoints2(-w4 / 2, -h3 / 2 + taper, -w4 / 2 + taper, -h3 / 2, radius2, radius2, true) + // Top-left arc (4 to 5) + ]; + const pathData = createPathFromPoints(points); + const shapeNode = rc.path(pathData, options2); + const polygon2 = shapeSvg.insert(() => shapeNode, ":first-child"); + polygon2.attr("class", "basic label-container outer-path"); + if (cssStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, polygon2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_roundedRect = __esm({ + "src/rendering-util/rendering-elements/shapes/roundedRect.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + __name(generateArcPoints2, "generateArcPoints"); + __name(roundedRect, "roundedRect"); + } + }); + + // src/rendering-util/rendering-elements/shapes/shadedProcess.ts + async function shadedProcess(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const halfPadding = node2?.padding ?? 0; + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const x5 = -bbox.width / 2 - halfPadding; + const y6 = -bbox.height / 2 - halfPadding; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: x5, y: y6 }, + { x: x5 + w4 + 8, y: y6 }, + { x: x5 + w4 + 8, y: y6 + h3 }, + { x: x5 - 8, y: y6 + h3 }, + { x: x5 - 8, y: y6 }, + { x: x5, y: y6 }, + { x: x5, y: y6 + h3 } + ]; + const roughNode = rc.polygon( + points.map((p3) => [p3.x, p3.y]), + options2 + ); + const rect3 = shapeSvg.insert(() => roughNode, ":first-child"); + rect3.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles)); + if (nodeStyles && node2.look !== "handDrawn") { + rect3.selectAll("path").attr("style", nodeStyles); + } + if (cssStyles && node2.look !== "handDrawn") { + rect3.selectAll("path").attr("style", nodeStyles); + } + label.attr( + "transform", + `translate(${-w4 / 2 + 4 + (node2.padding ?? 0) - (bbox.x - (bbox.left ?? 0))},${-h3 / 2 + (node2.padding ?? 0) - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, rect3); + node2.intersect = function(point8) { + return intersect_default.rect(node2, point8); + }; + return shapeSvg; + } + var init_shadedProcess = __esm({ + "src/rendering-util/rendering-elements/shapes/shadedProcess.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_utils2(); + __name(shadedProcess, "shadedProcess"); + } + }); + + // src/rendering-util/rendering-elements/shapes/slopedRect.ts + async function slopedRect(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const x5 = -w4 / 2; + const y6 = -h3 / 2; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: x5, y: y6 }, + { x: x5, y: y6 + h3 }, + { x: x5 + w4, y: y6 + h3 }, + { x: x5 + w4, y: y6 - h3 / 2 } + ]; + const pathData = createPathFromPoints(points); + const shapeNode = rc.path(pathData, options2); + const polygon2 = shapeSvg.insert(() => shapeNode, ":first-child"); + polygon2.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", nodeStyles); + } + polygon2.attr("transform", `translate(0, ${h3 / 4})`); + label.attr( + "transform", + `translate(${-w4 / 2 + (node2.padding ?? 0) - (bbox.x - (bbox.left ?? 0))}, ${-h3 / 4 + (node2.padding ?? 0) - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, polygon2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_slopedRect = __esm({ + "src/rendering-util/rendering-elements/shapes/slopedRect.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + __name(slopedRect, "slopedRect"); + } + }); + + // src/rendering-util/rendering-elements/shapes/squareRect.ts + async function squareRect(parent4, node2) { + const options2 = { + rx: 0, + ry: 0, + classes: "", + labelPaddingX: node2.labelPaddingX ?? (node2?.padding || 0) * 2, + labelPaddingY: (node2?.padding || 0) * 1 + }; + return drawRect3(parent4, node2, options2); + } + var init_squareRect = __esm({ + "src/rendering-util/rendering-elements/shapes/squareRect.ts"() { + "use strict"; + init_drawRect(); + __name(squareRect, "squareRect"); + } + }); + + // src/rendering-util/rendering-elements/shapes/stadium.ts + async function stadium(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const h3 = bbox.height + node2.padding; + const w4 = bbox.width + h3 / 4 + node2.padding; + const radius2 = h3 / 2; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: -w4 / 2 + radius2, y: -h3 / 2 }, + { x: w4 / 2 - radius2, y: -h3 / 2 }, + ...generateCirclePoints(-w4 / 2 + radius2, 0, radius2, 50, 90, 270), + { x: w4 / 2 - radius2, y: h3 / 2 }, + ...generateCirclePoints(w4 / 2 - radius2, 0, radius2, 50, 270, 450) + ]; + const pathData = createPathFromPoints(points); + const shapeNode = rc.path(pathData, options2); + const polygon2 = shapeSvg.insert(() => shapeNode, ":first-child"); + polygon2.attr("class", "basic label-container outer-path"); + if (cssStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, polygon2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_stadium = __esm({ + "src/rendering-util/rendering-elements/shapes/stadium.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + __name(stadium, "stadium"); + } + }); + + // src/rendering-util/rendering-elements/shapes/state.ts + async function state(parent4, node2) { + const options2 = { + rx: 5, + ry: 5, + classes: "flowchart-node" + }; + return drawRect3(parent4, node2, options2); + } + var init_state = __esm({ + "src/rendering-util/rendering-elements/shapes/state.ts"() { + "use strict"; + init_drawRect(); + __name(state, "state"); + } + }); + + // src/rendering-util/rendering-elements/shapes/stateEnd.ts + function stateEnd(parent4, node2, { config: { themeVariables } }) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { cssStyles } = node2; + const { lineColor, stateBorder, nodeBorder } = themeVariables; + const shapeSvg = parent4.insert("g").attr("class", "node default").attr("id", node2.domId || node2.id); + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const roughNode = rc.circle(0, 0, 14, { + ...options2, + stroke: lineColor, + strokeWidth: 2 + }); + const innerFill = stateBorder ?? nodeBorder; + const roughInnerNode = rc.circle(0, 0, 5, { + ...options2, + fill: innerFill, + stroke: innerFill, + strokeWidth: 2, + fillStyle: "solid" + }); + const circle6 = shapeSvg.insert(() => roughNode, ":first-child"); + circle6.insert(() => roughInnerNode); + if (cssStyles) { + circle6.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles) { + circle6.selectAll("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, circle6); + node2.intersect = function(point8) { + return intersect_default.circle(node2, 7, point8); + }; + return shapeSvg; + } + var init_stateEnd = __esm({ + "src/rendering-util/rendering-elements/shapes/stateEnd.ts"() { + "use strict"; + init_rough_esm(); + init_intersect(); + init_handDrawnShapeStyles(); + init_util(); + __name(stateEnd, "stateEnd"); + } + }); + + // src/rendering-util/rendering-elements/shapes/stateStart.ts + function stateStart(parent4, node2, { config: { themeVariables } }) { + const { lineColor } = themeVariables; + const shapeSvg = parent4.insert("g").attr("class", "node default").attr("id", node2.domId || node2.id); + let circle6; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const roughNode = rc.circle(0, 0, 14, solidStateFill(lineColor)); + circle6 = shapeSvg.insert(() => roughNode); + circle6.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14); + } else { + circle6 = shapeSvg.insert("circle", ":first-child"); + circle6.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14); + } + updateNodeBounds(node2, circle6); + node2.intersect = function(point8) { + return intersect_default.circle(node2, 7, point8); + }; + return shapeSvg; + } + var init_stateStart = __esm({ + "src/rendering-util/rendering-elements/shapes/stateStart.ts"() { + "use strict"; + init_rough_esm(); + init_intersect(); + init_handDrawnShapeStyles(); + init_util(); + __name(stateStart, "stateStart"); + } + }); + + // src/rendering-util/rendering-elements/shapes/subroutine.ts + async function subroutine(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const halfPadding = (node2?.padding || 0) / 2; + const w4 = bbox.width + node2.padding; + const h3 = bbox.height + node2.padding; + const x5 = -bbox.width / 2 - halfPadding; + const y6 = -bbox.height / 2 - halfPadding; + const points = [ + { x: 0, y: 0 }, + { x: w4, y: 0 }, + { x: w4, y: -h3 }, + { x: 0, y: -h3 }, + { x: 0, y: 0 }, + { x: -8, y: 0 }, + { x: w4 + 8, y: 0 }, + { x: w4 + 8, y: -h3 }, + { x: -8, y: -h3 }, + { x: -8, y: 0 } + ]; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + const roughNode = rc.rectangle(x5 - 8, y6, w4 + 16, h3, options2); + const l1 = rc.line(x5, y6, x5, y6 + h3, options2); + const l22 = rc.line(x5 + w4, y6, x5 + w4, y6 + h3, options2); + shapeSvg.insert(() => l1, ":first-child"); + shapeSvg.insert(() => l22, ":first-child"); + const rect3 = shapeSvg.insert(() => roughNode, ":first-child"); + const { cssStyles } = node2; + rect3.attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles)); + updateNodeBounds(node2, rect3); + } else { + const el = insertPolygonShape(shapeSvg, w4, h3, points); + if (nodeStyles) { + el.attr("style", nodeStyles); + } + updateNodeBounds(node2, el); + } + node2.intersect = function(point8) { + return intersect_default.polygon(node2, points, point8); + }; + return shapeSvg; + } + var init_subroutine = __esm({ + "src/rendering-util/rendering-elements/shapes/subroutine.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_insertPolygonShape(); + init_utils2(); + __name(subroutine, "subroutine"); + } + }); + + // src/rendering-util/rendering-elements/shapes/taggedRect.ts + async function taggedRect(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const x5 = -w4 / 2; + const y6 = -h3 / 2; + const tagWidth = 0.2 * h3; + const tagHeight = 0.2 * h3; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + const rectPoints = [ + { x: x5 - tagWidth / 2, y: y6 }, + { x: x5 + w4 + tagWidth / 2, y: y6 }, + { x: x5 + w4 + tagWidth / 2, y: y6 + h3 }, + { x: x5 - tagWidth / 2, y: y6 + h3 } + ]; + const tagPoints = [ + { x: x5 + w4 - tagWidth / 2, y: y6 + h3 }, + { x: x5 + w4 + tagWidth / 2, y: y6 + h3 }, + { x: x5 + w4 + tagWidth / 2, y: y6 + h3 - tagHeight } + ]; + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const rectPath = createPathFromPoints(rectPoints); + const rectNode = rc.path(rectPath, options2); + const tagPath = createPathFromPoints(tagPoints); + const tagNode = rc.path(tagPath, { ...options2, fillStyle: "solid" }); + const taggedRect2 = shapeSvg.insert(() => tagNode, ":first-child"); + taggedRect2.insert(() => rectNode, ":first-child"); + taggedRect2.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + taggedRect2.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + taggedRect2.selectAll("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, taggedRect2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, rectPoints, point8); + return pos; + }; + return shapeSvg; + } + var init_taggedRect = __esm({ + "src/rendering-util/rendering-elements/shapes/taggedRect.ts"() { + "use strict"; + init_util(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_intersect(); + __name(taggedRect, "taggedRect"); + } + }); + + // src/rendering-util/rendering-elements/shapes/taggedWaveEdgedRectangle.ts + async function taggedWaveEdgedRectangle(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const waveAmplitude = h3 / 4; + const tagWidth = 0.2 * w4; + const tagHeight = 0.2 * h3; + const finalH = h3 + waveAmplitude; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: -w4 / 2 - w4 / 2 * 0.1, y: finalH / 2 }, + ...generateFullSineWavePoints( + -w4 / 2 - w4 / 2 * 0.1, + finalH / 2, + w4 / 2 + w4 / 2 * 0.1, + finalH / 2, + waveAmplitude, + 0.8 + ), + { x: w4 / 2 + w4 / 2 * 0.1, y: -finalH / 2 }, + { x: -w4 / 2 - w4 / 2 * 0.1, y: -finalH / 2 } + ]; + const x5 = -w4 / 2 + w4 / 2 * 0.1; + const y6 = -finalH / 2 - tagHeight * 0.4; + const tagPoints = [ + { x: x5 + w4 - tagWidth, y: (y6 + h3) * 1.4 }, + { x: x5 + w4, y: y6 + h3 - tagHeight }, + { x: x5 + w4, y: (y6 + h3) * 0.9 }, + ...generateFullSineWavePoints( + x5 + w4, + (y6 + h3) * 1.3, + x5 + w4 - tagWidth, + (y6 + h3) * 1.5, + -h3 * 0.03, + 0.5 + ) + ]; + const waveEdgeRectPath = createPathFromPoints(points); + const waveEdgeRectNode = rc.path(waveEdgeRectPath, options2); + const taggedWaveEdgeRectPath = createPathFromPoints(tagPoints); + const taggedWaveEdgeRectNode = rc.path(taggedWaveEdgeRectPath, { + ...options2, + fillStyle: "solid" + }); + const waveEdgeRect = shapeSvg.insert(() => taggedWaveEdgeRectNode, ":first-child"); + waveEdgeRect.insert(() => waveEdgeRectNode, ":first-child"); + waveEdgeRect.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + waveEdgeRect.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + waveEdgeRect.selectAll("path").attr("style", nodeStyles); + } + waveEdgeRect.attr("transform", `translate(0,${-waveAmplitude / 2})`); + label.attr( + "transform", + `translate(${-w4 / 2 + (node2.padding ?? 0) - (bbox.x - (bbox.left ?? 0))},${-h3 / 2 + (node2.padding ?? 0) - waveAmplitude / 2 - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, waveEdgeRect); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_taggedWaveEdgedRectangle = __esm({ + "src/rendering-util/rendering-elements/shapes/taggedWaveEdgedRectangle.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_rough_esm(); + init_handDrawnShapeStyles(); + __name(taggedWaveEdgedRectangle, "taggedWaveEdgedRectangle"); + } + }); + + // src/rendering-util/rendering-elements/shapes/text.ts + async function text3(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const totalWidth = Math.max(bbox.width + node2.padding, node2?.width || 0); + const totalHeight = Math.max(bbox.height + node2.padding, node2?.height || 0); + const x5 = -totalWidth / 2; + const y6 = -totalHeight / 2; + const rect3 = shapeSvg.insert("rect", ":first-child"); + rect3.attr("class", "text").attr("style", nodeStyles).attr("rx", 0).attr("ry", 0).attr("x", x5).attr("y", y6).attr("width", totalWidth).attr("height", totalHeight); + updateNodeBounds(node2, rect3); + node2.intersect = function(point8) { + return intersect_default.rect(node2, point8); + }; + return shapeSvg; + } + var init_text3 = __esm({ + "src/rendering-util/rendering-elements/shapes/text.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + __name(text3, "text"); + } + }); + + // src/rendering-util/rendering-elements/shapes/tiltedCylinder.ts + async function tiltedCylinder(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label, halfPadding } = await labelHelper( + parent4, + node2, + getNodeClasses(node2) + ); + const labelPadding = node2.look === "neo" ? halfPadding * 2 : halfPadding; + const h3 = bbox.height + labelPadding; + const ry = h3 / 2; + const rx = ry / (2.5 + h3 / 50); + const w4 = bbox.width + rx + labelPadding; + const { cssStyles } = node2; + let cylinder3; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const outerPathData = createOuterCylinderPathD3(0, 0, w4, h3, rx, ry); + const innerPathData = createInnerCylinderPathD3(0, 0, w4, h3, rx, ry); + const outerNode = rc.path(outerPathData, userNodeOverrides(node2, {})); + const innerLine = rc.path(innerPathData, userNodeOverrides(node2, { fill: "none" })); + cylinder3 = shapeSvg.insert(() => innerLine, ":first-child"); + cylinder3 = shapeSvg.insert(() => outerNode, ":first-child"); + cylinder3.attr("class", "basic label-container"); + if (cssStyles) { + cylinder3.attr("style", cssStyles); + } + } else { + const pathData = createCylinderPathD3(0, 0, w4, h3, rx, ry); + cylinder3 = shapeSvg.insert("path", ":first-child").attr("d", pathData).attr("class", "basic label-container").attr("style", handleUndefinedAttr(cssStyles)).attr("style", nodeStyles); + cylinder3.attr("class", "basic label-container"); + if (cssStyles) { + cylinder3.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles) { + cylinder3.selectAll("path").attr("style", nodeStyles); + } + } + cylinder3.attr("label-offset-x", rx); + cylinder3.attr("transform", `translate(${-w4 / 2}, ${h3 / 2} )`); + label.attr( + "transform", + `translate(${-(bbox.width / 2) - rx - (bbox.x - (bbox.left ?? 0))}, ${-(bbox.height / 2) - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, cylinder3); + node2.intersect = function(point8) { + const pos = intersect_default.rect(node2, point8); + const y6 = pos.y - (node2.y ?? 0); + if (ry != 0 && (Math.abs(y6) < (node2.height ?? 0) / 2 || Math.abs(y6) == (node2.height ?? 0) / 2 && Math.abs(pos.x - (node2.x ?? 0)) > (node2.width ?? 0) / 2 - rx)) { + let x5 = rx * rx * (1 - y6 * y6 / (ry * ry)); + if (x5 != 0) { + x5 = Math.sqrt(Math.abs(x5)); + } + x5 = rx - x5; + if (point8.x - (node2.x ?? 0) > 0) { + x5 = -x5; + } + pos.x += x5; + } + return pos; + }; + return shapeSvg; + } + var createCylinderPathD3, createOuterCylinderPathD3, createInnerCylinderPathD3; + var init_tiltedCylinder = __esm({ + "src/rendering-util/rendering-elements/shapes/tiltedCylinder.ts"() { + "use strict"; + init_util(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_intersect(); + init_utils2(); + createCylinderPathD3 = /* @__PURE__ */ __name((x5, y6, width3, height2, rx, ry) => { + return `M${x5},${y6} + a${rx},${ry} 0,0,1 ${0},${-height2} + l${width3},${0} + a${rx},${ry} 0,0,1 ${0},${height2} + M${width3},${-height2} + a${rx},${ry} 0,0,0 ${0},${height2} + l${-width3},${0}`; + }, "createCylinderPathD"); + createOuterCylinderPathD3 = /* @__PURE__ */ __name((x5, y6, width3, height2, rx, ry) => { + return [ + `M${x5},${y6}`, + `M${x5 + width3},${y6}`, + `a${rx},${ry} 0,0,0 ${0},${-height2}`, + `l${-width3},0`, + `a${rx},${ry} 0,0,0 ${0},${height2}`, + `l${width3},0` + ].join(" "); + }, "createOuterCylinderPathD"); + createInnerCylinderPathD3 = /* @__PURE__ */ __name((x5, y6, width3, height2, rx, ry) => { + return [`M${x5 + width3 / 2},${-height2 / 2}`, `a${rx},${ry} 0,0,0 0,${height2}`].join(" "); + }, "createInnerCylinderPathD"); + __name(tiltedCylinder, "tiltedCylinder"); + } + }); + + // src/rendering-util/rendering-elements/shapes/trapezoid.ts + async function trapezoid(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = bbox.width + node2.padding; + const h3 = bbox.height + node2.padding; + const points = [ + { x: -3 * h3 / 6, y: 0 }, + { x: w4 + 3 * h3 / 6, y: 0 }, + { x: w4, y: -h3 }, + { x: 0, y: -h3 } + ]; + let polygon2; + const { cssStyles } = node2; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + const pathData = createPathFromPoints(points); + const roughNode = rc.path(pathData, options2); + polygon2 = shapeSvg.insert(() => roughNode, ":first-child").attr("transform", `translate(${-w4 / 2}, ${h3 / 2})`); + if (cssStyles) { + polygon2.attr("style", cssStyles); + } + } else { + polygon2 = insertPolygonShape(shapeSvg, w4, h3, points); + } + if (nodeStyles) { + polygon2.attr("style", nodeStyles); + } + node2.width = w4; + node2.height = h3; + updateNodeBounds(node2, polygon2); + node2.intersect = function(point8) { + return intersect_default.polygon(node2, points, point8); + }; + return shapeSvg; + } + var init_trapezoid = __esm({ + "src/rendering-util/rendering-elements/shapes/trapezoid.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_insertPolygonShape(); + __name(trapezoid, "trapezoid"); + } + }); + + // src/rendering-util/rendering-elements/shapes/trapezoidalPentagon.ts + async function trapezoidalPentagon(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const minWidth = 60, minHeight = 20; + const w4 = Math.max(minWidth, bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(minHeight, bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: -w4 / 2 * 0.8, y: -h3 / 2 }, + { x: w4 / 2 * 0.8, y: -h3 / 2 }, + { x: w4 / 2, y: -h3 / 2 * 0.6 }, + { x: w4 / 2, y: h3 / 2 }, + { x: -w4 / 2, y: h3 / 2 }, + { x: -w4 / 2, y: -h3 / 2 * 0.6 } + ]; + const pathData = createPathFromPoints(points); + const shapeNode = rc.path(pathData, options2); + const polygon2 = shapeSvg.insert(() => shapeNode, ":first-child"); + polygon2.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, polygon2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_trapezoidalPentagon = __esm({ + "src/rendering-util/rendering-elements/shapes/trapezoidalPentagon.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + __name(trapezoidalPentagon, "trapezoidalPentagon"); + } + }); + + // src/rendering-util/rendering-elements/shapes/triangle.ts + async function triangle(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const useHtmlLabels = evaluate(getConfig2().flowchart?.htmlLabels); + const w4 = bbox.width + (node2.padding ?? 0); + const h3 = w4 + bbox.height; + const tw = w4 + bbox.height; + const points = [ + { x: 0, y: 0 }, + { x: tw, y: 0 }, + { x: tw / 2, y: -h3 } + ]; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const pathData = createPathFromPoints(points); + const roughNode = rc.path(pathData, options2); + const polygon2 = shapeSvg.insert(() => roughNode, ":first-child").attr("transform", `translate(${-h3 / 2}, ${h3 / 2})`); + if (cssStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + polygon2.selectChildren("path").attr("style", nodeStyles); + } + node2.width = w4; + node2.height = h3; + updateNodeBounds(node2, polygon2); + label.attr( + "transform", + `translate(${-bbox.width / 2 - (bbox.x - (bbox.left ?? 0))}, ${h3 / 2 - (bbox.height + (node2.padding ?? 0) / (useHtmlLabels ? 2 : 1) - (bbox.y - (bbox.top ?? 0)))})` + ); + node2.intersect = function(point8) { + log.info("Triangle intersect", node2, points, point8); + return intersect_default.polygon(node2, points, point8); + }; + return shapeSvg; + } + var init_triangle = __esm({ + "src/rendering-util/rendering-elements/shapes/triangle.ts"() { + "use strict"; + init_logger(); + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_util(); + init_common(); + init_diagramAPI(); + __name(triangle, "triangle"); + } + }); + + // src/rendering-util/rendering-elements/shapes/waveEdgedRectangle.ts + async function waveEdgedRectangle(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const waveAmplitude = h3 / 8; + const finalH = h3 + waveAmplitude; + const { cssStyles } = node2; + const minWidth = 70; + const widthDif = minWidth - w4; + const extraW = widthDif > 0 ? widthDif / 2 : 0; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: -w4 / 2 - extraW, y: finalH / 2 }, + ...generateFullSineWavePoints( + -w4 / 2 - extraW, + finalH / 2, + w4 / 2 + extraW, + finalH / 2, + waveAmplitude, + 0.8 + ), + { x: w4 / 2 + extraW, y: -finalH / 2 }, + { x: -w4 / 2 - extraW, y: -finalH / 2 } + ]; + const waveEdgeRectPath = createPathFromPoints(points); + const waveEdgeRectNode = rc.path(waveEdgeRectPath, options2); + const waveEdgeRect = shapeSvg.insert(() => waveEdgeRectNode, ":first-child"); + waveEdgeRect.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + waveEdgeRect.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + waveEdgeRect.selectAll("path").attr("style", nodeStyles); + } + waveEdgeRect.attr("transform", `translate(0,${-waveAmplitude / 2})`); + label.attr( + "transform", + `translate(${-w4 / 2 + (node2.padding ?? 0) - (bbox.x - (bbox.left ?? 0))},${-h3 / 2 + (node2.padding ?? 0) - waveAmplitude - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, waveEdgeRect); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_waveEdgedRectangle = __esm({ + "src/rendering-util/rendering-elements/shapes/waveEdgedRectangle.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_rough_esm(); + init_handDrawnShapeStyles(); + __name(waveEdgedRectangle, "waveEdgedRectangle"); + } + }); + + // src/rendering-util/rendering-elements/shapes/waveRectangle.ts + async function waveRectangle(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const minWidth = 100; + const minHeight = 50; + const baseWidth = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const baseHeight = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const aspectRatio = baseWidth / baseHeight; + let w4 = baseWidth; + let h3 = baseHeight; + if (w4 > h3 * aspectRatio) { + h3 = w4 / aspectRatio; + } else { + w4 = h3 * aspectRatio; + } + w4 = Math.max(w4, minWidth); + h3 = Math.max(h3, minHeight); + const waveAmplitude = Math.min(h3 * 0.2, h3 / 4); + const finalH = h3 + waveAmplitude * 2; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const points = [ + { x: -w4 / 2, y: finalH / 2 }, + ...generateFullSineWavePoints(-w4 / 2, finalH / 2, w4 / 2, finalH / 2, waveAmplitude, 1), + { x: w4 / 2, y: -finalH / 2 }, + ...generateFullSineWavePoints(w4 / 2, -finalH / 2, -w4 / 2, -finalH / 2, waveAmplitude, -1) + ]; + const waveRectPath = createPathFromPoints(points); + const waveRectNode = rc.path(waveRectPath, options2); + const waveRect = shapeSvg.insert(() => waveRectNode, ":first-child"); + waveRect.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + waveRect.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + waveRect.selectAll("path").attr("style", nodeStyles); + } + updateNodeBounds(node2, waveRect); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, points, point8); + return pos; + }; + return shapeSvg; + } + var init_waveRectangle = __esm({ + "src/rendering-util/rendering-elements/shapes/waveRectangle.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + __name(waveRectangle, "waveRectangle"); + } + }); + + // src/rendering-util/rendering-elements/shapes/windowPane.ts + async function windowPane(parent4, node2) { + const { labelStyles, nodeStyles } = styles2String(node2); + node2.labelStyle = labelStyles; + const { shapeSvg, bbox, label } = await labelHelper(parent4, node2, getNodeClasses(node2)); + const w4 = Math.max(bbox.width + (node2.padding ?? 0) * 2, node2?.width ?? 0); + const h3 = Math.max(bbox.height + (node2.padding ?? 0) * 2, node2?.height ?? 0); + const rectOffset = 5; + const x5 = -w4 / 2; + const y6 = -h3 / 2; + const { cssStyles } = node2; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + const outerPathPoints = [ + { x: x5 - rectOffset, y: y6 - rectOffset }, + { x: x5 - rectOffset, y: y6 + h3 }, + { x: x5 + w4, y: y6 + h3 }, + { x: x5 + w4, y: y6 - rectOffset } + ]; + const path4 = `M${x5 - rectOffset},${y6 - rectOffset} L${x5 + w4},${y6 - rectOffset} L${x5 + w4},${y6 + h3} L${x5 - rectOffset},${y6 + h3} L${x5 - rectOffset},${y6 - rectOffset} + M${x5 - rectOffset},${y6} L${x5 + w4},${y6} + M${x5},${y6 - rectOffset} L${x5},${y6 + h3}`; + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + const no = rc.path(path4, options2); + const windowPane2 = shapeSvg.insert(() => no, ":first-child"); + windowPane2.attr("transform", `translate(${rectOffset / 2}, ${rectOffset / 2})`); + windowPane2.attr("class", "basic label-container"); + if (cssStyles && node2.look !== "handDrawn") { + windowPane2.selectAll("path").attr("style", cssStyles); + } + if (nodeStyles && node2.look !== "handDrawn") { + windowPane2.selectAll("path").attr("style", nodeStyles); + } + label.attr( + "transform", + `translate(${-(bbox.width / 2) + rectOffset / 2 - (bbox.x - (bbox.left ?? 0))}, ${-(bbox.height / 2) + rectOffset / 2 - (bbox.y - (bbox.top ?? 0))})` + ); + updateNodeBounds(node2, windowPane2); + node2.intersect = function(point8) { + const pos = intersect_default.polygon(node2, outerPathPoints, point8); + return pos; + }; + return shapeSvg; + } + var init_windowPane = __esm({ + "src/rendering-util/rendering-elements/shapes/windowPane.ts"() { + "use strict"; + init_util(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_intersect(); + __name(windowPane, "windowPane"); + } + }); + + // src/rendering-util/rendering-elements/shapes/erBox.ts + async function erBox(parent4, node2) { + const entityNode = node2; + if (entityNode.alias) { + node2.label = entityNode.alias; + } + if (node2.look === "handDrawn") { + const { themeVariables: themeVariables2 } = getConfig(); + const { background } = themeVariables2; + const backgroundNode = { + ...node2, + id: node2.id + "-background", + look: "default", + cssStyles: ["stroke: none", `fill: ${background}`] + }; + await erBox(parent4, backgroundNode); + } + const config5 = getConfig(); + node2.useHtmlLabels = config5.htmlLabels; + let PADDING = config5.er?.diagramPadding ?? 10; + let TEXT_PADDING = config5.er?.entityPadding ?? 6; + const { cssStyles } = node2; + const { labelStyles, nodeStyles } = styles2String(node2); + if (entityNode.attributes.length === 0 && node2.label) { + const options3 = { + rx: 0, + ry: 0, + labelPaddingX: PADDING, + labelPaddingY: PADDING * 1.5, + classes: "" + }; + if (calculateTextWidth(node2.label, config5) + options3.labelPaddingX * 2 < config5.er.minEntityWidth) { + node2.width = config5.er.minEntityWidth; + } + const shapeSvg2 = await drawRect3(parent4, node2, options3); + if (!evaluate(config5.htmlLabels)) { + const textElement = shapeSvg2.select("text"); + const bbox = textElement.node()?.getBBox(); + textElement.attr("transform", `translate(${-bbox.width / 2}, 0)`); + } + return shapeSvg2; + } + if (!config5.htmlLabels) { + PADDING *= 1.25; + TEXT_PADDING *= 1.25; + } + let cssClasses = getNodeClasses(node2); + if (!cssClasses) { + cssClasses = "node default"; + } + const shapeSvg = parent4.insert("g").attr("class", cssClasses).attr("id", node2.domId || node2.id); + const nameBBox = await addText(shapeSvg, node2.label ?? "", config5, 0, 0, ["name"], labelStyles); + nameBBox.height += TEXT_PADDING; + let yOffset = 0; + const yOffsets = []; + const rows = []; + let maxTypeWidth = 0; + let maxNameWidth = 0; + let maxKeysWidth = 0; + let maxCommentWidth = 0; + let keysPresent = true; + let commentPresent = true; + for (const attribute of entityNode.attributes) { + const typeBBox = await addText( + shapeSvg, + attribute.type, + config5, + 0, + yOffset, + ["attribute-type"], + labelStyles + ); + maxTypeWidth = Math.max(maxTypeWidth, typeBBox.width + PADDING); + const nameBBox2 = await addText( + shapeSvg, + attribute.name, + config5, + 0, + yOffset, + ["attribute-name"], + labelStyles + ); + maxNameWidth = Math.max(maxNameWidth, nameBBox2.width + PADDING); + const keysBBox = await addText( + shapeSvg, + attribute.keys.join(), + config5, + 0, + yOffset, + ["attribute-keys"], + labelStyles + ); + maxKeysWidth = Math.max(maxKeysWidth, keysBBox.width + PADDING); + const commentBBox = await addText( + shapeSvg, + attribute.comment, + config5, + 0, + yOffset, + ["attribute-comment"], + labelStyles + ); + maxCommentWidth = Math.max(maxCommentWidth, commentBBox.width + PADDING); + const rowHeight = Math.max(typeBBox.height, nameBBox2.height, keysBBox.height, commentBBox.height) + TEXT_PADDING; + rows.push({ yOffset, rowHeight }); + yOffset += rowHeight; + } + let totalWidthSections = 4; + if (maxKeysWidth <= PADDING) { + keysPresent = false; + maxKeysWidth = 0; + totalWidthSections--; + } + if (maxCommentWidth <= PADDING) { + commentPresent = false; + maxCommentWidth = 0; + totalWidthSections--; + } + const shapeBBox = shapeSvg.node().getBBox(); + if (nameBBox.width + PADDING * 2 - (maxTypeWidth + maxNameWidth + maxKeysWidth + maxCommentWidth) > 0) { + const difference2 = nameBBox.width + PADDING * 2 - (maxTypeWidth + maxNameWidth + maxKeysWidth + maxCommentWidth); + maxTypeWidth += difference2 / totalWidthSections; + maxNameWidth += difference2 / totalWidthSections; + if (maxKeysWidth > 0) { + maxKeysWidth += difference2 / totalWidthSections; + } + if (maxCommentWidth > 0) { + maxCommentWidth += difference2 / totalWidthSections; + } + } + const maxWidth2 = maxTypeWidth + maxNameWidth + maxKeysWidth + maxCommentWidth; + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, {}); + if (node2.look !== "handDrawn") { + options2.roughness = 0; + options2.fillStyle = "solid"; + } + let totalShapeBBoxHeight = 0; + if (rows.length > 0) { + totalShapeBBoxHeight = rows.reduce((sum2, row) => sum2 + (row?.rowHeight ?? 0), 0); + } + const w4 = Math.max(shapeBBox.width + PADDING * 2, node2?.width || 0, maxWidth2); + const h3 = Math.max((totalShapeBBoxHeight ?? 0) + nameBBox.height, node2?.height || 0); + const x5 = -w4 / 2; + const y6 = -h3 / 2; + shapeSvg.selectAll("g:not(:first-child)").each((_3, i2, nodes5) => { + const text4 = select_default2(nodes5[i2]); + const transform8 = text4.attr("transform"); + let translateX2 = 0; + let translateY2 = 0; + if (transform8) { + const regex2 = RegExp(/translate\(([^,]+),([^)]+)\)/); + const translate2 = regex2.exec(transform8); + if (translate2) { + translateX2 = parseFloat(translate2[1]); + translateY2 = parseFloat(translate2[2]); + if (text4.attr("class").includes("attribute-name")) { + translateX2 += maxTypeWidth; + } else if (text4.attr("class").includes("attribute-keys")) { + translateX2 += maxTypeWidth + maxNameWidth; + } else if (text4.attr("class").includes("attribute-comment")) { + translateX2 += maxTypeWidth + maxNameWidth + maxKeysWidth; + } + } + } + text4.attr( + "transform", + `translate(${x5 + PADDING / 2 + translateX2}, ${translateY2 + y6 + nameBBox.height + TEXT_PADDING / 2})` + ); + }); + shapeSvg.select(".name").attr("transform", "translate(" + -nameBBox.width / 2 + ", " + (y6 + TEXT_PADDING / 2) + ")"); + const roughRect = rc.rectangle(x5, y6, w4, h3, options2); + const rect3 = shapeSvg.insert(() => roughRect, ":first-child").attr("style", cssStyles.join("")); + const { themeVariables } = getConfig(); + const { rowEven, rowOdd, nodeBorder } = themeVariables; + yOffsets.push(0); + for (const [i2, row] of rows.entries()) { + const contentRowIndex = i2 + 1; + const isEven = contentRowIndex % 2 === 0 && row.yOffset !== 0; + const roughRect2 = rc.rectangle(x5, nameBBox.height + y6 + row?.yOffset, w4, row?.rowHeight, { + ...options2, + fill: isEven ? rowEven : rowOdd, + stroke: nodeBorder + }); + shapeSvg.insert(() => roughRect2, "g.label").attr("style", cssStyles.join("")).attr("class", `row-rect-${isEven ? "even" : "odd"}`); + } + let roughLine = rc.line(x5, nameBBox.height + y6, w4 + x5, nameBBox.height + y6, options2); + shapeSvg.insert(() => roughLine).attr("class", "divider"); + roughLine = rc.line(maxTypeWidth + x5, nameBBox.height + y6, maxTypeWidth + x5, h3 + y6, options2); + shapeSvg.insert(() => roughLine).attr("class", "divider"); + if (keysPresent) { + roughLine = rc.line( + maxTypeWidth + maxNameWidth + x5, + nameBBox.height + y6, + maxTypeWidth + maxNameWidth + x5, + h3 + y6, + options2 + ); + shapeSvg.insert(() => roughLine).attr("class", "divider"); + } + if (commentPresent) { + roughLine = rc.line( + maxTypeWidth + maxNameWidth + maxKeysWidth + x5, + nameBBox.height + y6, + maxTypeWidth + maxNameWidth + maxKeysWidth + x5, + h3 + y6, + options2 + ); + shapeSvg.insert(() => roughLine).attr("class", "divider"); + } + for (const yOffset2 of yOffsets) { + roughLine = rc.line( + x5, + nameBBox.height + y6 + yOffset2, + w4 + x5, + nameBBox.height + y6 + yOffset2, + options2 + ); + shapeSvg.insert(() => roughLine).attr("class", "divider"); + } + updateNodeBounds(node2, rect3); + if (nodeStyles && node2.look !== "handDrawn") { + const allStyle = nodeStyles.split(";"); + const strokeStyles = allStyle?.filter((e3) => { + return e3.includes("stroke"); + })?.map((s2) => `${s2}`).join("; "); + shapeSvg.selectAll("path").attr("style", strokeStyles ?? ""); + shapeSvg.selectAll(".row-rect-even path").attr("style", nodeStyles); + } + node2.intersect = function(point8) { + return intersect_default.rect(node2, point8); + }; + return shapeSvg; + } + async function addText(shapeSvg, labelText, config5, translateX2 = 0, translateY2 = 0, classes3 = [], style3 = "") { + const label = shapeSvg.insert("g").attr("class", `label ${classes3.join(" ")}`).attr("transform", `translate(${translateX2}, ${translateY2})`).attr("style", style3); + if (labelText !== parseGenericTypes(labelText)) { + labelText = parseGenericTypes(labelText); + labelText = labelText.replaceAll("<", "<").replaceAll(">", ">"); + } + const text4 = label.node().appendChild( + await createText( + label, + labelText, + { + width: calculateTextWidth(labelText, config5) + 100, + style: style3, + useHtmlLabels: config5.htmlLabels + }, + config5 + ) + ); + if (labelText.includes("<") || labelText.includes(">")) { + let child = text4.children[0]; + child.textContent = child.textContent.replaceAll("<", "<").replaceAll(">", ">"); + while (child.childNodes[0]) { + child = child.childNodes[0]; + child.textContent = child.textContent.replaceAll("<", "<").replaceAll(">", ">"); + } + } + let bbox = text4.getBBox(); + if (evaluate(config5.htmlLabels)) { + const div = text4.children[0]; + div.style.textAlign = "start"; + const dv = select_default2(text4); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + return bbox; + } + var init_erBox = __esm({ + "src/rendering-util/rendering-elements/shapes/erBox.ts"() { + "use strict"; + init_util(); + init_intersect(); + init_handDrawnShapeStyles(); + init_rough_esm(); + init_drawRect(); + init_config(); + init_createText(); + init_common(); + init_src32(); + init_utils2(); + __name(erBox, "erBox"); + __name(addText, "addText"); + } + }); + + // src/diagrams/class/shapeUtil.ts + async function textHelper(parent4, node2, config5, useHtmlLabels, GAP = config5.class.padding ?? 12) { + const TEXT_PADDING = !useHtmlLabels ? 3 : 0; + const shapeSvg = parent4.insert("g").attr("class", getNodeClasses(node2)).attr("id", node2.domId || node2.id); + let annotationGroup = null; + let labelGroup = null; + let membersGroup = null; + let methodsGroup = null; + let annotationGroupHeight = 0; + let labelGroupHeight = 0; + let membersGroupHeight = 0; + annotationGroup = shapeSvg.insert("g").attr("class", "annotation-group text"); + if (node2.annotations.length > 0) { + const annotation = node2.annotations[0]; + await addText2(annotationGroup, { text: `\xAB${annotation}\xBB` }, 0); + const annotationGroupBBox = annotationGroup.node().getBBox(); + annotationGroupHeight = annotationGroupBBox.height; + } + labelGroup = shapeSvg.insert("g").attr("class", "label-group text"); + await addText2(labelGroup, node2, 0, ["font-weight: bolder"]); + const labelGroupBBox = labelGroup.node().getBBox(); + labelGroupHeight = labelGroupBBox.height; + membersGroup = shapeSvg.insert("g").attr("class", "members-group text"); + let yOffset = 0; + for (const member of node2.members) { + const height2 = await addText2(membersGroup, member, yOffset, [member.parseClassifier()]); + yOffset += height2 + TEXT_PADDING; + } + membersGroupHeight = membersGroup.node().getBBox().height; + if (membersGroupHeight <= 0) { + membersGroupHeight = GAP / 2; + } + methodsGroup = shapeSvg.insert("g").attr("class", "methods-group text"); + let methodsYOffset = 0; + for (const method of node2.methods) { + const height2 = await addText2(methodsGroup, method, methodsYOffset, [method.parseClassifier()]); + methodsYOffset += height2 + TEXT_PADDING; + } + let bbox = shapeSvg.node().getBBox(); + if (annotationGroup !== null) { + const annotationGroupBBox = annotationGroup.node().getBBox(); + annotationGroup.attr("transform", `translate(${-annotationGroupBBox.width / 2})`); + } + labelGroup.attr("transform", `translate(${-labelGroupBBox.width / 2}, ${annotationGroupHeight})`); + bbox = shapeSvg.node().getBBox(); + membersGroup.attr( + "transform", + `translate(${0}, ${annotationGroupHeight + labelGroupHeight + GAP * 2})` + ); + bbox = shapeSvg.node().getBBox(); + methodsGroup.attr( + "transform", + `translate(${0}, ${annotationGroupHeight + labelGroupHeight + (membersGroupHeight ? membersGroupHeight + GAP * 4 : GAP * 2)})` + ); + bbox = shapeSvg.node().getBBox(); + return { shapeSvg, bbox }; + } + async function addText2(parentGroup, node2, yOffset, styles4 = []) { + const textEl = parentGroup.insert("g").attr("class", "label").attr("style", styles4.join("; ")); + const config5 = getConfig(); + let useHtmlLabels = "useHtmlLabels" in node2 ? node2.useHtmlLabels : evaluate(config5.htmlLabels) ?? true; + let textContent = ""; + if ("text" in node2) { + textContent = node2.text; + } else { + textContent = node2.label; + } + if (!useHtmlLabels && textContent.startsWith("\\")) { + textContent = textContent.substring(1); + } + if (hasKatex(textContent)) { + useHtmlLabels = true; + } + const text4 = await createText( + textEl, + sanitizeText3(decodeEntities(textContent)), + { + width: calculateTextWidth(textContent, config5) + 50, + // Add room for error when splitting text into multiple lines + classes: "markdown-node-label", + useHtmlLabels + }, + config5 + ); + let bbox; + let numberOfLines = 1; + if (!useHtmlLabels) { + if (styles4.includes("font-weight: bolder")) { + select_default2(text4).selectAll("tspan").attr("font-weight", ""); + } + numberOfLines = text4.children.length; + const textChild = text4.children[0]; + if (text4.textContent === "" || text4.textContent.includes(">")) { + textChild.textContent = textContent[0] + textContent.substring(1).replaceAll(">", ">").replaceAll("<", "<").trim(); + const preserveSpace = textContent[1] === " "; + if (preserveSpace) { + textChild.textContent = textChild.textContent[0] + " " + textChild.textContent.substring(1); + } + } + if (textChild.textContent === "undefined") { + textChild.textContent = ""; + } + bbox = text4.getBBox(); + } else { + const div = text4.children[0]; + const dv = select_default2(text4); + numberOfLines = div.innerHTML.split("
").length; + if (div.innerHTML.includes("")) { + numberOfLines += div.innerHTML.split("
")); + el.classed("hover", true); + }).on("mouseout", (e3) => { + tooltipElem.transition().duration(500).style("opacity", 0); + const el = select_default2(e3.currentTarget); + el.classed("hover", false); + }); + } + /** + * Clears the internal graph db so that a new graph can be parsed. + * + */ + clear(ver = "gen-2") { + this.vertices = /* @__PURE__ */ new Map(); + this.classes = /* @__PURE__ */ new Map(); + this.edges = []; + this.funs = [this.setupToolTips.bind(this)]; + this.subGraphs = []; + this.subGraphLookup = /* @__PURE__ */ new Map(); + this.subCount = 0; + this.tooltips = /* @__PURE__ */ new Map(); + this.firstGraphFlag = true; + this.version = ver; + this.config = getConfig2(); + clear(); + } + setGen(ver) { + this.version = ver || "gen-2"; + } + defaultStyle() { + return "fill:#ffa;stroke: #f66; stroke-width: 3px; stroke-dasharray: 5, 5;fill:#ffa;stroke: #666;"; + } + addSubGraph(_id, list, _title) { + let id30 = _id.text.trim(); + let title2 = _title.text; + if (_id === _title && /\s/.exec(_title.text)) { + id30 = void 0; + } + const uniq2 = /* @__PURE__ */ __name((a2) => { + const prims = { boolean: {}, number: {}, string: {} }; + const objs = []; + let dir3; + const nodeList2 = a2.filter(function(item) { + const type3 = typeof item; + if (item.stmt && item.stmt === "dir") { + dir3 = item.value; + return false; + } + if (item.trim() === "") { + return false; + } + if (type3 in prims) { + return prims[type3].hasOwnProperty(item) ? false : prims[type3][item] = true; + } else { + return objs.includes(item) ? false : objs.push(item); + } + }); + return { nodeList: nodeList2, dir: dir3 }; + }, "uniq"); + const result = uniq2(list.flat()); + const nodeList = result.nodeList; + let dir2 = result.dir; + const flowchartConfig = getConfig2().flowchart ?? {}; + dir2 = dir2 ?? (flowchartConfig.inheritDir ? this.getDirection() ?? getConfig2().direction ?? void 0 : void 0); + if (this.version === "gen-1") { + for (let i2 = 0; i2 < nodeList.length; i2++) { + nodeList[i2] = this.lookUpDomId(nodeList[i2]); + } + } + id30 = id30 ?? "subGraph" + this.subCount; + title2 = title2 || ""; + title2 = this.sanitizeText(title2); + this.subCount = this.subCount + 1; + const subGraph = { + id: id30, + nodes: nodeList, + title: title2.trim(), + classes: [], + dir: dir2, + labelType: _title.type + }; + log.info("Adding", subGraph.id, subGraph.nodes, subGraph.dir); + subGraph.nodes = this.makeUniq(subGraph, this.subGraphs).nodes; + this.subGraphs.push(subGraph); + this.subGraphLookup.set(id30, subGraph); + return id30; + } + getPosForId(id30) { + for (const [i2, subGraph] of this.subGraphs.entries()) { + if (subGraph.id === id30) { + return i2; + } + } + return -1; + } + indexNodes2(id30, pos) { + const nodes5 = this.subGraphs[pos].nodes; + this.secCount = this.secCount + 1; + if (this.secCount > 2e3) { + return { + result: false, + count: 0 + }; + } + this.posCrossRef[this.secCount] = pos; + if (this.subGraphs[pos].id === id30) { + return { + result: true, + count: 0 + }; + } + let count2 = 0; + let posCount = 1; + while (count2 < nodes5.length) { + const childPos = this.getPosForId(nodes5[count2]); + if (childPos >= 0) { + const res = this.indexNodes2(id30, childPos); + if (res.result) { + return { + result: true, + count: posCount + res.count + }; + } else { + posCount = posCount + res.count; + } + } + count2 = count2 + 1; + } + return { + result: false, + count: posCount + }; + } + getDepthFirstPos(pos) { + return this.posCrossRef[pos]; + } + indexNodes() { + this.secCount = -1; + if (this.subGraphs.length > 0) { + this.indexNodes2("none", this.subGraphs.length - 1); + } + } + getSubGraphs() { + return this.subGraphs; + } + firstGraph() { + if (this.firstGraphFlag) { + this.firstGraphFlag = false; + return true; + } + return false; + } + destructStartLink(_str) { + let str2 = _str.trim(); + let type3 = "arrow_open"; + switch (str2[0]) { + case "<": + type3 = "arrow_point"; + str2 = str2.slice(1); + break; + case "x": + type3 = "arrow_cross"; + str2 = str2.slice(1); + break; + case "o": + type3 = "arrow_circle"; + str2 = str2.slice(1); + break; + } + let stroke = "normal"; + if (str2.includes("=")) { + stroke = "thick"; + } + if (str2.includes(".")) { + stroke = "dotted"; + } + return { type: type3, stroke }; + } + countChar(char2, str2) { + const length2 = str2.length; + let count2 = 0; + for (let i2 = 0; i2 < length2; ++i2) { + if (str2[i2] === char2) { + ++count2; + } + } + return count2; + } + destructEndLink(_str) { + const str2 = _str.trim(); + let line2 = str2.slice(0, -1); + let type3 = "arrow_open"; + switch (str2.slice(-1)) { + case "x": + type3 = "arrow_cross"; + if (str2.startsWith("x")) { + type3 = "double_" + type3; + line2 = line2.slice(1); + } + break; + case ">": + type3 = "arrow_point"; + if (str2.startsWith("<")) { + type3 = "double_" + type3; + line2 = line2.slice(1); + } + break; + case "o": + type3 = "arrow_circle"; + if (str2.startsWith("o")) { + type3 = "double_" + type3; + line2 = line2.slice(1); + } + break; + } + let stroke = "normal"; + let length2 = line2.length - 1; + if (line2.startsWith("=")) { + stroke = "thick"; + } + if (line2.startsWith("~")) { + stroke = "invisible"; + } + const dots = this.countChar(".", line2); + if (dots) { + stroke = "dotted"; + length2 = dots; + } + return { type: type3, stroke, length: length2 }; + } + destructLink(_str, _startStr) { + const info2 = this.destructEndLink(_str); + let startInfo; + if (_startStr) { + startInfo = this.destructStartLink(_startStr); + if (startInfo.stroke !== info2.stroke) { + return { type: "INVALID", stroke: "INVALID" }; + } + if (startInfo.type === "arrow_open") { + startInfo.type = info2.type; + } else { + if (startInfo.type !== info2.type) { + return { type: "INVALID", stroke: "INVALID" }; + } + startInfo.type = "double_" + startInfo.type; + } + if (startInfo.type === "double_arrow") { + startInfo.type = "double_arrow_point"; + } + startInfo.length = info2.length; + return startInfo; + } + return info2; + } + // Todo optimizer this by caching existing nodes + exists(allSgs, _id) { + for (const sg of allSgs) { + if (sg.nodes.includes(_id)) { + return true; + } + } + return false; + } + /** + * Deletes an id from all subgraphs + * + */ + makeUniq(sg, allSubgraphs) { + const res = []; + sg.nodes.forEach((_id, pos) => { + if (!this.exists(allSubgraphs, _id)) { + res.push(sg.nodes[pos]); + } + }); + return { nodes: res }; + } + getTypeFromVertex(vertex) { + if (vertex.img) { + return "imageSquare"; + } + if (vertex.icon) { + if (vertex.form === "circle") { + return "iconCircle"; + } + if (vertex.form === "square") { + return "iconSquare"; + } + if (vertex.form === "rounded") { + return "iconRounded"; + } + return "icon"; + } + switch (vertex.type) { + case "square": + case void 0: + return "squareRect"; + case "round": + return "roundedRect"; + case "ellipse": + return "ellipse"; + default: + return vertex.type; + } + } + findNode(nodes5, id30) { + return nodes5.find((node2) => node2.id === id30); + } + destructEdgeType(type3) { + let arrowTypeStart = "none"; + let arrowTypeEnd = "arrow_point"; + switch (type3) { + case "arrow_point": + case "arrow_circle": + case "arrow_cross": + arrowTypeEnd = type3; + break; + case "double_arrow_point": + case "double_arrow_circle": + case "double_arrow_cross": + arrowTypeStart = type3.replace("double_", ""); + arrowTypeEnd = arrowTypeStart; + break; + } + return { arrowTypeStart, arrowTypeEnd }; + } + addNodeFromVertex(vertex, nodes5, parentDB, subGraphDB, config5, look) { + const parentId = parentDB.get(vertex.id); + const isGroup2 = subGraphDB.get(vertex.id) ?? false; + const node2 = this.findNode(nodes5, vertex.id); + if (node2) { + node2.cssStyles = vertex.styles; + node2.cssCompiledStyles = this.getCompiledStyles(vertex.classes); + node2.cssClasses = vertex.classes.join(" "); + } else { + const baseNode = { + id: vertex.id, + label: vertex.text, + labelStyle: "", + parentId, + padding: config5.flowchart?.padding || 8, + cssStyles: vertex.styles, + cssCompiledStyles: this.getCompiledStyles(["default", "node", ...vertex.classes]), + cssClasses: "default " + vertex.classes.join(" "), + dir: vertex.dir, + domId: vertex.domId, + look, + link: vertex.link, + linkTarget: vertex.linkTarget, + tooltip: this.getTooltip(vertex.id), + icon: vertex.icon, + pos: vertex.pos, + img: vertex.img, + assetWidth: vertex.assetWidth, + assetHeight: vertex.assetHeight, + constraint: vertex.constraint + }; + if (isGroup2) { + nodes5.push({ + ...baseNode, + isGroup: true, + shape: "rect" + }); + } else { + nodes5.push({ + ...baseNode, + isGroup: false, + shape: this.getTypeFromVertex(vertex) + }); + } + } + } + getCompiledStyles(classDefs) { + let compiledStyles = []; + for (const customClass of classDefs) { + const cssClass = this.classes.get(customClass); + if (cssClass?.styles) { + compiledStyles = [...compiledStyles, ...cssClass.styles ?? []].map((s2) => s2.trim()); + } + if (cssClass?.textStyles) { + compiledStyles = [...compiledStyles, ...cssClass.textStyles ?? []].map((s2) => s2.trim()); + } + } + return compiledStyles; + } + getData() { + const config5 = getConfig2(); + const nodes5 = []; + const edges3 = []; + const subGraphs = this.getSubGraphs(); + const parentDB = /* @__PURE__ */ new Map(); + const subGraphDB = /* @__PURE__ */ new Map(); + for (let i2 = subGraphs.length - 1; i2 >= 0; i2--) { + const subGraph = subGraphs[i2]; + if (subGraph.nodes.length > 0) { + subGraphDB.set(subGraph.id, true); + } + for (const id30 of subGraph.nodes) { + parentDB.set(id30, subGraph.id); + } + } + for (let i2 = subGraphs.length - 1; i2 >= 0; i2--) { + const subGraph = subGraphs[i2]; + nodes5.push({ + id: subGraph.id, + label: subGraph.title, + labelStyle: "", + parentId: parentDB.get(subGraph.id), + padding: 8, + cssCompiledStyles: this.getCompiledStyles(subGraph.classes), + cssClasses: subGraph.classes.join(" "), + shape: "rect", + dir: subGraph.dir, + isGroup: true, + look: config5.look + }); + } + const n2 = this.getVertices(); + n2.forEach((vertex) => { + this.addNodeFromVertex(vertex, nodes5, parentDB, subGraphDB, config5, config5.look || "classic"); + }); + const e3 = this.getEdges(); + e3.forEach((rawEdge, index) => { + const { arrowTypeStart, arrowTypeEnd } = this.destructEdgeType(rawEdge.type); + const styles4 = [...e3.defaultStyle ?? []]; + if (rawEdge.style) { + styles4.push(...rawEdge.style); + } + const edge = { + id: getEdgeId(rawEdge.start, rawEdge.end, { counter: index, prefix: "L" }, rawEdge.id), + isUserDefinedId: rawEdge.isUserDefinedId, + start: rawEdge.start, + end: rawEdge.end, + type: rawEdge.type ?? "normal", + label: rawEdge.text, + labelpos: "c", + thickness: rawEdge.stroke, + minlen: rawEdge.length, + classes: rawEdge?.stroke === "invisible" ? "" : "edge-thickness-normal edge-pattern-solid flowchart-link", + arrowTypeStart: rawEdge?.stroke === "invisible" || rawEdge?.type === "arrow_open" ? "none" : arrowTypeStart, + arrowTypeEnd: rawEdge?.stroke === "invisible" || rawEdge?.type === "arrow_open" ? "none" : arrowTypeEnd, + arrowheadStyle: "fill: #333", + cssCompiledStyles: this.getCompiledStyles(rawEdge.classes), + labelStyle: styles4, + style: styles4, + pattern: rawEdge.stroke, + look: config5.look, + animate: rawEdge.animate, + animation: rawEdge.animation, + curve: rawEdge.interpolate || this.edges.defaultInterpolate || config5.flowchart?.curve + }; + edges3.push(edge); + }); + return { nodes: nodes5, edges: edges3, other: {}, config: config5 }; + } + defaultConfig() { + return defaultConfig2.flowchart; + } + }; + } + }); + + // src/rendering-util/insertElementsForSize.js + var getDiagramElement; + var init_insertElementsForSize = __esm({ + "src/rendering-util/insertElementsForSize.js"() { + "use strict"; + init_src32(); + getDiagramElement = /* @__PURE__ */ __name((id30, securityLevel) => { + let sandboxElement; + if (securityLevel === "sandbox") { + sandboxElement = select_default2("#i" + id30); + } + const root3 = securityLevel === "sandbox" ? select_default2(sandboxElement.nodes()[0].contentDocument.body) : select_default2("body"); + const svg2 = root3.select(`[id="${id30}"]`); + return svg2; + }, "getDiagramElement"); + } + }); + + // src/utils/subGraphTitleMargins.ts + var getSubGraphTitleMargins; + var init_subGraphTitleMargins = __esm({ + "src/utils/subGraphTitleMargins.ts"() { + "use strict"; + getSubGraphTitleMargins = /* @__PURE__ */ __name(({ + flowchart + }) => { + const subGraphTitleTopMargin = flowchart?.subGraphTitleMargin?.top ?? 0; + const subGraphTitleBottomMargin = flowchart?.subGraphTitleMargin?.bottom ?? 0; + const subGraphTitleTotalMargin = subGraphTitleTopMargin + subGraphTitleBottomMargin; + return { + subGraphTitleTopMargin, + subGraphTitleBottomMargin, + subGraphTitleTotalMargin + }; + }, "getSubGraphTitleMargins"); + } + }); + + // src/rendering-util/rendering-elements/clusters.js + var rect, noteGroup, roundedWithTitle, kanbanSection, divider, squareRect2, shapes2, clusterElems, insertCluster, clear3; + var init_clusters = __esm({ + "src/rendering-util/rendering-elements/clusters.js"() { + "use strict"; + init_diagramAPI(); + init_common(); + init_logger(); + init_subGraphTitleMargins(); + init_src32(); + init_rough_esm(); + init_createText(); + init_intersect_rect(); + init_createLabel(); + init_roundedRectPath(); + init_handDrawnShapeStyles(); + rect = /* @__PURE__ */ __name(async (parent4, node2) => { + log.info("Creating subgraph rect for ", node2.id, node2); + const siteConfig2 = getConfig2(); + const { themeVariables, handDrawnSeed } = siteConfig2; + const { clusterBkg, clusterBorder } = themeVariables; + const { labelStyles, nodeStyles, borderStyles, backgroundStyles } = styles2String(node2); + const shapeSvg = parent4.insert("g").attr("class", "cluster " + node2.cssClasses).attr("id", node2.id).attr("data-look", node2.look); + const useHtmlLabels = evaluate(siteConfig2.flowchart.htmlLabels); + const labelEl = shapeSvg.insert("g").attr("class", "cluster-label "); + const text4 = await createText(labelEl, node2.label, { + style: node2.labelStyle, + useHtmlLabels, + isNode: true + }); + let bbox = text4.getBBox(); + if (evaluate(siteConfig2.flowchart.htmlLabels)) { + const div = text4.children[0]; + const dv = select_default2(text4); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + const width3 = node2.width <= bbox.width + node2.padding ? bbox.width + node2.padding : node2.width; + if (node2.width <= bbox.width + node2.padding) { + node2.diff = (width3 - node2.width) / 2 - node2.padding; + } else { + node2.diff = -node2.padding; + } + const height2 = node2.height; + const x5 = node2.x - width3 / 2; + const y6 = node2.y - height2 / 2; + log.trace("Data ", node2, JSON.stringify(node2)); + let rect3; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, { + roughness: 0.7, + fill: clusterBkg, + // fill: 'red', + stroke: clusterBorder, + fillWeight: 3, + seed: handDrawnSeed + }); + const roughNode = rc.path(createRoundedRectPathD(x5, y6, width3, height2, 0), options2); + rect3 = shapeSvg.insert(() => { + log.debug("Rough node insert CXC", roughNode); + return roughNode; + }, ":first-child"); + rect3.select("path:nth-child(2)").attr("style", borderStyles.join(";")); + rect3.select("path").attr("style", backgroundStyles.join(";").replace("fill", "stroke")); + } else { + rect3 = shapeSvg.insert("rect", ":first-child"); + rect3.attr("style", nodeStyles).attr("rx", node2.rx).attr("ry", node2.ry).attr("x", x5).attr("y", y6).attr("width", width3).attr("height", height2); + } + const { subGraphTitleTopMargin } = getSubGraphTitleMargins(siteConfig2); + labelEl.attr( + "transform", + // This puts the label on top of the box instead of inside it + `translate(${node2.x - bbox.width / 2}, ${node2.y - node2.height / 2 + subGraphTitleTopMargin})` + ); + if (labelStyles) { + const span = labelEl.select("span"); + if (span) { + span.attr("style", labelStyles); + } + } + const rectBox = rect3.node().getBBox(); + node2.offsetX = 0; + node2.width = rectBox.width; + node2.height = rectBox.height; + node2.offsetY = bbox.height - node2.padding / 2; + node2.intersect = function(point8) { + return intersect_rect_default(node2, point8); + }; + return { cluster: shapeSvg, labelBBox: bbox }; + }, "rect"); + noteGroup = /* @__PURE__ */ __name((parent4, node2) => { + const shapeSvg = parent4.insert("g").attr("class", "note-cluster").attr("id", node2.id); + const rect3 = shapeSvg.insert("rect", ":first-child"); + const padding2 = 0 * node2.padding; + const halfPadding = padding2 / 2; + rect3.attr("rx", node2.rx).attr("ry", node2.ry).attr("x", node2.x - node2.width / 2 - halfPadding).attr("y", node2.y - node2.height / 2 - halfPadding).attr("width", node2.width + padding2).attr("height", node2.height + padding2).attr("fill", "none"); + const rectBox = rect3.node().getBBox(); + node2.width = rectBox.width; + node2.height = rectBox.height; + node2.intersect = function(point8) { + return intersect_rect_default(node2, point8); + }; + return { cluster: shapeSvg, labelBBox: { width: 0, height: 0 } }; + }, "noteGroup"); + roundedWithTitle = /* @__PURE__ */ __name(async (parent4, node2) => { + const siteConfig2 = getConfig2(); + const { themeVariables, handDrawnSeed } = siteConfig2; + const { altBackground, compositeBackground, compositeTitleBackground, nodeBorder } = themeVariables; + const shapeSvg = parent4.insert("g").attr("class", node2.cssClasses).attr("id", node2.id).attr("data-id", node2.id).attr("data-look", node2.look); + const outerRectG = shapeSvg.insert("g", ":first-child"); + const label = shapeSvg.insert("g").attr("class", "cluster-label"); + let innerRect = shapeSvg.append("rect"); + const text4 = label.node().appendChild(await createLabel_default(node2.label, node2.labelStyle, void 0, true)); + let bbox = text4.getBBox(); + if (evaluate(siteConfig2.flowchart.htmlLabels)) { + const div = text4.children[0]; + const dv = select_default2(text4); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + const padding2 = 0 * node2.padding; + const halfPadding = padding2 / 2; + const width3 = (node2.width <= bbox.width + node2.padding ? bbox.width + node2.padding : node2.width) + padding2; + if (node2.width <= bbox.width + node2.padding) { + node2.diff = (width3 - node2.width) / 2 - node2.padding; + } else { + node2.diff = -node2.padding; + } + const height2 = node2.height + padding2; + const innerHeight = node2.height + padding2 - bbox.height - 6; + const x5 = node2.x - width3 / 2; + const y6 = node2.y - height2 / 2; + node2.width = width3; + const innerY = node2.y - node2.height / 2 - halfPadding + bbox.height + 2; + let rect3; + if (node2.look === "handDrawn") { + const isAlt = node2.cssClasses.includes("statediagram-cluster-alt"); + const rc = at.svg(shapeSvg); + const roughOuterNode = node2.rx || node2.ry ? rc.path(createRoundedRectPathD(x5, y6, width3, height2, 10), { + roughness: 0.7, + fill: compositeTitleBackground, + fillStyle: "solid", + stroke: nodeBorder, + seed: handDrawnSeed + }) : rc.rectangle(x5, y6, width3, height2, { seed: handDrawnSeed }); + rect3 = shapeSvg.insert(() => roughOuterNode, ":first-child"); + const roughInnerNode = rc.rectangle(x5, innerY, width3, innerHeight, { + fill: isAlt ? altBackground : compositeBackground, + fillStyle: isAlt ? "hachure" : "solid", + stroke: nodeBorder, + seed: handDrawnSeed + }); + rect3 = shapeSvg.insert(() => roughOuterNode, ":first-child"); + innerRect = shapeSvg.insert(() => roughInnerNode); + } else { + rect3 = outerRectG.insert("rect", ":first-child"); + const outerRectClass = "outer"; + rect3.attr("class", outerRectClass).attr("x", x5).attr("y", y6).attr("width", width3).attr("height", height2).attr("data-look", node2.look); + innerRect.attr("class", "inner").attr("x", x5).attr("y", innerY).attr("width", width3).attr("height", innerHeight); + } + label.attr( + "transform", + `translate(${node2.x - bbox.width / 2}, ${y6 + 1 - (evaluate(siteConfig2.flowchart.htmlLabels) ? 0 : 3)})` + ); + const rectBox = rect3.node().getBBox(); + node2.height = rectBox.height; + node2.offsetX = 0; + node2.offsetY = bbox.height - node2.padding / 2; + node2.labelBBox = bbox; + node2.intersect = function(point8) { + return intersect_rect_default(node2, point8); + }; + return { cluster: shapeSvg, labelBBox: bbox }; + }, "roundedWithTitle"); + kanbanSection = /* @__PURE__ */ __name(async (parent4, node2) => { + log.info("Creating subgraph rect for ", node2.id, node2); + const siteConfig2 = getConfig2(); + const { themeVariables, handDrawnSeed } = siteConfig2; + const { clusterBkg, clusterBorder } = themeVariables; + const { labelStyles, nodeStyles, borderStyles, backgroundStyles } = styles2String(node2); + const shapeSvg = parent4.insert("g").attr("class", "cluster " + node2.cssClasses).attr("id", node2.id).attr("data-look", node2.look); + const useHtmlLabels = evaluate(siteConfig2.flowchart.htmlLabels); + const labelEl = shapeSvg.insert("g").attr("class", "cluster-label "); + const text4 = await createText(labelEl, node2.label, { + style: node2.labelStyle, + useHtmlLabels, + isNode: true, + width: node2.width + }); + let bbox = text4.getBBox(); + if (evaluate(siteConfig2.flowchart.htmlLabels)) { + const div = text4.children[0]; + const dv = select_default2(text4); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + const width3 = node2.width <= bbox.width + node2.padding ? bbox.width + node2.padding : node2.width; + if (node2.width <= bbox.width + node2.padding) { + node2.diff = (width3 - node2.width) / 2 - node2.padding; + } else { + node2.diff = -node2.padding; + } + const height2 = node2.height; + const x5 = node2.x - width3 / 2; + const y6 = node2.y - height2 / 2; + log.trace("Data ", node2, JSON.stringify(node2)); + let rect3; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const options2 = userNodeOverrides(node2, { + roughness: 0.7, + fill: clusterBkg, + // fill: 'red', + stroke: clusterBorder, + fillWeight: 4, + seed: handDrawnSeed + }); + const roughNode = rc.path(createRoundedRectPathD(x5, y6, width3, height2, node2.rx), options2); + rect3 = shapeSvg.insert(() => { + log.debug("Rough node insert CXC", roughNode); + return roughNode; + }, ":first-child"); + rect3.select("path:nth-child(2)").attr("style", borderStyles.join(";")); + rect3.select("path").attr("style", backgroundStyles.join(";").replace("fill", "stroke")); + } else { + rect3 = shapeSvg.insert("rect", ":first-child"); + rect3.attr("style", nodeStyles).attr("rx", node2.rx).attr("ry", node2.ry).attr("x", x5).attr("y", y6).attr("width", width3).attr("height", height2); + } + const { subGraphTitleTopMargin } = getSubGraphTitleMargins(siteConfig2); + labelEl.attr( + "transform", + // This puts the label on top of the box instead of inside it + `translate(${node2.x - bbox.width / 2}, ${node2.y - node2.height / 2 + subGraphTitleTopMargin})` + ); + if (labelStyles) { + const span = labelEl.select("span"); + if (span) { + span.attr("style", labelStyles); + } + } + const rectBox = rect3.node().getBBox(); + node2.offsetX = 0; + node2.width = rectBox.width; + node2.height = rectBox.height; + node2.offsetY = bbox.height - node2.padding / 2; + node2.intersect = function(point8) { + return intersect_rect_default(node2, point8); + }; + return { cluster: shapeSvg, labelBBox: bbox }; + }, "kanbanSection"); + divider = /* @__PURE__ */ __name((parent4, node2) => { + const siteConfig2 = getConfig2(); + const { themeVariables, handDrawnSeed } = siteConfig2; + const { nodeBorder } = themeVariables; + const shapeSvg = parent4.insert("g").attr("class", node2.cssClasses).attr("id", node2.id).attr("data-look", node2.look); + const outerRectG = shapeSvg.insert("g", ":first-child"); + const padding2 = 0 * node2.padding; + const width3 = node2.width + padding2; + node2.diff = -node2.padding; + const height2 = node2.height + padding2; + const x5 = node2.x - width3 / 2; + const y6 = node2.y - height2 / 2; + node2.width = width3; + let rect3; + if (node2.look === "handDrawn") { + const rc = at.svg(shapeSvg); + const roughOuterNode = rc.rectangle(x5, y6, width3, height2, { + fill: "lightgrey", + roughness: 0.5, + strokeLineDash: [5], + stroke: nodeBorder, + seed: handDrawnSeed + }); + rect3 = shapeSvg.insert(() => roughOuterNode, ":first-child"); + } else { + rect3 = outerRectG.insert("rect", ":first-child"); + const outerRectClass = "divider"; + rect3.attr("class", outerRectClass).attr("x", x5).attr("y", y6).attr("width", width3).attr("height", height2).attr("data-look", node2.look); + } + const rectBox = rect3.node().getBBox(); + node2.height = rectBox.height; + node2.offsetX = 0; + node2.offsetY = 0; + node2.intersect = function(point8) { + return intersect_rect_default(node2, point8); + }; + return { cluster: shapeSvg, labelBBox: {} }; + }, "divider"); + squareRect2 = rect; + shapes2 = { + rect, + squareRect: squareRect2, + roundedWithTitle, + noteGroup, + divider, + kanbanSection + }; + clusterElems = /* @__PURE__ */ new Map(); + insertCluster = /* @__PURE__ */ __name(async (elem, node2) => { + const shape = node2.shape || "rect"; + const cluster = await shapes2[shape](elem, node2); + clusterElems.set(node2.id, cluster); + return cluster; + }, "insertCluster"); + clear3 = /* @__PURE__ */ __name(() => { + clusterElems = /* @__PURE__ */ new Map(); + }, "clear"); + } + }); + + // src/utils/lineWithOffset.ts + function calculateDeltaAndAngle(point1, point22) { + if (point1 === void 0 || point22 === void 0) { + return { angle: 0, deltaX: 0, deltaY: 0 }; + } + point1 = pointTransformer(point1); + point22 = pointTransformer(point22); + const [x1, y1] = [point1.x, point1.y]; + const [x22, y22] = [point22.x, point22.y]; + const deltaX = x22 - x1; + const deltaY = y22 - y1; + return { angle: Math.atan(deltaY / deltaX), deltaX, deltaY }; + } + var markerOffsets, markerOffsets2, pointTransformer, getLineFunctionsWithOffset; + var init_lineWithOffset = __esm({ + "src/utils/lineWithOffset.ts"() { + "use strict"; + markerOffsets = { + aggregation: 17.25, + extension: 17.25, + composition: 17.25, + dependency: 6, + lollipop: 13.5, + arrow_point: 4 + //arrow_cross: 24, + }; + markerOffsets2 = { + arrow_point: 9, + arrow_cross: 12.5, + arrow_circle: 12.5 + }; + __name(calculateDeltaAndAngle, "calculateDeltaAndAngle"); + pointTransformer = /* @__PURE__ */ __name((data5) => { + if (Array.isArray(data5)) { + return { x: data5[0], y: data5[1] }; + } + return data5; + }, "pointTransformer"); + getLineFunctionsWithOffset = /* @__PURE__ */ __name((edge) => { + return { + x: /* @__PURE__ */ __name(function(d3, i2, data5) { + let offset = 0; + const DIRECTION = pointTransformer(data5[0]).x < pointTransformer(data5[data5.length - 1]).x ? "left" : "right"; + if (i2 === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) { + const { angle: angle2, deltaX } = calculateDeltaAndAngle(data5[0], data5[1]); + offset = markerOffsets[edge.arrowTypeStart] * Math.cos(angle2) * (deltaX >= 0 ? 1 : -1); + } else if (i2 === data5.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) { + const { angle: angle2, deltaX } = calculateDeltaAndAngle( + data5[data5.length - 1], + data5[data5.length - 2] + ); + offset = markerOffsets[edge.arrowTypeEnd] * Math.cos(angle2) * (deltaX >= 0 ? 1 : -1); + } + const differenceToEnd = Math.abs( + pointTransformer(d3).x - pointTransformer(data5[data5.length - 1]).x + ); + const differenceInYEnd = Math.abs( + pointTransformer(d3).y - pointTransformer(data5[data5.length - 1]).y + ); + const differenceToStart = Math.abs(pointTransformer(d3).x - pointTransformer(data5[0]).x); + const differenceInYStart = Math.abs(pointTransformer(d3).y - pointTransformer(data5[0]).y); + const startMarkerHeight = markerOffsets[edge.arrowTypeStart]; + const endMarkerHeight = markerOffsets[edge.arrowTypeEnd]; + const extraRoom = 1; + if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInYEnd < endMarkerHeight) { + let adjustment = endMarkerHeight + extraRoom - differenceToEnd; + adjustment *= DIRECTION === "right" ? -1 : 1; + offset -= adjustment; + } + if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInYStart < startMarkerHeight) { + let adjustment = startMarkerHeight + extraRoom - differenceToStart; + adjustment *= DIRECTION === "right" ? -1 : 1; + offset += adjustment; + } + return pointTransformer(d3).x + offset; + }, "x"), + y: /* @__PURE__ */ __name(function(d3, i2, data5) { + let offset = 0; + const DIRECTION = pointTransformer(data5[0]).y < pointTransformer(data5[data5.length - 1]).y ? "down" : "up"; + if (i2 === 0 && Object.hasOwn(markerOffsets, edge.arrowTypeStart)) { + const { angle: angle2, deltaY } = calculateDeltaAndAngle(data5[0], data5[1]); + offset = markerOffsets[edge.arrowTypeStart] * Math.abs(Math.sin(angle2)) * (deltaY >= 0 ? 1 : -1); + } else if (i2 === data5.length - 1 && Object.hasOwn(markerOffsets, edge.arrowTypeEnd)) { + const { angle: angle2, deltaY } = calculateDeltaAndAngle( + data5[data5.length - 1], + data5[data5.length - 2] + ); + offset = markerOffsets[edge.arrowTypeEnd] * Math.abs(Math.sin(angle2)) * (deltaY >= 0 ? 1 : -1); + } + const differenceToEnd = Math.abs( + pointTransformer(d3).y - pointTransformer(data5[data5.length - 1]).y + ); + const differenceInXEnd = Math.abs( + pointTransformer(d3).x - pointTransformer(data5[data5.length - 1]).x + ); + const differenceToStart = Math.abs(pointTransformer(d3).y - pointTransformer(data5[0]).y); + const differenceInXStart = Math.abs(pointTransformer(d3).x - pointTransformer(data5[0]).x); + const startMarkerHeight = markerOffsets[edge.arrowTypeStart]; + const endMarkerHeight = markerOffsets[edge.arrowTypeEnd]; + const extraRoom = 1; + if (differenceToEnd < endMarkerHeight && differenceToEnd > 0 && differenceInXEnd < endMarkerHeight) { + let adjustment = endMarkerHeight + extraRoom - differenceToEnd; + adjustment *= DIRECTION === "up" ? -1 : 1; + offset -= adjustment; + } + if (differenceToStart < startMarkerHeight && differenceToStart > 0 && differenceInXStart < startMarkerHeight) { + let adjustment = startMarkerHeight + extraRoom - differenceToStart; + adjustment *= DIRECTION === "up" ? -1 : 1; + offset += adjustment; + } + return pointTransformer(d3).y + offset; + }, "y") + }; + }, "getLineFunctionsWithOffset"); + if (void 0) { + const { it, expect, describe } = void 0; + describe("calculateDeltaAndAngle", () => { + it("should calculate the angle and deltas between two points", () => { + expect(calculateDeltaAndAngle([0, 0], [0, 1])).toStrictEqual({ + angle: 1.5707963267948966, + deltaX: 0, + deltaY: 1 + }); + expect(calculateDeltaAndAngle([1, 0], [0, -1])).toStrictEqual({ + angle: 0.7853981633974483, + deltaX: -1, + deltaY: -1 + }); + expect(calculateDeltaAndAngle({ x: 1, y: 0 }, [0, -1])).toStrictEqual({ + angle: 0.7853981633974483, + deltaX: -1, + deltaY: -1 + }); + expect(calculateDeltaAndAngle({ x: 1, y: 0 }, { x: 1, y: 0 })).toStrictEqual({ + angle: NaN, + deltaX: 0, + deltaY: 0 + }); + }); + it("should calculate the angle and deltas if one point in undefined", () => { + expect(calculateDeltaAndAngle(void 0, [0, 1])).toStrictEqual({ + angle: 0, + deltaX: 0, + deltaY: 0 + }); + expect(calculateDeltaAndAngle([0, 1], void 0)).toStrictEqual({ + angle: 0, + deltaX: 0, + deltaY: 0 + }); + }); + }); + } + } + }); + + // src/rendering-util/rendering-elements/edgeMarker.ts + var addEdgeMarkers, arrowTypesMap, addEdgeMarker; + var init_edgeMarker = __esm({ + "src/rendering-util/rendering-elements/edgeMarker.ts"() { + "use strict"; + init_logger(); + addEdgeMarkers = /* @__PURE__ */ __name((svgPath, edge, url, id30, diagramType, strokeColor) => { + if (edge.arrowTypeStart) { + addEdgeMarker(svgPath, "start", edge.arrowTypeStart, url, id30, diagramType, strokeColor); + } + if (edge.arrowTypeEnd) { + addEdgeMarker(svgPath, "end", edge.arrowTypeEnd, url, id30, diagramType, strokeColor); + } + }, "addEdgeMarkers"); + arrowTypesMap = { + arrow_cross: { type: "cross", fill: false }, + arrow_point: { type: "point", fill: true }, + arrow_barb: { type: "barb", fill: true }, + arrow_circle: { type: "circle", fill: false }, + aggregation: { type: "aggregation", fill: false }, + extension: { type: "extension", fill: false }, + composition: { type: "composition", fill: true }, + dependency: { type: "dependency", fill: true }, + lollipop: { type: "lollipop", fill: false }, + only_one: { type: "onlyOne", fill: false }, + zero_or_one: { type: "zeroOrOne", fill: false }, + one_or_more: { type: "oneOrMore", fill: false }, + zero_or_more: { type: "zeroOrMore", fill: false }, + requirement_arrow: { type: "requirement_arrow", fill: false }, + requirement_contains: { type: "requirement_contains", fill: false } + }; + addEdgeMarker = /* @__PURE__ */ __name((svgPath, position5, arrowType, url, id30, diagramType, strokeColor) => { + const arrowTypeInfo = arrowTypesMap[arrowType]; + if (!arrowTypeInfo) { + log.warn(`Unknown arrow type: ${arrowType}`); + return; + } + const endMarkerType = arrowTypeInfo.type; + const suffix = position5 === "start" ? "Start" : "End"; + const originalMarkerId = `${id30}_${diagramType}-${endMarkerType}${suffix}`; + if (strokeColor && strokeColor.trim() !== "") { + const colorId = strokeColor.replace(/[^\dA-Za-z]/g, "_"); + const coloredMarkerId = `${originalMarkerId}_${colorId}`; + if (!document.getElementById(coloredMarkerId)) { + const originalMarker = document.getElementById(originalMarkerId); + if (originalMarker) { + const coloredMarker = originalMarker.cloneNode(true); + coloredMarker.id = coloredMarkerId; + const paths = coloredMarker.querySelectorAll("path, circle, line"); + paths.forEach((path4) => { + path4.setAttribute("stroke", strokeColor); + if (arrowTypeInfo.fill) { + path4.setAttribute("fill", strokeColor); + } + }); + originalMarker.parentNode?.appendChild(coloredMarker); + } + } + svgPath.attr(`marker-${position5}`, `url(${url}#${coloredMarkerId})`); + } else { + svgPath.attr(`marker-${position5}`, `url(${url}#${originalMarkerId})`); + } + }, "addEdgeMarker"); + } + }); + + // src/rendering-util/rendering-elements/edges.js + function setTerminalWidth(fo, value2) { + if (getConfig2().flowchart.htmlLabels && fo) { + fo.style.width = value2.length * 9 + "px"; + fo.style.height = "12px"; + } + } + function extractCornerPoints(points) { + const cornerPoints = []; + const cornerPointPositions = []; + for (let i2 = 1; i2 < points.length - 1; i2++) { + const prev2 = points[i2 - 1]; + const curr = points[i2]; + const next3 = points[i2 + 1]; + if (prev2.x === curr.x && curr.y === next3.y && Math.abs(curr.x - next3.x) > 5 && Math.abs(curr.y - prev2.y) > 5) { + cornerPoints.push(curr); + cornerPointPositions.push(i2); + } else if (prev2.y === curr.y && curr.x === next3.x && Math.abs(curr.x - prev2.x) > 5 && Math.abs(curr.y - next3.y) > 5) { + cornerPoints.push(curr); + cornerPointPositions.push(i2); + } + } + return { cornerPoints, cornerPointPositions }; + } + function generateRoundedPath(points, radius2) { + if (points.length < 2) { + return ""; + } + let path4 = ""; + const size4 = points.length; + const epsilon6 = 1e-5; + for (let i2 = 0; i2 < size4; i2++) { + const currPoint = points[i2]; + const prevPoint = points[i2 - 1]; + const nextPoint = points[i2 + 1]; + if (i2 === 0) { + path4 += `M${currPoint.x},${currPoint.y}`; + } else if (i2 === size4 - 1) { + path4 += `L${currPoint.x},${currPoint.y}`; + } else { + const dx1 = currPoint.x - prevPoint.x; + const dy1 = currPoint.y - prevPoint.y; + const dx2 = nextPoint.x - currPoint.x; + const dy2 = nextPoint.y - currPoint.y; + const len1 = Math.hypot(dx1, dy1); + const len2 = Math.hypot(dx2, dy2); + if (len1 < epsilon6 || len2 < epsilon6) { + path4 += `L${currPoint.x},${currPoint.y}`; + continue; + } + const nx1 = dx1 / len1; + const ny1 = dy1 / len1; + const nx2 = dx2 / len2; + const ny2 = dy2 / len2; + const dot = nx1 * nx2 + ny1 * ny2; + const clampedDot = Math.max(-1, Math.min(1, dot)); + const angle2 = Math.acos(clampedDot); + if (angle2 < epsilon6 || Math.abs(Math.PI - angle2) < epsilon6) { + path4 += `L${currPoint.x},${currPoint.y}`; + continue; + } + const cutLen = Math.min(radius2 / Math.sin(angle2 / 2), len1 / 2, len2 / 2); + const startX2 = currPoint.x - nx1 * cutLen; + const startY2 = currPoint.y - ny1 * cutLen; + const endX = currPoint.x + nx2 * cutLen; + const endY = currPoint.y + ny2 * cutLen; + path4 += `L${startX2},${startY2}`; + path4 += `Q${currPoint.x},${currPoint.y} ${endX},${endY}`; + } + } + return path4; + } + function calculateDeltaAndAngle2(point1, point22) { + if (!point1 || !point22) { + return { angle: 0, deltaX: 0, deltaY: 0 }; + } + const deltaX = point22.x - point1.x; + const deltaY = point22.y - point1.y; + const angle2 = Math.atan2(deltaY, deltaX); + return { angle: angle2, deltaX, deltaY }; + } + function applyMarkerOffsetsToPoints(points, edge) { + const newPoints = points.map((point8) => ({ ...point8 })); + if (points.length >= 2 && markerOffsets[edge.arrowTypeStart]) { + const offsetValue = markerOffsets[edge.arrowTypeStart]; + const point1 = points[0]; + const point22 = points[1]; + const { angle: angle2 } = calculateDeltaAndAngle2(point1, point22); + const offsetX = offsetValue * Math.cos(angle2); + const offsetY = offsetValue * Math.sin(angle2); + newPoints[0].x = point1.x + offsetX; + newPoints[0].y = point1.y + offsetY; + } + const n2 = points.length; + if (n2 >= 2 && markerOffsets[edge.arrowTypeEnd]) { + const offsetValue = markerOffsets[edge.arrowTypeEnd]; + const point1 = points[n2 - 1]; + const point22 = points[n2 - 2]; + const { angle: angle2 } = calculateDeltaAndAngle2(point22, point1); + const offsetX = offsetValue * Math.cos(angle2); + const offsetY = offsetValue * Math.sin(angle2); + newPoints[n2 - 1].x = point1.x - offsetX; + newPoints[n2 - 1].y = point1.y - offsetY; + } + return newPoints; + } + var edgeLabels, terminalLabels, clear4, getLabelStyles, insertEdgeLabel, positionEdgeLabel, outsideNode, intersection, cutPathAtIntersect, findAdjacentPoint, fixCorners, generateDashArray, insertEdge; + var init_edges = __esm({ + "src/rendering-util/rendering-elements/edges.js"() { + "use strict"; + init_diagramAPI(); + init_common(); + init_logger(); + init_createText(); + init_utils2(); + init_lineWithOffset(); + init_subGraphTitleMargins(); + init_src32(); + init_rough_esm(); + init_createLabel(); + init_edgeMarker(); + init_handDrawnShapeStyles(); + edgeLabels = /* @__PURE__ */ new Map(); + terminalLabels = /* @__PURE__ */ new Map(); + clear4 = /* @__PURE__ */ __name(() => { + edgeLabels.clear(); + terminalLabels.clear(); + }, "clear"); + getLabelStyles = /* @__PURE__ */ __name((styleArray) => { + let styles4 = styleArray ? styleArray.reduce((acc, style3) => acc + ";" + style3, "") : ""; + return styles4; + }, "getLabelStyles"); + insertEdgeLabel = /* @__PURE__ */ __name(async (elem, edge) => { + let useHtmlLabels = evaluate(getConfig2().flowchart.htmlLabels); + const { labelStyles } = styles2String(edge); + edge.labelStyle = labelStyles; + const labelElement = await createText(elem, edge.label, { + style: edge.labelStyle, + useHtmlLabels, + addSvgBackground: true, + isNode: false + }); + log.info("abc82", edge, edge.labelType); + const edgeLabel = elem.insert("g").attr("class", "edgeLabel"); + const label = edgeLabel.insert("g").attr("class", "label").attr("data-id", edge.id); + label.node().appendChild(labelElement); + let bbox = labelElement.getBBox(); + if (useHtmlLabels) { + const div = labelElement.children[0]; + const dv = select_default2(labelElement); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + label.attr("transform", "translate(" + -bbox.width / 2 + ", " + -bbox.height / 2 + ")"); + edgeLabels.set(edge.id, edgeLabel); + edge.width = bbox.width; + edge.height = bbox.height; + let fo; + if (edge.startLabelLeft) { + const startLabelElement = await createLabel_default( + edge.startLabelLeft, + getLabelStyles(edge.labelStyle) + ); + const startEdgeLabelLeft = elem.insert("g").attr("class", "edgeTerminals"); + const inner2 = startEdgeLabelLeft.insert("g").attr("class", "inner"); + fo = inner2.node().appendChild(startLabelElement); + const slBox = startLabelElement.getBBox(); + inner2.attr("transform", "translate(" + -slBox.width / 2 + ", " + -slBox.height / 2 + ")"); + if (!terminalLabels.get(edge.id)) { + terminalLabels.set(edge.id, {}); + } + terminalLabels.get(edge.id).startLeft = startEdgeLabelLeft; + setTerminalWidth(fo, edge.startLabelLeft); + } + if (edge.startLabelRight) { + const startLabelElement = await createLabel_default( + edge.startLabelRight, + getLabelStyles(edge.labelStyle) + ); + const startEdgeLabelRight = elem.insert("g").attr("class", "edgeTerminals"); + const inner2 = startEdgeLabelRight.insert("g").attr("class", "inner"); + fo = startEdgeLabelRight.node().appendChild(startLabelElement); + inner2.node().appendChild(startLabelElement); + const slBox = startLabelElement.getBBox(); + inner2.attr("transform", "translate(" + -slBox.width / 2 + ", " + -slBox.height / 2 + ")"); + if (!terminalLabels.get(edge.id)) { + terminalLabels.set(edge.id, {}); + } + terminalLabels.get(edge.id).startRight = startEdgeLabelRight; + setTerminalWidth(fo, edge.startLabelRight); + } + if (edge.endLabelLeft) { + const endLabelElement = await createLabel_default(edge.endLabelLeft, getLabelStyles(edge.labelStyle)); + const endEdgeLabelLeft = elem.insert("g").attr("class", "edgeTerminals"); + const inner2 = endEdgeLabelLeft.insert("g").attr("class", "inner"); + fo = inner2.node().appendChild(endLabelElement); + const slBox = endLabelElement.getBBox(); + inner2.attr("transform", "translate(" + -slBox.width / 2 + ", " + -slBox.height / 2 + ")"); + endEdgeLabelLeft.node().appendChild(endLabelElement); + if (!terminalLabels.get(edge.id)) { + terminalLabels.set(edge.id, {}); + } + terminalLabels.get(edge.id).endLeft = endEdgeLabelLeft; + setTerminalWidth(fo, edge.endLabelLeft); + } + if (edge.endLabelRight) { + const endLabelElement = await createLabel_default(edge.endLabelRight, getLabelStyles(edge.labelStyle)); + const endEdgeLabelRight = elem.insert("g").attr("class", "edgeTerminals"); + const inner2 = endEdgeLabelRight.insert("g").attr("class", "inner"); + fo = inner2.node().appendChild(endLabelElement); + const slBox = endLabelElement.getBBox(); + inner2.attr("transform", "translate(" + -slBox.width / 2 + ", " + -slBox.height / 2 + ")"); + endEdgeLabelRight.node().appendChild(endLabelElement); + if (!terminalLabels.get(edge.id)) { + terminalLabels.set(edge.id, {}); + } + terminalLabels.get(edge.id).endRight = endEdgeLabelRight; + setTerminalWidth(fo, edge.endLabelRight); + } + return labelElement; + }, "insertEdgeLabel"); + __name(setTerminalWidth, "setTerminalWidth"); + positionEdgeLabel = /* @__PURE__ */ __name((edge, paths) => { + log.debug("Moving label abc88 ", edge.id, edge.label, edgeLabels.get(edge.id), paths); + let path4 = paths.updatedPath ? paths.updatedPath : paths.originalPath; + const siteConfig2 = getConfig2(); + const { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig2); + if (edge.label) { + const el = edgeLabels.get(edge.id); + let x5 = edge.x; + let y6 = edge.y; + if (path4) { + const pos = utils_default2.calcLabelPosition(path4); + log.debug( + "Moving label " + edge.label + " from (", + x5, + ",", + y6, + ") to (", + pos.x, + ",", + pos.y, + ") abc88" + ); + if (paths.updatedPath) { + x5 = pos.x; + y6 = pos.y; + } + } + el.attr("transform", `translate(${x5}, ${y6 + subGraphTitleTotalMargin / 2})`); + } + if (edge.startLabelLeft) { + const el = terminalLabels.get(edge.id).startLeft; + let x5 = edge.x; + let y6 = edge.y; + if (path4) { + const pos = utils_default2.calcTerminalLabelPosition(edge.arrowTypeStart ? 10 : 0, "start_left", path4); + x5 = pos.x; + y6 = pos.y; + } + el.attr("transform", `translate(${x5}, ${y6})`); + } + if (edge.startLabelRight) { + const el = terminalLabels.get(edge.id).startRight; + let x5 = edge.x; + let y6 = edge.y; + if (path4) { + const pos = utils_default2.calcTerminalLabelPosition( + edge.arrowTypeStart ? 10 : 0, + "start_right", + path4 + ); + x5 = pos.x; + y6 = pos.y; + } + el.attr("transform", `translate(${x5}, ${y6})`); + } + if (edge.endLabelLeft) { + const el = terminalLabels.get(edge.id).endLeft; + let x5 = edge.x; + let y6 = edge.y; + if (path4) { + const pos = utils_default2.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_left", path4); + x5 = pos.x; + y6 = pos.y; + } + el.attr("transform", `translate(${x5}, ${y6})`); + } + if (edge.endLabelRight) { + const el = terminalLabels.get(edge.id).endRight; + let x5 = edge.x; + let y6 = edge.y; + if (path4) { + const pos = utils_default2.calcTerminalLabelPosition(edge.arrowTypeEnd ? 10 : 0, "end_right", path4); + x5 = pos.x; + y6 = pos.y; + } + el.attr("transform", `translate(${x5}, ${y6})`); + } + }, "positionEdgeLabel"); + outsideNode = /* @__PURE__ */ __name((node2, point8) => { + const x5 = node2.x; + const y6 = node2.y; + const dx = Math.abs(point8.x - x5); + const dy = Math.abs(point8.y - y6); + const w4 = node2.width / 2; + const h3 = node2.height / 2; + return dx >= w4 || dy >= h3; + }, "outsideNode"); + intersection = /* @__PURE__ */ __name((node2, outsidePoint, insidePoint) => { + log.debug(`intersection calc abc89: + outsidePoint: ${JSON.stringify(outsidePoint)} + insidePoint : ${JSON.stringify(insidePoint)} + node : x:${node2.x} y:${node2.y} w:${node2.width} h:${node2.height}`); + const x5 = node2.x; + const y6 = node2.y; + const dx = Math.abs(x5 - insidePoint.x); + const w4 = node2.width / 2; + let r2 = insidePoint.x < outsidePoint.x ? w4 - dx : w4 + dx; + const h3 = node2.height / 2; + const Q3 = Math.abs(outsidePoint.y - insidePoint.y); + const R3 = Math.abs(outsidePoint.x - insidePoint.x); + if (Math.abs(y6 - outsidePoint.y) * w4 > Math.abs(x5 - outsidePoint.x) * h3) { + let q3 = insidePoint.y < outsidePoint.y ? outsidePoint.y - h3 - y6 : y6 - h3 - outsidePoint.y; + r2 = R3 * q3 / Q3; + const res = { + x: insidePoint.x < outsidePoint.x ? insidePoint.x + r2 : insidePoint.x - R3 + r2, + y: insidePoint.y < outsidePoint.y ? insidePoint.y + Q3 - q3 : insidePoint.y - Q3 + q3 + }; + if (r2 === 0) { + res.x = outsidePoint.x; + res.y = outsidePoint.y; + } + if (R3 === 0) { + res.x = outsidePoint.x; + } + if (Q3 === 0) { + res.y = outsidePoint.y; + } + log.debug(`abc89 top/bottom calc, Q ${Q3}, q ${q3}, R ${R3}, r ${r2}`, res); + return res; + } else { + if (insidePoint.x < outsidePoint.x) { + r2 = outsidePoint.x - w4 - x5; + } else { + r2 = x5 - w4 - outsidePoint.x; + } + let q3 = Q3 * r2 / R3; + let _x = insidePoint.x < outsidePoint.x ? insidePoint.x + R3 - r2 : insidePoint.x - R3 + r2; + let _y = insidePoint.y < outsidePoint.y ? insidePoint.y + q3 : insidePoint.y - q3; + log.debug(`sides calc abc89, Q ${Q3}, q ${q3}, R ${R3}, r ${r2}`, { _x, _y }); + if (r2 === 0) { + _x = outsidePoint.x; + _y = outsidePoint.y; + } + if (R3 === 0) { + _x = outsidePoint.x; + } + if (Q3 === 0) { + _y = outsidePoint.y; + } + return { x: _x, y: _y }; + } + }, "intersection"); + cutPathAtIntersect = /* @__PURE__ */ __name((_points, boundaryNode) => { + log.warn("abc88 cutPathAtIntersect", _points, boundaryNode); + let points = []; + let lastPointOutside = _points[0]; + let isInside = false; + _points.forEach((point8) => { + log.info("abc88 checking point", point8, boundaryNode); + if (!outsideNode(boundaryNode, point8) && !isInside) { + const inter = intersection(boundaryNode, lastPointOutside, point8); + log.debug("abc88 inside", point8, lastPointOutside, inter); + log.debug("abc88 intersection", inter, boundaryNode); + let pointPresent = false; + points.forEach((p3) => { + pointPresent = pointPresent || p3.x === inter.x && p3.y === inter.y; + }); + if (!points.some((e3) => e3.x === inter.x && e3.y === inter.y)) { + points.push(inter); + } else { + log.warn("abc88 no intersect", inter, points); + } + isInside = true; + } else { + log.warn("abc88 outside", point8, lastPointOutside); + lastPointOutside = point8; + if (!isInside) { + points.push(point8); + } + } + }); + log.debug("returning points", points); + return points; + }, "cutPathAtIntersect"); + __name(extractCornerPoints, "extractCornerPoints"); + findAdjacentPoint = /* @__PURE__ */ __name(function(pointA, pointB, distance2) { + const xDiff = pointB.x - pointA.x; + const yDiff = pointB.y - pointA.y; + const length2 = Math.sqrt(xDiff * xDiff + yDiff * yDiff); + const ratio = distance2 / length2; + return { x: pointB.x - ratio * xDiff, y: pointB.y - ratio * yDiff }; + }, "findAdjacentPoint"); + fixCorners = /* @__PURE__ */ __name(function(lineData) { + const { cornerPointPositions } = extractCornerPoints(lineData); + const newLineData = []; + for (let i2 = 0; i2 < lineData.length; i2++) { + if (cornerPointPositions.includes(i2)) { + const prevPoint = lineData[i2 - 1]; + const nextPoint = lineData[i2 + 1]; + const cornerPoint = lineData[i2]; + const newPrevPoint = findAdjacentPoint(prevPoint, cornerPoint, 5); + const newNextPoint = findAdjacentPoint(nextPoint, cornerPoint, 5); + const xDiff = newNextPoint.x - newPrevPoint.x; + const yDiff = newNextPoint.y - newPrevPoint.y; + newLineData.push(newPrevPoint); + const a2 = Math.sqrt(2) * 2; + let newCornerPoint = { x: cornerPoint.x, y: cornerPoint.y }; + if (Math.abs(nextPoint.x - prevPoint.x) > 10 && Math.abs(nextPoint.y - prevPoint.y) >= 10) { + log.debug( + "Corner point fixing", + Math.abs(nextPoint.x - prevPoint.x), + Math.abs(nextPoint.y - prevPoint.y) + ); + const r2 = 5; + if (cornerPoint.x === newPrevPoint.x) { + newCornerPoint = { + x: xDiff < 0 ? newPrevPoint.x - r2 + a2 : newPrevPoint.x + r2 - a2, + y: yDiff < 0 ? newPrevPoint.y - a2 : newPrevPoint.y + a2 + }; + } else { + newCornerPoint = { + x: xDiff < 0 ? newPrevPoint.x - a2 : newPrevPoint.x + a2, + y: yDiff < 0 ? newPrevPoint.y - r2 + a2 : newPrevPoint.y + r2 - a2 + }; + } + } else { + log.debug( + "Corner point skipping fixing", + Math.abs(nextPoint.x - prevPoint.x), + Math.abs(nextPoint.y - prevPoint.y) + ); + } + newLineData.push(newCornerPoint, newNextPoint); + } else { + newLineData.push(lineData[i2]); + } + } + return newLineData; + }, "fixCorners"); + generateDashArray = /* @__PURE__ */ __name((len, oValueS, oValueE) => { + const middleLength = len - oValueS - oValueE; + const dashLength = 2; + const gapLength = 2; + const dashGapPairLength = dashLength + gapLength; + const numberOfPairs = Math.floor(middleLength / dashGapPairLength); + const middlePattern = Array(numberOfPairs).fill(`${dashLength} ${gapLength}`).join(" "); + const dashArray = `0 ${oValueS} ${middlePattern} ${oValueE}`; + return dashArray; + }, "generateDashArray"); + insertEdge = /* @__PURE__ */ __name(function(elem, edge, clusterDb2, diagramType, startNode, endNode, id30, skipIntersect = false) { + const { handDrawnSeed } = getConfig2(); + let points = edge.points; + let pointsHasChanged = false; + const tail = startNode; + var head2 = endNode; + const edgeClassStyles = []; + for (const key in edge.cssCompiledStyles) { + if (isLabelStyle(key)) { + continue; + } + edgeClassStyles.push(edge.cssCompiledStyles[key]); + } + log.debug("UIO intersect check", edge.points, head2.x, tail.x); + if (head2.intersect && tail.intersect && !skipIntersect) { + points = points.slice(1, edge.points.length - 1); + points.unshift(tail.intersect(points[0])); + log.debug( + "Last point UIO", + edge.start, + "-->", + edge.end, + points[points.length - 1], + head2, + head2.intersect(points[points.length - 1]) + ); + points.push(head2.intersect(points[points.length - 1])); + } + const pointsStr = btoa(JSON.stringify(points)); + if (edge.toCluster) { + log.info("to cluster abc88", clusterDb2.get(edge.toCluster)); + points = cutPathAtIntersect(edge.points, clusterDb2.get(edge.toCluster).node); + pointsHasChanged = true; + } + if (edge.fromCluster) { + log.debug( + "from cluster abc88", + clusterDb2.get(edge.fromCluster), + JSON.stringify(points, null, 2) + ); + points = cutPathAtIntersect(points.reverse(), clusterDb2.get(edge.fromCluster).node).reverse(); + pointsHasChanged = true; + } + let lineData = points.filter((p3) => !Number.isNaN(p3.y)); + lineData = fixCorners(lineData); + let curve = basis_default2; + curve = linear_default; + switch (edge.curve) { + case "linear": + curve = linear_default; + break; + case "basis": + curve = basis_default2; + break; + case "cardinal": + curve = cardinal_default; + break; + case "bumpX": + curve = bumpX; + break; + case "bumpY": + curve = bumpY; + break; + case "catmullRom": + curve = catmullRom_default; + break; + case "monotoneX": + curve = monotoneX; + break; + case "monotoneY": + curve = monotoneY; + break; + case "natural": + curve = natural_default; + break; + case "step": + curve = step_default; + break; + case "stepAfter": + curve = stepAfter; + break; + case "stepBefore": + curve = stepBefore; + break; + default: + curve = basis_default2; + } + const { x: x5, y: y6 } = getLineFunctionsWithOffset(edge); + const lineFunction = line_default().x(x5).y(y6).curve(curve); + let strokeClasses; + switch (edge.thickness) { + case "normal": + strokeClasses = "edge-thickness-normal"; + break; + case "thick": + strokeClasses = "edge-thickness-thick"; + break; + case "invisible": + strokeClasses = "edge-thickness-invisible"; + break; + default: + strokeClasses = "edge-thickness-normal"; + } + switch (edge.pattern) { + case "solid": + strokeClasses += " edge-pattern-solid"; + break; + case "dotted": + strokeClasses += " edge-pattern-dotted"; + break; + case "dashed": + strokeClasses += " edge-pattern-dashed"; + break; + default: + strokeClasses += " edge-pattern-solid"; + } + let svgPath; + let linePath = edge.curve === "rounded" ? generateRoundedPath(applyMarkerOffsetsToPoints(lineData, edge), 5) : lineFunction(lineData); + const edgeStyles = Array.isArray(edge.style) ? edge.style : [edge.style]; + let strokeColor = edgeStyles.find((style3) => style3?.startsWith("stroke:")); + let animatedEdge = false; + if (edge.look === "handDrawn") { + const rc = at.svg(elem); + Object.assign([], lineData); + const svgPathNode = rc.path(linePath, { + roughness: 0.3, + seed: handDrawnSeed + }); + strokeClasses += " transition"; + svgPath = select_default2(svgPathNode).select("path").attr("id", edge.id).attr("class", " " + strokeClasses + (edge.classes ? " " + edge.classes : "")).attr("style", edgeStyles ? edgeStyles.reduce((acc, style3) => acc + ";" + style3, "") : ""); + let d3 = svgPath.attr("d"); + svgPath.attr("d", d3); + elem.node().appendChild(svgPath.node()); + } else { + const stylesFromClasses = edgeClassStyles.join(";"); + const styles4 = edgeStyles ? edgeStyles.reduce((acc, style3) => acc + style3 + ";", "") : ""; + let animationClass = ""; + if (edge.animate) { + animationClass = " edge-animation-fast"; + } + if (edge.animation) { + animationClass = " edge-animation-" + edge.animation; + } + const pathStyle = (stylesFromClasses ? stylesFromClasses + ";" + styles4 + ";" : styles4) + ";" + (edgeStyles ? edgeStyles.reduce((acc, style3) => acc + ";" + style3, "") : ""); + svgPath = elem.append("path").attr("d", linePath).attr("id", edge.id).attr( + "class", + " " + strokeClasses + (edge.classes ? " " + edge.classes : "") + (animationClass ?? "") + ).attr("style", pathStyle); + strokeColor = pathStyle.match(/stroke:([^;]+)/)?.[1]; + animatedEdge = edge.animate === true || !!edge.animation || stylesFromClasses.includes("animation"); + const pathNode = svgPath.node(); + const len = typeof pathNode.getTotalLength === "function" ? pathNode.getTotalLength() : 0; + const oValueS = markerOffsets2[edge.arrowTypeStart] || 0; + const oValueE = markerOffsets2[edge.arrowTypeEnd] || 0; + if (edge.look === "neo" && !animatedEdge) { + const dashArray = edge.pattern === "dotted" || edge.pattern === "dashed" ? generateDashArray(len, oValueS, oValueE) : `0 ${oValueS} ${len - oValueS - oValueE} ${oValueE}`; + const mOffset = `stroke-dasharray: ${dashArray}; stroke-dashoffset: 0;`; + svgPath.attr("style", mOffset + svgPath.attr("style")); + } + } + svgPath.attr("data-edge", true); + svgPath.attr("data-et", "edge"); + svgPath.attr("data-id", edge.id); + svgPath.attr("data-points", pointsStr); + if (edge.showPoints) { + lineData.forEach((point9) => { + elem.append("circle").style("stroke", "red").style("fill", "red").attr("r", 1).attr("cx", point9.x).attr("cy", point9.y); + }); + } + let url = ""; + if (getConfig2().flowchart.arrowMarkerAbsolute || getConfig2().state.arrowMarkerAbsolute) { + url = window.location.protocol + "//" + window.location.host + window.location.pathname + window.location.search; + url = url.replace(/\(/g, "\\(").replace(/\)/g, "\\)"); + } + log.info("arrowTypeStart", edge.arrowTypeStart); + log.info("arrowTypeEnd", edge.arrowTypeEnd); + addEdgeMarkers(svgPath, edge, url, id30, diagramType, strokeColor); + const midIndex = Math.floor(points.length / 2); + const point8 = points[midIndex]; + if (!utils_default2.isLabelCoordinateInPath(point8, svgPath.attr("d"))) { + pointsHasChanged = true; + } + let paths = {}; + if (pointsHasChanged) { + paths.updatedPath = points; + } + paths.originalPath = edge.points; + return paths; + }, "insertEdge"); + __name(generateRoundedPath, "generateRoundedPath"); + __name(calculateDeltaAndAngle2, "calculateDeltaAndAngle"); + __name(applyMarkerOffsetsToPoints, "applyMarkerOffsetsToPoints"); + } + }); + + // src/rendering-util/rendering-elements/markers.js + var insertMarkers, extension, composition, aggregation, dependency, lollipop, point6, circle2, cross, barb, only_one, zero_or_one, one_or_more, zero_or_more, requirement_arrow, requirement_contains, markers, markers_default; + var init_markers = __esm({ + "src/rendering-util/rendering-elements/markers.js"() { + "use strict"; + init_logger(); + insertMarkers = /* @__PURE__ */ __name((elem, markerArray, type3, id30) => { + markerArray.forEach((markerName) => { + markers[markerName](elem, type3, id30); + }); + }, "insertMarkers"); + extension = /* @__PURE__ */ __name((elem, type3, id30) => { + log.trace("Making markers for ", id30); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-extensionStart").attr("class", "marker extension " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 1,7 L18,13 V 1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-extensionEnd").attr("class", "marker extension " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 1,1 V 13 L18,7 Z"); + }, "extension"); + composition = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-compositionStart").attr("class", "marker composition " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-compositionEnd").attr("class", "marker composition " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + }, "composition"); + aggregation = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-aggregationStart").attr("class", "marker aggregation " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-aggregationEnd").attr("class", "marker aggregation " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + }, "aggregation"); + dependency = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-dependencyStart").attr("class", "marker dependency " + type3).attr("refX", 6).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 5,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-dependencyEnd").attr("class", "marker dependency " + type3).attr("refX", 13).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L14,7 L9,1 Z"); + }, "dependency"); + lollipop = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-lollipopStart").attr("class", "marker lollipop " + type3).attr("refX", 13).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-lollipopEnd").attr("class", "marker lollipop " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); + }, "lollipop"); + point6 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-pointEnd").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 5).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 8).attr("markerHeight", 8).attr("orient", "auto").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-pointStart").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 4.5).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 8).attr("markerHeight", 8).attr("orient", "auto").append("path").attr("d", "M 0 5 L 10 10 L 10 0 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + }, "point"); + circle2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-circleEnd").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 11).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-circleStart").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", -1).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + }, "circle"); + cross = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-crossEnd").attr("class", "marker cross " + type3).attr("viewBox", "0 0 11 11").attr("refX", 12).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-crossStart").attr("class", "marker cross " + type3).attr("viewBox", "0 0 11 11").attr("refX", -1).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); + }, "cross"); + barb = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-barbEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 14).attr("markerUnits", "userSpaceOnUse").attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z"); + }, "barb"); + only_one = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-onlyOneStart").attr("class", "marker onlyOne " + type3).attr("refX", 0).attr("refY", 9).attr("markerWidth", 18).attr("markerHeight", 18).attr("orient", "auto").append("path").attr("d", "M9,0 L9,18 M15,0 L15,18"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-onlyOneEnd").attr("class", "marker onlyOne " + type3).attr("refX", 18).attr("refY", 9).attr("markerWidth", 18).attr("markerHeight", 18).attr("orient", "auto").append("path").attr("d", "M3,0 L3,18 M9,0 L9,18"); + }, "only_one"); + zero_or_one = /* @__PURE__ */ __name((elem, type3, id30) => { + const startMarker = elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-zeroOrOneStart").attr("class", "marker zeroOrOne " + type3).attr("refX", 0).attr("refY", 9).attr("markerWidth", 30).attr("markerHeight", 18).attr("orient", "auto"); + startMarker.append("circle").attr("fill", "white").attr("cx", 21).attr("cy", 9).attr("r", 6); + startMarker.append("path").attr("d", "M9,0 L9,18"); + const endMarker = elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-zeroOrOneEnd").attr("class", "marker zeroOrOne " + type3).attr("refX", 30).attr("refY", 9).attr("markerWidth", 30).attr("markerHeight", 18).attr("orient", "auto"); + endMarker.append("circle").attr("fill", "white").attr("cx", 9).attr("cy", 9).attr("r", 6); + endMarker.append("path").attr("d", "M21,0 L21,18"); + }, "zero_or_one"); + one_or_more = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-oneOrMoreStart").attr("class", "marker oneOrMore " + type3).attr("refX", 18).attr("refY", 18).attr("markerWidth", 45).attr("markerHeight", 36).attr("orient", "auto").append("path").attr("d", "M0,18 Q 18,0 36,18 Q 18,36 0,18 M42,9 L42,27"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-oneOrMoreEnd").attr("class", "marker oneOrMore " + type3).attr("refX", 27).attr("refY", 18).attr("markerWidth", 45).attr("markerHeight", 36).attr("orient", "auto").append("path").attr("d", "M3,9 L3,27 M9,18 Q27,0 45,18 Q27,36 9,18"); + }, "one_or_more"); + zero_or_more = /* @__PURE__ */ __name((elem, type3, id30) => { + const startMarker = elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-zeroOrMoreStart").attr("class", "marker zeroOrMore " + type3).attr("refX", 18).attr("refY", 18).attr("markerWidth", 57).attr("markerHeight", 36).attr("orient", "auto"); + startMarker.append("circle").attr("fill", "white").attr("cx", 48).attr("cy", 18).attr("r", 6); + startMarker.append("path").attr("d", "M0,18 Q18,0 36,18 Q18,36 0,18"); + const endMarker = elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-zeroOrMoreEnd").attr("class", "marker zeroOrMore " + type3).attr("refX", 39).attr("refY", 18).attr("markerWidth", 57).attr("markerHeight", 36).attr("orient", "auto"); + endMarker.append("circle").attr("fill", "white").attr("cx", 9).attr("cy", 18).attr("r", 6); + endMarker.append("path").attr("d", "M21,18 Q39,0 57,18 Q39,36 21,18"); + }, "zero_or_more"); + requirement_arrow = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-requirement_arrowEnd").attr("refX", 20).attr("refY", 10).attr("markerWidth", 20).attr("markerHeight", 20).attr("orient", "auto").append("path").attr( + "d", + `M0,0 + L20,10 + M20,10 + L0,20` + ); + }, "requirement_arrow"); + requirement_contains = /* @__PURE__ */ __name((elem, type3, id30) => { + const containsNode = elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-requirement_containsStart").attr("refX", 0).attr("refY", 10).attr("markerWidth", 20).attr("markerHeight", 20).attr("orient", "auto").append("g"); + containsNode.append("circle").attr("cx", 10).attr("cy", 10).attr("r", 9).attr("fill", "none"); + containsNode.append("line").attr("x1", 1).attr("x2", 19).attr("y1", 10).attr("y2", 10); + containsNode.append("line").attr("y1", 1).attr("y2", 19).attr("x1", 10).attr("x2", 10); + }, "requirement_contains"); + markers = { + extension, + composition, + aggregation, + dependency, + lollipop, + point: point6, + circle: circle2, + cross, + barb, + only_one, + zero_or_one, + one_or_more, + zero_or_more, + requirement_arrow, + requirement_contains + }; + markers_default = insertMarkers; + } + }); + + // src/rendering-util/rendering-elements/nodes.ts + async function insertNode(elem, node2, renderOptions) { + let newEl; + let el; + if (node2.shape === "rect") { + if (node2.rx && node2.ry) { + node2.shape = "roundedRect"; + } else { + node2.shape = "squareRect"; + } + } + const shapeHandler = node2.shape ? shapes[node2.shape] : void 0; + if (!shapeHandler) { + throw new Error(`No such shape: ${node2.shape}. Please check your syntax.`); + } + if (node2.link) { + let target; + if (renderOptions.config.securityLevel === "sandbox") { + target = "_top"; + } else if (node2.linkTarget) { + target = node2.linkTarget || "_blank"; + } + newEl = elem.insert("svg:a").attr("xlink:href", node2.link).attr("target", target ?? null); + el = await shapeHandler(newEl, node2, renderOptions); + } else { + el = await shapeHandler(elem, node2, renderOptions); + newEl = el; + } + if (node2.tooltip) { + el.attr("title", node2.tooltip); + } + nodeElems.set(node2.id, newEl); + if (node2.haveCallback) { + newEl.attr("class", newEl.attr("class") + " clickable"); + } + return newEl; + } + var nodeElems, setNodeElem, clear5, positionNode; + var init_nodes2 = __esm({ + "src/rendering-util/rendering-elements/nodes.ts"() { + "use strict"; + init_logger(); + init_shapes(); + nodeElems = /* @__PURE__ */ new Map(); + __name(insertNode, "insertNode"); + setNodeElem = /* @__PURE__ */ __name((elem, node2) => { + nodeElems.set(node2.id, elem); + }, "setNodeElem"); + clear5 = /* @__PURE__ */ __name(() => { + nodeElems.clear(); + }, "clear"); + positionNode = /* @__PURE__ */ __name((node2) => { + const el = nodeElems.get(node2.id); + log.trace( + "Transforming node", + node2.diff, + node2, + "translate(" + (node2.x - node2.width / 2 - 5) + ", " + node2.width / 2 + ")" + ); + const padding2 = 8; + const diff2 = node2.diff || 0; + if (node2.clusterNode) { + el.attr( + "transform", + "translate(" + (node2.x + diff2 - node2.width / 2) + ", " + (node2.y - node2.height / 2 - padding2) + ")" + ); + } else { + el.attr("transform", "translate(" + node2.x + ", " + node2.y + ")"); + } + return diff2; + }, "positionNode"); + } + }); + + // src/internals.ts + var internalHelpers; + var init_internals = __esm({ + "src/internals.ts"() { + "use strict"; + init_config(); + init_common(); + init_logger(); + init_clusters(); + init_edges(); + init_markers(); + init_nodes2(); + init_util(); + init_utils2(); + internalHelpers = { + common: common_default, + getConfig, + insertCluster, + insertEdge, + insertEdgeLabel, + insertMarkers: markers_default, + insertNode, + interpolateToCurve, + labelHelper, + log, + positionEdgeLabel + }; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSymbol.js + function isSymbol(value2) { + return typeof value2 == "symbol" || isObjectLike_default(value2) && baseGetTag_default(value2) == symbolTag; + } + var symbolTag, isSymbol_default; + var init_isSymbol = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSymbol.js"() { + "use strict"; + init_baseGetTag(); + init_isObjectLike(); + symbolTag = "[object Symbol]"; + __name(isSymbol, "isSymbol"); + isSymbol_default = isSymbol; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayMap.js + function arrayMap(array4, iteratee) { + var index = -1, length2 = array4 == null ? 0 : array4.length, result = Array(length2); + while (++index < length2) { + result[index] = iteratee(array4[index], index, array4); + } + return result; + } + var arrayMap_default; + var init_arrayMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayMap.js"() { + "use strict"; + __name(arrayMap, "arrayMap"); + arrayMap_default = arrayMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseToString.js + function baseToString(value2) { + if (typeof value2 == "string") { + return value2; + } + if (isArray_default(value2)) { + return arrayMap_default(value2, baseToString) + ""; + } + if (isSymbol_default(value2)) { + return symbolToString ? symbolToString.call(value2) : ""; + } + var result = value2 + ""; + return result == "0" && 1 / value2 == -INFINITY ? "-0" : result; + } + var INFINITY, symbolProto, symbolToString, baseToString_default; + var init_baseToString = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseToString.js"() { + "use strict"; + init_Symbol(); + init_arrayMap(); + init_isArray(); + init_isSymbol(); + INFINITY = 1 / 0; + symbolProto = Symbol_default ? Symbol_default.prototype : void 0; + symbolToString = symbolProto ? symbolProto.toString : void 0; + __name(baseToString, "baseToString"); + baseToString_default = baseToString; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_trimmedEndIndex.js + function trimmedEndIndex(string3) { + var index = string3.length; + while (index-- && reWhitespace.test(string3.charAt(index))) { + } + return index; + } + var reWhitespace, trimmedEndIndex_default; + var init_trimmedEndIndex = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_trimmedEndIndex.js"() { + "use strict"; + reWhitespace = /\s/; + __name(trimmedEndIndex, "trimmedEndIndex"); + trimmedEndIndex_default = trimmedEndIndex; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseTrim.js + function baseTrim(string3) { + return string3 ? string3.slice(0, trimmedEndIndex_default(string3) + 1).replace(reTrimStart, "") : string3; + } + var reTrimStart, baseTrim_default; + var init_baseTrim = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseTrim.js"() { + "use strict"; + init_trimmedEndIndex(); + reTrimStart = /^\s+/; + __name(baseTrim, "baseTrim"); + baseTrim_default = baseTrim; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toNumber.js + function toNumber(value2) { + if (typeof value2 == "number") { + return value2; + } + if (isSymbol_default(value2)) { + return NAN; + } + if (isObject_default(value2)) { + var other = typeof value2.valueOf == "function" ? value2.valueOf() : value2; + value2 = isObject_default(other) ? other + "" : other; + } + if (typeof value2 != "string") { + return value2 === 0 ? value2 : +value2; + } + value2 = baseTrim_default(value2); + var isBinary2 = reIsBinary.test(value2); + return isBinary2 || reIsOctal.test(value2) ? freeParseInt(value2.slice(2), isBinary2 ? 2 : 8) : reIsBadHex.test(value2) ? NAN : +value2; + } + var NAN, reIsBadHex, reIsBinary, reIsOctal, freeParseInt, toNumber_default; + var init_toNumber = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toNumber.js"() { + "use strict"; + init_baseTrim(); + init_isObject(); + init_isSymbol(); + NAN = 0 / 0; + reIsBadHex = /^[-+]0x[0-9a-f]+$/i; + reIsBinary = /^0b[01]+$/i; + reIsOctal = /^0o[0-7]+$/i; + freeParseInt = parseInt; + __name(toNumber, "toNumber"); + toNumber_default = toNumber; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toFinite.js + function toFinite(value2) { + if (!value2) { + return value2 === 0 ? value2 : 0; + } + value2 = toNumber_default(value2); + if (value2 === INFINITY2 || value2 === -INFINITY2) { + var sign2 = value2 < 0 ? -1 : 1; + return sign2 * MAX_INTEGER; + } + return value2 === value2 ? value2 : 0; + } + var INFINITY2, MAX_INTEGER, toFinite_default; + var init_toFinite = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toFinite.js"() { + "use strict"; + init_toNumber(); + INFINITY2 = 1 / 0; + MAX_INTEGER = 17976931348623157e292; + __name(toFinite, "toFinite"); + toFinite_default = toFinite; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toInteger.js + function toInteger(value2) { + var result = toFinite_default(value2), remainder = result % 1; + return result === result ? remainder ? result - remainder : result : 0; + } + var toInteger_default; + var init_toInteger = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toInteger.js"() { + "use strict"; + init_toFinite(); + __name(toInteger, "toInteger"); + toInteger_default = toInteger; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_WeakMap.js + var WeakMap, WeakMap_default; + var init_WeakMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_WeakMap.js"() { + "use strict"; + init_getNative(); + init_root(); + WeakMap = getNative_default(root_default, "WeakMap"); + WeakMap_default = WeakMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/noop.js + function noop2() { + } + var noop_default2; + var init_noop2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/noop.js"() { + "use strict"; + __name(noop2, "noop"); + noop_default2 = noop2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEach.js + function arrayEach(array4, iteratee) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + while (++index < length2) { + if (iteratee(array4[index], index, array4) === false) { + break; + } + } + return array4; + } + var arrayEach_default; + var init_arrayEach = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEach.js"() { + "use strict"; + __name(arrayEach, "arrayEach"); + arrayEach_default = arrayEach; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFindIndex.js + function baseFindIndex(array4, predicate, fromIndex, fromRight) { + var length2 = array4.length, index = fromIndex + (fromRight ? 1 : -1); + while (fromRight ? index-- : ++index < length2) { + if (predicate(array4[index], index, array4)) { + return index; + } + } + return -1; + } + var baseFindIndex_default; + var init_baseFindIndex = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFindIndex.js"() { + "use strict"; + __name(baseFindIndex, "baseFindIndex"); + baseFindIndex_default = baseFindIndex; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsNaN.js + function baseIsNaN(value2) { + return value2 !== value2; + } + var baseIsNaN_default; + var init_baseIsNaN = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsNaN.js"() { + "use strict"; + __name(baseIsNaN, "baseIsNaN"); + baseIsNaN_default = baseIsNaN; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_strictIndexOf.js + function strictIndexOf(array4, value2, fromIndex) { + var index = fromIndex - 1, length2 = array4.length; + while (++index < length2) { + if (array4[index] === value2) { + return index; + } + } + return -1; + } + var strictIndexOf_default; + var init_strictIndexOf = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_strictIndexOf.js"() { + "use strict"; + __name(strictIndexOf, "strictIndexOf"); + strictIndexOf_default = strictIndexOf; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIndexOf.js + function baseIndexOf(array4, value2, fromIndex) { + return value2 === value2 ? strictIndexOf_default(array4, value2, fromIndex) : baseFindIndex_default(array4, baseIsNaN_default, fromIndex); + } + var baseIndexOf_default; + var init_baseIndexOf = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIndexOf.js"() { + "use strict"; + init_baseFindIndex(); + init_baseIsNaN(); + init_strictIndexOf(); + __name(baseIndexOf, "baseIndexOf"); + baseIndexOf_default = baseIndexOf; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludes.js + function arrayIncludes(array4, value2) { + var length2 = array4 == null ? 0 : array4.length; + return !!length2 && baseIndexOf_default(array4, value2, 0) > -1; + } + var arrayIncludes_default; + var init_arrayIncludes = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludes.js"() { + "use strict"; + init_baseIndexOf(); + __name(arrayIncludes, "arrayIncludes"); + arrayIncludes_default = arrayIncludes; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeKeys.js + var nativeKeys, nativeKeys_default; + var init_nativeKeys = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_nativeKeys.js"() { + "use strict"; + init_overArg(); + nativeKeys = overArg_default(Object.keys, Object); + nativeKeys_default = nativeKeys; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseKeys.js + function baseKeys(object3) { + if (!isPrototype_default(object3)) { + return nativeKeys_default(object3); + } + var result = []; + for (var key in Object(object3)) { + if (hasOwnProperty10.call(object3, key) && key != "constructor") { + result.push(key); + } + } + return result; + } + var objectProto12, hasOwnProperty10, baseKeys_default; + var init_baseKeys = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseKeys.js"() { + "use strict"; + init_isPrototype(); + init_nativeKeys(); + objectProto12 = Object.prototype; + hasOwnProperty10 = objectProto12.hasOwnProperty; + __name(baseKeys, "baseKeys"); + baseKeys_default = baseKeys; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/keys.js + function keys(object3) { + return isArrayLike_default(object3) ? arrayLikeKeys_default(object3) : baseKeys_default(object3); + } + var keys_default; + var init_keys = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/keys.js"() { + "use strict"; + init_arrayLikeKeys(); + init_baseKeys(); + init_isArrayLike(); + __name(keys, "keys"); + keys_default = keys; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/assign.js + var objectProto13, hasOwnProperty11, assign, assign_default; + var init_assign = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/assign.js"() { + "use strict"; + init_assignValue(); + init_copyObject(); + init_createAssigner(); + init_isArrayLike(); + init_isPrototype(); + init_keys(); + objectProto13 = Object.prototype; + hasOwnProperty11 = objectProto13.hasOwnProperty; + assign = createAssigner_default(function(object3, source) { + if (isPrototype_default(source) || isArrayLike_default(source)) { + copyObject_default(source, keys_default(source), object3); + return; + } + for (var key in source) { + if (hasOwnProperty11.call(source, key)) { + assignValue_default(object3, key, source[key]); + } + } + }); + assign_default = assign; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isKey.js + function isKey(value2, object3) { + if (isArray_default(value2)) { + return false; + } + var type3 = typeof value2; + if (type3 == "number" || type3 == "symbol" || type3 == "boolean" || value2 == null || isSymbol_default(value2)) { + return true; + } + return reIsPlainProp.test(value2) || !reIsDeepProp.test(value2) || object3 != null && value2 in Object(object3); + } + var reIsDeepProp, reIsPlainProp, isKey_default; + var init_isKey = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isKey.js"() { + "use strict"; + init_isArray(); + init_isSymbol(); + reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/; + reIsPlainProp = /^\w*$/; + __name(isKey, "isKey"); + isKey_default = isKey; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_memoizeCapped.js + function memoizeCapped(func) { + var result = memoize_default(func, function(key) { + if (cache3.size === MAX_MEMOIZE_SIZE) { + cache3.clear(); + } + return key; + }); + var cache3 = result.cache; + return result; + } + var MAX_MEMOIZE_SIZE, memoizeCapped_default; + var init_memoizeCapped = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_memoizeCapped.js"() { + "use strict"; + init_memoize(); + MAX_MEMOIZE_SIZE = 500; + __name(memoizeCapped, "memoizeCapped"); + memoizeCapped_default = memoizeCapped; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stringToPath.js + var rePropName, reEscapeChar, stringToPath, stringToPath_default; + var init_stringToPath = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stringToPath.js"() { + "use strict"; + init_memoizeCapped(); + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + reEscapeChar = /\\(\\)?/g; + stringToPath = memoizeCapped_default(function(string3) { + var result = []; + if (string3.charCodeAt(0) === 46) { + result.push(""); + } + string3.replace(rePropName, function(match2, number7, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, "$1") : number7 || match2); + }); + return result; + }); + stringToPath_default = stringToPath; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toString.js + function toString2(value2) { + return value2 == null ? "" : baseToString_default(value2); + } + var toString_default; + var init_toString = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/toString.js"() { + "use strict"; + init_baseToString(); + __name(toString2, "toString"); + toString_default = toString2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castPath.js + function castPath(value2, object3) { + if (isArray_default(value2)) { + return value2; + } + return isKey_default(value2, object3) ? [value2] : stringToPath_default(toString_default(value2)); + } + var castPath_default; + var init_castPath = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castPath.js"() { + "use strict"; + init_isArray(); + init_isKey(); + init_stringToPath(); + init_toString(); + __name(castPath, "castPath"); + castPath_default = castPath; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_toKey.js + function toKey(value2) { + if (typeof value2 == "string" || isSymbol_default(value2)) { + return value2; + } + var result = value2 + ""; + return result == "0" && 1 / value2 == -INFINITY3 ? "-0" : result; + } + var INFINITY3, toKey_default; + var init_toKey = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_toKey.js"() { + "use strict"; + init_isSymbol(); + INFINITY3 = 1 / 0; + __name(toKey, "toKey"); + toKey_default = toKey; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGet.js + function baseGet(object3, path4) { + path4 = castPath_default(path4, object3); + var index = 0, length2 = path4.length; + while (object3 != null && index < length2) { + object3 = object3[toKey_default(path4[index++])]; + } + return index && index == length2 ? object3 : void 0; + } + var baseGet_default; + var init_baseGet = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGet.js"() { + "use strict"; + init_castPath(); + init_toKey(); + __name(baseGet, "baseGet"); + baseGet_default = baseGet; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/get.js + function get3(object3, path4, defaultValue) { + var result = object3 == null ? void 0 : baseGet_default(object3, path4); + return result === void 0 ? defaultValue : result; + } + var get_default; + var init_get = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/get.js"() { + "use strict"; + init_baseGet(); + __name(get3, "get"); + get_default = get3; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayPush.js + function arrayPush2(array4, values2) { + var index = -1, length2 = values2.length, offset = array4.length; + while (++index < length2) { + array4[offset + index] = values2[index]; + } + return array4; + } + var arrayPush_default; + var init_arrayPush = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayPush.js"() { + "use strict"; + __name(arrayPush2, "arrayPush"); + arrayPush_default = arrayPush2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isFlattenable.js + function isFlattenable(value2) { + return isArray_default(value2) || isArguments_default(value2) || !!(spreadableSymbol && value2 && value2[spreadableSymbol]); + } + var spreadableSymbol, isFlattenable_default; + var init_isFlattenable = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isFlattenable.js"() { + "use strict"; + init_Symbol(); + init_isArguments(); + init_isArray(); + spreadableSymbol = Symbol_default ? Symbol_default.isConcatSpreadable : void 0; + __name(isFlattenable, "isFlattenable"); + isFlattenable_default = isFlattenable; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFlatten.js + function baseFlatten(array4, depth, predicate, isStrict, result) { + var index = -1, length2 = array4.length; + predicate || (predicate = isFlattenable_default); + result || (result = []); + while (++index < length2) { + var value2 = array4[index]; + if (depth > 0 && predicate(value2)) { + if (depth > 1) { + baseFlatten(value2, depth - 1, predicate, isStrict, result); + } else { + arrayPush_default(result, value2); + } + } else if (!isStrict) { + result[result.length] = value2; + } + } + return result; + } + var baseFlatten_default; + var init_baseFlatten = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFlatten.js"() { + "use strict"; + init_arrayPush(); + init_isFlattenable(); + __name(baseFlatten, "baseFlatten"); + baseFlatten_default = baseFlatten; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatten.js + function flatten(array4) { + var length2 = array4 == null ? 0 : array4.length; + return length2 ? baseFlatten_default(array4, 1) : []; + } + var flatten_default; + var init_flatten = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatten.js"() { + "use strict"; + init_baseFlatten(); + __name(flatten, "flatten"); + flatten_default = flatten; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_flatRest.js + function flatRest(func) { + return setToString_default(overRest_default(func, void 0, flatten_default), func + ""); + } + var flatRest_default; + var init_flatRest = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_flatRest.js"() { + "use strict"; + init_flatten(); + init_overRest(); + init_setToString(); + __name(flatRest, "flatRest"); + flatRest_default = flatRest; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSlice.js + function baseSlice(array4, start3, end2) { + var index = -1, length2 = array4.length; + if (start3 < 0) { + start3 = -start3 > length2 ? 0 : length2 + start3; + } + end2 = end2 > length2 ? length2 : end2; + if (end2 < 0) { + end2 += length2; + } + length2 = start3 > end2 ? 0 : end2 - start3 >>> 0; + start3 >>>= 0; + var result = Array(length2); + while (++index < length2) { + result[index] = array4[index + start3]; + } + return result; + } + var baseSlice_default; + var init_baseSlice = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSlice.js"() { + "use strict"; + __name(baseSlice, "baseSlice"); + baseSlice_default = baseSlice; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hasUnicode.js + function hasUnicode(string3) { + return reHasUnicode.test(string3); + } + var rsAstralRange, rsComboMarksRange, reComboHalfMarksRange, rsComboSymbolsRange, rsComboRange, rsVarRange, rsZWJ, reHasUnicode, hasUnicode_default; + var init_hasUnicode = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hasUnicode.js"() { + "use strict"; + rsAstralRange = "\\ud800-\\udfff"; + rsComboMarksRange = "\\u0300-\\u036f"; + reComboHalfMarksRange = "\\ufe20-\\ufe2f"; + rsComboSymbolsRange = "\\u20d0-\\u20ff"; + rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange; + rsVarRange = "\\ufe0e\\ufe0f"; + rsZWJ = "\\u200d"; + reHasUnicode = RegExp("[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]"); + __name(hasUnicode, "hasUnicode"); + hasUnicode_default = hasUnicode; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayReduce.js + function arrayReduce(array4, iteratee, accumulator, initAccum) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + if (initAccum && length2) { + accumulator = array4[++index]; + } + while (++index < length2) { + accumulator = iteratee(accumulator, array4[index], index, array4); + } + return accumulator; + } + var arrayReduce_default; + var init_arrayReduce = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayReduce.js"() { + "use strict"; + __name(arrayReduce, "arrayReduce"); + arrayReduce_default = arrayReduce; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssign.js + function baseAssign(object3, source) { + return object3 && copyObject_default(source, keys_default(source), object3); + } + var baseAssign_default; + var init_baseAssign = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssign.js"() { + "use strict"; + init_copyObject(); + init_keys(); + __name(baseAssign, "baseAssign"); + baseAssign_default = baseAssign; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssignIn.js + function baseAssignIn(object3, source) { + return object3 && copyObject_default(source, keysIn_default(source), object3); + } + var baseAssignIn_default; + var init_baseAssignIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAssignIn.js"() { + "use strict"; + init_copyObject(); + init_keysIn(); + __name(baseAssignIn, "baseAssignIn"); + baseAssignIn_default = baseAssignIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayFilter.js + function arrayFilter(array4, predicate) { + var index = -1, length2 = array4 == null ? 0 : array4.length, resIndex = 0, result = []; + while (++index < length2) { + var value2 = array4[index]; + if (predicate(value2, index, array4)) { + result[resIndex++] = value2; + } + } + return result; + } + var arrayFilter_default; + var init_arrayFilter = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayFilter.js"() { + "use strict"; + __name(arrayFilter, "arrayFilter"); + arrayFilter_default = arrayFilter; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/stubArray.js + function stubArray() { + return []; + } + var stubArray_default; + var init_stubArray = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/stubArray.js"() { + "use strict"; + __name(stubArray, "stubArray"); + stubArray_default = stubArray; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbols.js + var objectProto14, propertyIsEnumerable2, nativeGetSymbols, getSymbols, getSymbols_default; + var init_getSymbols = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbols.js"() { + "use strict"; + init_arrayFilter(); + init_stubArray(); + objectProto14 = Object.prototype; + propertyIsEnumerable2 = objectProto14.propertyIsEnumerable; + nativeGetSymbols = Object.getOwnPropertySymbols; + getSymbols = !nativeGetSymbols ? stubArray_default : function(object3) { + if (object3 == null) { + return []; + } + object3 = Object(object3); + return arrayFilter_default(nativeGetSymbols(object3), function(symbol) { + return propertyIsEnumerable2.call(object3, symbol); + }); + }; + getSymbols_default = getSymbols; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbols.js + function copySymbols(source, object3) { + return copyObject_default(source, getSymbols_default(source), object3); + } + var copySymbols_default; + var init_copySymbols = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbols.js"() { + "use strict"; + init_copyObject(); + init_getSymbols(); + __name(copySymbols, "copySymbols"); + copySymbols_default = copySymbols; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbolsIn.js + var nativeGetSymbols2, getSymbolsIn, getSymbolsIn_default; + var init_getSymbolsIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getSymbolsIn.js"() { + "use strict"; + init_arrayPush(); + init_getPrototype(); + init_getSymbols(); + init_stubArray(); + nativeGetSymbols2 = Object.getOwnPropertySymbols; + getSymbolsIn = !nativeGetSymbols2 ? stubArray_default : function(object3) { + var result = []; + while (object3) { + arrayPush_default(result, getSymbols_default(object3)); + object3 = getPrototype_default(object3); + } + return result; + }; + getSymbolsIn_default = getSymbolsIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbolsIn.js + function copySymbolsIn(source, object3) { + return copyObject_default(source, getSymbolsIn_default(source), object3); + } + var copySymbolsIn_default; + var init_copySymbolsIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_copySymbolsIn.js"() { + "use strict"; + init_copyObject(); + init_getSymbolsIn(); + __name(copySymbolsIn, "copySymbolsIn"); + copySymbolsIn_default = copySymbolsIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGetAllKeys.js + function baseGetAllKeys(object3, keysFunc, symbolsFunc) { + var result = keysFunc(object3); + return isArray_default(object3) ? result : arrayPush_default(result, symbolsFunc(object3)); + } + var baseGetAllKeys_default; + var init_baseGetAllKeys = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGetAllKeys.js"() { + "use strict"; + init_arrayPush(); + init_isArray(); + __name(baseGetAllKeys, "baseGetAllKeys"); + baseGetAllKeys_default = baseGetAllKeys; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeys.js + function getAllKeys(object3) { + return baseGetAllKeys_default(object3, keys_default, getSymbols_default); + } + var getAllKeys_default; + var init_getAllKeys = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeys.js"() { + "use strict"; + init_baseGetAllKeys(); + init_getSymbols(); + init_keys(); + __name(getAllKeys, "getAllKeys"); + getAllKeys_default = getAllKeys; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeysIn.js + function getAllKeysIn(object3) { + return baseGetAllKeys_default(object3, keysIn_default, getSymbolsIn_default); + } + var getAllKeysIn_default; + var init_getAllKeysIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getAllKeysIn.js"() { + "use strict"; + init_baseGetAllKeys(); + init_getSymbolsIn(); + init_keysIn(); + __name(getAllKeysIn, "getAllKeysIn"); + getAllKeysIn_default = getAllKeysIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_DataView.js + var DataView2, DataView_default; + var init_DataView = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_DataView.js"() { + "use strict"; + init_getNative(); + init_root(); + DataView2 = getNative_default(root_default, "DataView"); + DataView_default = DataView2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Promise.js + var Promise2, Promise_default; + var init_Promise = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Promise.js"() { + "use strict"; + init_getNative(); + init_root(); + Promise2 = getNative_default(root_default, "Promise"); + Promise_default = Promise2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Set.js + var Set2, Set_default; + var init_Set = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_Set.js"() { + "use strict"; + init_getNative(); + init_root(); + Set2 = getNative_default(root_default, "Set"); + Set_default = Set2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getTag.js + var mapTag2, objectTag3, promiseTag, setTag2, weakMapTag2, dataViewTag2, dataViewCtorString, mapCtorString, promiseCtorString, setCtorString, weakMapCtorString, getTag, getTag_default; + var init_getTag = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getTag.js"() { + "use strict"; + init_DataView(); + init_Map(); + init_Promise(); + init_Set(); + init_WeakMap(); + init_baseGetTag(); + init_toSource(); + mapTag2 = "[object Map]"; + objectTag3 = "[object Object]"; + promiseTag = "[object Promise]"; + setTag2 = "[object Set]"; + weakMapTag2 = "[object WeakMap]"; + dataViewTag2 = "[object DataView]"; + dataViewCtorString = toSource_default(DataView_default); + mapCtorString = toSource_default(Map_default); + promiseCtorString = toSource_default(Promise_default); + setCtorString = toSource_default(Set_default); + weakMapCtorString = toSource_default(WeakMap_default); + getTag = baseGetTag_default; + if (DataView_default && getTag(new DataView_default(new ArrayBuffer(1))) != dataViewTag2 || Map_default && getTag(new Map_default()) != mapTag2 || Promise_default && getTag(Promise_default.resolve()) != promiseTag || Set_default && getTag(new Set_default()) != setTag2 || WeakMap_default && getTag(new WeakMap_default()) != weakMapTag2) { + getTag = /* @__PURE__ */ __name(function(value2) { + var result = baseGetTag_default(value2), Ctor = result == objectTag3 ? value2.constructor : void 0, ctorString = Ctor ? toSource_default(Ctor) : ""; + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: + return dataViewTag2; + case mapCtorString: + return mapTag2; + case promiseCtorString: + return promiseTag; + case setCtorString: + return setTag2; + case weakMapCtorString: + return weakMapTag2; + } + } + return result; + }, "getTag"); + } + getTag_default = getTag; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneArray.js + function initCloneArray(array4) { + var length2 = array4.length, result = new array4.constructor(length2); + if (length2 && typeof array4[0] == "string" && hasOwnProperty12.call(array4, "index")) { + result.index = array4.index; + result.input = array4.input; + } + return result; + } + var objectProto15, hasOwnProperty12, initCloneArray_default; + var init_initCloneArray = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneArray.js"() { + "use strict"; + objectProto15 = Object.prototype; + hasOwnProperty12 = objectProto15.hasOwnProperty; + __name(initCloneArray, "initCloneArray"); + initCloneArray_default = initCloneArray; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneDataView.js + function cloneDataView(dataView, isDeep) { + var buffer = isDeep ? cloneArrayBuffer_default(dataView.buffer) : dataView.buffer; + return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength); + } + var cloneDataView_default; + var init_cloneDataView = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneDataView.js"() { + "use strict"; + init_cloneArrayBuffer(); + __name(cloneDataView, "cloneDataView"); + cloneDataView_default = cloneDataView; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneRegExp.js + function cloneRegExp(regexp) { + var result = new regexp.constructor(regexp.source, reFlags.exec(regexp)); + result.lastIndex = regexp.lastIndex; + return result; + } + var reFlags, cloneRegExp_default; + var init_cloneRegExp = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneRegExp.js"() { + "use strict"; + reFlags = /\w*$/; + __name(cloneRegExp, "cloneRegExp"); + cloneRegExp_default = cloneRegExp; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneSymbol.js + function cloneSymbol(symbol) { + return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {}; + } + var symbolProto2, symbolValueOf, cloneSymbol_default; + var init_cloneSymbol = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cloneSymbol.js"() { + "use strict"; + init_Symbol(); + symbolProto2 = Symbol_default ? Symbol_default.prototype : void 0; + symbolValueOf = symbolProto2 ? symbolProto2.valueOf : void 0; + __name(cloneSymbol, "cloneSymbol"); + cloneSymbol_default = cloneSymbol; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneByTag.js + function initCloneByTag(object3, tag, isDeep) { + var Ctor = object3.constructor; + switch (tag) { + case arrayBufferTag2: + return cloneArrayBuffer_default(object3); + case boolTag2: + case dateTag2: + return new Ctor(+object3); + case dataViewTag3: + return cloneDataView_default(object3, isDeep); + case float32Tag2: + case float64Tag2: + case int8Tag2: + case int16Tag2: + case int32Tag2: + case uint8Tag2: + case uint8ClampedTag2: + case uint16Tag2: + case uint32Tag2: + return cloneTypedArray_default(object3, isDeep); + case mapTag3: + return new Ctor(); + case numberTag2: + case stringTag2: + return new Ctor(object3); + case regexpTag2: + return cloneRegExp_default(object3); + case setTag3: + return new Ctor(); + case symbolTag2: + return cloneSymbol_default(object3); + } + } + var boolTag2, dateTag2, mapTag3, numberTag2, regexpTag2, setTag3, stringTag2, symbolTag2, arrayBufferTag2, dataViewTag3, float32Tag2, float64Tag2, int8Tag2, int16Tag2, int32Tag2, uint8Tag2, uint8ClampedTag2, uint16Tag2, uint32Tag2, initCloneByTag_default; + var init_initCloneByTag = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_initCloneByTag.js"() { + "use strict"; + init_cloneArrayBuffer(); + init_cloneDataView(); + init_cloneRegExp(); + init_cloneSymbol(); + init_cloneTypedArray(); + boolTag2 = "[object Boolean]"; + dateTag2 = "[object Date]"; + mapTag3 = "[object Map]"; + numberTag2 = "[object Number]"; + regexpTag2 = "[object RegExp]"; + setTag3 = "[object Set]"; + stringTag2 = "[object String]"; + symbolTag2 = "[object Symbol]"; + arrayBufferTag2 = "[object ArrayBuffer]"; + dataViewTag3 = "[object DataView]"; + float32Tag2 = "[object Float32Array]"; + float64Tag2 = "[object Float64Array]"; + int8Tag2 = "[object Int8Array]"; + int16Tag2 = "[object Int16Array]"; + int32Tag2 = "[object Int32Array]"; + uint8Tag2 = "[object Uint8Array]"; + uint8ClampedTag2 = "[object Uint8ClampedArray]"; + uint16Tag2 = "[object Uint16Array]"; + uint32Tag2 = "[object Uint32Array]"; + __name(initCloneByTag, "initCloneByTag"); + initCloneByTag_default = initCloneByTag; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMap.js + function baseIsMap(value2) { + return isObjectLike_default(value2) && getTag_default(value2) == mapTag4; + } + var mapTag4, baseIsMap_default; + var init_baseIsMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMap.js"() { + "use strict"; + init_getTag(); + init_isObjectLike(); + mapTag4 = "[object Map]"; + __name(baseIsMap, "baseIsMap"); + baseIsMap_default = baseIsMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isMap.js + var nodeIsMap, isMap, isMap_default; + var init_isMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isMap.js"() { + "use strict"; + init_baseIsMap(); + init_baseUnary(); + init_nodeUtil(); + nodeIsMap = nodeUtil_default && nodeUtil_default.isMap; + isMap = nodeIsMap ? baseUnary_default(nodeIsMap) : baseIsMap_default; + isMap_default = isMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsSet.js + function baseIsSet(value2) { + return isObjectLike_default(value2) && getTag_default(value2) == setTag4; + } + var setTag4, baseIsSet_default; + var init_baseIsSet = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsSet.js"() { + "use strict"; + init_getTag(); + init_isObjectLike(); + setTag4 = "[object Set]"; + __name(baseIsSet, "baseIsSet"); + baseIsSet_default = baseIsSet; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSet.js + var nodeIsSet, isSet, isSet_default; + var init_isSet = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isSet.js"() { + "use strict"; + init_baseIsSet(); + init_baseUnary(); + init_nodeUtil(); + nodeIsSet = nodeUtil_default && nodeUtil_default.isSet; + isSet = nodeIsSet ? baseUnary_default(nodeIsSet) : baseIsSet_default; + isSet_default = isSet; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseClone.js + function baseClone(value2, bitmask, customizer, key, object3, stack) { + var result, isDeep = bitmask & CLONE_DEEP_FLAG, isFlat = bitmask & CLONE_FLAT_FLAG, isFull = bitmask & CLONE_SYMBOLS_FLAG; + if (customizer) { + result = object3 ? customizer(value2, key, object3, stack) : customizer(value2); + } + if (result !== void 0) { + return result; + } + if (!isObject_default(value2)) { + return value2; + } + var isArr = isArray_default(value2); + if (isArr) { + result = initCloneArray_default(value2); + if (!isDeep) { + return copyArray_default(value2, result); + } + } else { + var tag = getTag_default(value2), isFunc = tag == funcTag3 || tag == genTag2; + if (isBuffer_default(value2)) { + return cloneBuffer_default(value2, isDeep); + } + if (tag == objectTag4 || tag == argsTag3 || isFunc && !object3) { + result = isFlat || isFunc ? {} : initCloneObject_default(value2); + if (!isDeep) { + return isFlat ? copySymbolsIn_default(value2, baseAssignIn_default(result, value2)) : copySymbols_default(value2, baseAssign_default(result, value2)); + } + } else { + if (!cloneableTags[tag]) { + return object3 ? value2 : {}; + } + result = initCloneByTag_default(value2, tag, isDeep); + } + } + stack || (stack = new Stack_default()); + var stacked = stack.get(value2); + if (stacked) { + return stacked; + } + stack.set(value2, result); + if (isSet_default(value2)) { + value2.forEach(function(subValue) { + result.add(baseClone(subValue, bitmask, customizer, subValue, value2, stack)); + }); + } else if (isMap_default(value2)) { + value2.forEach(function(subValue, key2) { + result.set(key2, baseClone(subValue, bitmask, customizer, key2, value2, stack)); + }); + } + var keysFunc = isFull ? isFlat ? getAllKeysIn_default : getAllKeys_default : isFlat ? keysIn_default : keys_default; + var props = isArr ? void 0 : keysFunc(value2); + arrayEach_default(props || value2, function(subValue, key2) { + if (props) { + key2 = subValue; + subValue = value2[key2]; + } + assignValue_default(result, key2, baseClone(subValue, bitmask, customizer, key2, value2, stack)); + }); + return result; + } + var CLONE_DEEP_FLAG, CLONE_FLAT_FLAG, CLONE_SYMBOLS_FLAG, argsTag3, arrayTag2, boolTag3, dateTag3, errorTag2, funcTag3, genTag2, mapTag5, numberTag3, objectTag4, regexpTag3, setTag5, stringTag3, symbolTag3, weakMapTag3, arrayBufferTag3, dataViewTag4, float32Tag3, float64Tag3, int8Tag3, int16Tag3, int32Tag3, uint8Tag3, uint8ClampedTag3, uint16Tag3, uint32Tag3, cloneableTags, baseClone_default; + var init_baseClone = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseClone.js"() { + "use strict"; + init_Stack(); + init_arrayEach(); + init_assignValue(); + init_baseAssign(); + init_baseAssignIn(); + init_cloneBuffer(); + init_copyArray(); + init_copySymbols(); + init_copySymbolsIn(); + init_getAllKeys(); + init_getAllKeysIn(); + init_getTag(); + init_initCloneArray(); + init_initCloneByTag(); + init_initCloneObject(); + init_isArray(); + init_isBuffer(); + init_isMap(); + init_isObject(); + init_isSet(); + init_keys(); + init_keysIn(); + CLONE_DEEP_FLAG = 1; + CLONE_FLAT_FLAG = 2; + CLONE_SYMBOLS_FLAG = 4; + argsTag3 = "[object Arguments]"; + arrayTag2 = "[object Array]"; + boolTag3 = "[object Boolean]"; + dateTag3 = "[object Date]"; + errorTag2 = "[object Error]"; + funcTag3 = "[object Function]"; + genTag2 = "[object GeneratorFunction]"; + mapTag5 = "[object Map]"; + numberTag3 = "[object Number]"; + objectTag4 = "[object Object]"; + regexpTag3 = "[object RegExp]"; + setTag5 = "[object Set]"; + stringTag3 = "[object String]"; + symbolTag3 = "[object Symbol]"; + weakMapTag3 = "[object WeakMap]"; + arrayBufferTag3 = "[object ArrayBuffer]"; + dataViewTag4 = "[object DataView]"; + float32Tag3 = "[object Float32Array]"; + float64Tag3 = "[object Float64Array]"; + int8Tag3 = "[object Int8Array]"; + int16Tag3 = "[object Int16Array]"; + int32Tag3 = "[object Int32Array]"; + uint8Tag3 = "[object Uint8Array]"; + uint8ClampedTag3 = "[object Uint8ClampedArray]"; + uint16Tag3 = "[object Uint16Array]"; + uint32Tag3 = "[object Uint32Array]"; + cloneableTags = {}; + cloneableTags[argsTag3] = cloneableTags[arrayTag2] = cloneableTags[arrayBufferTag3] = cloneableTags[dataViewTag4] = cloneableTags[boolTag3] = cloneableTags[dateTag3] = cloneableTags[float32Tag3] = cloneableTags[float64Tag3] = cloneableTags[int8Tag3] = cloneableTags[int16Tag3] = cloneableTags[int32Tag3] = cloneableTags[mapTag5] = cloneableTags[numberTag3] = cloneableTags[objectTag4] = cloneableTags[regexpTag3] = cloneableTags[setTag5] = cloneableTags[stringTag3] = cloneableTags[symbolTag3] = cloneableTags[uint8Tag3] = cloneableTags[uint8ClampedTag3] = cloneableTags[uint16Tag3] = cloneableTags[uint32Tag3] = true; + cloneableTags[errorTag2] = cloneableTags[funcTag3] = cloneableTags[weakMapTag3] = false; + __name(baseClone, "baseClone"); + baseClone_default = baseClone; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/clone.js + function clone2(value2) { + return baseClone_default(value2, CLONE_SYMBOLS_FLAG2); + } + var CLONE_SYMBOLS_FLAG2, clone_default2; + var init_clone2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/clone.js"() { + "use strict"; + init_baseClone(); + CLONE_SYMBOLS_FLAG2 = 4; + __name(clone2, "clone"); + clone_default2 = clone2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/cloneDeep.js + function cloneDeep(value2) { + return baseClone_default(value2, CLONE_DEEP_FLAG2 | CLONE_SYMBOLS_FLAG3); + } + var CLONE_DEEP_FLAG2, CLONE_SYMBOLS_FLAG3, cloneDeep_default; + var init_cloneDeep = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/cloneDeep.js"() { + "use strict"; + init_baseClone(); + CLONE_DEEP_FLAG2 = 1; + CLONE_SYMBOLS_FLAG3 = 4; + __name(cloneDeep, "cloneDeep"); + cloneDeep_default = cloneDeep; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/compact.js + function compact(array4) { + var index = -1, length2 = array4 == null ? 0 : array4.length, resIndex = 0, result = []; + while (++index < length2) { + var value2 = array4[index]; + if (value2) { + result[resIndex++] = value2; + } + } + return result; + } + var compact_default; + var init_compact = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/compact.js"() { + "use strict"; + __name(compact, "compact"); + compact_default = compact; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheAdd.js + function setCacheAdd(value2) { + this.__data__.set(value2, HASH_UNDEFINED3); + return this; + } + var HASH_UNDEFINED3, setCacheAdd_default; + var init_setCacheAdd = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheAdd.js"() { + "use strict"; + HASH_UNDEFINED3 = "__lodash_hash_undefined__"; + __name(setCacheAdd, "setCacheAdd"); + setCacheAdd_default = setCacheAdd; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheHas.js + function setCacheHas(value2) { + return this.__data__.has(value2); + } + var setCacheHas_default; + var init_setCacheHas = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setCacheHas.js"() { + "use strict"; + __name(setCacheHas, "setCacheHas"); + setCacheHas_default = setCacheHas; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_SetCache.js + function SetCache(values2) { + var index = -1, length2 = values2 == null ? 0 : values2.length; + this.__data__ = new MapCache_default(); + while (++index < length2) { + this.add(values2[index]); + } + } + var SetCache_default; + var init_SetCache = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_SetCache.js"() { + "use strict"; + init_MapCache(); + init_setCacheAdd(); + init_setCacheHas(); + __name(SetCache, "SetCache"); + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd_default; + SetCache.prototype.has = setCacheHas_default; + SetCache_default = SetCache; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arraySome.js + function arraySome(array4, predicate) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + while (++index < length2) { + if (predicate(array4[index], index, array4)) { + return true; + } + } + return false; + } + var arraySome_default; + var init_arraySome = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arraySome.js"() { + "use strict"; + __name(arraySome, "arraySome"); + arraySome_default = arraySome; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cacheHas.js + function cacheHas(cache3, key) { + return cache3.has(key); + } + var cacheHas_default; + var init_cacheHas = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_cacheHas.js"() { + "use strict"; + __name(cacheHas, "cacheHas"); + cacheHas_default = cacheHas; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalArrays.js + function equalArrays(array4, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array4.length, othLength = other.length; + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + var arrStacked = stack.get(array4); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array4; + } + var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache_default() : void 0; + stack.set(array4, other); + stack.set(other, array4); + while (++index < arrLength) { + var arrValue = array4[index], othValue = other[index]; + if (customizer) { + var compared = isPartial ? customizer(othValue, arrValue, index, other, array4, stack) : customizer(arrValue, othValue, index, array4, other, stack); + } + if (compared !== void 0) { + if (compared) { + continue; + } + result = false; + break; + } + if (seen) { + if (!arraySome_default(other, function(othValue2, othIndex) { + if (!cacheHas_default(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + result = false; + break; + } + } + stack["delete"](array4); + stack["delete"](other); + return result; + } + var COMPARE_PARTIAL_FLAG, COMPARE_UNORDERED_FLAG, equalArrays_default; + var init_equalArrays = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalArrays.js"() { + "use strict"; + init_SetCache(); + init_arraySome(); + init_cacheHas(); + COMPARE_PARTIAL_FLAG = 1; + COMPARE_UNORDERED_FLAG = 2; + __name(equalArrays, "equalArrays"); + equalArrays_default = equalArrays; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapToArray.js + function mapToArray(map5) { + var index = -1, result = Array(map5.size); + map5.forEach(function(value2, key) { + result[++index] = [key, value2]; + }); + return result; + } + var mapToArray_default; + var init_mapToArray = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_mapToArray.js"() { + "use strict"; + __name(mapToArray, "mapToArray"); + mapToArray_default = mapToArray; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setToArray.js + function setToArray(set5) { + var index = -1, result = Array(set5.size); + set5.forEach(function(value2) { + result[++index] = value2; + }); + return result; + } + var setToArray_default; + var init_setToArray = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_setToArray.js"() { + "use strict"; + __name(setToArray, "setToArray"); + setToArray_default = setToArray; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalByTag.js + function equalByTag(object3, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag5: + if (object3.byteLength != other.byteLength || object3.byteOffset != other.byteOffset) { + return false; + } + object3 = object3.buffer; + other = other.buffer; + case arrayBufferTag4: + if (object3.byteLength != other.byteLength || !equalFunc(new Uint8Array_default(object3), new Uint8Array_default(other))) { + return false; + } + return true; + case boolTag4: + case dateTag4: + case numberTag4: + return eq_default(+object3, +other); + case errorTag3: + return object3.name == other.name && object3.message == other.message; + case regexpTag4: + case stringTag4: + return object3 == other + ""; + case mapTag6: + var convert = mapToArray_default; + case setTag6: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG2; + convert || (convert = setToArray_default); + if (object3.size != other.size && !isPartial) { + return false; + } + var stacked = stack.get(object3); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG2; + stack.set(object3, other); + var result = equalArrays_default(convert(object3), convert(other), bitmask, customizer, equalFunc, stack); + stack["delete"](object3); + return result; + case symbolTag4: + if (symbolValueOf2) { + return symbolValueOf2.call(object3) == symbolValueOf2.call(other); + } + } + return false; + } + var COMPARE_PARTIAL_FLAG2, COMPARE_UNORDERED_FLAG2, boolTag4, dateTag4, errorTag3, mapTag6, numberTag4, regexpTag4, setTag6, stringTag4, symbolTag4, arrayBufferTag4, dataViewTag5, symbolProto3, symbolValueOf2, equalByTag_default; + var init_equalByTag = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalByTag.js"() { + "use strict"; + init_Symbol(); + init_Uint8Array(); + init_eq(); + init_equalArrays(); + init_mapToArray(); + init_setToArray(); + COMPARE_PARTIAL_FLAG2 = 1; + COMPARE_UNORDERED_FLAG2 = 2; + boolTag4 = "[object Boolean]"; + dateTag4 = "[object Date]"; + errorTag3 = "[object Error]"; + mapTag6 = "[object Map]"; + numberTag4 = "[object Number]"; + regexpTag4 = "[object RegExp]"; + setTag6 = "[object Set]"; + stringTag4 = "[object String]"; + symbolTag4 = "[object Symbol]"; + arrayBufferTag4 = "[object ArrayBuffer]"; + dataViewTag5 = "[object DataView]"; + symbolProto3 = Symbol_default ? Symbol_default.prototype : void 0; + symbolValueOf2 = symbolProto3 ? symbolProto3.valueOf : void 0; + __name(equalByTag, "equalByTag"); + equalByTag_default = equalByTag; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalObjects.js + function equalObjects(object3, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG3, objProps = getAllKeys_default(object3), objLength = objProps.length, othProps = getAllKeys_default(other), othLength = othProps.length; + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty13.call(other, key))) { + return false; + } + } + var objStacked = stack.get(object3); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object3; + } + var result = true; + stack.set(object3, other); + stack.set(other, object3); + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object3[key], othValue = other[key]; + if (customizer) { + var compared = isPartial ? customizer(othValue, objValue, key, other, object3, stack) : customizer(objValue, othValue, key, object3, other, stack); + } + if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) { + result = false; + break; + } + skipCtor || (skipCtor = key == "constructor"); + } + if (result && !skipCtor) { + var objCtor = object3.constructor, othCtor = other.constructor; + if (objCtor != othCtor && ("constructor" in object3 && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) { + result = false; + } + } + stack["delete"](object3); + stack["delete"](other); + return result; + } + var COMPARE_PARTIAL_FLAG3, objectProto16, hasOwnProperty13, equalObjects_default; + var init_equalObjects = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_equalObjects.js"() { + "use strict"; + init_getAllKeys(); + COMPARE_PARTIAL_FLAG3 = 1; + objectProto16 = Object.prototype; + hasOwnProperty13 = objectProto16.hasOwnProperty; + __name(equalObjects, "equalObjects"); + equalObjects_default = equalObjects; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqualDeep.js + function baseIsEqualDeep(object3, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray_default(object3), othIsArr = isArray_default(other), objTag = objIsArr ? arrayTag3 : getTag_default(object3), othTag = othIsArr ? arrayTag3 : getTag_default(other); + objTag = objTag == argsTag4 ? objectTag5 : objTag; + othTag = othTag == argsTag4 ? objectTag5 : othTag; + var objIsObj = objTag == objectTag5, othIsObj = othTag == objectTag5, isSameTag = objTag == othTag; + if (isSameTag && isBuffer_default(object3)) { + if (!isBuffer_default(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack_default()); + return objIsArr || isTypedArray_default(object3) ? equalArrays_default(object3, other, bitmask, customizer, equalFunc, stack) : equalByTag_default(object3, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG4)) { + var objIsWrapped = objIsObj && hasOwnProperty14.call(object3, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty14.call(other, "__wrapped__"); + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object3.value() : object3, othUnwrapped = othIsWrapped ? other.value() : other; + stack || (stack = new Stack_default()); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack_default()); + return equalObjects_default(object3, other, bitmask, customizer, equalFunc, stack); + } + var COMPARE_PARTIAL_FLAG4, argsTag4, arrayTag3, objectTag5, objectProto17, hasOwnProperty14, baseIsEqualDeep_default; + var init_baseIsEqualDeep = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqualDeep.js"() { + "use strict"; + init_Stack(); + init_equalArrays(); + init_equalByTag(); + init_equalObjects(); + init_getTag(); + init_isArray(); + init_isBuffer(); + init_isTypedArray(); + COMPARE_PARTIAL_FLAG4 = 1; + argsTag4 = "[object Arguments]"; + arrayTag3 = "[object Array]"; + objectTag5 = "[object Object]"; + objectProto17 = Object.prototype; + hasOwnProperty14 = objectProto17.hasOwnProperty; + __name(baseIsEqualDeep, "baseIsEqualDeep"); + baseIsEqualDeep_default = baseIsEqualDeep; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqual.js + function baseIsEqual(value2, other, bitmask, customizer, stack) { + if (value2 === other) { + return true; + } + if (value2 == null || other == null || !isObjectLike_default(value2) && !isObjectLike_default(other)) { + return value2 !== value2 && other !== other; + } + return baseIsEqualDeep_default(value2, other, bitmask, customizer, baseIsEqual, stack); + } + var baseIsEqual_default; + var init_baseIsEqual = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsEqual.js"() { + "use strict"; + init_baseIsEqualDeep(); + init_isObjectLike(); + __name(baseIsEqual, "baseIsEqual"); + baseIsEqual_default = baseIsEqual; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMatch.js + function baseIsMatch(object3, source, matchData, customizer) { + var index = matchData.length, length2 = index, noCustomizer = !customizer; + if (object3 == null) { + return !length2; + } + object3 = Object(object3); + while (index--) { + var data5 = matchData[index]; + if (noCustomizer && data5[2] ? data5[1] !== object3[data5[0]] : !(data5[0] in object3)) { + return false; + } + } + while (++index < length2) { + data5 = matchData[index]; + var key = data5[0], objValue = object3[key], srcValue = data5[1]; + if (noCustomizer && data5[2]) { + if (objValue === void 0 && !(key in object3)) { + return false; + } + } else { + var stack = new Stack_default(); + if (customizer) { + var result = customizer(objValue, srcValue, key, object3, source, stack); + } + if (!(result === void 0 ? baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG5 | COMPARE_UNORDERED_FLAG3, customizer, stack) : result)) { + return false; + } + } + } + return true; + } + var COMPARE_PARTIAL_FLAG5, COMPARE_UNORDERED_FLAG3, baseIsMatch_default; + var init_baseIsMatch = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsMatch.js"() { + "use strict"; + init_Stack(); + init_baseIsEqual(); + COMPARE_PARTIAL_FLAG5 = 1; + COMPARE_UNORDERED_FLAG3 = 2; + __name(baseIsMatch, "baseIsMatch"); + baseIsMatch_default = baseIsMatch; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isStrictComparable.js + function isStrictComparable(value2) { + return value2 === value2 && !isObject_default(value2); + } + var isStrictComparable_default; + var init_isStrictComparable = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_isStrictComparable.js"() { + "use strict"; + init_isObject(); + __name(isStrictComparable, "isStrictComparable"); + isStrictComparable_default = isStrictComparable; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getMatchData.js + function getMatchData(object3) { + var result = keys_default(object3), length2 = result.length; + while (length2--) { + var key = result[length2], value2 = object3[key]; + result[length2] = [key, value2, isStrictComparable_default(value2)]; + } + return result; + } + var getMatchData_default; + var init_getMatchData = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_getMatchData.js"() { + "use strict"; + init_isStrictComparable(); + init_keys(); + __name(getMatchData, "getMatchData"); + getMatchData_default = getMatchData; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_matchesStrictComparable.js + function matchesStrictComparable(key, srcValue) { + return function(object3) { + if (object3 == null) { + return false; + } + return object3[key] === srcValue && (srcValue !== void 0 || key in Object(object3)); + }; + } + var matchesStrictComparable_default; + var init_matchesStrictComparable = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_matchesStrictComparable.js"() { + "use strict"; + __name(matchesStrictComparable, "matchesStrictComparable"); + matchesStrictComparable_default = matchesStrictComparable; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatches.js + function baseMatches(source) { + var matchData = getMatchData_default(source); + if (matchData.length == 1 && matchData[0][2]) { + return matchesStrictComparable_default(matchData[0][0], matchData[0][1]); + } + return function(object3) { + return object3 === source || baseIsMatch_default(object3, source, matchData); + }; + } + var baseMatches_default; + var init_baseMatches = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatches.js"() { + "use strict"; + init_baseIsMatch(); + init_getMatchData(); + init_matchesStrictComparable(); + __name(baseMatches, "baseMatches"); + baseMatches_default = baseMatches; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHasIn.js + function baseHasIn(object3, key) { + return object3 != null && key in Object(object3); + } + var baseHasIn_default; + var init_baseHasIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHasIn.js"() { + "use strict"; + __name(baseHasIn, "baseHasIn"); + baseHasIn_default = baseHasIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hasPath.js + function hasPath(object3, path4, hasFunc) { + path4 = castPath_default(path4, object3); + var index = -1, length2 = path4.length, result = false; + while (++index < length2) { + var key = toKey_default(path4[index]); + if (!(result = object3 != null && hasFunc(object3, key))) { + break; + } + object3 = object3[key]; + } + if (result || ++index != length2) { + return result; + } + length2 = object3 == null ? 0 : object3.length; + return !!length2 && isLength_default(length2) && isIndex_default(key, length2) && (isArray_default(object3) || isArguments_default(object3)); + } + var hasPath_default; + var init_hasPath = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_hasPath.js"() { + "use strict"; + init_castPath(); + init_isArguments(); + init_isArray(); + init_isIndex(); + init_isLength(); + init_toKey(); + __name(hasPath, "hasPath"); + hasPath_default = hasPath; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/hasIn.js + function hasIn(object3, path4) { + return object3 != null && hasPath_default(object3, path4, baseHasIn_default); + } + var hasIn_default; + var init_hasIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/hasIn.js"() { + "use strict"; + init_baseHasIn(); + init_hasPath(); + __name(hasIn, "hasIn"); + hasIn_default = hasIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatchesProperty.js + function baseMatchesProperty(path4, srcValue) { + if (isKey_default(path4) && isStrictComparable_default(srcValue)) { + return matchesStrictComparable_default(toKey_default(path4), srcValue); + } + return function(object3) { + var objValue = get_default(object3, path4); + return objValue === void 0 && objValue === srcValue ? hasIn_default(object3, path4) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4); + }; + } + var COMPARE_PARTIAL_FLAG6, COMPARE_UNORDERED_FLAG4, baseMatchesProperty_default; + var init_baseMatchesProperty = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMatchesProperty.js"() { + "use strict"; + init_baseIsEqual(); + init_get(); + init_hasIn(); + init_isKey(); + init_isStrictComparable(); + init_matchesStrictComparable(); + init_toKey(); + COMPARE_PARTIAL_FLAG6 = 1; + COMPARE_UNORDERED_FLAG4 = 2; + __name(baseMatchesProperty, "baseMatchesProperty"); + baseMatchesProperty_default = baseMatchesProperty; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseProperty.js + function baseProperty(key) { + return function(object3) { + return object3 == null ? void 0 : object3[key]; + }; + } + var baseProperty_default; + var init_baseProperty = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseProperty.js"() { + "use strict"; + __name(baseProperty, "baseProperty"); + baseProperty_default = baseProperty; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePropertyDeep.js + function basePropertyDeep(path4) { + return function(object3) { + return baseGet_default(object3, path4); + }; + } + var basePropertyDeep_default; + var init_basePropertyDeep = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePropertyDeep.js"() { + "use strict"; + init_baseGet(); + __name(basePropertyDeep, "basePropertyDeep"); + basePropertyDeep_default = basePropertyDeep; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/property.js + function property(path4) { + return isKey_default(path4) ? baseProperty_default(toKey_default(path4)) : basePropertyDeep_default(path4); + } + var property_default2; + var init_property2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/property.js"() { + "use strict"; + init_baseProperty(); + init_basePropertyDeep(); + init_isKey(); + init_toKey(); + __name(property, "property"); + property_default2 = property; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIteratee.js + function baseIteratee(value2) { + if (typeof value2 == "function") { + return value2; + } + if (value2 == null) { + return identity_default4; + } + if (typeof value2 == "object") { + return isArray_default(value2) ? baseMatchesProperty_default(value2[0], value2[1]) : baseMatches_default(value2); + } + return property_default2(value2); + } + var baseIteratee_default; + var init_baseIteratee = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIteratee.js"() { + "use strict"; + init_baseMatches(); + init_baseMatchesProperty(); + init_identity4(); + init_isArray(); + init_property2(); + __name(baseIteratee, "baseIteratee"); + baseIteratee_default = baseIteratee; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayAggregator.js + function arrayAggregator(array4, setter, iteratee, accumulator) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + while (++index < length2) { + var value2 = array4[index]; + setter(accumulator, value2, iteratee(value2), array4); + } + return accumulator; + } + var arrayAggregator_default; + var init_arrayAggregator = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayAggregator.js"() { + "use strict"; + __name(arrayAggregator, "arrayAggregator"); + arrayAggregator_default = arrayAggregator; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseForOwn.js + function baseForOwn(object3, iteratee) { + return object3 && baseFor_default(object3, iteratee, keys_default); + } + var baseForOwn_default; + var init_baseForOwn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseForOwn.js"() { + "use strict"; + init_baseFor(); + init_keys(); + __name(baseForOwn, "baseForOwn"); + baseForOwn_default = baseForOwn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createBaseEach.js + function createBaseEach(eachFunc, fromRight) { + return function(collection4, iteratee) { + if (collection4 == null) { + return collection4; + } + if (!isArrayLike_default(collection4)) { + return eachFunc(collection4, iteratee); + } + var length2 = collection4.length, index = fromRight ? length2 : -1, iterable = Object(collection4); + while (fromRight ? index-- : ++index < length2) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection4; + }; + } + var createBaseEach_default; + var init_createBaseEach = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createBaseEach.js"() { + "use strict"; + init_isArrayLike(); + __name(createBaseEach, "createBaseEach"); + createBaseEach_default = createBaseEach; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEach.js + var baseEach, baseEach_default; + var init_baseEach = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEach.js"() { + "use strict"; + init_baseForOwn(); + init_createBaseEach(); + baseEach = createBaseEach_default(baseForOwn_default); + baseEach_default = baseEach; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAggregator.js + function baseAggregator(collection4, setter, iteratee, accumulator) { + baseEach_default(collection4, function(value2, key, collection5) { + setter(accumulator, value2, iteratee(value2), collection5); + }); + return accumulator; + } + var baseAggregator_default; + var init_baseAggregator = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseAggregator.js"() { + "use strict"; + init_baseEach(); + __name(baseAggregator, "baseAggregator"); + baseAggregator_default = baseAggregator; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createAggregator.js + function createAggregator(setter, initializer) { + return function(collection4, iteratee) { + var func = isArray_default(collection4) ? arrayAggregator_default : baseAggregator_default, accumulator = initializer ? initializer() : {}; + return func(collection4, setter, baseIteratee_default(iteratee, 2), accumulator); + }; + } + var createAggregator_default; + var init_createAggregator = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createAggregator.js"() { + "use strict"; + init_arrayAggregator(); + init_baseAggregator(); + init_baseIteratee(); + init_isArray(); + __name(createAggregator, "createAggregator"); + createAggregator_default = createAggregator; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/now.js + var now2, now_default; + var init_now = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/now.js"() { + "use strict"; + init_root(); + now2 = /* @__PURE__ */ __name(function() { + return root_default.Date.now(); + }, "now"); + now_default = now2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/defaults.js + var objectProto18, hasOwnProperty15, defaults, defaults_default; + var init_defaults3 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/defaults.js"() { + "use strict"; + init_baseRest(); + init_eq(); + init_isIterateeCall(); + init_keysIn(); + objectProto18 = Object.prototype; + hasOwnProperty15 = objectProto18.hasOwnProperty; + defaults = baseRest_default(function(object3, sources) { + object3 = Object(object3); + var index = -1; + var length2 = sources.length; + var guard = length2 > 2 ? sources[2] : void 0; + if (guard && isIterateeCall_default(sources[0], sources[1], guard)) { + length2 = 1; + } + while (++index < length2) { + var source = sources[index]; + var props = keysIn_default(source); + var propsIndex = -1; + var propsLength = props.length; + while (++propsIndex < propsLength) { + var key = props[propsIndex]; + var value2 = object3[key]; + if (value2 === void 0 || eq_default(value2, objectProto18[key]) && !hasOwnProperty15.call(object3, key)) { + object3[key] = source[key]; + } + } + } + return object3; + }); + defaults_default = defaults; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludesWith.js + function arrayIncludesWith(array4, value2, comparator) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + while (++index < length2) { + if (comparator(value2, array4[index])) { + return true; + } + } + return false; + } + var arrayIncludesWith_default; + var init_arrayIncludesWith = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayIncludesWith.js"() { + "use strict"; + __name(arrayIncludesWith, "arrayIncludesWith"); + arrayIncludesWith_default = arrayIncludesWith; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseDifference.js + function baseDifference(array4, values2, iteratee, comparator) { + var index = -1, includes3 = arrayIncludes_default, isCommon = true, length2 = array4.length, result = [], valuesLength = values2.length; + if (!length2) { + return result; + } + if (iteratee) { + values2 = arrayMap_default(values2, baseUnary_default(iteratee)); + } + if (comparator) { + includes3 = arrayIncludesWith_default; + isCommon = false; + } else if (values2.length >= LARGE_ARRAY_SIZE2) { + includes3 = cacheHas_default; + isCommon = false; + values2 = new SetCache_default(values2); + } + outer: + while (++index < length2) { + var value2 = array4[index], computed = iteratee == null ? value2 : iteratee(value2); + value2 = comparator || value2 !== 0 ? value2 : 0; + if (isCommon && computed === computed) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values2[valuesIndex] === computed) { + continue outer; + } + } + result.push(value2); + } else if (!includes3(values2, computed, comparator)) { + result.push(value2); + } + } + return result; + } + var LARGE_ARRAY_SIZE2, baseDifference_default; + var init_baseDifference = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseDifference.js"() { + "use strict"; + init_SetCache(); + init_arrayIncludes(); + init_arrayIncludesWith(); + init_arrayMap(); + init_baseUnary(); + init_cacheHas(); + LARGE_ARRAY_SIZE2 = 200; + __name(baseDifference, "baseDifference"); + baseDifference_default = baseDifference; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/difference.js + var difference, difference_default; + var init_difference = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/difference.js"() { + "use strict"; + init_baseDifference(); + init_baseFlatten(); + init_baseRest(); + init_isArrayLikeObject(); + difference = baseRest_default(function(array4, values2) { + return isArrayLikeObject_default(array4) ? baseDifference_default(array4, baseFlatten_default(values2, 1, isArrayLikeObject_default, true)) : []; + }); + difference_default = difference; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/last.js + function last(array4) { + var length2 = array4 == null ? 0 : array4.length; + return length2 ? array4[length2 - 1] : void 0; + } + var last_default; + var init_last = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/last.js"() { + "use strict"; + __name(last, "last"); + last_default = last; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/drop.js + function drop(array4, n2, guard) { + var length2 = array4 == null ? 0 : array4.length; + if (!length2) { + return []; + } + n2 = guard || n2 === void 0 ? 1 : toInteger_default(n2); + return baseSlice_default(array4, n2 < 0 ? 0 : n2, length2); + } + var drop_default; + var init_drop = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/drop.js"() { + "use strict"; + init_baseSlice(); + init_toInteger(); + __name(drop, "drop"); + drop_default = drop; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/dropRight.js + function dropRight(array4, n2, guard) { + var length2 = array4 == null ? 0 : array4.length; + if (!length2) { + return []; + } + n2 = guard || n2 === void 0 ? 1 : toInteger_default(n2); + n2 = length2 - n2; + return baseSlice_default(array4, 0, n2 < 0 ? 0 : n2); + } + var dropRight_default; + var init_dropRight = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/dropRight.js"() { + "use strict"; + init_baseSlice(); + init_toInteger(); + __name(dropRight, "dropRight"); + dropRight_default = dropRight; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castFunction.js + function castFunction(value2) { + return typeof value2 == "function" ? value2 : identity_default4; + } + var castFunction_default; + var init_castFunction = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_castFunction.js"() { + "use strict"; + init_identity4(); + __name(castFunction, "castFunction"); + castFunction_default = castFunction; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forEach.js + function forEach(collection4, iteratee) { + var func = isArray_default(collection4) ? arrayEach_default : baseEach_default; + return func(collection4, castFunction_default(iteratee)); + } + var forEach_default; + var init_forEach = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forEach.js"() { + "use strict"; + init_arrayEach(); + init_baseEach(); + init_castFunction(); + init_isArray(); + __name(forEach, "forEach"); + forEach_default = forEach; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/each.js + var init_each3 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/each.js"() { + "use strict"; + init_forEach(); + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEvery.js + function arrayEvery(array4, predicate) { + var index = -1, length2 = array4 == null ? 0 : array4.length; + while (++index < length2) { + if (!predicate(array4[index], index, array4)) { + return false; + } + } + return true; + } + var arrayEvery_default; + var init_arrayEvery = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_arrayEvery.js"() { + "use strict"; + __name(arrayEvery, "arrayEvery"); + arrayEvery_default = arrayEvery; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEvery.js + function baseEvery(collection4, predicate) { + var result = true; + baseEach_default(collection4, function(value2, index, collection5) { + result = !!predicate(value2, index, collection5); + return result; + }); + return result; + } + var baseEvery_default; + var init_baseEvery = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseEvery.js"() { + "use strict"; + init_baseEach(); + __name(baseEvery, "baseEvery"); + baseEvery_default = baseEvery; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/every.js + function every(collection4, predicate, guard) { + var func = isArray_default(collection4) ? arrayEvery_default : baseEvery_default; + if (guard && isIterateeCall_default(collection4, predicate, guard)) { + predicate = void 0; + } + return func(collection4, baseIteratee_default(predicate, 3)); + } + var every_default; + var init_every = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/every.js"() { + "use strict"; + init_arrayEvery(); + init_baseEvery(); + init_baseIteratee(); + init_isArray(); + init_isIterateeCall(); + __name(every, "every"); + every_default = every; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFilter.js + function baseFilter(collection4, predicate) { + var result = []; + baseEach_default(collection4, function(value2, index, collection5) { + if (predicate(value2, index, collection5)) { + result.push(value2); + } + }); + return result; + } + var baseFilter_default; + var init_baseFilter = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseFilter.js"() { + "use strict"; + init_baseEach(); + __name(baseFilter, "baseFilter"); + baseFilter_default = baseFilter; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/filter.js + function filter2(collection4, predicate) { + var func = isArray_default(collection4) ? arrayFilter_default : baseFilter_default; + return func(collection4, baseIteratee_default(predicate, 3)); + } + var filter_default3; + var init_filter3 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/filter.js"() { + "use strict"; + init_arrayFilter(); + init_baseFilter(); + init_baseIteratee(); + init_isArray(); + __name(filter2, "filter"); + filter_default3 = filter2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createFind.js + function createFind(findIndexFunc) { + return function(collection4, predicate, fromIndex) { + var iterable = Object(collection4); + if (!isArrayLike_default(collection4)) { + var iteratee = baseIteratee_default(predicate, 3); + collection4 = keys_default(collection4); + predicate = /* @__PURE__ */ __name(function(key) { + return iteratee(iterable[key], key, iterable); + }, "predicate"); + } + var index = findIndexFunc(collection4, predicate, fromIndex); + return index > -1 ? iterable[iteratee ? collection4[index] : index] : void 0; + }; + } + var createFind_default; + var init_createFind = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createFind.js"() { + "use strict"; + init_baseIteratee(); + init_isArrayLike(); + init_keys(); + __name(createFind, "createFind"); + createFind_default = createFind; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/findIndex.js + function findIndex(array4, predicate, fromIndex) { + var length2 = array4 == null ? 0 : array4.length; + if (!length2) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger_default(fromIndex); + if (index < 0) { + index = nativeMax2(length2 + index, 0); + } + return baseFindIndex_default(array4, baseIteratee_default(predicate, 3), index); + } + var nativeMax2, findIndex_default; + var init_findIndex = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/findIndex.js"() { + "use strict"; + init_baseFindIndex(); + init_baseIteratee(); + init_toInteger(); + nativeMax2 = Math.max; + __name(findIndex, "findIndex"); + findIndex_default = findIndex; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/find.js + var find2, find_default2; + var init_find2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/find.js"() { + "use strict"; + init_createFind(); + init_findIndex(); + find2 = createFind_default(findIndex_default); + find_default2 = find2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/head.js + function head(array4) { + return array4 && array4.length ? array4[0] : void 0; + } + var head_default; + var init_head = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/head.js"() { + "use strict"; + __name(head, "head"); + head_default = head; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/first.js + var init_first = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/first.js"() { + "use strict"; + init_head(); + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMap.js + function baseMap(collection4, iteratee) { + var index = -1, result = isArrayLike_default(collection4) ? Array(collection4.length) : []; + baseEach_default(collection4, function(value2, key, collection5) { + result[++index] = iteratee(value2, key, collection5); + }); + return result; + } + var baseMap_default; + var init_baseMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseMap.js"() { + "use strict"; + init_baseEach(); + init_isArrayLike(); + __name(baseMap, "baseMap"); + baseMap_default = baseMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/map.js + function map3(collection4, iteratee) { + var func = isArray_default(collection4) ? arrayMap_default : baseMap_default; + return func(collection4, baseIteratee_default(iteratee, 3)); + } + var map_default; + var init_map = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/map.js"() { + "use strict"; + init_arrayMap(); + init_baseIteratee(); + init_baseMap(); + init_isArray(); + __name(map3, "map"); + map_default = map3; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatMap.js + function flatMap(collection4, iteratee) { + return baseFlatten_default(map_default(collection4, iteratee), 1); + } + var flatMap_default; + var init_flatMap = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/flatMap.js"() { + "use strict"; + init_baseFlatten(); + init_map(); + __name(flatMap, "flatMap"); + flatMap_default = flatMap; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forIn.js + function forIn(object3, iteratee) { + return object3 == null ? object3 : baseFor_default(object3, castFunction_default(iteratee), keysIn_default); + } + var forIn_default; + var init_forIn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forIn.js"() { + "use strict"; + init_baseFor(); + init_castFunction(); + init_keysIn(); + __name(forIn, "forIn"); + forIn_default = forIn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forOwn.js + function forOwn(object3, iteratee) { + return object3 && baseForOwn_default(object3, castFunction_default(iteratee)); + } + var forOwn_default; + var init_forOwn = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/forOwn.js"() { + "use strict"; + init_baseForOwn(); + init_castFunction(); + __name(forOwn, "forOwn"); + forOwn_default = forOwn; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/groupBy.js + var objectProto19, hasOwnProperty16, groupBy, groupBy_default; + var init_groupBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/groupBy.js"() { + "use strict"; + init_baseAssignValue(); + init_createAggregator(); + objectProto19 = Object.prototype; + hasOwnProperty16 = objectProto19.hasOwnProperty; + groupBy = createAggregator_default(function(result, value2, key) { + if (hasOwnProperty16.call(result, key)) { + result[key].push(value2); + } else { + baseAssignValue_default(result, key, [value2]); + } + }); + groupBy_default = groupBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGt.js + function baseGt(value2, other) { + return value2 > other; + } + var baseGt_default; + var init_baseGt = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseGt.js"() { + "use strict"; + __name(baseGt, "baseGt"); + baseGt_default = baseGt; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHas.js + function baseHas(object3, key) { + return object3 != null && hasOwnProperty17.call(object3, key); + } + var objectProto20, hasOwnProperty17, baseHas_default; + var init_baseHas = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseHas.js"() { + "use strict"; + objectProto20 = Object.prototype; + hasOwnProperty17 = objectProto20.hasOwnProperty; + __name(baseHas, "baseHas"); + baseHas_default = baseHas; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/has.js + function has(object3, path4) { + return object3 != null && hasPath_default(object3, path4, baseHas_default); + } + var has_default; + var init_has = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/has.js"() { + "use strict"; + init_baseHas(); + init_hasPath(); + __name(has, "has"); + has_default = has; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isString.js + function isString(value2) { + return typeof value2 == "string" || !isArray_default(value2) && isObjectLike_default(value2) && baseGetTag_default(value2) == stringTag5; + } + var stringTag5, isString_default; + var init_isString = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isString.js"() { + "use strict"; + init_baseGetTag(); + init_isArray(); + init_isObjectLike(); + stringTag5 = "[object String]"; + __name(isString, "isString"); + isString_default = isString; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseValues.js + function baseValues(object3, props) { + return arrayMap_default(props, function(key) { + return object3[key]; + }); + } + var baseValues_default; + var init_baseValues = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseValues.js"() { + "use strict"; + init_arrayMap(); + __name(baseValues, "baseValues"); + baseValues_default = baseValues; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/values.js + function values(object3) { + return object3 == null ? [] : baseValues_default(object3, keys_default(object3)); + } + var values_default; + var init_values = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/values.js"() { + "use strict"; + init_baseValues(); + init_keys(); + __name(values, "values"); + values_default = values; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/includes.js + function includes(collection4, value2, fromIndex, guard) { + collection4 = isArrayLike_default(collection4) ? collection4 : values_default(collection4); + fromIndex = fromIndex && !guard ? toInteger_default(fromIndex) : 0; + var length2 = collection4.length; + if (fromIndex < 0) { + fromIndex = nativeMax3(length2 + fromIndex, 0); + } + return isString_default(collection4) ? fromIndex <= length2 && collection4.indexOf(value2, fromIndex) > -1 : !!length2 && baseIndexOf_default(collection4, value2, fromIndex) > -1; + } + var nativeMax3, includes_default; + var init_includes = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/includes.js"() { + "use strict"; + init_baseIndexOf(); + init_isArrayLike(); + init_isString(); + init_toInteger(); + init_values(); + nativeMax3 = Math.max; + __name(includes, "includes"); + includes_default = includes; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/indexOf.js + function indexOf(array4, value2, fromIndex) { + var length2 = array4 == null ? 0 : array4.length; + if (!length2) { + return -1; + } + var index = fromIndex == null ? 0 : toInteger_default(fromIndex); + if (index < 0) { + index = nativeMax4(length2 + index, 0); + } + return baseIndexOf_default(array4, value2, index); + } + var nativeMax4, indexOf_default; + var init_indexOf = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/indexOf.js"() { + "use strict"; + init_baseIndexOf(); + init_toInteger(); + nativeMax4 = Math.max; + __name(indexOf, "indexOf"); + indexOf_default = indexOf; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js + function isEmpty(value2) { + if (value2 == null) { + return true; + } + if (isArrayLike_default(value2) && (isArray_default(value2) || typeof value2 == "string" || typeof value2.splice == "function" || isBuffer_default(value2) || isTypedArray_default(value2) || isArguments_default(value2))) { + return !value2.length; + } + var tag = getTag_default(value2); + if (tag == mapTag7 || tag == setTag7) { + return !value2.size; + } + if (isPrototype_default(value2)) { + return !baseKeys_default(value2).length; + } + for (var key in value2) { + if (hasOwnProperty18.call(value2, key)) { + return false; + } + } + return true; + } + var mapTag7, setTag7, objectProto21, hasOwnProperty18, isEmpty_default; + var init_isEmpty = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isEmpty.js"() { + "use strict"; + init_baseKeys(); + init_getTag(); + init_isArguments(); + init_isArray(); + init_isArrayLike(); + init_isBuffer(); + init_isPrototype(); + init_isTypedArray(); + mapTag7 = "[object Map]"; + setTag7 = "[object Set]"; + objectProto21 = Object.prototype; + hasOwnProperty18 = objectProto21.hasOwnProperty; + __name(isEmpty, "isEmpty"); + isEmpty_default = isEmpty; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsRegExp.js + function baseIsRegExp(value2) { + return isObjectLike_default(value2) && baseGetTag_default(value2) == regexpTag5; + } + var regexpTag5, baseIsRegExp_default; + var init_baseIsRegExp = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseIsRegExp.js"() { + "use strict"; + init_baseGetTag(); + init_isObjectLike(); + regexpTag5 = "[object RegExp]"; + __name(baseIsRegExp, "baseIsRegExp"); + baseIsRegExp_default = baseIsRegExp; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isRegExp.js + var nodeIsRegExp, isRegExp, isRegExp_default; + var init_isRegExp = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isRegExp.js"() { + "use strict"; + init_baseIsRegExp(); + init_baseUnary(); + init_nodeUtil(); + nodeIsRegExp = nodeUtil_default && nodeUtil_default.isRegExp; + isRegExp = nodeIsRegExp ? baseUnary_default(nodeIsRegExp) : baseIsRegExp_default; + isRegExp_default = isRegExp; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isUndefined.js + function isUndefined(value2) { + return value2 === void 0; + } + var isUndefined_default; + var init_isUndefined = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/isUndefined.js"() { + "use strict"; + __name(isUndefined, "isUndefined"); + isUndefined_default = isUndefined; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseLt.js + function baseLt(value2, other) { + return value2 < other; + } + var baseLt_default; + var init_baseLt = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseLt.js"() { + "use strict"; + __name(baseLt, "baseLt"); + baseLt_default = baseLt; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/mapValues.js + function mapValues(object3, iteratee) { + var result = {}; + iteratee = baseIteratee_default(iteratee, 3); + baseForOwn_default(object3, function(value2, key, object4) { + baseAssignValue_default(result, key, iteratee(value2, key, object4)); + }); + return result; + } + var mapValues_default; + var init_mapValues = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/mapValues.js"() { + "use strict"; + init_baseAssignValue(); + init_baseForOwn(); + init_baseIteratee(); + __name(mapValues, "mapValues"); + mapValues_default = mapValues; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseExtremum.js + function baseExtremum(array4, iteratee, comparator) { + var index = -1, length2 = array4.length; + while (++index < length2) { + var value2 = array4[index], current = iteratee(value2); + if (current != null && (computed === void 0 ? current === current && !isSymbol_default(current) : comparator(current, computed))) { + var computed = current, result = value2; + } + } + return result; + } + var baseExtremum_default; + var init_baseExtremum = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseExtremum.js"() { + "use strict"; + init_isSymbol(); + __name(baseExtremum, "baseExtremum"); + baseExtremum_default = baseExtremum; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/max.js + function max4(array4) { + return array4 && array4.length ? baseExtremum_default(array4, identity_default4, baseGt_default) : void 0; + } + var max_default; + var init_max2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/max.js"() { + "use strict"; + init_baseExtremum(); + init_baseGt(); + init_identity4(); + __name(max4, "max"); + max_default = max4; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/min.js + function min4(array4) { + return array4 && array4.length ? baseExtremum_default(array4, identity_default4, baseLt_default) : void 0; + } + var min_default; + var init_min2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/min.js"() { + "use strict"; + init_baseExtremum(); + init_baseLt(); + init_identity4(); + __name(min4, "min"); + min_default = min4; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/minBy.js + function minBy(array4, iteratee) { + return array4 && array4.length ? baseExtremum_default(array4, baseIteratee_default(iteratee, 2), baseLt_default) : void 0; + } + var minBy_default; + var init_minBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/minBy.js"() { + "use strict"; + init_baseExtremum(); + init_baseIteratee(); + init_baseLt(); + __name(minBy, "minBy"); + minBy_default = minBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/negate.js + function negate(predicate) { + if (typeof predicate != "function") { + throw new TypeError(FUNC_ERROR_TEXT2); + } + return function() { + var args = arguments; + switch (args.length) { + case 0: + return !predicate.call(this); + case 1: + return !predicate.call(this, args[0]); + case 2: + return !predicate.call(this, args[0], args[1]); + case 3: + return !predicate.call(this, args[0], args[1], args[2]); + } + return !predicate.apply(this, args); + }; + } + var FUNC_ERROR_TEXT2, negate_default; + var init_negate = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/negate.js"() { + "use strict"; + FUNC_ERROR_TEXT2 = "Expected a function"; + __name(negate, "negate"); + negate_default = negate; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSet.js + function baseSet(object3, path4, value2, customizer) { + if (!isObject_default(object3)) { + return object3; + } + path4 = castPath_default(path4, object3); + var index = -1, length2 = path4.length, lastIndex = length2 - 1, nested = object3; + while (nested != null && ++index < length2) { + var key = toKey_default(path4[index]), newValue = value2; + if (key === "__proto__" || key === "constructor" || key === "prototype") { + return object3; + } + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : void 0; + if (newValue === void 0) { + newValue = isObject_default(objValue) ? objValue : isIndex_default(path4[index + 1]) ? [] : {}; + } + } + assignValue_default(nested, key, newValue); + nested = nested[key]; + } + return object3; + } + var baseSet_default; + var init_baseSet = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSet.js"() { + "use strict"; + init_assignValue(); + init_castPath(); + init_isIndex(); + init_isObject(); + init_toKey(); + __name(baseSet, "baseSet"); + baseSet_default = baseSet; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePickBy.js + function basePickBy(object3, paths, predicate) { + var index = -1, length2 = paths.length, result = {}; + while (++index < length2) { + var path4 = paths[index], value2 = baseGet_default(object3, path4); + if (predicate(value2, path4)) { + baseSet_default(result, castPath_default(path4, object3), value2); + } + } + return result; + } + var basePickBy_default; + var init_basePickBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePickBy.js"() { + "use strict"; + init_baseGet(); + init_baseSet(); + init_castPath(); + __name(basePickBy, "basePickBy"); + basePickBy_default = basePickBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/pickBy.js + function pickBy(object3, predicate) { + if (object3 == null) { + return {}; + } + var props = arrayMap_default(getAllKeysIn_default(object3), function(prop) { + return [prop]; + }); + predicate = baseIteratee_default(predicate); + return basePickBy_default(object3, props, function(value2, path4) { + return predicate(value2, path4[0]); + }); + } + var pickBy_default; + var init_pickBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/pickBy.js"() { + "use strict"; + init_arrayMap(); + init_baseIteratee(); + init_basePickBy(); + init_getAllKeysIn(); + __name(pickBy, "pickBy"); + pickBy_default = pickBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSortBy.js + function baseSortBy(array4, comparer) { + var length2 = array4.length; + array4.sort(comparer); + while (length2--) { + array4[length2] = array4[length2].value; + } + return array4; + } + var baseSortBy_default; + var init_baseSortBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSortBy.js"() { + "use strict"; + __name(baseSortBy, "baseSortBy"); + baseSortBy_default = baseSortBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_compareAscending.js + function compareAscending(value2, other) { + if (value2 !== other) { + var valIsDefined = value2 !== void 0, valIsNull = value2 === null, valIsReflexive = value2 === value2, valIsSymbol = isSymbol_default(value2); + var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol_default(other); + if (!othIsNull && !othIsSymbol && !valIsSymbol && value2 > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) { + return 1; + } + if (!valIsNull && !valIsSymbol && !othIsSymbol && value2 < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) { + return -1; + } + } + return 0; + } + var compareAscending_default; + var init_compareAscending = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_compareAscending.js"() { + "use strict"; + init_isSymbol(); + __name(compareAscending, "compareAscending"); + compareAscending_default = compareAscending; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_compareMultiple.js + function compareMultiple(object3, other, orders) { + var index = -1, objCriteria = object3.criteria, othCriteria = other.criteria, length2 = objCriteria.length, ordersLength = orders.length; + while (++index < length2) { + var result = compareAscending_default(objCriteria[index], othCriteria[index]); + if (result) { + if (index >= ordersLength) { + return result; + } + var order2 = orders[index]; + return result * (order2 == "desc" ? -1 : 1); + } + } + return object3.index - other.index; + } + var compareMultiple_default; + var init_compareMultiple = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_compareMultiple.js"() { + "use strict"; + init_compareAscending(); + __name(compareMultiple, "compareMultiple"); + compareMultiple_default = compareMultiple; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseOrderBy.js + function baseOrderBy(collection4, iteratees, orders) { + if (iteratees.length) { + iteratees = arrayMap_default(iteratees, function(iteratee) { + if (isArray_default(iteratee)) { + return function(value2) { + return baseGet_default(value2, iteratee.length === 1 ? iteratee[0] : iteratee); + }; + } + return iteratee; + }); + } else { + iteratees = [identity_default4]; + } + var index = -1; + iteratees = arrayMap_default(iteratees, baseUnary_default(baseIteratee_default)); + var result = baseMap_default(collection4, function(value2, key, collection5) { + var criteria = arrayMap_default(iteratees, function(iteratee) { + return iteratee(value2); + }); + return { "criteria": criteria, "index": ++index, "value": value2 }; + }); + return baseSortBy_default(result, function(object3, other) { + return compareMultiple_default(object3, other, orders); + }); + } + var baseOrderBy_default; + var init_baseOrderBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseOrderBy.js"() { + "use strict"; + init_arrayMap(); + init_baseGet(); + init_baseIteratee(); + init_baseMap(); + init_baseSortBy(); + init_baseUnary(); + init_compareMultiple(); + init_identity4(); + init_isArray(); + __name(baseOrderBy, "baseOrderBy"); + baseOrderBy_default = baseOrderBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_asciiSize.js + var asciiSize, asciiSize_default; + var init_asciiSize = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_asciiSize.js"() { + "use strict"; + init_baseProperty(); + asciiSize = baseProperty_default("length"); + asciiSize_default = asciiSize; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_unicodeSize.js + function unicodeSize(string3) { + var result = reUnicode.lastIndex = 0; + while (reUnicode.test(string3)) { + ++result; + } + return result; + } + var rsAstralRange2, rsComboMarksRange2, reComboHalfMarksRange2, rsComboSymbolsRange2, rsComboRange2, rsVarRange2, rsAstral, rsCombo, rsFitz, rsModifier, rsNonAstral, rsRegional, rsSurrPair, rsZWJ2, reOptMod, rsOptVar, rsOptJoin, rsSeq, rsSymbol, reUnicode, unicodeSize_default; + var init_unicodeSize = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_unicodeSize.js"() { + "use strict"; + rsAstralRange2 = "\\ud800-\\udfff"; + rsComboMarksRange2 = "\\u0300-\\u036f"; + reComboHalfMarksRange2 = "\\ufe20-\\ufe2f"; + rsComboSymbolsRange2 = "\\u20d0-\\u20ff"; + rsComboRange2 = rsComboMarksRange2 + reComboHalfMarksRange2 + rsComboSymbolsRange2; + rsVarRange2 = "\\ufe0e\\ufe0f"; + rsAstral = "[" + rsAstralRange2 + "]"; + rsCombo = "[" + rsComboRange2 + "]"; + rsFitz = "\\ud83c[\\udffb-\\udfff]"; + rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")"; + rsNonAstral = "[^" + rsAstralRange2 + "]"; + rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}"; + rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]"; + rsZWJ2 = "\\u200d"; + reOptMod = rsModifier + "?"; + rsOptVar = "[" + rsVarRange2 + "]?"; + rsOptJoin = "(?:" + rsZWJ2 + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*"; + rsSeq = rsOptVar + reOptMod + rsOptJoin; + rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")"; + reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g"); + __name(unicodeSize, "unicodeSize"); + unicodeSize_default = unicodeSize; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stringSize.js + function stringSize(string3) { + return hasUnicode_default(string3) ? unicodeSize_default(string3) : asciiSize_default(string3); + } + var stringSize_default; + var init_stringSize = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_stringSize.js"() { + "use strict"; + init_asciiSize(); + init_hasUnicode(); + init_unicodeSize(); + __name(stringSize, "stringSize"); + stringSize_default = stringSize; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePick.js + function basePick(object3, paths) { + return basePickBy_default(object3, paths, function(value2, path4) { + return hasIn_default(object3, path4); + }); + } + var basePick_default; + var init_basePick = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_basePick.js"() { + "use strict"; + init_basePickBy(); + init_hasIn(); + __name(basePick, "basePick"); + basePick_default = basePick; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/pick.js + var pick, pick_default; + var init_pick = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/pick.js"() { + "use strict"; + init_basePick(); + init_flatRest(); + pick = flatRest_default(function(object3, paths) { + return object3 == null ? {} : basePick_default(object3, paths); + }); + pick_default = pick; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseRange.js + function baseRange(start3, end2, step3, fromRight) { + var index = -1, length2 = nativeMax5(nativeCeil((end2 - start3) / (step3 || 1)), 0), result = Array(length2); + while (length2--) { + result[fromRight ? length2 : ++index] = start3; + start3 += step3; + } + return result; + } + var nativeCeil, nativeMax5, baseRange_default; + var init_baseRange = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseRange.js"() { + "use strict"; + nativeCeil = Math.ceil; + nativeMax5 = Math.max; + __name(baseRange, "baseRange"); + baseRange_default = baseRange; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createRange.js + function createRange(fromRight) { + return function(start3, end2, step3) { + if (step3 && typeof step3 != "number" && isIterateeCall_default(start3, end2, step3)) { + end2 = step3 = void 0; + } + start3 = toFinite_default(start3); + if (end2 === void 0) { + end2 = start3; + start3 = 0; + } else { + end2 = toFinite_default(end2); + } + step3 = step3 === void 0 ? start3 < end2 ? 1 : -1 : toFinite_default(step3); + return baseRange_default(start3, end2, step3, fromRight); + }; + } + var createRange_default; + var init_createRange = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createRange.js"() { + "use strict"; + init_baseRange(); + init_isIterateeCall(); + init_toFinite(); + __name(createRange, "createRange"); + createRange_default = createRange; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/range.js + var range2, range_default; + var init_range2 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/range.js"() { + "use strict"; + init_createRange(); + range2 = createRange_default(); + range_default = range2; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseReduce.js + function baseReduce(collection4, iteratee, accumulator, initAccum, eachFunc) { + eachFunc(collection4, function(value2, index, collection5) { + accumulator = initAccum ? (initAccum = false, value2) : iteratee(accumulator, value2, index, collection5); + }); + return accumulator; + } + var baseReduce_default; + var init_baseReduce = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseReduce.js"() { + "use strict"; + __name(baseReduce, "baseReduce"); + baseReduce_default = baseReduce; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reduce.js + function reduce(collection4, iteratee, accumulator) { + var func = isArray_default(collection4) ? arrayReduce_default : baseReduce_default, initAccum = arguments.length < 3; + return func(collection4, baseIteratee_default(iteratee, 4), accumulator, initAccum, baseEach_default); + } + var reduce_default; + var init_reduce = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reduce.js"() { + "use strict"; + init_arrayReduce(); + init_baseEach(); + init_baseIteratee(); + init_baseReduce(); + init_isArray(); + __name(reduce, "reduce"); + reduce_default = reduce; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reject.js + function reject(collection4, predicate) { + var func = isArray_default(collection4) ? arrayFilter_default : baseFilter_default; + return func(collection4, negate_default(baseIteratee_default(predicate, 3))); + } + var reject_default; + var init_reject = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/reject.js"() { + "use strict"; + init_arrayFilter(); + init_baseFilter(); + init_baseIteratee(); + init_isArray(); + init_negate(); + __name(reject, "reject"); + reject_default = reject; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/size.js + function size(collection4) { + if (collection4 == null) { + return 0; + } + if (isArrayLike_default(collection4)) { + return isString_default(collection4) ? stringSize_default(collection4) : collection4.length; + } + var tag = getTag_default(collection4); + if (tag == mapTag8 || tag == setTag8) { + return collection4.size; + } + return baseKeys_default(collection4).length; + } + var mapTag8, setTag8, size_default2; + var init_size3 = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/size.js"() { + "use strict"; + init_baseKeys(); + init_getTag(); + init_isArrayLike(); + init_isString(); + init_stringSize(); + mapTag8 = "[object Map]"; + setTag8 = "[object Set]"; + __name(size, "size"); + size_default2 = size; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSome.js + function baseSome(collection4, predicate) { + var result; + baseEach_default(collection4, function(value2, index, collection5) { + result = predicate(value2, index, collection5); + return !result; + }); + return !!result; + } + var baseSome_default; + var init_baseSome = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseSome.js"() { + "use strict"; + init_baseEach(); + __name(baseSome, "baseSome"); + baseSome_default = baseSome; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/some.js + function some(collection4, predicate, guard) { + var func = isArray_default(collection4) ? arraySome_default : baseSome_default; + if (guard && isIterateeCall_default(collection4, predicate, guard)) { + predicate = void 0; + } + return func(collection4, baseIteratee_default(predicate, 3)); + } + var some_default; + var init_some = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/some.js"() { + "use strict"; + init_arraySome(); + init_baseIteratee(); + init_baseSome(); + init_isArray(); + init_isIterateeCall(); + __name(some, "some"); + some_default = some; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/sortBy.js + var sortBy, sortBy_default; + var init_sortBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/sortBy.js"() { + "use strict"; + init_baseFlatten(); + init_baseOrderBy(); + init_baseRest(); + init_isIterateeCall(); + sortBy = baseRest_default(function(collection4, iteratees) { + if (collection4 == null) { + return []; + } + var length2 = iteratees.length; + if (length2 > 1 && isIterateeCall_default(collection4, iteratees[0], iteratees[1])) { + iteratees = []; + } else if (length2 > 2 && isIterateeCall_default(iteratees[0], iteratees[1], iteratees[2])) { + iteratees = [iteratees[0]]; + } + return baseOrderBy_default(collection4, baseFlatten_default(iteratees, 1), []); + }); + sortBy_default = sortBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createSet.js + var INFINITY4, createSet, createSet_default; + var init_createSet = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_createSet.js"() { + "use strict"; + init_Set(); + init_noop2(); + init_setToArray(); + INFINITY4 = 1 / 0; + createSet = !(Set_default && 1 / setToArray_default(new Set_default([, -0]))[1] == INFINITY4) ? noop_default2 : function(values2) { + return new Set_default(values2); + }; + createSet_default = createSet; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseUniq.js + function baseUniq(array4, iteratee, comparator) { + var index = -1, includes3 = arrayIncludes_default, length2 = array4.length, isCommon = true, result = [], seen = result; + if (comparator) { + isCommon = false; + includes3 = arrayIncludesWith_default; + } else if (length2 >= LARGE_ARRAY_SIZE3) { + var set5 = iteratee ? null : createSet_default(array4); + if (set5) { + return setToArray_default(set5); + } + isCommon = false; + includes3 = cacheHas_default; + seen = new SetCache_default(); + } else { + seen = iteratee ? [] : result; + } + outer: + while (++index < length2) { + var value2 = array4[index], computed = iteratee ? iteratee(value2) : value2; + value2 = comparator || value2 !== 0 ? value2 : 0; + if (isCommon && computed === computed) { + var seenIndex = seen.length; + while (seenIndex--) { + if (seen[seenIndex] === computed) { + continue outer; + } + } + if (iteratee) { + seen.push(computed); + } + result.push(value2); + } else if (!includes3(seen, computed, comparator)) { + if (seen !== result) { + seen.push(computed); + } + result.push(value2); + } + } + return result; + } + var LARGE_ARRAY_SIZE3, baseUniq_default; + var init_baseUniq = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseUniq.js"() { + "use strict"; + init_SetCache(); + init_arrayIncludes(); + init_arrayIncludesWith(); + init_cacheHas(); + init_createSet(); + init_setToArray(); + LARGE_ARRAY_SIZE3 = 200; + __name(baseUniq, "baseUniq"); + baseUniq_default = baseUniq; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/union.js + var union, union_default; + var init_union = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/union.js"() { + "use strict"; + init_baseFlatten(); + init_baseRest(); + init_baseUniq(); + init_isArrayLikeObject(); + union = baseRest_default(function(arrays) { + return baseUniq_default(baseFlatten_default(arrays, 1, isArrayLikeObject_default, true)); + }); + union_default = union; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniq.js + function uniq(array4) { + return array4 && array4.length ? baseUniq_default(array4) : []; + } + var uniq_default; + var init_uniq = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniq.js"() { + "use strict"; + init_baseUniq(); + __name(uniq, "uniq"); + uniq_default = uniq; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniqBy.js + function uniqBy(array4, iteratee) { + return array4 && array4.length ? baseUniq_default(array4, baseIteratee_default(iteratee, 2)) : []; + } + var uniqBy_default; + var init_uniqBy = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniqBy.js"() { + "use strict"; + init_baseIteratee(); + init_baseUniq(); + __name(uniqBy, "uniqBy"); + uniqBy_default = uniqBy; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniqueId.js + function uniqueId(prefix) { + var id30 = ++idCounter; + return toString_default(prefix) + id30; + } + var idCounter, uniqueId_default; + var init_uniqueId = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/uniqueId.js"() { + "use strict"; + init_toString(); + idCounter = 0; + __name(uniqueId, "uniqueId"); + uniqueId_default = uniqueId; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseZipObject.js + function baseZipObject(props, values2, assignFunc) { + var index = -1, length2 = props.length, valsLength = values2.length, result = {}; + while (++index < length2) { + var value2 = index < valsLength ? values2[index] : void 0; + assignFunc(result, props[index], value2); + } + return result; + } + var baseZipObject_default; + var init_baseZipObject = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/_baseZipObject.js"() { + "use strict"; + __name(baseZipObject, "baseZipObject"); + baseZipObject_default = baseZipObject; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/zipObject.js + function zipObject(props, values2) { + return baseZipObject_default(props || [], values2 || [], assignValue_default); + } + var zipObject_default; + var init_zipObject = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/zipObject.js"() { + "use strict"; + init_assignValue(); + init_baseZipObject(); + __name(zipObject, "zipObject"); + zipObject_default = zipObject; + } + }); + + // ../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/lodash.js + var init_lodash = __esm({ + "../../node_modules/.pnpm/lodash-es@4.17.23/node_modules/lodash-es/lodash.js"() { + "use strict"; + init_assign(); + init_clone2(); + init_cloneDeep(); + init_compact(); + init_constant8(); + init_defaults3(); + init_difference(); + init_drop(); + init_dropRight(); + init_each3(); + init_every(); + init_filter3(); + init_find2(); + init_first(); + init_flatMap(); + init_flatten(); + init_forEach(); + init_forIn(); + init_forOwn(); + init_groupBy(); + init_has(); + init_identity4(); + init_includes(); + init_indexOf(); + init_isArray(); + init_isEmpty(); + init_isFunction(); + init_isObject(); + init_isRegExp(); + init_isString(); + init_isUndefined(); + init_keys(); + init_last(); + init_map(); + init_mapValues(); + init_max2(); + init_merge4(); + init_min2(); + init_minBy(); + init_noop2(); + init_now(); + init_pick(); + init_pickBy(); + init_range2(); + init_reduce(); + init_reject(); + init_size3(); + init_some(); + init_sortBy(); + init_union(); + init_uniq(); + init_uniqueId(); + init_values(); + init_zipObject(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/graph.js + function incrementOrInitEntry(map5, k2) { + if (map5[k2]) { + map5[k2]++; + } else { + map5[k2] = 1; + } + } + function decrementOrRemoveEntry(map5, k2) { + if (!--map5[k2]) { + delete map5[k2]; + } + } + function edgeArgsToId(isDirected, v_, w_, name) { + var v3 = "" + v_; + var w4 = "" + w_; + if (!isDirected && v3 > w4) { + var tmp = v3; + v3 = w4; + w4 = tmp; + } + return v3 + EDGE_KEY_DELIM + w4 + EDGE_KEY_DELIM + (isUndefined_default(name) ? DEFAULT_EDGE_NAME : name); + } + function edgeArgsToObj(isDirected, v_, w_, name) { + var v3 = "" + v_; + var w4 = "" + w_; + if (!isDirected && v3 > w4) { + var tmp = v3; + v3 = w4; + w4 = tmp; + } + var edgeObj = { v: v3, w: w4 }; + if (name) { + edgeObj.name = name; + } + return edgeObj; + } + function edgeObjToId(isDirected, edgeObj) { + return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name); + } + var DEFAULT_EDGE_NAME, GRAPH_NODE, EDGE_KEY_DELIM, Graph; + var init_graph = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/graph.js"() { + "use strict"; + init_lodash(); + DEFAULT_EDGE_NAME = "\0"; + GRAPH_NODE = "\0"; + EDGE_KEY_DELIM = ""; + Graph = class { + static { + __name(this, "Graph"); + } + constructor(opts = {}) { + this._isDirected = Object.prototype.hasOwnProperty.call(opts, "directed") ? opts.directed : true; + this._isMultigraph = Object.prototype.hasOwnProperty.call(opts, "multigraph") ? opts.multigraph : false; + this._isCompound = Object.prototype.hasOwnProperty.call(opts, "compound") ? opts.compound : false; + this._label = void 0; + this._defaultNodeLabelFn = constant_default7(void 0); + this._defaultEdgeLabelFn = constant_default7(void 0); + this._nodes = {}; + if (this._isCompound) { + this._parent = {}; + this._children = {}; + this._children[GRAPH_NODE] = {}; + } + this._in = {}; + this._preds = {}; + this._out = {}; + this._sucs = {}; + this._edgeObjs = {}; + this._edgeLabels = {}; + } + /* === Graph functions ========= */ + isDirected() { + return this._isDirected; + } + isMultigraph() { + return this._isMultigraph; + } + isCompound() { + return this._isCompound; + } + setGraph(label) { + this._label = label; + return this; + } + graph() { + return this._label; + } + /* === Node functions ========== */ + setDefaultNodeLabel(newDefault) { + if (!isFunction_default(newDefault)) { + newDefault = constant_default7(newDefault); + } + this._defaultNodeLabelFn = newDefault; + return this; + } + nodeCount() { + return this._nodeCount; + } + nodes() { + return keys_default(this._nodes); + } + sources() { + var self2 = this; + return filter_default3(this.nodes(), function(v3) { + return isEmpty_default(self2._in[v3]); + }); + } + sinks() { + var self2 = this; + return filter_default3(this.nodes(), function(v3) { + return isEmpty_default(self2._out[v3]); + }); + } + setNodes(vs, value2) { + var args = arguments; + var self2 = this; + forEach_default(vs, function(v3) { + if (args.length > 1) { + self2.setNode(v3, value2); + } else { + self2.setNode(v3); + } + }); + return this; + } + setNode(v3, value2) { + if (Object.prototype.hasOwnProperty.call(this._nodes, v3)) { + if (arguments.length > 1) { + this._nodes[v3] = value2; + } + return this; + } + this._nodes[v3] = arguments.length > 1 ? value2 : this._defaultNodeLabelFn(v3); + if (this._isCompound) { + this._parent[v3] = GRAPH_NODE; + this._children[v3] = {}; + this._children[GRAPH_NODE][v3] = true; + } + this._in[v3] = {}; + this._preds[v3] = {}; + this._out[v3] = {}; + this._sucs[v3] = {}; + ++this._nodeCount; + return this; + } + node(v3) { + return this._nodes[v3]; + } + hasNode(v3) { + return Object.prototype.hasOwnProperty.call(this._nodes, v3); + } + removeNode(v3) { + if (Object.prototype.hasOwnProperty.call(this._nodes, v3)) { + var removeEdge = /* @__PURE__ */ __name((e3) => this.removeEdge(this._edgeObjs[e3]), "removeEdge"); + delete this._nodes[v3]; + if (this._isCompound) { + this._removeFromParentsChildList(v3); + delete this._parent[v3]; + forEach_default(this.children(v3), (child) => { + this.setParent(child); + }); + delete this._children[v3]; + } + forEach_default(keys_default(this._in[v3]), removeEdge); + delete this._in[v3]; + delete this._preds[v3]; + forEach_default(keys_default(this._out[v3]), removeEdge); + delete this._out[v3]; + delete this._sucs[v3]; + --this._nodeCount; + } + return this; + } + setParent(v3, parent4) { + if (!this._isCompound) { + throw new Error("Cannot set parent in a non-compound graph"); + } + if (isUndefined_default(parent4)) { + parent4 = GRAPH_NODE; + } else { + parent4 += ""; + for (var ancestor = parent4; !isUndefined_default(ancestor); ancestor = this.parent(ancestor)) { + if (ancestor === v3) { + throw new Error("Setting " + parent4 + " as parent of " + v3 + " would create a cycle"); + } + } + this.setNode(parent4); + } + this.setNode(v3); + this._removeFromParentsChildList(v3); + this._parent[v3] = parent4; + this._children[parent4][v3] = true; + return this; + } + _removeFromParentsChildList(v3) { + delete this._children[this._parent[v3]][v3]; + } + parent(v3) { + if (this._isCompound) { + var parent4 = this._parent[v3]; + if (parent4 !== GRAPH_NODE) { + return parent4; + } + } + } + children(v3) { + if (isUndefined_default(v3)) { + v3 = GRAPH_NODE; + } + if (this._isCompound) { + var children2 = this._children[v3]; + if (children2) { + return keys_default(children2); + } + } else if (v3 === GRAPH_NODE) { + return this.nodes(); + } else if (this.hasNode(v3)) { + return []; + } + } + predecessors(v3) { + var predsV = this._preds[v3]; + if (predsV) { + return keys_default(predsV); + } + } + successors(v3) { + var sucsV = this._sucs[v3]; + if (sucsV) { + return keys_default(sucsV); + } + } + neighbors(v3) { + var preds = this.predecessors(v3); + if (preds) { + return union_default(preds, this.successors(v3)); + } + } + isLeaf(v3) { + var neighbors; + if (this.isDirected()) { + neighbors = this.successors(v3); + } else { + neighbors = this.neighbors(v3); + } + return neighbors.length === 0; + } + filterNodes(filter6) { + var copy5 = new this.constructor({ + directed: this._isDirected, + multigraph: this._isMultigraph, + compound: this._isCompound + }); + copy5.setGraph(this.graph()); + var self2 = this; + forEach_default(this._nodes, function(value2, v3) { + if (filter6(v3)) { + copy5.setNode(v3, value2); + } + }); + forEach_default(this._edgeObjs, function(e3) { + if (copy5.hasNode(e3.v) && copy5.hasNode(e3.w)) { + copy5.setEdge(e3, self2.edge(e3)); + } + }); + var parents3 = {}; + function findParent(v3) { + var parent4 = self2.parent(v3); + if (parent4 === void 0 || copy5.hasNode(parent4)) { + parents3[v3] = parent4; + return parent4; + } else if (parent4 in parents3) { + return parents3[parent4]; + } else { + return findParent(parent4); + } + } + __name(findParent, "findParent"); + if (this._isCompound) { + forEach_default(copy5.nodes(), function(v3) { + copy5.setParent(v3, findParent(v3)); + }); + } + return copy5; + } + /* === Edge functions ========== */ + setDefaultEdgeLabel(newDefault) { + if (!isFunction_default(newDefault)) { + newDefault = constant_default7(newDefault); + } + this._defaultEdgeLabelFn = newDefault; + return this; + } + edgeCount() { + return this._edgeCount; + } + edges() { + return values_default(this._edgeObjs); + } + setPath(vs, value2) { + var self2 = this; + var args = arguments; + reduce_default(vs, function(v3, w4) { + if (args.length > 1) { + self2.setEdge(v3, w4, value2); + } else { + self2.setEdge(v3, w4); + } + return w4; + }); + return this; + } + /* + * setEdge(v, w, [value, [name]]) + * setEdge({ v, w, [name] }, [value]) + */ + setEdge() { + var v3, w4, name, value2; + var valueSpecified = false; + var arg0 = arguments[0]; + if (typeof arg0 === "object" && arg0 !== null && "v" in arg0) { + v3 = arg0.v; + w4 = arg0.w; + name = arg0.name; + if (arguments.length === 2) { + value2 = arguments[1]; + valueSpecified = true; + } + } else { + v3 = arg0; + w4 = arguments[1]; + name = arguments[3]; + if (arguments.length > 2) { + value2 = arguments[2]; + valueSpecified = true; + } + } + v3 = "" + v3; + w4 = "" + w4; + if (!isUndefined_default(name)) { + name = "" + name; + } + var e3 = edgeArgsToId(this._isDirected, v3, w4, name); + if (Object.prototype.hasOwnProperty.call(this._edgeLabels, e3)) { + if (valueSpecified) { + this._edgeLabels[e3] = value2; + } + return this; + } + if (!isUndefined_default(name) && !this._isMultigraph) { + throw new Error("Cannot set a named edge when isMultigraph = false"); + } + this.setNode(v3); + this.setNode(w4); + this._edgeLabels[e3] = valueSpecified ? value2 : this._defaultEdgeLabelFn(v3, w4, name); + var edgeObj = edgeArgsToObj(this._isDirected, v3, w4, name); + v3 = edgeObj.v; + w4 = edgeObj.w; + Object.freeze(edgeObj); + this._edgeObjs[e3] = edgeObj; + incrementOrInitEntry(this._preds[w4], v3); + incrementOrInitEntry(this._sucs[v3], w4); + this._in[w4][e3] = edgeObj; + this._out[v3][e3] = edgeObj; + this._edgeCount++; + return this; + } + edge(v3, w4, name) { + var e3 = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v3, w4, name); + return this._edgeLabels[e3]; + } + hasEdge(v3, w4, name) { + var e3 = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v3, w4, name); + return Object.prototype.hasOwnProperty.call(this._edgeLabels, e3); + } + removeEdge(v3, w4, name) { + var e3 = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, v3, w4, name); + var edge = this._edgeObjs[e3]; + if (edge) { + v3 = edge.v; + w4 = edge.w; + delete this._edgeLabels[e3]; + delete this._edgeObjs[e3]; + decrementOrRemoveEntry(this._preds[w4], v3); + decrementOrRemoveEntry(this._sucs[v3], w4); + delete this._in[w4][e3]; + delete this._out[v3][e3]; + this._edgeCount--; + } + return this; + } + inEdges(v3, u2) { + var inV = this._in[v3]; + if (inV) { + var edges3 = values_default(inV); + if (!u2) { + return edges3; + } + return filter_default3(edges3, function(edge) { + return edge.v === u2; + }); + } + } + outEdges(v3, w4) { + var outV = this._out[v3]; + if (outV) { + var edges3 = values_default(outV); + if (!w4) { + return edges3; + } + return filter_default3(edges3, function(edge) { + return edge.w === w4; + }); + } + } + nodeEdges(v3, w4) { + var inEdges = this.inEdges(v3, w4); + if (inEdges) { + return inEdges.concat(this.outEdges(v3, w4)); + } + } + }; + Graph.prototype._nodeCount = 0; + Graph.prototype._edgeCount = 0; + __name(incrementOrInitEntry, "incrementOrInitEntry"); + __name(decrementOrRemoveEntry, "decrementOrRemoveEntry"); + __name(edgeArgsToId, "edgeArgsToId"); + __name(edgeArgsToObj, "edgeArgsToObj"); + __name(edgeObjToId, "edgeObjToId"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/index.js + var init_graphlib = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/index.js"() { + "use strict"; + init_graph(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/data/list.js + function unlink(entry) { + entry._prev._next = entry._next; + entry._next._prev = entry._prev; + delete entry._next; + delete entry._prev; + } + function filterOutLinks(k2, v3) { + if (k2 !== "_next" && k2 !== "_prev") { + return v3; + } + } + var List; + var init_list = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/data/list.js"() { + "use strict"; + List = class { + static { + __name(this, "List"); + } + constructor() { + var sentinel = {}; + sentinel._next = sentinel._prev = sentinel; + this._sentinel = sentinel; + } + dequeue() { + var sentinel = this._sentinel; + var entry = sentinel._prev; + if (entry !== sentinel) { + unlink(entry); + return entry; + } + } + enqueue(entry) { + var sentinel = this._sentinel; + if (entry._prev && entry._next) { + unlink(entry); + } + entry._next = sentinel._next; + sentinel._next._prev = entry; + sentinel._next = entry; + entry._prev = sentinel; + } + toString() { + var strs = []; + var sentinel = this._sentinel; + var curr = sentinel._prev; + while (curr !== sentinel) { + strs.push(JSON.stringify(curr, filterOutLinks)); + curr = curr._prev; + } + return "[" + strs.join(", ") + "]"; + } + }; + __name(unlink, "unlink"); + __name(filterOutLinks, "filterOutLinks"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/greedy-fas.js + function greedyFAS(g2, weightFn) { + if (g2.nodeCount() <= 1) { + return []; + } + var state3 = buildState(g2, weightFn || DEFAULT_WEIGHT_FN); + var results = doGreedyFAS(state3.graph, state3.buckets, state3.zeroIdx); + return flatten_default( + map_default(results, function(e3) { + return g2.outEdges(e3.v, e3.w); + }) + ); + } + function doGreedyFAS(g2, buckets, zeroIdx) { + var results = []; + var sources = buckets[buckets.length - 1]; + var sinks = buckets[0]; + var entry; + while (g2.nodeCount()) { + while (entry = sinks.dequeue()) { + removeNode(g2, buckets, zeroIdx, entry); + } + while (entry = sources.dequeue()) { + removeNode(g2, buckets, zeroIdx, entry); + } + if (g2.nodeCount()) { + for (var i2 = buckets.length - 2; i2 > 0; --i2) { + entry = buckets[i2].dequeue(); + if (entry) { + results = results.concat(removeNode(g2, buckets, zeroIdx, entry, true)); + break; + } + } + } + } + return results; + } + function removeNode(g2, buckets, zeroIdx, entry, collectPredecessors) { + var results = collectPredecessors ? [] : void 0; + forEach_default(g2.inEdges(entry.v), function(edge) { + var weight8 = g2.edge(edge); + var uEntry = g2.node(edge.v); + if (collectPredecessors) { + results.push({ v: edge.v, w: edge.w }); + } + uEntry.out -= weight8; + assignBucket(buckets, zeroIdx, uEntry); + }); + forEach_default(g2.outEdges(entry.v), function(edge) { + var weight8 = g2.edge(edge); + var w4 = edge.w; + var wEntry = g2.node(w4); + wEntry["in"] -= weight8; + assignBucket(buckets, zeroIdx, wEntry); + }); + g2.removeNode(entry.v); + return results; + } + function buildState(g2, weightFn) { + var fasGraph = new Graph(); + var maxIn = 0; + var maxOut = 0; + forEach_default(g2.nodes(), function(v3) { + fasGraph.setNode(v3, { v: v3, in: 0, out: 0 }); + }); + forEach_default(g2.edges(), function(e3) { + var prevWeight = fasGraph.edge(e3.v, e3.w) || 0; + var weight8 = weightFn(e3); + var edgeWeight = prevWeight + weight8; + fasGraph.setEdge(e3.v, e3.w, edgeWeight); + maxOut = Math.max(maxOut, fasGraph.node(e3.v).out += weight8); + maxIn = Math.max(maxIn, fasGraph.node(e3.w)["in"] += weight8); + }); + var buckets = range_default(maxOut + maxIn + 3).map(function() { + return new List(); + }); + var zeroIdx = maxIn + 1; + forEach_default(fasGraph.nodes(), function(v3) { + assignBucket(buckets, zeroIdx, fasGraph.node(v3)); + }); + return { graph: fasGraph, buckets, zeroIdx }; + } + function assignBucket(buckets, zeroIdx, entry) { + if (!entry.out) { + buckets[0].enqueue(entry); + } else if (!entry["in"]) { + buckets[buckets.length - 1].enqueue(entry); + } else { + buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry); + } + } + var DEFAULT_WEIGHT_FN; + var init_greedy_fas = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/greedy-fas.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + init_list(); + DEFAULT_WEIGHT_FN = constant_default7(1); + __name(greedyFAS, "greedyFAS"); + __name(doGreedyFAS, "doGreedyFAS"); + __name(removeNode, "removeNode"); + __name(buildState, "buildState"); + __name(assignBucket, "assignBucket"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/acyclic.js + function run(g2) { + var fas = g2.graph().acyclicer === "greedy" ? greedyFAS(g2, weightFn(g2)) : dfsFAS(g2); + forEach_default(fas, function(e3) { + var label = g2.edge(e3); + g2.removeEdge(e3); + label.forwardName = e3.name; + label.reversed = true; + g2.setEdge(e3.w, e3.v, label, uniqueId_default("rev")); + }); + function weightFn(g3) { + return function(e3) { + return g3.edge(e3).weight; + }; + } + __name(weightFn, "weightFn"); + } + function dfsFAS(g2) { + var fas = []; + var stack = {}; + var visited = {}; + function dfs3(v3) { + if (Object.prototype.hasOwnProperty.call(visited, v3)) { + return; + } + visited[v3] = true; + stack[v3] = true; + forEach_default(g2.outEdges(v3), function(e3) { + if (Object.prototype.hasOwnProperty.call(stack, e3.w)) { + fas.push(e3); + } else { + dfs3(e3.w); + } + }); + delete stack[v3]; + } + __name(dfs3, "dfs"); + forEach_default(g2.nodes(), dfs3); + return fas; + } + function undo(g2) { + forEach_default(g2.edges(), function(e3) { + var label = g2.edge(e3); + if (label.reversed) { + g2.removeEdge(e3); + var forwardName = label.forwardName; + delete label.reversed; + delete label.forwardName; + g2.setEdge(e3.w, e3.v, label, forwardName); + } + }); + } + var init_acyclic = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/acyclic.js"() { + "use strict"; + init_lodash(); + init_greedy_fas(); + __name(run, "run"); + __name(dfsFAS, "dfsFAS"); + __name(undo, "undo"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/util.js + function addDummyNode(g2, type3, attrs, name) { + var v3; + do { + v3 = uniqueId_default(name); + } while (g2.hasNode(v3)); + attrs.dummy = type3; + g2.setNode(v3, attrs); + return v3; + } + function simplify(g2) { + var simplified = new Graph().setGraph(g2.graph()); + forEach_default(g2.nodes(), function(v3) { + simplified.setNode(v3, g2.node(v3)); + }); + forEach_default(g2.edges(), function(e3) { + var simpleLabel = simplified.edge(e3.v, e3.w) || { weight: 0, minlen: 1 }; + var label = g2.edge(e3); + simplified.setEdge(e3.v, e3.w, { + weight: simpleLabel.weight + label.weight, + minlen: Math.max(simpleLabel.minlen, label.minlen) + }); + }); + return simplified; + } + function asNonCompoundGraph(g2) { + var simplified = new Graph({ multigraph: g2.isMultigraph() }).setGraph(g2.graph()); + forEach_default(g2.nodes(), function(v3) { + if (!g2.children(v3).length) { + simplified.setNode(v3, g2.node(v3)); + } + }); + forEach_default(g2.edges(), function(e3) { + simplified.setEdge(e3, g2.edge(e3)); + }); + return simplified; + } + function intersectRect2(rect3, point8) { + var x5 = rect3.x; + var y6 = rect3.y; + var dx = point8.x - x5; + var dy = point8.y - y6; + var w4 = rect3.width / 2; + var h3 = rect3.height / 2; + if (!dx && !dy) { + throw new Error("Not possible to find intersection inside of the rectangle"); + } + var sx, sy; + if (Math.abs(dy) * w4 > Math.abs(dx) * h3) { + if (dy < 0) { + h3 = -h3; + } + sx = h3 * dx / dy; + sy = h3; + } else { + if (dx < 0) { + w4 = -w4; + } + sx = w4; + sy = w4 * dy / dx; + } + return { x: x5 + sx, y: y6 + sy }; + } + function buildLayerMatrix(g2) { + var layering = map_default(range_default(maxRank(g2) + 1), function() { + return []; + }); + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + var rank2 = node2.rank; + if (!isUndefined_default(rank2)) { + layering[rank2][node2.order] = v3; + } + }); + return layering; + } + function normalizeRanks(g2) { + var min9 = min_default( + map_default(g2.nodes(), function(v3) { + return g2.node(v3).rank; + }) + ); + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + if (has_default(node2, "rank")) { + node2.rank -= min9; + } + }); + } + function removeEmptyRanks(g2) { + var offset = min_default( + map_default(g2.nodes(), function(v3) { + return g2.node(v3).rank; + }) + ); + var layers = []; + forEach_default(g2.nodes(), function(v3) { + var rank2 = g2.node(v3).rank - offset; + if (!layers[rank2]) { + layers[rank2] = []; + } + layers[rank2].push(v3); + }); + var delta = 0; + var nodeRankFactor = g2.graph().nodeRankFactor; + forEach_default(layers, function(vs, i2) { + if (isUndefined_default(vs) && i2 % nodeRankFactor !== 0) { + --delta; + } else if (delta) { + forEach_default(vs, function(v3) { + g2.node(v3).rank += delta; + }); + } + }); + } + function addBorderNode(g2, prefix, rank2, order2) { + var node2 = { + width: 0, + height: 0 + }; + if (arguments.length >= 4) { + node2.rank = rank2; + node2.order = order2; + } + return addDummyNode(g2, "border", node2, prefix); + } + function maxRank(g2) { + return max_default( + map_default(g2.nodes(), function(v3) { + var rank2 = g2.node(v3).rank; + if (!isUndefined_default(rank2)) { + return rank2; + } + }) + ); + } + function partition(collection4, fn3) { + var result = { lhs: [], rhs: [] }; + forEach_default(collection4, function(value2) { + if (fn3(value2)) { + result.lhs.push(value2); + } else { + result.rhs.push(value2); + } + }); + return result; + } + function time2(name, fn3) { + var start3 = now_default(); + try { + return fn3(); + } finally { + console.log(name + " time: " + (now_default() - start3) + "ms"); + } + } + function notime(name, fn3) { + return fn3(); + } + var init_util2 = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/util.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + __name(addDummyNode, "addDummyNode"); + __name(simplify, "simplify"); + __name(asNonCompoundGraph, "asNonCompoundGraph"); + __name(intersectRect2, "intersectRect"); + __name(buildLayerMatrix, "buildLayerMatrix"); + __name(normalizeRanks, "normalizeRanks"); + __name(removeEmptyRanks, "removeEmptyRanks"); + __name(addBorderNode, "addBorderNode"); + __name(maxRank, "maxRank"); + __name(partition, "partition"); + __name(time2, "time"); + __name(notime, "notime"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/add-border-segments.js + function addBorderSegments(g2) { + function dfs3(v3) { + var children2 = g2.children(v3); + var node2 = g2.node(v3); + if (children2.length) { + forEach_default(children2, dfs3); + } + if (Object.prototype.hasOwnProperty.call(node2, "minRank")) { + node2.borderLeft = []; + node2.borderRight = []; + for (var rank2 = node2.minRank, maxRank2 = node2.maxRank + 1; rank2 < maxRank2; ++rank2) { + addBorderNode2(g2, "borderLeft", "_bl", v3, node2, rank2); + addBorderNode2(g2, "borderRight", "_br", v3, node2, rank2); + } + } + } + __name(dfs3, "dfs"); + forEach_default(g2.children(), dfs3); + } + function addBorderNode2(g2, prop, prefix, sg, sgNode, rank2) { + var label = { width: 0, height: 0, rank: rank2, borderType: prop }; + var prev2 = sgNode[prop][rank2 - 1]; + var curr = addDummyNode(g2, "border", label, prefix); + sgNode[prop][rank2] = curr; + g2.setParent(curr, sg); + if (prev2) { + g2.setEdge(prev2, curr, { weight: 1 }); + } + } + var init_add_border_segments = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/add-border-segments.js"() { + "use strict"; + init_lodash(); + init_util2(); + __name(addBorderSegments, "addBorderSegments"); + __name(addBorderNode2, "addBorderNode"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/coordinate-system.js + function adjust2(g2) { + var rankDir = g2.graph().rankdir.toLowerCase(); + if (rankDir === "lr" || rankDir === "rl") { + swapWidthHeight(g2); + } + } + function undo2(g2) { + var rankDir = g2.graph().rankdir.toLowerCase(); + if (rankDir === "bt" || rankDir === "rl") { + reverseY(g2); + } + if (rankDir === "lr" || rankDir === "rl") { + swapXY(g2); + swapWidthHeight(g2); + } + } + function swapWidthHeight(g2) { + forEach_default(g2.nodes(), function(v3) { + swapWidthHeightOne(g2.node(v3)); + }); + forEach_default(g2.edges(), function(e3) { + swapWidthHeightOne(g2.edge(e3)); + }); + } + function swapWidthHeightOne(attrs) { + var w4 = attrs.width; + attrs.width = attrs.height; + attrs.height = w4; + } + function reverseY(g2) { + forEach_default(g2.nodes(), function(v3) { + reverseYOne(g2.node(v3)); + }); + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + forEach_default(edge.points, reverseYOne); + if (Object.prototype.hasOwnProperty.call(edge, "y")) { + reverseYOne(edge); + } + }); + } + function reverseYOne(attrs) { + attrs.y = -attrs.y; + } + function swapXY(g2) { + forEach_default(g2.nodes(), function(v3) { + swapXYOne(g2.node(v3)); + }); + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + forEach_default(edge.points, swapXYOne); + if (Object.prototype.hasOwnProperty.call(edge, "x")) { + swapXYOne(edge); + } + }); + } + function swapXYOne(attrs) { + var x5 = attrs.x; + attrs.x = attrs.y; + attrs.y = x5; + } + var init_coordinate_system = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/coordinate-system.js"() { + "use strict"; + init_lodash(); + __name(adjust2, "adjust"); + __name(undo2, "undo"); + __name(swapWidthHeight, "swapWidthHeight"); + __name(swapWidthHeightOne, "swapWidthHeightOne"); + __name(reverseY, "reverseY"); + __name(reverseYOne, "reverseYOne"); + __name(swapXY, "swapXY"); + __name(swapXYOne, "swapXYOne"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/normalize.js + function run2(g2) { + g2.graph().dummyChains = []; + forEach_default(g2.edges(), function(edge) { + normalizeEdge(g2, edge); + }); + } + function normalizeEdge(g2, e3) { + var v3 = e3.v; + var vRank = g2.node(v3).rank; + var w4 = e3.w; + var wRank = g2.node(w4).rank; + var name = e3.name; + var edgeLabel = g2.edge(e3); + var labelRank = edgeLabel.labelRank; + if (wRank === vRank + 1) return; + g2.removeEdge(e3); + var attrs = void 0; + var dummy, i2; + for (i2 = 0, ++vRank; vRank < wRank; ++i2, ++vRank) { + edgeLabel.points = []; + attrs = { + width: 0, + height: 0, + edgeLabel, + edgeObj: e3, + rank: vRank + }; + dummy = addDummyNode(g2, "edge", attrs, "_d"); + if (vRank === labelRank) { + attrs.width = edgeLabel.width; + attrs.height = edgeLabel.height; + attrs.dummy = "edge-label"; + attrs.labelpos = edgeLabel.labelpos; + } + g2.setEdge(v3, dummy, { weight: edgeLabel.weight }, name); + if (i2 === 0) { + g2.graph().dummyChains.push(dummy); + } + v3 = dummy; + } + g2.setEdge(v3, w4, { weight: edgeLabel.weight }, name); + } + function undo3(g2) { + forEach_default(g2.graph().dummyChains, function(v3) { + var node2 = g2.node(v3); + var origLabel = node2.edgeLabel; + var w4; + g2.setEdge(node2.edgeObj, origLabel); + while (node2.dummy) { + w4 = g2.successors(v3)[0]; + g2.removeNode(v3); + origLabel.points.push({ x: node2.x, y: node2.y }); + if (node2.dummy === "edge-label") { + origLabel.x = node2.x; + origLabel.y = node2.y; + origLabel.width = node2.width; + origLabel.height = node2.height; + } + v3 = w4; + node2 = g2.node(v3); + } + }); + } + var init_normalize = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/normalize.js"() { + "use strict"; + init_lodash(); + init_util2(); + __name(run2, "run"); + __name(normalizeEdge, "normalizeEdge"); + __name(undo3, "undo"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/util.js + function longestPath(g2) { + var visited = {}; + function dfs3(v3) { + var label = g2.node(v3); + if (Object.prototype.hasOwnProperty.call(visited, v3)) { + return label.rank; + } + visited[v3] = true; + var rank2 = min_default( + map_default(g2.outEdges(v3), function(e3) { + return dfs3(e3.w) - g2.edge(e3).minlen; + }) + ); + if (rank2 === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3 + rank2 === void 0 || // return value of _.map([]) for Lodash 4 + rank2 === null) { + rank2 = 0; + } + return label.rank = rank2; + } + __name(dfs3, "dfs"); + forEach_default(g2.sources(), dfs3); + } + function slack(g2, e3) { + return g2.node(e3.w).rank - g2.node(e3.v).rank - g2.edge(e3).minlen; + } + var init_util3 = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/util.js"() { + "use strict"; + init_lodash(); + __name(longestPath, "longestPath"); + __name(slack, "slack"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js + function feasibleTree(g2) { + var t4 = new Graph({ directed: false }); + var start3 = g2.nodes()[0]; + var size4 = g2.nodeCount(); + t4.setNode(start3, {}); + var edge, delta; + while (tightTree(t4, g2) < size4) { + edge = findMinSlackEdge(t4, g2); + delta = t4.hasNode(edge.v) ? slack(g2, edge) : -slack(g2, edge); + shiftRanks(t4, g2, delta); + } + return t4; + } + function tightTree(t4, g2) { + function dfs3(v3) { + forEach_default(g2.nodeEdges(v3), function(e3) { + var edgeV = e3.v, w4 = v3 === edgeV ? e3.w : edgeV; + if (!t4.hasNode(w4) && !slack(g2, e3)) { + t4.setNode(w4, {}); + t4.setEdge(v3, w4, {}); + dfs3(w4); + } + }); + } + __name(dfs3, "dfs"); + forEach_default(t4.nodes(), dfs3); + return t4.nodeCount(); + } + function findMinSlackEdge(t4, g2) { + return minBy_default(g2.edges(), function(e3) { + if (t4.hasNode(e3.v) !== t4.hasNode(e3.w)) { + return slack(g2, e3); + } + }); + } + function shiftRanks(t4, g2, delta) { + forEach_default(t4.nodes(), function(v3) { + g2.node(v3).rank += delta; + }); + } + var init_feasible_tree = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + init_util3(); + __name(feasibleTree, "feasibleTree"); + __name(tightTree, "tightTree"); + __name(findMinSlackEdge, "findMinSlackEdge"); + __name(shiftRanks, "shiftRanks"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/components.js + var init_components = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/components.js"() { + "use strict"; + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/data/priority-queue.js + var init_priority_queue = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/data/priority-queue.js"() { + "use strict"; + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.js + var DEFAULT_WEIGHT_FUNC; + var init_dijkstra = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.js"() { + "use strict"; + init_lodash(); + init_priority_queue(); + DEFAULT_WEIGHT_FUNC = constant_default7(1); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra-all.js + var init_dijkstra_all = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dijkstra-all.js"() { + "use strict"; + init_dijkstra(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/tarjan.js + var init_tarjan = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/tarjan.js"() { + "use strict"; + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/find-cycles.js + var init_find_cycles = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/find-cycles.js"() { + "use strict"; + init_tarjan(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.js + var DEFAULT_WEIGHT_FUNC2; + var init_floyd_warshall = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.js"() { + "use strict"; + init_lodash(); + DEFAULT_WEIGHT_FUNC2 = constant_default7(1); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/topsort.js + function topsort(g2) { + var visited = {}; + var stack = {}; + var results = []; + function visit(node2) { + if (Object.prototype.hasOwnProperty.call(stack, node2)) { + throw new CycleException(); + } + if (!Object.prototype.hasOwnProperty.call(visited, node2)) { + stack[node2] = true; + visited[node2] = true; + forEach_default(g2.predecessors(node2), visit); + delete stack[node2]; + results.push(node2); + } + } + __name(visit, "visit"); + forEach_default(g2.sinks(), visit); + if (size_default2(visited) !== g2.nodeCount()) { + throw new CycleException(); + } + return results; + } + function CycleException() { + } + var init_topsort = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/topsort.js"() { + "use strict"; + init_lodash(); + topsort.CycleException = CycleException; + __name(topsort, "topsort"); + __name(CycleException, "CycleException"); + CycleException.prototype = new Error(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/is-acyclic.js + var init_is_acyclic = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/is-acyclic.js"() { + "use strict"; + init_topsort(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dfs.js + function dfs(g2, vs, order2) { + if (!isArray_default(vs)) { + vs = [vs]; + } + var navigation = (g2.isDirected() ? g2.successors : g2.neighbors).bind(g2); + var acc = []; + var visited = {}; + forEach_default(vs, function(v3) { + if (!g2.hasNode(v3)) { + throw new Error("Graph does not have node: " + v3); + } + doDfs(g2, v3, order2 === "post", visited, navigation, acc); + }); + return acc; + } + function doDfs(g2, v3, postorder3, visited, navigation, acc) { + if (!Object.prototype.hasOwnProperty.call(visited, v3)) { + visited[v3] = true; + if (!postorder3) { + acc.push(v3); + } + forEach_default(navigation(v3), function(w4) { + doDfs(g2, w4, postorder3, visited, navigation, acc); + }); + if (postorder3) { + acc.push(v3); + } + } + } + var init_dfs = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/dfs.js"() { + "use strict"; + init_lodash(); + __name(dfs, "dfs"); + __name(doDfs, "doDfs"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/postorder.js + function postorder(g2, vs) { + return dfs(g2, vs, "post"); + } + var init_postorder = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/postorder.js"() { + "use strict"; + init_dfs(); + __name(postorder, "postorder"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/preorder.js + function preorder(g2, vs) { + return dfs(g2, vs, "pre"); + } + var init_preorder = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/preorder.js"() { + "use strict"; + init_dfs(); + __name(preorder, "preorder"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/prim.js + var init_prim = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/prim.js"() { + "use strict"; + init_priority_queue(); + init_graph(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/index.js + var init_alg = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/alg/index.js"() { + "use strict"; + init_components(); + init_dijkstra(); + init_dijkstra_all(); + init_find_cycles(); + init_floyd_warshall(); + init_is_acyclic(); + init_postorder(); + init_preorder(); + init_prim(); + init_tarjan(); + init_topsort(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js + function networkSimplex(g2) { + g2 = simplify(g2); + longestPath(g2); + var t4 = feasibleTree(g2); + initLowLimValues(t4); + initCutValues(t4, g2); + var e3, f2; + while (e3 = leaveEdge(t4)) { + f2 = enterEdge(t4, g2, e3); + exchangeEdges(t4, g2, e3, f2); + } + } + function initCutValues(t4, g2) { + var vs = postorder(t4, t4.nodes()); + vs = vs.slice(0, vs.length - 1); + forEach_default(vs, function(v3) { + assignCutValue(t4, g2, v3); + }); + } + function assignCutValue(t4, g2, child) { + var childLab = t4.node(child); + var parent4 = childLab.parent; + t4.edge(child, parent4).cutvalue = calcCutValue(t4, g2, child); + } + function calcCutValue(t4, g2, child) { + var childLab = t4.node(child); + var parent4 = childLab.parent; + var childIsTail = true; + var graphEdge = g2.edge(child, parent4); + var cutValue = 0; + if (!graphEdge) { + childIsTail = false; + graphEdge = g2.edge(parent4, child); + } + cutValue = graphEdge.weight; + forEach_default(g2.nodeEdges(child), function(e3) { + var isOutEdge = e3.v === child, other = isOutEdge ? e3.w : e3.v; + if (other !== parent4) { + var pointsToHead = isOutEdge === childIsTail, otherWeight = g2.edge(e3).weight; + cutValue += pointsToHead ? otherWeight : -otherWeight; + if (isTreeEdge(t4, child, other)) { + var otherCutValue = t4.edge(child, other).cutvalue; + cutValue += pointsToHead ? -otherCutValue : otherCutValue; + } + } + }); + return cutValue; + } + function initLowLimValues(tree, root3) { + if (arguments.length < 2) { + root3 = tree.nodes()[0]; + } + dfsAssignLowLim(tree, {}, 1, root3); + } + function dfsAssignLowLim(tree, visited, nextLim, v3, parent4) { + var low = nextLim; + var label = tree.node(v3); + visited[v3] = true; + forEach_default(tree.neighbors(v3), function(w4) { + if (!Object.prototype.hasOwnProperty.call(visited, w4)) { + nextLim = dfsAssignLowLim(tree, visited, nextLim, w4, v3); + } + }); + label.low = low; + label.lim = nextLim++; + if (parent4) { + label.parent = parent4; + } else { + delete label.parent; + } + return nextLim; + } + function leaveEdge(tree) { + return find_default2(tree.edges(), function(e3) { + return tree.edge(e3).cutvalue < 0; + }); + } + function enterEdge(t4, g2, edge) { + var v3 = edge.v; + var w4 = edge.w; + if (!g2.hasEdge(v3, w4)) { + v3 = edge.w; + w4 = edge.v; + } + var vLabel = t4.node(v3); + var wLabel = t4.node(w4); + var tailLabel = vLabel; + var flip = false; + if (vLabel.lim > wLabel.lim) { + tailLabel = wLabel; + flip = true; + } + var candidates = filter_default3(g2.edges(), function(edge2) { + return flip === isDescendant(t4, t4.node(edge2.v), tailLabel) && flip !== isDescendant(t4, t4.node(edge2.w), tailLabel); + }); + return minBy_default(candidates, function(edge2) { + return slack(g2, edge2); + }); + } + function exchangeEdges(t4, g2, e3, f2) { + var v3 = e3.v; + var w4 = e3.w; + t4.removeEdge(v3, w4); + t4.setEdge(f2.v, f2.w, {}); + initLowLimValues(t4); + initCutValues(t4, g2); + updateRanks(t4, g2); + } + function updateRanks(t4, g2) { + var root3 = find_default2(t4.nodes(), function(v3) { + return !g2.node(v3).parent; + }); + var vs = preorder(t4, root3); + vs = vs.slice(1); + forEach_default(vs, function(v3) { + var parent4 = t4.node(v3).parent, edge = g2.edge(v3, parent4), flipped = false; + if (!edge) { + edge = g2.edge(parent4, v3); + flipped = true; + } + g2.node(v3).rank = g2.node(parent4).rank + (flipped ? edge.minlen : -edge.minlen); + }); + } + function isTreeEdge(tree, u2, v3) { + return tree.hasEdge(u2, v3); + } + function isDescendant(tree, vLabel, rootLabel) { + return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim; + } + var init_network_simplex = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js"() { + "use strict"; + init_lodash(); + init_alg(); + init_util2(); + init_feasible_tree(); + init_util3(); + networkSimplex.initLowLimValues = initLowLimValues; + networkSimplex.initCutValues = initCutValues; + networkSimplex.calcCutValue = calcCutValue; + networkSimplex.leaveEdge = leaveEdge; + networkSimplex.enterEdge = enterEdge; + networkSimplex.exchangeEdges = exchangeEdges; + __name(networkSimplex, "networkSimplex"); + __name(initCutValues, "initCutValues"); + __name(assignCutValue, "assignCutValue"); + __name(calcCutValue, "calcCutValue"); + __name(initLowLimValues, "initLowLimValues"); + __name(dfsAssignLowLim, "dfsAssignLowLim"); + __name(leaveEdge, "leaveEdge"); + __name(enterEdge, "enterEdge"); + __name(exchangeEdges, "exchangeEdges"); + __name(updateRanks, "updateRanks"); + __name(isTreeEdge, "isTreeEdge"); + __name(isDescendant, "isDescendant"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/index.js + function rank(g2) { + switch (g2.graph().ranker) { + case "network-simplex": + networkSimplexRanker(g2); + break; + case "tight-tree": + tightTreeRanker(g2); + break; + case "longest-path": + longestPathRanker(g2); + break; + default: + networkSimplexRanker(g2); + } + } + function tightTreeRanker(g2) { + longestPath(g2); + feasibleTree(g2); + } + function networkSimplexRanker(g2) { + networkSimplex(g2); + } + var longestPathRanker; + var init_rank = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/rank/index.js"() { + "use strict"; + init_feasible_tree(); + init_network_simplex(); + init_util3(); + __name(rank, "rank"); + longestPathRanker = longestPath; + __name(tightTreeRanker, "tightTreeRanker"); + __name(networkSimplexRanker, "networkSimplexRanker"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/nesting-graph.js + function run3(g2) { + var root3 = addDummyNode(g2, "root", {}, "_root"); + var depths = treeDepths(g2); + var height2 = max_default(values_default(depths)) - 1; + var nodeSep = 2 * height2 + 1; + g2.graph().nestingRoot = root3; + forEach_default(g2.edges(), function(e3) { + g2.edge(e3).minlen *= nodeSep; + }); + var weight8 = sumWeights(g2) + 1; + forEach_default(g2.children(), function(child) { + dfs2(g2, root3, nodeSep, weight8, height2, depths, child); + }); + g2.graph().nodeRankFactor = nodeSep; + } + function dfs2(g2, root3, nodeSep, weight8, height2, depths, v3) { + var children2 = g2.children(v3); + if (!children2.length) { + if (v3 !== root3) { + g2.setEdge(root3, v3, { weight: 0, minlen: nodeSep }); + } + return; + } + var top2 = addBorderNode(g2, "_bt"); + var bottom2 = addBorderNode(g2, "_bb"); + var label = g2.node(v3); + g2.setParent(top2, v3); + label.borderTop = top2; + g2.setParent(bottom2, v3); + label.borderBottom = bottom2; + forEach_default(children2, function(child) { + dfs2(g2, root3, nodeSep, weight8, height2, depths, child); + var childNode = g2.node(child); + var childTop = childNode.borderTop ? childNode.borderTop : child; + var childBottom = childNode.borderBottom ? childNode.borderBottom : child; + var thisWeight = childNode.borderTop ? weight8 : 2 * weight8; + var minlen = childTop !== childBottom ? 1 : height2 - depths[v3] + 1; + g2.setEdge(top2, childTop, { + weight: thisWeight, + minlen, + nestingEdge: true + }); + g2.setEdge(childBottom, bottom2, { + weight: thisWeight, + minlen, + nestingEdge: true + }); + }); + if (!g2.parent(v3)) { + g2.setEdge(root3, top2, { weight: 0, minlen: height2 + depths[v3] }); + } + } + function treeDepths(g2) { + var depths = {}; + function dfs3(v3, depth) { + var children2 = g2.children(v3); + if (children2 && children2.length) { + forEach_default(children2, function(child) { + dfs3(child, depth + 1); + }); + } + depths[v3] = depth; + } + __name(dfs3, "dfs"); + forEach_default(g2.children(), function(v3) { + dfs3(v3, 1); + }); + return depths; + } + function sumWeights(g2) { + return reduce_default( + g2.edges(), + function(acc, e3) { + return acc + g2.edge(e3).weight; + }, + 0 + ); + } + function cleanup(g2) { + var graphLabel = g2.graph(); + g2.removeNode(graphLabel.nestingRoot); + delete graphLabel.nestingRoot; + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + if (edge.nestingEdge) { + g2.removeEdge(e3); + } + }); + } + var init_nesting_graph = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/nesting-graph.js"() { + "use strict"; + init_lodash(); + init_util2(); + __name(run3, "run"); + __name(dfs2, "dfs"); + __name(treeDepths, "treeDepths"); + __name(sumWeights, "sumWeights"); + __name(cleanup, "cleanup"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.js + function addSubgraphConstraints(g2, cg, vs) { + var prev2 = {}, rootPrev; + forEach_default(vs, function(v3) { + var child = g2.parent(v3), parent4, prevChild; + while (child) { + parent4 = g2.parent(child); + if (parent4) { + prevChild = prev2[parent4]; + prev2[parent4] = child; + } else { + prevChild = rootPrev; + rootPrev = child; + } + if (prevChild && prevChild !== child) { + cg.setEdge(prevChild, child); + return; + } + child = parent4; + } + }); + } + var init_add_subgraph_constraints = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.js"() { + "use strict"; + init_lodash(); + __name(addSubgraphConstraints, "addSubgraphConstraints"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js + function buildLayerGraph(g2, rank2, relationship) { + var root3 = createRootNode(g2), result = new Graph({ compound: true }).setGraph({ root: root3 }).setDefaultNodeLabel(function(v3) { + return g2.node(v3); + }); + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3), parent4 = g2.parent(v3); + if (node2.rank === rank2 || node2.minRank <= rank2 && rank2 <= node2.maxRank) { + result.setNode(v3); + result.setParent(v3, parent4 || root3); + forEach_default(g2[relationship](v3), function(e3) { + var u2 = e3.v === v3 ? e3.w : e3.v, edge = result.edge(u2, v3), weight8 = !isUndefined_default(edge) ? edge.weight : 0; + result.setEdge(u2, v3, { weight: g2.edge(e3).weight + weight8 }); + }); + if (Object.prototype.hasOwnProperty.call(node2, "minRank")) { + result.setNode(v3, { + borderLeft: node2.borderLeft[rank2], + borderRight: node2.borderRight[rank2] + }); + } + } + }); + return result; + } + function createRootNode(g2) { + var v3; + while (g2.hasNode(v3 = uniqueId_default("_root"))) ; + return v3; + } + var init_build_layer_graph = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + __name(buildLayerGraph, "buildLayerGraph"); + __name(createRootNode, "createRootNode"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.js + function crossCount(g2, layering) { + var cc2 = 0; + for (var i2 = 1; i2 < layering.length; ++i2) { + cc2 += twoLayerCrossCount(g2, layering[i2 - 1], layering[i2]); + } + return cc2; + } + function twoLayerCrossCount(g2, northLayer, southLayer) { + var southPos = zipObject_default( + southLayer, + map_default(southLayer, function(v3, i2) { + return i2; + }) + ); + var southEntries = flatten_default( + map_default(northLayer, function(v3) { + return sortBy_default( + map_default(g2.outEdges(v3), function(e3) { + return { pos: southPos[e3.w], weight: g2.edge(e3).weight }; + }), + "pos" + ); + }) + ); + var firstIndex = 1; + while (firstIndex < southLayer.length) firstIndex <<= 1; + var treeSize = 2 * firstIndex - 1; + firstIndex -= 1; + var tree = map_default(new Array(treeSize), function() { + return 0; + }); + var cc2 = 0; + forEach_default( + // @ts-expect-error + southEntries.forEach(function(entry) { + var index = entry.pos + firstIndex; + tree[index] += entry.weight; + var weightSum = 0; + while (index > 0) { + if (index % 2) { + weightSum += tree[index + 1]; + } + index = index - 1 >> 1; + tree[index] += entry.weight; + } + cc2 += entry.weight * weightSum; + }) + ); + return cc2; + } + var init_cross_count = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/cross-count.js"() { + "use strict"; + init_lodash(); + __name(crossCount, "crossCount"); + __name(twoLayerCrossCount, "twoLayerCrossCount"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/init-order.js + function initOrder(g2) { + var visited = {}; + var simpleNodes = filter_default3(g2.nodes(), function(v3) { + return !g2.children(v3).length; + }); + var maxRank2 = max_default( + map_default(simpleNodes, function(v3) { + return g2.node(v3).rank; + }) + ); + var layers = map_default(range_default(maxRank2 + 1), function() { + return []; + }); + function dfs3(v3) { + if (has_default(visited, v3)) return; + visited[v3] = true; + var node2 = g2.node(v3); + layers[node2.rank].push(v3); + forEach_default(g2.successors(v3), dfs3); + } + __name(dfs3, "dfs"); + var orderedVs = sortBy_default(simpleNodes, function(v3) { + return g2.node(v3).rank; + }); + forEach_default(orderedVs, dfs3); + return layers; + } + var init_init_order = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/init-order.js"() { + "use strict"; + init_lodash(); + __name(initOrder, "initOrder"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/barycenter.js + function barycenter(g2, movable) { + return map_default(movable, function(v3) { + var inV = g2.inEdges(v3); + if (!inV.length) { + return { v: v3 }; + } else { + var result = reduce_default( + inV, + function(acc, e3) { + var edge = g2.edge(e3), nodeU = g2.node(e3.v); + return { + sum: acc.sum + edge.weight * nodeU.order, + weight: acc.weight + edge.weight + }; + }, + { sum: 0, weight: 0 } + ); + return { + v: v3, + barycenter: result.sum / result.weight, + weight: result.weight + }; + } + }); + } + var init_barycenter = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/barycenter.js"() { + "use strict"; + init_lodash(); + __name(barycenter, "barycenter"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js + function resolveConflicts(entries2, cg) { + var mappedEntries = {}; + forEach_default(entries2, function(entry, i2) { + var tmp = mappedEntries[entry.v] = { + indegree: 0, + in: [], + out: [], + vs: [entry.v], + i: i2 + }; + if (!isUndefined_default(entry.barycenter)) { + tmp.barycenter = entry.barycenter; + tmp.weight = entry.weight; + } + }); + forEach_default(cg.edges(), function(e3) { + var entryV = mappedEntries[e3.v]; + var entryW = mappedEntries[e3.w]; + if (!isUndefined_default(entryV) && !isUndefined_default(entryW)) { + entryW.indegree++; + entryV.out.push(mappedEntries[e3.w]); + } + }); + var sourceSet = filter_default3(mappedEntries, function(entry) { + return !entry.indegree; + }); + return doResolveConflicts(sourceSet); + } + function doResolveConflicts(sourceSet) { + var entries2 = []; + function handleIn(vEntry) { + return function(uEntry) { + if (uEntry.merged) { + return; + } + if (isUndefined_default(uEntry.barycenter) || isUndefined_default(vEntry.barycenter) || uEntry.barycenter >= vEntry.barycenter) { + mergeEntries(vEntry, uEntry); + } + }; + } + __name(handleIn, "handleIn"); + function handleOut(vEntry) { + return function(wEntry) { + wEntry["in"].push(vEntry); + if (--wEntry.indegree === 0) { + sourceSet.push(wEntry); + } + }; + } + __name(handleOut, "handleOut"); + while (sourceSet.length) { + var entry = sourceSet.pop(); + entries2.push(entry); + forEach_default(entry["in"].reverse(), handleIn(entry)); + forEach_default(entry.out, handleOut(entry)); + } + return map_default( + filter_default3(entries2, function(entry2) { + return !entry2.merged; + }), + function(entry2) { + return pick_default(entry2, ["vs", "i", "barycenter", "weight"]); + } + ); + } + function mergeEntries(target, source) { + var sum2 = 0; + var weight8 = 0; + if (target.weight) { + sum2 += target.barycenter * target.weight; + weight8 += target.weight; + } + if (source.weight) { + sum2 += source.barycenter * source.weight; + weight8 += source.weight; + } + target.vs = source.vs.concat(target.vs); + target.barycenter = sum2 / weight8; + target.weight = weight8; + target.i = Math.min(source.i, target.i); + source.merged = true; + } + var init_resolve_conflicts = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js"() { + "use strict"; + init_lodash(); + __name(resolveConflicts, "resolveConflicts"); + __name(doResolveConflicts, "doResolveConflicts"); + __name(mergeEntries, "mergeEntries"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort.js + function sort(entries2, biasRight) { + var parts = partition(entries2, function(entry) { + return Object.prototype.hasOwnProperty.call(entry, "barycenter"); + }); + var sortable = parts.lhs, unsortable = sortBy_default(parts.rhs, function(entry) { + return -entry.i; + }), vs = [], sum2 = 0, weight8 = 0, vsIndex = 0; + sortable.sort(compareWithBias(!!biasRight)); + vsIndex = consumeUnsortable(vs, unsortable, vsIndex); + forEach_default(sortable, function(entry) { + vsIndex += entry.vs.length; + vs.push(entry.vs); + sum2 += entry.barycenter * entry.weight; + weight8 += entry.weight; + vsIndex = consumeUnsortable(vs, unsortable, vsIndex); + }); + var result = { vs: flatten_default(vs) }; + if (weight8) { + result.barycenter = sum2 / weight8; + result.weight = weight8; + } + return result; + } + function consumeUnsortable(vs, unsortable, index) { + var last3; + while (unsortable.length && (last3 = last_default(unsortable)).i <= index) { + unsortable.pop(); + vs.push(last3.vs); + index++; + } + return index; + } + function compareWithBias(bias) { + return function(entryV, entryW) { + if (entryV.barycenter < entryW.barycenter) { + return -1; + } else if (entryV.barycenter > entryW.barycenter) { + return 1; + } + return !bias ? entryV.i - entryW.i : entryW.i - entryV.i; + }; + } + var init_sort3 = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort.js"() { + "use strict"; + init_lodash(); + init_util2(); + __name(sort, "sort"); + __name(consumeUnsortable, "consumeUnsortable"); + __name(compareWithBias, "compareWithBias"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js + function sortSubgraph(g2, v3, cg, biasRight) { + var movable = g2.children(v3); + var node2 = g2.node(v3); + var bl = node2 ? node2.borderLeft : void 0; + var br = node2 ? node2.borderRight : void 0; + var subgraphs = {}; + if (bl) { + movable = filter_default3(movable, function(w4) { + return w4 !== bl && w4 !== br; + }); + } + var barycenters = barycenter(g2, movable); + forEach_default(barycenters, function(entry) { + if (g2.children(entry.v).length) { + var subgraphResult = sortSubgraph(g2, entry.v, cg, biasRight); + subgraphs[entry.v] = subgraphResult; + if (Object.prototype.hasOwnProperty.call(subgraphResult, "barycenter")) { + mergeBarycenters(entry, subgraphResult); + } + } + }); + var entries2 = resolveConflicts(barycenters, cg); + expandSubgraphs(entries2, subgraphs); + var result = sort(entries2, biasRight); + if (bl) { + result.vs = flatten_default([bl, result.vs, br]); + if (g2.predecessors(bl).length) { + var blPred = g2.node(g2.predecessors(bl)[0]), brPred = g2.node(g2.predecessors(br)[0]); + if (!Object.prototype.hasOwnProperty.call(result, "barycenter")) { + result.barycenter = 0; + result.weight = 0; + } + result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2); + result.weight += 2; + } + } + return result; + } + function expandSubgraphs(entries2, subgraphs) { + forEach_default(entries2, function(entry) { + entry.vs = flatten_default( + entry.vs.map(function(v3) { + if (subgraphs[v3]) { + return subgraphs[v3].vs; + } + return v3; + }) + ); + }); + } + function mergeBarycenters(target, other) { + if (!isUndefined_default(target.barycenter)) { + target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight); + target.weight += other.weight; + } else { + target.barycenter = other.barycenter; + target.weight = other.weight; + } + } + var init_sort_subgraph = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js"() { + "use strict"; + init_lodash(); + init_barycenter(); + init_resolve_conflicts(); + init_sort3(); + __name(sortSubgraph, "sortSubgraph"); + __name(expandSubgraphs, "expandSubgraphs"); + __name(mergeBarycenters, "mergeBarycenters"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/index.js + function order(g2) { + var maxRank2 = maxRank(g2), downLayerGraphs = buildLayerGraphs(g2, range_default(1, maxRank2 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g2, range_default(maxRank2 - 1, -1, -1), "outEdges"); + var layering = initOrder(g2); + assignOrder(g2, layering); + var bestCC = Number.POSITIVE_INFINITY, best; + for (var i2 = 0, lastBest = 0; lastBest < 4; ++i2, ++lastBest) { + sweepLayerGraphs(i2 % 2 ? downLayerGraphs : upLayerGraphs, i2 % 4 >= 2); + layering = buildLayerMatrix(g2); + var cc2 = crossCount(g2, layering); + if (cc2 < bestCC) { + lastBest = 0; + best = cloneDeep_default(layering); + bestCC = cc2; + } + } + assignOrder(g2, best); + } + function buildLayerGraphs(g2, ranks, relationship) { + return map_default(ranks, function(rank2) { + return buildLayerGraph(g2, rank2, relationship); + }); + } + function sweepLayerGraphs(layerGraphs, biasRight) { + var cg = new Graph(); + forEach_default(layerGraphs, function(lg) { + var root3 = lg.graph().root; + var sorted = sortSubgraph(lg, root3, cg, biasRight); + forEach_default(sorted.vs, function(v3, i2) { + lg.node(v3).order = i2; + }); + addSubgraphConstraints(lg, cg, sorted.vs); + }); + } + function assignOrder(g2, layering) { + forEach_default(layering, function(layer) { + forEach_default(layer, function(v3, i2) { + g2.node(v3).order = i2; + }); + }); + } + var init_order2 = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/order/index.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + init_util2(); + init_add_subgraph_constraints(); + init_build_layer_graph(); + init_cross_count(); + init_init_order(); + init_sort_subgraph(); + __name(order, "order"); + __name(buildLayerGraphs, "buildLayerGraphs"); + __name(sweepLayerGraphs, "sweepLayerGraphs"); + __name(assignOrder, "assignOrder"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js + function parentDummyChains(g2) { + var postorderNums = postorder2(g2); + forEach_default(g2.graph().dummyChains, function(v3) { + var node2 = g2.node(v3); + var edgeObj = node2.edgeObj; + var pathData = findPath(g2, postorderNums, edgeObj.v, edgeObj.w); + var path4 = pathData.path; + var lca = pathData.lca; + var pathIdx = 0; + var pathV = path4[pathIdx]; + var ascending5 = true; + while (v3 !== edgeObj.w) { + node2 = g2.node(v3); + if (ascending5) { + while ((pathV = path4[pathIdx]) !== lca && g2.node(pathV).maxRank < node2.rank) { + pathIdx++; + } + if (pathV === lca) { + ascending5 = false; + } + } + if (!ascending5) { + while (pathIdx < path4.length - 1 && g2.node(pathV = path4[pathIdx + 1]).minRank <= node2.rank) { + pathIdx++; + } + pathV = path4[pathIdx]; + } + g2.setParent(v3, pathV); + v3 = g2.successors(v3)[0]; + } + }); + } + function findPath(g2, postorderNums, v3, w4) { + var vPath = []; + var wPath = []; + var low = Math.min(postorderNums[v3].low, postorderNums[w4].low); + var lim = Math.max(postorderNums[v3].lim, postorderNums[w4].lim); + var parent4; + var lca; + parent4 = v3; + do { + parent4 = g2.parent(parent4); + vPath.push(parent4); + } while (parent4 && (postorderNums[parent4].low > low || lim > postorderNums[parent4].lim)); + lca = parent4; + parent4 = w4; + while ((parent4 = g2.parent(parent4)) !== lca) { + wPath.push(parent4); + } + return { path: vPath.concat(wPath.reverse()), lca }; + } + function postorder2(g2) { + var result = {}; + var lim = 0; + function dfs3(v3) { + var low = lim; + forEach_default(g2.children(v3), dfs3); + result[v3] = { low, lim: lim++ }; + } + __name(dfs3, "dfs"); + forEach_default(g2.children(), dfs3); + return result; + } + var init_parent_dummy_chains = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js"() { + "use strict"; + init_lodash(); + __name(parentDummyChains, "parentDummyChains"); + __name(findPath, "findPath"); + __name(postorder2, "postorder"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/bk.js + function findType1Conflicts(g2, layering) { + var conflicts = {}; + function visitLayer(prevLayer, layer) { + var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = last_default(layer); + forEach_default(layer, function(v3, i2) { + var w4 = findOtherInnerSegmentNode(g2, v3), k1 = w4 ? g2.node(w4).order : prevLayerLength; + if (w4 || v3 === lastNode) { + forEach_default(layer.slice(scanPos, i2 + 1), function(scanNode) { + forEach_default(g2.predecessors(scanNode), function(u2) { + var uLabel = g2.node(u2), uPos = uLabel.order; + if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g2.node(scanNode).dummy)) { + addConflict(conflicts, u2, scanNode); + } + }); + }); + scanPos = i2 + 1; + k0 = k1; + } + }); + return layer; + } + __name(visitLayer, "visitLayer"); + reduce_default(layering, visitLayer); + return conflicts; + } + function findType2Conflicts(g2, layering) { + var conflicts = {}; + function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) { + var v3; + forEach_default(range_default(southPos, southEnd), function(i2) { + v3 = south[i2]; + if (g2.node(v3).dummy) { + forEach_default(g2.predecessors(v3), function(u2) { + var uNode = g2.node(u2); + if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) { + addConflict(conflicts, u2, v3); + } + }); + } + }); + } + __name(scan, "scan"); + function visitLayer(north, south) { + var prevNorthPos = -1, nextNorthPos, southPos = 0; + forEach_default(south, function(v3, southLookahead) { + if (g2.node(v3).dummy === "border") { + var predecessors = g2.predecessors(v3); + if (predecessors.length) { + nextNorthPos = g2.node(predecessors[0]).order; + scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos); + southPos = southLookahead; + prevNorthPos = nextNorthPos; + } + } + scan(south, southPos, south.length, nextNorthPos, north.length); + }); + return south; + } + __name(visitLayer, "visitLayer"); + reduce_default(layering, visitLayer); + return conflicts; + } + function findOtherInnerSegmentNode(g2, v3) { + if (g2.node(v3).dummy) { + return find_default2(g2.predecessors(v3), function(u2) { + return g2.node(u2).dummy; + }); + } + } + function addConflict(conflicts, v3, w4) { + if (v3 > w4) { + var tmp = v3; + v3 = w4; + w4 = tmp; + } + if (!Object.prototype.hasOwnProperty.call(conflicts, v3)) { + Object.defineProperty(conflicts, v3, { + enumerable: true, + configurable: true, + value: {}, + writable: true + }); + } + var conflictsV = conflicts[v3]; + Object.defineProperty(conflictsV, w4, { + enumerable: true, + configurable: true, + value: true, + writable: true + }); + } + function hasConflict(conflicts, v3, w4) { + if (v3 > w4) { + var tmp = v3; + v3 = w4; + w4 = tmp; + } + return !!conflicts[v3] && Object.prototype.hasOwnProperty.call(conflicts[v3], w4); + } + function verticalAlignment(g2, layering, conflicts, neighborFn) { + var root3 = {}, align = {}, pos = {}; + forEach_default(layering, function(layer) { + forEach_default(layer, function(v3, order2) { + root3[v3] = v3; + align[v3] = v3; + pos[v3] = order2; + }); + }); + forEach_default(layering, function(layer) { + var prevIdx = -1; + forEach_default(layer, function(v3) { + var ws = neighborFn(v3); + if (ws.length) { + ws = sortBy_default(ws, function(w5) { + return pos[w5]; + }); + var mp = (ws.length - 1) / 2; + for (var i2 = Math.floor(mp), il = Math.ceil(mp); i2 <= il; ++i2) { + var w4 = ws[i2]; + if (align[v3] === v3 && prevIdx < pos[w4] && !hasConflict(conflicts, v3, w4)) { + align[w4] = v3; + align[v3] = root3[v3] = root3[w4]; + prevIdx = pos[w4]; + } + } + } + }); + }); + return { root: root3, align }; + } + function horizontalCompaction(g2, layering, root3, align, reverseSep) { + var xs = {}, blockG = buildBlockGraph(g2, layering, root3, reverseSep), borderType = reverseSep ? "borderLeft" : "borderRight"; + function iterate(setXsFunc, nextNodesFunc) { + var stack = blockG.nodes(); + var elem = stack.pop(); + var visited = {}; + while (elem) { + if (visited[elem]) { + setXsFunc(elem); + } else { + visited[elem] = true; + stack.push(elem); + stack = stack.concat(nextNodesFunc(elem)); + } + elem = stack.pop(); + } + } + __name(iterate, "iterate"); + function pass1(elem) { + xs[elem] = blockG.inEdges(elem).reduce(function(acc, e3) { + return Math.max(acc, xs[e3.v] + blockG.edge(e3)); + }, 0); + } + __name(pass1, "pass1"); + function pass2(elem) { + var min9 = blockG.outEdges(elem).reduce(function(acc, e3) { + return Math.min(acc, xs[e3.w] - blockG.edge(e3)); + }, Number.POSITIVE_INFINITY); + var node2 = g2.node(elem); + if (min9 !== Number.POSITIVE_INFINITY && node2.borderType !== borderType) { + xs[elem] = Math.max(xs[elem], min9); + } + } + __name(pass2, "pass2"); + iterate(pass1, blockG.predecessors.bind(blockG)); + iterate(pass2, blockG.successors.bind(blockG)); + forEach_default(align, function(v3) { + xs[v3] = xs[root3[v3]]; + }); + return xs; + } + function buildBlockGraph(g2, layering, root3, reverseSep) { + var blockGraph = new Graph(), graphLabel = g2.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep); + forEach_default(layering, function(layer) { + var u2; + forEach_default(layer, function(v3) { + var vRoot = root3[v3]; + blockGraph.setNode(vRoot); + if (u2) { + var uRoot = root3[u2], prevMax = blockGraph.edge(uRoot, vRoot); + blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g2, v3, u2), prevMax || 0)); + } + u2 = v3; + }); + }); + return blockGraph; + } + function findSmallestWidthAlignment(g2, xss) { + return minBy_default(values_default(xss), function(xs) { + var max10 = Number.NEGATIVE_INFINITY; + var min9 = Number.POSITIVE_INFINITY; + forIn_default(xs, function(x5, v3) { + var halfWidth = width(g2, v3) / 2; + max10 = Math.max(x5 + halfWidth, max10); + min9 = Math.min(x5 - halfWidth, min9); + }); + return max10 - min9; + }); + } + function alignCoordinates(xss, alignTo) { + var alignToVals = values_default(alignTo), alignToMin = min_default(alignToVals), alignToMax = max_default(alignToVals); + forEach_default(["u", "d"], function(vert) { + forEach_default(["l", "r"], function(horiz) { + var alignment = vert + horiz, xs = xss[alignment], delta; + if (xs === alignTo) return; + var xsVals = values_default(xs); + delta = horiz === "l" ? alignToMin - min_default(xsVals) : alignToMax - max_default(xsVals); + if (delta) { + xss[alignment] = mapValues_default(xs, function(x5) { + return x5 + delta; + }); + } + }); + }); + } + function balance(xss, align) { + return mapValues_default(xss.ul, function(ignore, v3) { + if (align) { + return xss[align.toLowerCase()][v3]; + } else { + var xs = sortBy_default(map_default(xss, v3)); + return (xs[1] + xs[2]) / 2; + } + }); + } + function positionX(g2) { + var layering = buildLayerMatrix(g2); + var conflicts = merge_default3(findType1Conflicts(g2, layering), findType2Conflicts(g2, layering)); + var xss = {}; + var adjustedLayering; + forEach_default(["u", "d"], function(vert) { + adjustedLayering = vert === "u" ? layering : values_default(layering).reverse(); + forEach_default(["l", "r"], function(horiz) { + if (horiz === "r") { + adjustedLayering = map_default(adjustedLayering, function(inner2) { + return values_default(inner2).reverse(); + }); + } + var neighborFn = (vert === "u" ? g2.predecessors : g2.successors).bind(g2); + var align = verticalAlignment(g2, adjustedLayering, conflicts, neighborFn); + var xs = horizontalCompaction(g2, adjustedLayering, align.root, align.align, horiz === "r"); + if (horiz === "r") { + xs = mapValues_default(xs, function(x5) { + return -x5; + }); + } + xss[vert + horiz] = xs; + }); + }); + var smallestWidth = findSmallestWidthAlignment(g2, xss); + alignCoordinates(xss, smallestWidth); + return balance(xss, g2.graph().align); + } + function sep(nodeSep, edgeSep, reverseSep) { + return function(g2, v3, w4) { + var vLabel = g2.node(v3); + var wLabel = g2.node(w4); + var sum2 = 0; + var delta; + sum2 += vLabel.width / 2; + if (Object.prototype.hasOwnProperty.call(vLabel, "labelpos")) { + switch (vLabel.labelpos.toLowerCase()) { + case "l": + delta = -vLabel.width / 2; + break; + case "r": + delta = vLabel.width / 2; + break; + } + } + if (delta) { + sum2 += reverseSep ? delta : -delta; + } + delta = 0; + sum2 += (vLabel.dummy ? edgeSep : nodeSep) / 2; + sum2 += (wLabel.dummy ? edgeSep : nodeSep) / 2; + sum2 += wLabel.width / 2; + if (Object.prototype.hasOwnProperty.call(wLabel, "labelpos")) { + switch (wLabel.labelpos.toLowerCase()) { + case "l": + delta = wLabel.width / 2; + break; + case "r": + delta = -wLabel.width / 2; + break; + } + } + if (delta) { + sum2 += reverseSep ? delta : -delta; + } + delta = 0; + return sum2; + }; + } + function width(g2, v3) { + return g2.node(v3).width; + } + var init_bk = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/bk.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + init_util2(); + __name(findType1Conflicts, "findType1Conflicts"); + __name(findType2Conflicts, "findType2Conflicts"); + __name(findOtherInnerSegmentNode, "findOtherInnerSegmentNode"); + __name(addConflict, "addConflict"); + __name(hasConflict, "hasConflict"); + __name(verticalAlignment, "verticalAlignment"); + __name(horizontalCompaction, "horizontalCompaction"); + __name(buildBlockGraph, "buildBlockGraph"); + __name(findSmallestWidthAlignment, "findSmallestWidthAlignment"); + __name(alignCoordinates, "alignCoordinates"); + __name(balance, "balance"); + __name(positionX, "positionX"); + __name(sep, "sep"); + __name(width, "width"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/index.js + function position(g2) { + g2 = asNonCompoundGraph(g2); + positionY(g2); + forOwn_default(positionX(g2), function(x5, v3) { + g2.node(v3).x = x5; + }); + } + function positionY(g2) { + var layering = buildLayerMatrix(g2); + var rankSep = g2.graph().ranksep; + var prevY = 0; + forEach_default(layering, function(layer) { + var maxHeight = max_default( + map_default(layer, function(v3) { + return g2.node(v3).height; + }) + ); + forEach_default(layer, function(v3) { + g2.node(v3).y = prevY + maxHeight / 2; + }); + prevY += maxHeight + rankSep; + }); + } + var init_position = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/position/index.js"() { + "use strict"; + init_lodash(); + init_util2(); + init_bk(); + __name(position, "position"); + __name(positionY, "positionY"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/layout.js + function layout(g2, opts) { + var time4 = opts && opts.debugTiming ? time2 : notime; + time4("layout", () => { + var layoutGraph = time4(" buildLayoutGraph", () => buildLayoutGraph(g2)); + time4(" runLayout", () => runLayout(layoutGraph, time4)); + time4(" updateInputGraph", () => updateInputGraph(g2, layoutGraph)); + }); + } + function runLayout(g2, time4) { + time4(" makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g2)); + time4(" removeSelfEdges", () => removeSelfEdges(g2)); + time4(" acyclic", () => run(g2)); + time4(" nestingGraph.run", () => run3(g2)); + time4(" rank", () => rank(asNonCompoundGraph(g2))); + time4(" injectEdgeLabelProxies", () => injectEdgeLabelProxies(g2)); + time4(" removeEmptyRanks", () => removeEmptyRanks(g2)); + time4(" nestingGraph.cleanup", () => cleanup(g2)); + time4(" normalizeRanks", () => normalizeRanks(g2)); + time4(" assignRankMinMax", () => assignRankMinMax(g2)); + time4(" removeEdgeLabelProxies", () => removeEdgeLabelProxies(g2)); + time4(" normalize.run", () => run2(g2)); + time4(" parentDummyChains", () => parentDummyChains(g2)); + time4(" addBorderSegments", () => addBorderSegments(g2)); + time4(" order", () => order(g2)); + time4(" insertSelfEdges", () => insertSelfEdges(g2)); + time4(" adjustCoordinateSystem", () => adjust2(g2)); + time4(" position", () => position(g2)); + time4(" positionSelfEdges", () => positionSelfEdges(g2)); + time4(" removeBorderNodes", () => removeBorderNodes(g2)); + time4(" normalize.undo", () => undo3(g2)); + time4(" fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g2)); + time4(" undoCoordinateSystem", () => undo2(g2)); + time4(" translateGraph", () => translateGraph(g2)); + time4(" assignNodeIntersects", () => assignNodeIntersects(g2)); + time4(" reversePoints", () => reversePointsForReversedEdges(g2)); + time4(" acyclic.undo", () => undo(g2)); + } + function updateInputGraph(inputGraph, layoutGraph) { + forEach_default(inputGraph.nodes(), function(v3) { + var inputLabel = inputGraph.node(v3); + var layoutLabel = layoutGraph.node(v3); + if (inputLabel) { + inputLabel.x = layoutLabel.x; + inputLabel.y = layoutLabel.y; + if (layoutGraph.children(v3).length) { + inputLabel.width = layoutLabel.width; + inputLabel.height = layoutLabel.height; + } + } + }); + forEach_default(inputGraph.edges(), function(e3) { + var inputLabel = inputGraph.edge(e3); + var layoutLabel = layoutGraph.edge(e3); + inputLabel.points = layoutLabel.points; + if (Object.prototype.hasOwnProperty.call(layoutLabel, "x")) { + inputLabel.x = layoutLabel.x; + inputLabel.y = layoutLabel.y; + } + }); + inputGraph.graph().width = layoutGraph.graph().width; + inputGraph.graph().height = layoutGraph.graph().height; + } + function buildLayoutGraph(inputGraph) { + var g2 = new Graph({ multigraph: true, compound: true }); + var graph = canonicalize(inputGraph.graph()); + g2.setGraph( + merge_default3({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), pick_default(graph, graphAttrs)) + ); + forEach_default(inputGraph.nodes(), function(v3) { + var node2 = canonicalize(inputGraph.node(v3)); + g2.setNode(v3, defaults_default(selectNumberAttrs(node2, nodeNumAttrs), nodeDefaults)); + g2.setParent(v3, inputGraph.parent(v3)); + }); + forEach_default(inputGraph.edges(), function(e3) { + var edge = canonicalize(inputGraph.edge(e3)); + g2.setEdge( + e3, + merge_default3({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pick_default(edge, edgeAttrs)) + ); + }); + return g2; + } + function makeSpaceForEdgeLabels(g2) { + var graph = g2.graph(); + graph.ranksep /= 2; + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + edge.minlen *= 2; + if (edge.labelpos.toLowerCase() !== "c") { + if (graph.rankdir === "TB" || graph.rankdir === "BT") { + edge.width += edge.labeloffset; + } else { + edge.height += edge.labeloffset; + } + } + }); + } + function injectEdgeLabelProxies(g2) { + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + if (edge.width && edge.height) { + var v3 = g2.node(e3.v); + var w4 = g2.node(e3.w); + var label = { rank: (w4.rank - v3.rank) / 2 + v3.rank, e: e3 }; + addDummyNode(g2, "edge-proxy", label, "_ep"); + } + }); + } + function assignRankMinMax(g2) { + var maxRank2 = 0; + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + if (node2.borderTop) { + node2.minRank = g2.node(node2.borderTop).rank; + node2.maxRank = g2.node(node2.borderBottom).rank; + maxRank2 = max_default(maxRank2, node2.maxRank); + } + }); + g2.graph().maxRank = maxRank2; + } + function removeEdgeLabelProxies(g2) { + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + if (node2.dummy === "edge-proxy") { + g2.edge(node2.e).labelRank = node2.rank; + g2.removeNode(v3); + } + }); + } + function translateGraph(g2) { + var minX = Number.POSITIVE_INFINITY; + var maxX = 0; + var minY = Number.POSITIVE_INFINITY; + var maxY = 0; + var graphLabel = g2.graph(); + var marginX = graphLabel.marginx || 0; + var marginY = graphLabel.marginy || 0; + function getExtremes(attrs) { + var x5 = attrs.x; + var y6 = attrs.y; + var w4 = attrs.width; + var h3 = attrs.height; + minX = Math.min(minX, x5 - w4 / 2); + maxX = Math.max(maxX, x5 + w4 / 2); + minY = Math.min(minY, y6 - h3 / 2); + maxY = Math.max(maxY, y6 + h3 / 2); + } + __name(getExtremes, "getExtremes"); + forEach_default(g2.nodes(), function(v3) { + getExtremes(g2.node(v3)); + }); + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + if (Object.prototype.hasOwnProperty.call(edge, "x")) { + getExtremes(edge); + } + }); + minX -= marginX; + minY -= marginY; + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + node2.x -= minX; + node2.y -= minY; + }); + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + forEach_default(edge.points, function(p3) { + p3.x -= minX; + p3.y -= minY; + }); + if (Object.prototype.hasOwnProperty.call(edge, "x")) { + edge.x -= minX; + } + if (Object.prototype.hasOwnProperty.call(edge, "y")) { + edge.y -= minY; + } + }); + graphLabel.width = maxX - minX + marginX; + graphLabel.height = maxY - minY + marginY; + } + function assignNodeIntersects(g2) { + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + var nodeV = g2.node(e3.v); + var nodeW = g2.node(e3.w); + var p1, p22; + if (!edge.points) { + edge.points = []; + p1 = nodeW; + p22 = nodeV; + } else { + p1 = edge.points[0]; + p22 = edge.points[edge.points.length - 1]; + } + edge.points.unshift(intersectRect2(nodeV, p1)); + edge.points.push(intersectRect2(nodeW, p22)); + }); + } + function fixupEdgeLabelCoords(g2) { + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + if (Object.prototype.hasOwnProperty.call(edge, "x")) { + if (edge.labelpos === "l" || edge.labelpos === "r") { + edge.width -= edge.labeloffset; + } + switch (edge.labelpos) { + case "l": + edge.x -= edge.width / 2 + edge.labeloffset; + break; + case "r": + edge.x += edge.width / 2 + edge.labeloffset; + break; + } + } + }); + } + function reversePointsForReversedEdges(g2) { + forEach_default(g2.edges(), function(e3) { + var edge = g2.edge(e3); + if (edge.reversed) { + edge.points.reverse(); + } + }); + } + function removeBorderNodes(g2) { + forEach_default(g2.nodes(), function(v3) { + if (g2.children(v3).length) { + var node2 = g2.node(v3); + var t4 = g2.node(node2.borderTop); + var b3 = g2.node(node2.borderBottom); + var l4 = g2.node(last_default(node2.borderLeft)); + var r2 = g2.node(last_default(node2.borderRight)); + node2.width = Math.abs(r2.x - l4.x); + node2.height = Math.abs(b3.y - t4.y); + node2.x = l4.x + node2.width / 2; + node2.y = t4.y + node2.height / 2; + } + }); + forEach_default(g2.nodes(), function(v3) { + if (g2.node(v3).dummy === "border") { + g2.removeNode(v3); + } + }); + } + function removeSelfEdges(g2) { + forEach_default(g2.edges(), function(e3) { + if (e3.v === e3.w) { + var node2 = g2.node(e3.v); + if (!node2.selfEdges) { + node2.selfEdges = []; + } + node2.selfEdges.push({ e: e3, label: g2.edge(e3) }); + g2.removeEdge(e3); + } + }); + } + function insertSelfEdges(g2) { + var layers = buildLayerMatrix(g2); + forEach_default(layers, function(layer) { + var orderShift = 0; + forEach_default(layer, function(v3, i2) { + var node2 = g2.node(v3); + node2.order = i2 + orderShift; + forEach_default(node2.selfEdges, function(selfEdge) { + addDummyNode( + g2, + "selfedge", + { + width: selfEdge.label.width, + height: selfEdge.label.height, + rank: node2.rank, + order: i2 + ++orderShift, + e: selfEdge.e, + label: selfEdge.label + }, + "_se" + ); + }); + delete node2.selfEdges; + }); + }); + } + function positionSelfEdges(g2) { + forEach_default(g2.nodes(), function(v3) { + var node2 = g2.node(v3); + if (node2.dummy === "selfedge") { + var selfNode = g2.node(node2.e.v); + var x5 = selfNode.x + selfNode.width / 2; + var y6 = selfNode.y; + var dx = node2.x - x5; + var dy = selfNode.height / 2; + g2.setEdge(node2.e, node2.label); + g2.removeNode(v3); + node2.label.points = [ + { x: x5 + 2 * dx / 3, y: y6 - dy }, + { x: x5 + 5 * dx / 6, y: y6 - dy }, + { x: x5 + dx, y: y6 }, + { x: x5 + 5 * dx / 6, y: y6 + dy }, + { x: x5 + 2 * dx / 3, y: y6 + dy } + ]; + node2.label.x = node2.x; + node2.label.y = node2.y; + } + }); + } + function selectNumberAttrs(obj, attrs) { + return mapValues_default(pick_default(obj, attrs), Number); + } + function canonicalize(attrs) { + var newAttrs = {}; + forEach_default(attrs, function(v3, k2) { + newAttrs[k2.toLowerCase()] = v3; + }); + return newAttrs; + } + var graphNumAttrs, graphDefaults, graphAttrs, nodeNumAttrs, nodeDefaults, edgeNumAttrs, edgeDefaults, edgeAttrs; + var init_layout = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/layout.js"() { + "use strict"; + init_lodash(); + init_graphlib(); + init_add_border_segments(); + init_coordinate_system(); + init_acyclic(); + init_normalize(); + init_rank(); + init_nesting_graph(); + init_order2(); + init_parent_dummy_chains(); + init_position(); + init_util2(); + __name(layout, "layout"); + __name(runLayout, "runLayout"); + __name(updateInputGraph, "updateInputGraph"); + graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"]; + graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" }; + graphAttrs = ["acyclicer", "ranker", "rankdir", "align"]; + nodeNumAttrs = ["width", "height"]; + nodeDefaults = { width: 0, height: 0 }; + edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"]; + edgeDefaults = { + minlen: 1, + weight: 1, + width: 0, + height: 0, + labeloffset: 10, + labelpos: "r" + }; + edgeAttrs = ["labelpos"]; + __name(buildLayoutGraph, "buildLayoutGraph"); + __name(makeSpaceForEdgeLabels, "makeSpaceForEdgeLabels"); + __name(injectEdgeLabelProxies, "injectEdgeLabelProxies"); + __name(assignRankMinMax, "assignRankMinMax"); + __name(removeEdgeLabelProxies, "removeEdgeLabelProxies"); + __name(translateGraph, "translateGraph"); + __name(assignNodeIntersects, "assignNodeIntersects"); + __name(fixupEdgeLabelCoords, "fixupEdgeLabelCoords"); + __name(reversePointsForReversedEdges, "reversePointsForReversedEdges"); + __name(removeBorderNodes, "removeBorderNodes"); + __name(removeSelfEdges, "removeSelfEdges"); + __name(insertSelfEdges, "insertSelfEdges"); + __name(positionSelfEdges, "positionSelfEdges"); + __name(selectNumberAttrs, "selectNumberAttrs"); + __name(canonicalize, "canonicalize"); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/index.js + var init_dagre = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/dagre/index.js"() { + "use strict"; + init_acyclic(); + init_layout(); + init_normalize(); + init_rank(); + } + }); + + // ../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/json.js + function write(g2) { + var json3 = { + options: { + directed: g2.isDirected(), + multigraph: g2.isMultigraph(), + compound: g2.isCompound() + }, + nodes: writeNodes(g2), + edges: writeEdges(g2) + }; + if (!isUndefined_default(g2.graph())) { + json3.value = clone_default2(g2.graph()); + } + return json3; + } + function writeNodes(g2) { + return map_default(g2.nodes(), function(v3) { + var nodeValue = g2.node(v3); + var parent4 = g2.parent(v3); + var node2 = { v: v3 }; + if (!isUndefined_default(nodeValue)) { + node2.value = nodeValue; + } + if (!isUndefined_default(parent4)) { + node2.parent = parent4; + } + return node2; + }); + } + function writeEdges(g2) { + return map_default(g2.edges(), function(e3) { + var edgeValue = g2.edge(e3); + var edge = { v: e3.v, w: e3.w }; + if (!isUndefined_default(e3.name)) { + edge.name = e3.name; + } + if (!isUndefined_default(edgeValue)) { + edge.value = edgeValue; + } + return edge; + }); + } + var init_json = __esm({ + "../../node_modules/.pnpm/dagre-d3-es@7.0.13/node_modules/dagre-d3-es/src/graphlib/json.js"() { + "use strict"; + init_lodash(); + init_graph(); + __name(write, "write"); + __name(writeNodes, "writeNodes"); + __name(writeEdges, "writeEdges"); + } + }); + + // src/rendering-util/layout-algorithms/dagre/mermaid-graphlib.js + var clusterDb, descendants, parents, clear6, isDescendant2, edgeInCluster, copy2, extractDescendants, findCommonEdges, findNonClusterChild, getAnchorId, adjustClustersAndEdges, extractor, sorter, sortNodesByHierarchy; + var init_mermaid_graphlib = __esm({ + "src/rendering-util/layout-algorithms/dagre/mermaid-graphlib.js"() { + "use strict"; + init_logger(); + init_graphlib(); + init_json(); + clusterDb = /* @__PURE__ */ new Map(); + descendants = /* @__PURE__ */ new Map(); + parents = /* @__PURE__ */ new Map(); + clear6 = /* @__PURE__ */ __name(() => { + descendants.clear(); + parents.clear(); + clusterDb.clear(); + }, "clear"); + isDescendant2 = /* @__PURE__ */ __name((id30, ancestorId) => { + const ancestorDescendants = descendants.get(ancestorId) || []; + log.trace("In isDescendant", ancestorId, " ", id30, " = ", ancestorDescendants.includes(id30)); + return ancestorDescendants.includes(id30); + }, "isDescendant"); + edgeInCluster = /* @__PURE__ */ __name((edge, clusterId) => { + const clusterDescendants = descendants.get(clusterId) || []; + log.info("Descendants of ", clusterId, " is ", clusterDescendants); + log.info("Edge is ", edge); + if (edge.v === clusterId || edge.w === clusterId) { + return false; + } + if (!clusterDescendants) { + log.debug("Tilt, ", clusterId, ",not in descendants"); + return false; + } + return clusterDescendants.includes(edge.v) || isDescendant2(edge.v, clusterId) || isDescendant2(edge.w, clusterId) || clusterDescendants.includes(edge.w); + }, "edgeInCluster"); + copy2 = /* @__PURE__ */ __name((clusterId, graph, newGraph, rootId) => { + log.warn( + "Copying children of ", + clusterId, + "root", + rootId, + "data", + graph.node(clusterId), + rootId + ); + const nodes5 = graph.children(clusterId) || []; + if (clusterId !== rootId) { + nodes5.push(clusterId); + } + log.warn("Copying (nodes) clusterId", clusterId, "nodes", nodes5); + nodes5.forEach((node2) => { + if (graph.children(node2).length > 0) { + copy2(node2, graph, newGraph, rootId); + } else { + const data5 = graph.node(node2); + log.info("cp ", node2, " to ", rootId, " with parent ", clusterId); + newGraph.setNode(node2, data5); + if (rootId !== graph.parent(node2)) { + log.warn("Setting parent", node2, graph.parent(node2)); + newGraph.setParent(node2, graph.parent(node2)); + } + if (clusterId !== rootId && node2 !== clusterId) { + log.debug("Setting parent", node2, clusterId); + newGraph.setParent(node2, clusterId); + } else { + log.info("In copy ", clusterId, "root", rootId, "data", graph.node(clusterId), rootId); + log.debug( + "Not Setting parent for node=", + node2, + "cluster!==rootId", + clusterId !== rootId, + "node!==clusterId", + node2 !== clusterId + ); + } + const edges3 = graph.edges(node2); + log.debug("Copying Edges", edges3); + edges3.forEach((edge) => { + log.info("Edge", edge); + const data6 = graph.edge(edge.v, edge.w, edge.name); + log.info("Edge data", data6, rootId); + try { + if (edgeInCluster(edge, rootId)) { + log.info("Copying as ", edge.v, edge.w, data6, edge.name); + newGraph.setEdge(edge.v, edge.w, data6, edge.name); + log.info("newGraph edges ", newGraph.edges(), newGraph.edge(newGraph.edges()[0])); + } else { + log.info( + "Skipping copy of edge ", + edge.v, + "-->", + edge.w, + " rootId: ", + rootId, + " clusterId:", + clusterId + ); + } + } catch (e3) { + log.error(e3); + } + }); + } + log.debug("Removing node", node2); + graph.removeNode(node2); + }); + }, "copy"); + extractDescendants = /* @__PURE__ */ __name((id30, graph) => { + const children2 = graph.children(id30); + let res = [...children2]; + for (const child of children2) { + parents.set(child, id30); + res = [...res, ...extractDescendants(child, graph)]; + } + return res; + }, "extractDescendants"); + findCommonEdges = /* @__PURE__ */ __name((graph, id1, id210) => { + const edges1 = graph.edges().filter((edge) => edge.v === id1 || edge.w === id1); + const edges22 = graph.edges().filter((edge) => edge.v === id210 || edge.w === id210); + const edges1Prim = edges1.map((edge) => { + return { v: edge.v === id1 ? id210 : edge.v, w: edge.w === id1 ? id1 : edge.w }; + }); + const edges2Prim = edges22.map((edge) => { + return { v: edge.v, w: edge.w }; + }); + const result = edges1Prim.filter((edgeIn1) => { + return edges2Prim.some((edge) => edgeIn1.v === edge.v && edgeIn1.w === edge.w); + }); + return result; + }, "findCommonEdges"); + findNonClusterChild = /* @__PURE__ */ __name((id30, graph, clusterId) => { + const children2 = graph.children(id30); + log.trace("Searching children of id ", id30, children2); + if (children2.length < 1) { + return id30; + } + let reserve; + for (const child of children2) { + const _id = findNonClusterChild(child, graph, clusterId); + const commonEdges = findCommonEdges(graph, clusterId, _id); + if (_id) { + if (commonEdges.length > 0) { + reserve = _id; + } else { + return _id; + } + } + } + return reserve; + }, "findNonClusterChild"); + getAnchorId = /* @__PURE__ */ __name((id30) => { + if (!clusterDb.has(id30)) { + return id30; + } + if (!clusterDb.get(id30).externalConnections) { + return id30; + } + if (clusterDb.has(id30)) { + return clusterDb.get(id30).id; + } + return id30; + }, "getAnchorId"); + adjustClustersAndEdges = /* @__PURE__ */ __name((graph, depth) => { + if (!graph || depth > 10) { + log.debug("Opting out, no graph "); + return; + } else { + log.debug("Opting in, graph "); + } + graph.nodes().forEach(function(id30) { + const children2 = graph.children(id30); + if (children2.length > 0) { + log.warn( + "Cluster identified", + id30, + " Replacement id in edges: ", + findNonClusterChild(id30, graph, id30) + ); + descendants.set(id30, extractDescendants(id30, graph)); + clusterDb.set(id30, { id: findNonClusterChild(id30, graph, id30), clusterData: graph.node(id30) }); + } + }); + graph.nodes().forEach(function(id30) { + const children2 = graph.children(id30); + const edges3 = graph.edges(); + if (children2.length > 0) { + log.debug("Cluster identified", id30, descendants); + edges3.forEach((edge) => { + const d1 = isDescendant2(edge.v, id30); + const d22 = isDescendant2(edge.w, id30); + if (d1 ^ d22) { + log.warn("Edge: ", edge, " leaves cluster ", id30); + log.warn("Descendants of XXX ", id30, ": ", descendants.get(id30)); + clusterDb.get(id30).externalConnections = true; + } + }); + } else { + log.debug("Not a cluster ", id30, descendants); + } + }); + for (let id30 of clusterDb.keys()) { + const nonClusterChild = clusterDb.get(id30).id; + const parent4 = graph.parent(nonClusterChild); + if (parent4 !== id30 && clusterDb.has(parent4) && !clusterDb.get(parent4).externalConnections) { + clusterDb.get(id30).id = parent4; + } + } + graph.edges().forEach(function(e3) { + const edge = graph.edge(e3); + log.warn("Edge " + e3.v + " -> " + e3.w + ": " + JSON.stringify(e3)); + log.warn("Edge " + e3.v + " -> " + e3.w + ": " + JSON.stringify(graph.edge(e3))); + let v3 = e3.v; + let w4 = e3.w; + log.warn( + "Fix XXX", + clusterDb, + "ids:", + e3.v, + e3.w, + "Translating: ", + clusterDb.get(e3.v), + " --- ", + clusterDb.get(e3.w) + ); + if (clusterDb.get(e3.v) || clusterDb.get(e3.w)) { + log.warn("Fixing and trying - removing XXX", e3.v, e3.w, e3.name); + v3 = getAnchorId(e3.v); + w4 = getAnchorId(e3.w); + graph.removeEdge(e3.v, e3.w, e3.name); + if (v3 !== e3.v) { + const parent4 = graph.parent(v3); + clusterDb.get(parent4).externalConnections = true; + edge.fromCluster = e3.v; + } + if (w4 !== e3.w) { + const parent4 = graph.parent(w4); + clusterDb.get(parent4).externalConnections = true; + edge.toCluster = e3.w; + } + log.warn("Fix Replacing with XXX", v3, w4, e3.name); + graph.setEdge(v3, w4, edge, e3.name); + } + }); + log.warn("Adjusted Graph", write(graph)); + extractor(graph, 0); + log.trace(clusterDb); + }, "adjustClustersAndEdges"); + extractor = /* @__PURE__ */ __name((graph, depth) => { + log.warn("extractor - ", depth, write(graph), graph.children("D")); + if (depth > 10) { + log.error("Bailing out"); + return; + } + let nodes5 = graph.nodes(); + let hasChildren = false; + for (const node2 of nodes5) { + const children2 = graph.children(node2); + hasChildren = hasChildren || children2.length > 0; + } + if (!hasChildren) { + log.debug("Done, no node has children", graph.nodes()); + return; + } + log.debug("Nodes = ", nodes5, depth); + for (const node2 of nodes5) { + log.debug( + "Extracting node", + node2, + clusterDb, + clusterDb.has(node2) && !clusterDb.get(node2).externalConnections, + !graph.parent(node2), + graph.node(node2), + graph.children("D"), + " Depth ", + depth + ); + if (!clusterDb.has(node2)) { + log.debug("Not a cluster", node2, depth); + } else if (!clusterDb.get(node2).externalConnections && graph.children(node2) && graph.children(node2).length > 0) { + log.warn( + "Cluster without external connections, without a parent and with children", + node2, + depth + ); + const graphSettings = graph.graph(); + let dir2 = graphSettings.rankdir === "TB" ? "LR" : "TB"; + if (clusterDb.get(node2)?.clusterData?.dir) { + dir2 = clusterDb.get(node2).clusterData.dir; + log.warn("Fixing dir", clusterDb.get(node2).clusterData.dir, dir2); + } + const clusterGraph = new Graph({ + multigraph: true, + compound: true + }).setGraph({ + rankdir: dir2, + nodesep: 50, + ranksep: 50, + marginx: 8, + marginy: 8 + }).setDefaultEdgeLabel(function() { + return {}; + }); + log.warn("Old graph before copy", write(graph)); + copy2(node2, graph, clusterGraph, node2); + graph.setNode(node2, { + clusterNode: true, + id: node2, + clusterData: clusterDb.get(node2).clusterData, + label: clusterDb.get(node2).label, + graph: clusterGraph + }); + log.warn("New graph after copy node: (", node2, ")", write(clusterGraph)); + log.debug("Old graph after copy", write(graph)); + } else { + log.warn( + "Cluster ** ", + node2, + " **not meeting the criteria !externalConnections:", + !clusterDb.get(node2).externalConnections, + " no parent: ", + !graph.parent(node2), + " children ", + graph.children(node2) && graph.children(node2).length > 0, + graph.children("D"), + depth + ); + log.debug(clusterDb); + } + } + nodes5 = graph.nodes(); + log.warn("New list of nodes", nodes5); + for (const node2 of nodes5) { + const data5 = graph.node(node2); + log.warn(" Now next level", node2, data5); + if (data5?.clusterNode) { + extractor(data5.graph, depth + 1); + } + } + }, "extractor"); + sorter = /* @__PURE__ */ __name((graph, nodes5) => { + if (nodes5.length === 0) { + return []; + } + let result = Object.assign([], nodes5); + nodes5.forEach((node2) => { + const children2 = graph.children(node2); + const sorted = sorter(graph, children2); + result = [...result, ...sorted]; + }); + return result; + }, "sorter"); + sortNodesByHierarchy = /* @__PURE__ */ __name((graph) => sorter(graph, graph.children()), "sortNodesByHierarchy"); + } + }); + + // src/rendering-util/layout-algorithms/dagre/index.js + var dagre_exports = {}; + __export(dagre_exports, { + render: () => render3 + }); + var recursiveRender, render3; + var init_dagre2 = __esm({ + "src/rendering-util/layout-algorithms/dagre/index.js"() { + "use strict"; + init_dagre(); + init_json(); + init_graphlib(); + init_markers(); + init_util(); + init_mermaid_graphlib(); + init_nodes2(); + init_clusters(); + init_edges(); + init_logger(); + init_subGraphTitleMargins(); + init_diagramAPI(); + recursiveRender = /* @__PURE__ */ __name(async (_elem, graph, diagramType, id30, parentCluster, siteConfig2) => { + log.warn("Graph in recursive render:XAX", write(graph), parentCluster); + const dir2 = graph.graph().rankdir; + log.trace("Dir in recursive render - dir:", dir2); + const elem = _elem.insert("g").attr("class", "root"); + if (!graph.nodes()) { + log.info("No nodes found for", graph); + } else { + log.info("Recursive render XXX", graph.nodes()); + } + if (graph.edges().length > 0) { + log.info("Recursive edges", graph.edge(graph.edges()[0])); + } + const clusters = elem.insert("g").attr("class", "clusters"); + const edgePaths = elem.insert("g").attr("class", "edgePaths"); + const edgeLabels3 = elem.insert("g").attr("class", "edgeLabels"); + const nodes5 = elem.insert("g").attr("class", "nodes"); + await Promise.all( + graph.nodes().map(async function(v3) { + const node2 = graph.node(v3); + if (parentCluster !== void 0) { + const data5 = JSON.parse(JSON.stringify(parentCluster.clusterData)); + log.trace( + "Setting data for parent cluster XXX\n Node.id = ", + v3, + "\n data=", + data5.height, + "\nParent cluster", + parentCluster.height + ); + graph.setNode(parentCluster.id, data5); + if (!graph.parent(v3)) { + log.trace("Setting parent", v3, parentCluster.id); + graph.setParent(v3, parentCluster.id, data5); + } + } + log.info("(Insert) Node XXX" + v3 + ": " + JSON.stringify(graph.node(v3))); + if (node2?.clusterNode) { + log.info("Cluster identified XBX", v3, node2.width, graph.node(v3)); + const { ranksep, nodesep } = graph.graph(); + node2.graph.setGraph({ + ...node2.graph.graph(), + ranksep: ranksep + 25, + nodesep + }); + const o2 = await recursiveRender( + nodes5, + node2.graph, + diagramType, + id30, + graph.node(v3), + siteConfig2 + ); + const newEl = o2.elem; + updateNodeBounds(node2, newEl); + node2.diff = o2.diff || 0; + log.info( + "New compound node after recursive render XAX", + v3, + "width", + // node, + node2.width, + "height", + node2.height + // node.x, + // node.y + ); + setNodeElem(newEl, node2); + } else { + if (graph.children(v3).length > 0) { + log.trace( + "Cluster - the non recursive path XBX", + v3, + node2.id, + node2, + node2.width, + "Graph:", + graph + ); + log.trace(findNonClusterChild(node2.id, graph)); + clusterDb.set(node2.id, { id: findNonClusterChild(node2.id, graph), node: node2 }); + } else { + log.trace("Node - the non recursive path XAX", v3, nodes5, graph.node(v3), dir2); + await insertNode(nodes5, graph.node(v3), { config: siteConfig2, dir: dir2 }); + } + } + }) + ); + const processEdges = /* @__PURE__ */ __name(async () => { + const edgePromises = graph.edges().map(async function(e3) { + const edge = graph.edge(e3.v, e3.w, e3.name); + log.info("Edge " + e3.v + " -> " + e3.w + ": " + JSON.stringify(e3)); + log.info("Edge " + e3.v + " -> " + e3.w + ": ", e3, " ", JSON.stringify(graph.edge(e3))); + log.info( + "Fix", + clusterDb, + "ids:", + e3.v, + e3.w, + "Translating: ", + clusterDb.get(e3.v), + clusterDb.get(e3.w) + ); + await insertEdgeLabel(edgeLabels3, edge); + }); + await Promise.all(edgePromises); + }, "processEdges"); + await processEdges(); + log.info("Graph before layout:", JSON.stringify(write(graph))); + log.info("############################################# XXX"); + log.info("### Layout ### XXX"); + log.info("############################################# XXX"); + layout(graph); + log.info("Graph after layout:", JSON.stringify(write(graph))); + let diff2 = 0; + let { subGraphTitleTotalMargin } = getSubGraphTitleMargins(siteConfig2); + await Promise.all( + sortNodesByHierarchy(graph).map(async function(v3) { + const node2 = graph.node(v3); + log.info( + "Position XBX => " + v3 + ": (" + node2.x, + "," + node2.y, + ") width: ", + node2.width, + " height: ", + node2.height + ); + if (node2?.clusterNode) { + node2.y += subGraphTitleTotalMargin; + log.info( + "A tainted cluster node XBX1", + v3, + node2.id, + node2.width, + node2.height, + node2.x, + node2.y, + graph.parent(v3) + ); + clusterDb.get(node2.id).node = node2; + positionNode(node2); + } else { + if (graph.children(v3).length > 0) { + log.info( + "A pure cluster node XBX1", + v3, + node2.id, + node2.x, + node2.y, + node2.width, + node2.height, + graph.parent(v3) + ); + node2.height += subGraphTitleTotalMargin; + graph.node(node2.parentId); + const halfPadding = node2?.padding / 2 || 0; + const labelHeight = node2?.labelBBox?.height || 0; + const offsetY = labelHeight - halfPadding || 0; + log.debug("OffsetY", offsetY, "labelHeight", labelHeight, "halfPadding", halfPadding); + await insertCluster(clusters, node2); + clusterDb.get(node2.id).node = node2; + } else { + const parent4 = graph.node(node2.parentId); + node2.y += subGraphTitleTotalMargin / 2; + log.info( + "A regular node XBX1 - using the padding", + node2.id, + "parent", + node2.parentId, + node2.width, + node2.height, + node2.x, + node2.y, + "offsetY", + node2.offsetY, + "parent", + parent4, + parent4?.offsetY, + node2 + ); + positionNode(node2); + } + } + }) + ); + graph.edges().forEach(function(e3) { + const edge = graph.edge(e3); + log.info("Edge " + e3.v + " -> " + e3.w + ": " + JSON.stringify(edge), edge); + edge.points.forEach((point8) => point8.y += subGraphTitleTotalMargin / 2); + const startNode = graph.node(e3.v); + var endNode = graph.node(e3.w); + const paths = insertEdge(edgePaths, edge, clusterDb, diagramType, startNode, endNode, id30); + positionEdgeLabel(edge, paths); + }); + graph.nodes().forEach(function(v3) { + const n2 = graph.node(v3); + log.info(v3, n2.type, n2.diff); + if (n2.isGroup) { + diff2 = n2.diff; + } + }); + log.warn("Returning from recursive render XAX", elem, diff2); + return { elem, diff: diff2 }; + }, "recursiveRender"); + render3 = /* @__PURE__ */ __name(async (data4Layout, svg2) => { + const graph = new Graph({ + multigraph: true, + compound: true + }).setGraph({ + rankdir: data4Layout.direction, + nodesep: data4Layout.config?.nodeSpacing || data4Layout.config?.flowchart?.nodeSpacing || data4Layout.nodeSpacing, + ranksep: data4Layout.config?.rankSpacing || data4Layout.config?.flowchart?.rankSpacing || data4Layout.rankSpacing, + marginx: 8, + marginy: 8 + }).setDefaultEdgeLabel(function() { + return {}; + }); + const element3 = svg2.select("g"); + markers_default(element3, data4Layout.markers, data4Layout.type, data4Layout.diagramId); + clear5(); + clear4(); + clear3(); + clear6(); + data4Layout.nodes.forEach((node2) => { + graph.setNode(node2.id, { ...node2 }); + if (node2.parentId) { + graph.setParent(node2.id, node2.parentId); + } + }); + log.debug("Edges:", data4Layout.edges); + data4Layout.edges.forEach((edge) => { + if (edge.start === edge.end) { + const nodeId = edge.start; + const specialId1 = nodeId + "---" + nodeId + "---1"; + const specialId2 = nodeId + "---" + nodeId + "---2"; + const node2 = graph.node(nodeId); + graph.setNode(specialId1, { + domId: specialId1, + id: specialId1, + parentId: node2.parentId, + labelStyle: "", + label: "", + padding: 0, + shape: "labelRect", + // shape: 'rect', + style: "", + width: 10, + height: 10 + }); + graph.setParent(specialId1, node2.parentId); + graph.setNode(specialId2, { + domId: specialId2, + id: specialId2, + parentId: node2.parentId, + labelStyle: "", + padding: 0, + // shape: 'rect', + shape: "labelRect", + label: "", + style: "", + width: 10, + height: 10 + }); + graph.setParent(specialId2, node2.parentId); + const edge1 = structuredClone(edge); + const edgeMid = structuredClone(edge); + const edge2 = structuredClone(edge); + edge1.label = ""; + edge1.arrowTypeEnd = "none"; + edge1.id = nodeId + "-cyclic-special-1"; + edgeMid.arrowTypeStart = "none"; + edgeMid.arrowTypeEnd = "none"; + edgeMid.id = nodeId + "-cyclic-special-mid"; + edge2.label = ""; + if (node2.isGroup) { + edge1.fromCluster = nodeId; + edge2.toCluster = nodeId; + } + edge2.id = nodeId + "-cyclic-special-2"; + edge2.arrowTypeStart = "none"; + graph.setEdge(nodeId, specialId1, edge1, nodeId + "-cyclic-special-0"); + graph.setEdge(specialId1, specialId2, edgeMid, nodeId + "-cyclic-special-1"); + graph.setEdge(specialId2, nodeId, edge2, nodeId + "-cyc
"); + return 40; + break; + case 11: + return 40; + break; + case 12: + this.popState(); + break; + case 13: + this.begin("callbackname"); + break; + case 14: + this.popState(); + break; + case 15: + this.popState(); + this.begin("callbackargs"); + break; + case 16: + return 95; + break; + case 17: + this.popState(); + break; + case 18: + return 96; + break; + case 19: + return "MD_STR"; + break; + case 20: + this.popState(); + break; + case 21: + this.begin("md_string"); + break; + case 22: + return "STR"; + break; + case 23: + this.popState(); + break; + case 24: + this.pushState("string"); + break; + case 25: + return 84; + break; + case 26: + return 102; + break; + case 27: + return 85; + break; + case 28: + return 104; + break; + case 29: + return 86; + break; + case 30: + return 87; + break; + case 31: + return 97; + break; + case 32: + this.begin("click"); + break; + case 33: + this.popState(); + break; + case 34: + return 88; + break; + case 35: + if (yy.lex.firstGraph()) { + this.begin("dir"); + } + return 12; + break; + case 36: + if (yy.lex.firstGraph()) { + this.begin("dir"); + } + return 12; + break; + case 37: + if (yy.lex.firstGraph()) { + this.begin("dir"); + } + return 12; + break; + case 38: + return 27; + break; + case 39: + return 32; + break; + case 40: + return 98; + break; + case 41: + return 98; + break; + case 42: + return 98; + break; + case 43: + return 98; + break; + case 44: + this.popState(); + return 13; + break; + case 45: + this.popState(); + return 14; + break; + case 46: + this.popState(); + return 14; + break; + case 47: + this.popState(); + return 14; + break; + case 48: + this.popState(); + return 14; + break; + case 49: + this.popState(); + return 14; + break; + case 50: + this.popState(); + return 14; + break; + case 51: + this.popState(); + return 14; + break; + case 52: + this.popState(); + return 14; + break; + case 53: + this.popState(); + return 14; + break; + case 54: + this.popState(); + return 14; + break; + case 55: + return 121; + break; + case 56: + return 122; + break; + case 57: + return 123; + break; + case 58: + return 124; + break; + case 59: + return 78; + break; + case 60: + return 105; + break; + case 61: + return 111; + break; + case 62: + return 46; + break; + case 63: + return 60; + break; + case 64: + return 44; + break; + case 65: + return 8; + break; + case 66: + return 106; + break; + case 67: + return 115; + break; + case 68: + this.popState(); + return 77; + break; + case 69: + this.pushState("edgeText"); + return 75; + break; + case 70: + return 119; + break; + case 71: + this.popState(); + return 77; + break; + case 72: + this.pushState("thickEdgeText"); + return 75; + break; + case 73: + return 119; + break; + case 74: + this.popState(); + return 77; + break; + case 75: + this.pushState("dottedEdgeText"); + return 75; + break; + case 76: + return 119; + break; + case 77: + return 77; + break; + case 78: + this.popState(); + return 53; + break; + case 79: + return "TEXT"; + break; + case 80: + this.pushState("ellipseText"); + return 52; + break; + case 81: + this.popState(); + return 55; + break; + case 82: + this.pushState("text"); + return 54; + break; + case 83: + this.popState(); + return 57; + break; + case 84: + this.pushState("text"); + return 56; + break; + case 85: + return 58; + break; + case 86: + this.pushState("text"); + return 67; + break; + case 87: + this.popState(); + return 64; + break; + case 88: + this.pushState("text"); + return 63; + break; + case 89: + this.popState(); + return 49; + break; + case 90: + this.pushState("text"); + return 48; + break; + case 91: + this.popState(); + return 69; + break; + case 92: + this.popState(); + return 71; + break; + case 93: + return 117; + break; + case 94: + this.pushState("trapText"); + return 68; + break; + case 95: + this.pushState("trapText"); + return 70; + break; + case 96: + return 118; + break; + case 97: + return 67; + break; + case 98: + return 90; + break; + case 99: + return "SEP"; + break; + case 100: + return 89; + break; + case 101: + return 115; + break; + case 102: + return 111; + break; + case 103: + return 44; + break; + case 104: + return 109; + break; + case 105: + return 114; + break; + case 106: + return 116; + break; + case 107: + this.popState(); + return 62; + break; + case 108: + this.pushState("text"); + return 62; + break; + case 109: + this.popState(); + return 51; + break; + case 110: + this.pushState("text"); + return 50; + break; + case 111: + this.popState(); + return 31; + break; + case 112: + this.pushState("text"); + return 29; + break; + case 113: + this.popState(); + return 66; + break; + case 114: + this.pushState("text"); + return 65; + break; + case 115: + return "TEXT"; + break; + case 116: + return "QUOTE"; + break; + case 117: + return 9; + break; + case 118: + return 10; + break; + case 119: + return 11; + break; + } + }, "anonymous"), + rules: [/^(?:accTitle\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*\{\s*)/, /^(?:[\}])/, /^(?:[^\}]*)/, /^(?:@\{)/, /^(?:["])/, /^(?:["])/, /^(?:[^\"]+)/, /^(?:[^}^"]+)/, /^(?:\})/, /^(?:call[\s]+)/, /^(?:\([\s]*\))/, /^(?:\()/, /^(?:[^(]*)/, /^(?:\))/, /^(?:[^)]*)/, /^(?:[^`"]+)/, /^(?:[`]["])/, /^(?:["][`])/, /^(?:[^"]+)/, /^(?:["])/, /^(?:["])/, /^(?:style\b)/, /^(?:default\b)/, /^(?:linkStyle\b)/, /^(?:interpolate\b)/, /^(?:classDef\b)/, /^(?:class\b)/, /^(?:href[\s])/, /^(?:click[\s]+)/, /^(?:[\s\n])/, /^(?:[^\s\n]*)/, /^(?:flowchart-elk\b)/, /^(?:graph\b)/, /^(?:flowchart\b)/, /^(?:subgraph\b)/, /^(?:end\b\s*)/, /^(?:_self\b)/, /^(?:_blank\b)/, /^(?:_parent\b)/, /^(?:_top\b)/, /^(?:(\r?\n)*\s*\n)/, /^(?:\s*LR\b)/, /^(?:\s*RL\b)/, /^(?:\s*TB\b)/, /^(?:\s*BT\b)/, /^(?:\s*TD\b)/, /^(?:\s*BR\b)/, /^(?:\s*<)/, /^(?:\s*>)/, /^(?:\s*\^)/, /^(?:\s*v\b)/, /^(?:.*direction\s+TB[^\n]*)/, /^(?:.*direction\s+BT[^\n]*)/, /^(?:.*direction\s+RL[^\n]*)/, /^(?:.*direction\s+LR[^\n]*)/, /^(?:[^\s\"]+@(?=[^\{\"]))/, /^(?:[0-9]+)/, /^(?:#)/, /^(?::::)/, /^(?::)/, /^(?:&)/, /^(?:;)/, /^(?:,)/, /^(?:\*)/, /^(?:\s*[xo<]?--+[-xo>]\s*)/, /^(?:\s*[xo<]?--\s*)/, /^(?:[^-]|-(?!-)+)/, /^(?:\s*[xo<]?==+[=xo>]\s*)/, /^(?:\s*[xo<]?==\s*)/, /^(?:[^=]|=(?!))/, /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/, /^(?:\s*[xo<]?-\.\s*)/, /^(?:[^\.]|\.(?!))/, /^(?:\s*~~[\~]+\s*)/, /^(?:[-/\)][\)])/, /^(?:[^\(\)\[\]\{\}]|!\)+)/, /^(?:\(-)/, /^(?:\]\))/, /^(?:\(\[)/, /^(?:\]\])/, /^(?:\[\[)/, /^(?:\[\|)/, /^(?:>)/, /^(?:\)\])/, /^(?:\[\()/, /^(?:\)\)\))/, /^(?:\(\(\()/, /^(?:[\\(?=\])][\]])/, /^(?:\/(?=\])\])/, /^(?:\/(?!\])|\\(?!\])|[^\\\[\]\(\)\{\}\/]+)/, /^(?:\[\/)/, /^(?:\[\\)/, /^(?:<)/, /^(?:>)/, /^(?:\^)/, /^(?:\\\|)/, /^(?:v\b)/, /^(?:\*)/, /^(?:#)/, /^(?:&)/, /^(?:([A-Za-z0-9!"\#$%&'*+\.`?\\_\/]|-(?=[^\>\-\.])|(?!))+)/, /^(?:-)/, /^(?:[\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6]|[\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377]|[\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5]|[\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA]|[\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE]|[\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA]|[\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0]|[\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977]|[\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2]|[\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A]|[\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39]|[\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8]|[\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C]|[\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C]|[\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99]|[\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0]|[\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D]|[\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3]|[\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10]|[\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1]|[\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81]|[\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3]|[\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6]|[\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A]|[\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081]|[\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D]|[\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0]|[\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310]|[\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C]|[\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711]|[\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7]|[\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C]|[\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16]|[\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF]|[\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC]|[\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D]|[\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D]|[\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3]|[\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F]|[\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128]|[\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184]|[\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3]|[\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6]|[\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE]|[\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C]|[\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D]|[\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC]|[\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B]|[\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788]|[\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805]|[\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB]|[\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28]|[\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5]|[\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4]|[\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E]|[\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D]|[\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36]|[\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D]|[\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC]|[\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF]|[\uFFD2-\uFFD7\uFFDA-\uFFDC])/, /^(?:\|)/, /^(?:\|)/, /^(?:\))/, /^(?:\()/, /^(?:\])/, /^(?:\[)/, /^(?:(\}))/, /^(?:\{)/, /^(?:[^\[\]\(\)\{\}\|\"]+)/, /^(?:")/, /^(?:(\r?\n)+)/, /^(?:\s)/, /^(?:$)/], + conditions: { "shapeDataEndBracket": { "rules": [21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "shapeDataStr": { "rules": [9, 10, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "shapeData": { "rules": [8, 11, 12, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "callbackargs": { "rules": [17, 18, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "callbackname": { "rules": [14, 15, 16, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "href": { "rules": [21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "click": { "rules": [21, 24, 33, 34, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "dottedEdgeText": { "rules": [21, 24, 74, 76, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "thickEdgeText": { "rules": [21, 24, 71, 73, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "edgeText": { "rules": [21, 24, 68, 70, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "trapText": { "rules": [21, 24, 77, 80, 82, 84, 88, 90, 91, 92, 93, 94, 95, 108, 110, 112, 114], "inclusive": false }, "ellipseText": { "rules": [21, 24, 77, 78, 79, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "text": { "rules": [21, 24, 77, 80, 81, 82, 83, 84, 87, 88, 89, 90, 94, 95, 107, 108, 109, 110, 111, 112, 113, 114, 115], "inclusive": false }, "vertex": { "rules": [21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "dir": { "rules": [21, 24, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "acc_descr_multiline": { "rules": [5, 6, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "acc_descr": { "rules": [3, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "acc_title": { "rules": [1, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "md_string": { "rules": [19, 20, 21, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "string": { "rules": [21, 22, 23, 24, 77, 80, 82, 84, 88, 90, 94, 95, 108, 110, 112, 114], "inclusive": false }, "INITIAL": { "rules": [0, 2, 4, 7, 13, 21, 24, 25, 26, 27, 28, 29, 30, 31, 32, 35, 36, 37, 38, 39, 40, 41, 42, 43, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 71, 72, 74, 75, 77, 80, 82, 84, 85, 86, 88, 90, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 108, 110, 112, 114, 116, 117, 118, 119], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser2.parser = parser2; + flow_default = parser2; + } + }); + + // src/diagrams/flowchart/parser/flowParser.ts + var newParser, flowParser_default; + var init_flowParser = __esm({ + "src/diagrams/flowchart/parser/flowParser.ts"() { + "use strict"; + init_flow(); + newParser = Object.assign({}, flow_default); + newParser.parse = (src) => { + const newSrc = src.replace(/}\s*\n/g, "}\n"); + return flow_default.parse(newSrc); + }; + flowParser_default = newParser; + } + }); + + // src/diagrams/globalStyles.ts + var getIconStyles; + var init_globalStyles = __esm({ + "src/diagrams/globalStyles.ts"() { + "use strict"; + getIconStyles = /* @__PURE__ */ __name(() => ` + /* Font Awesome icon styling - consolidated */ + .label-icon { + display: inline-block; + height: 1em; + overflow: visible; + vertical-align: -0.125em; + } + + .node .label-icon path { + fill: currentColor; + stroke: revert; + stroke-width: revert; + } +`, "getIconStyles"); + } + }); + + // src/diagrams/flowchart/styles.ts + var fade, getStyles3, styles_default3; + var init_styles3 = __esm({ + "src/diagrams/flowchart/styles.ts"() { + "use strict"; + init_dist(); + init_globalStyles(); + fade = /* @__PURE__ */ __name((color2, opacity) => { + const channel2 = channel_default2; + const r2 = channel2(color2, "r"); + const g2 = channel2(color2, "g"); + const b3 = channel2(color2, "b"); + return rgba_default(r2, g2, b3, opacity); + }, "fade"); + getStyles3 = /* @__PURE__ */ __name((options2) => `.label { + font-family: ${options2.fontFamily}; + color: ${options2.nodeTextColor || options2.textColor}; + } + .cluster-label text { + fill: ${options2.titleColor}; + } + .cluster-label span { + color: ${options2.titleColor}; + } + .cluster-label span p { + background-color: transparent; + } + + .label text,span { + fill: ${options2.nodeTextColor || options2.textColor}; + color: ${options2.nodeTextColor || options2.textColor}; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${options2.mainBkg}; + stroke: ${options2.nodeBorder}; + stroke-width: 1px; + } + .rough-node .label text , .node .label text, .image-shape .label, .icon-shape .label { + text-anchor: middle; + } + // .flowchart-label .text-outer-tspan { + // text-anchor: middle; + // } + // .flowchart-label .text-inner-tspan { + // text-anchor: start; + // } + + .node .katex path { + fill: #000; + stroke: #000; + stroke-width: 1px; + } + + .rough-node .label,.node .label, .image-shape .label, .icon-shape .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + + .root .anchor path { + fill: ${options2.lineColor} !important; + stroke-width: 0; + stroke: ${options2.lineColor}; + } + + .arrowheadPath { + fill: ${options2.arrowheadColor}; + } + + .edgePath .path { + stroke: ${options2.lineColor}; + stroke-width: 2.0px; + } + + .flowchart-link { + stroke: ${options2.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${options2.edgeLabelBackground}; + p { + background-color: ${options2.edgeLabelBackground}; + } + rect { + opacity: 0.5; + background-color: ${options2.edgeLabelBackground}; + fill: ${options2.edgeLabelBackground}; + } + text-align: center; + } + + /* For html labels only */ + .labelBkg { + background-color: ${fade(options2.edgeLabelBackground, 0.5)}; + // background-color: + } + + .cluster rect { + fill: ${options2.clusterBkg}; + stroke: ${options2.clusterBorder}; + stroke-width: 1px; + } + + .cluster text { + fill: ${options2.titleColor}; + } + + .cluster span { + color: ${options2.titleColor}; + } + /* .cluster div { + color: ${options2.titleColor}; + } */ + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${options2.fontFamily}; + font-size: 12px; + background: ${options2.tertiaryColor}; + border: 1px solid ${options2.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .flowchartTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${options2.textColor}; + } + + rect.text { + fill: none; + stroke-width: 0; + } + + .icon-shape, .image-shape { + background-color: ${options2.edgeLabelBackground}; + p { + background-color: ${options2.edgeLabelBackground}; + padding: 2px; + } + rect { + opacity: 0.5; + background-color: ${options2.edgeLabelBackground}; + fill: ${options2.edgeLabelBackground}; + } + text-align: center; + } + ${getIconStyles()} +`, "getStyles"); + styles_default3 = getStyles3; + } + }); + + // src/diagrams/flowchart/flowDiagram.ts + var flowDiagram_exports = {}; + __export(flowDiagram_exports, { + diagram: () => diagram2 + }); + var diagram2; + var init_flowDiagram = __esm({ + "src/diagrams/flowchart/flowDiagram.ts"() { + "use strict"; + init_diagramAPI(); + init_flowDb(); + init_flowRenderer_v3_unified(); + init_flowParser(); + init_styles3(); + diagram2 = { + parser: flowParser_default, + get db() { + return new FlowDB(); + }, + renderer: flowRenderer_v3_unified_default, + styles: styles_default3, + init: /* @__PURE__ */ __name((cnf) => { + if (!cnf.flowchart) { + cnf.flowchart = {}; + } + if (cnf.layout) { + setConfig2({ layout: cnf.layout }); + } + cnf.flowchart.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute; + setConfig2({ flowchart: { arrowMarkerAbsolute: cnf.arrowMarkerAbsolute } }); + }, "init") + }; + } + }); + + // src/diagrams/er/parser/erDiagram.jison + var parser3, erDiagram_default; + var init_erDiagram = __esm({ + "src/diagrams/er/parser/erDiagram.jison"() { + "use strict"; + parser3 = (function() { + var o2 = /* @__PURE__ */ __name(function(k2, v3, o3, l4) { + for (o3 = o3 || {}, l4 = k2.length; l4--; o3[k2[l4]] = v3) ; + return o3; + }, "o"), $V0 = [6, 8, 10, 22, 24, 26, 28, 33, 34, 35, 36, 37, 40, 43, 44, 50], $V1 = [1, 10], $V2 = [1, 11], $V3 = [1, 12], $V4 = [1, 13], $V5 = [1, 20], $V6 = [1, 21], $V7 = [1, 22], $V8 = [1, 23], $V9 = [1, 24], $Va = [1, 19], $Vb = [1, 25], $Vc = [1, 26], $Vd = [1, 18], $Ve = [1, 33], $Vf = [1, 34], $Vg = [1, 35], $Vh = [1, 36], $Vi = [1, 37], $Vj = [6, 8, 10, 13, 15, 17, 20, 21, 22, 24, 26, 28, 33, 34, 35, 36, 37, 40, 43, 44, 50, 63, 64, 65, 66, 67], $Vk = [1, 42], $Vl = [1, 43], $Vm = [1, 52], $Vn = [40, 50, 68, 69], $Vo = [1, 63], $Vp = [1, 61], $Vq = [1, 58], $Vr = [1, 62], $Vs = [1, 64], $Vt = [6, 8, 10, 13, 17, 22, 24, 26, 28, 33, 34, 35, 36, 37, 40, 41, 42, 43, 44, 48, 49, 50, 63, 64, 65, 66, 67], $Vu = [63, 64, 65, 66, 67], $Vv = [1, 81], $Vw = [1, 80], $Vx = [1, 78], $Vy = [1, 79], $Vz = [6, 10, 42, 47], $VA = [6, 10, 13, 41, 42, 47, 48, 49], $VB = [1, 89], $VC = [1, 88], $VD = [1, 87], $VE = [19, 56], $VF = [1, 98], $VG = [1, 97], $VH = [19, 56, 58, 60]; + var parser24 = { + trace: /* @__PURE__ */ __name(function trace() { + }, "trace"), + yy: {}, + symbols_: { "error": 2, "start": 3, "ER_DIAGRAM": 4, "document": 5, "EOF": 6, "line": 7, "SPACE": 8, "statement": 9, "NEWLINE": 10, "entityName": 11, "relSpec": 12, "COLON": 13, "role": 14, "STYLE_SEPARATOR": 15, "idList": 16, "BLOCK_START": 17, "attributes": 18, "BLOCK_STOP": 19, "SQS": 20, "SQE": 21, "title": 22, "title_value": 23, "acc_title": 24, "acc_title_value": 25, "acc_descr": 26, "acc_descr_value": 27, "acc_descr_multiline_value": 28, "direction": 29, "classDefStatement": 30, "classStatement": 31, "styleStatement": 32, "direction_tb": 33, "direction_bt": 34, "direction_rl": 35, "direction_lr": 36, "CLASSDEF": 37, "stylesOpt": 38, "separator": 39, "UNICODE_TEXT": 40, "STYLE_TEXT": 41, "COMMA": 42, "CLASS": 43, "STYLE": 44, "style": 45, "styleComponent": 46, "SEMI": 47, "NUM": 48, "BRKT": 49, "ENTITY_NAME": 50, "attribute": 51, "attributeType": 52, "attributeName": 53, "attributeKeyTypeList": 54, "attributeComment": 55, "ATTRIBUTE_WORD": 56, "attributeKeyType": 57, ",": 58, "ATTRIBUTE_KEY": 59, "COMMENT": 60, "cardinality": 61, "relType": 62, "ZERO_OR_ONE": 63, "ZERO_OR_MORE": 64, "ONE_OR_MORE": 65, "ONLY_ONE": 66, "MD_PARENT": 67, "NON_IDENTIFYING": 68, "IDENTIFYING": 69, "WORD": 70, "$accept": 0, "$end": 1 }, + terminals_: { 2: "error", 4: "ER_DIAGRAM", 6: "EOF", 8: "SPACE", 10: "NEWLINE", 13: "COLON", 15: "STYLE_SEPARATOR", 17: "BLOCK_START", 19: "BLOCK_STOP", 20: "SQS", 21: "SQE", 22: "title", 23: "title_value", 24: "acc_title", 25: "acc_title_value", 26: "acc_descr", 27: "acc_descr_value", 28: "acc_descr_multiline_value", 33: "direction_tb", 34: "direction_bt", 35: "direction_rl", 36: "direction_lr", 37: "CLASSDEF", 40: "UNICODE_TEXT", 41: "STYLE_TEXT", 42: "COMMA", 43: "CLASS", 44: "STYLE", 47: "SEMI", 48: "NUM", 49: "BRKT", 50: "ENTITY_NAME", 56: "ATTRIBUTE_WORD", 58: ",", 59: "ATTRIBUTE_KEY", 60: "COMMENT", 63: "ZERO_OR_ONE", 64: "ZERO_OR_MORE", 65: "ONE_OR_MORE", 66: "ONLY_ONE", 67: "MD_PARENT", 68: "NON_IDENTIFYING", 69: "IDENTIFYING", 70: "WORD" }, + productions_: [0, [3, 3], [5, 0], [5, 2], [7, 2], [7, 1], [7, 1], [7, 1], [9, 5], [9, 9], [9, 7], [9, 7], [9, 4], [9, 6], [9, 3], [9, 5], [9, 1], [9, 3], [9, 7], [9, 9], [9, 6], [9, 8], [9, 4], [9, 6], [9, 2], [9, 2], [9, 2], [9, 1], [9, 1], [9, 1], [9, 1], [9, 1], [29, 1], [29, 1], [29, 1], [29, 1], [30, 4], [16, 1], [16, 1], [16, 3], [16, 3], [31, 3], [32, 4], [38, 1], [38, 3], [45, 1], [45, 2], [39, 1], [39, 1], [39, 1], [46, 1], [46, 1], [46, 1], [46, 1], [11, 1], [11, 1], [18, 1], [18, 2], [51, 2], [51, 3], [51, 3], [51, 4], [52, 1], [53, 1], [54, 1], [54, 3], [57, 1], [55, 1], [12, 3], [61, 1], [61, 1], [61, 1], [61, 1], [61, 1], [62, 1], [62, 1], [14, 1], [14, 1], [14, 1]], + performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { + var $0 = $$.length - 1; + switch (yystate) { + case 1: + break; + case 2: + this.$ = []; + break; + case 3: + $$[$0 - 1].push($$[$0]); + this.$ = $$[$0 - 1]; + break; + case 4: + case 5: + this.$ = $$[$0]; + break; + case 6: + case 7: + this.$ = []; + break; + case 8: + yy.addEntity($$[$0 - 4]); + yy.addEntity($$[$0 - 2]); + yy.addRelationship($$[$0 - 4], $$[$0], $$[$0 - 2], $$[$0 - 3]); + break; + case 9: + yy.addEntity($$[$0 - 8]); + yy.addEntity($$[$0 - 4]); + yy.addRelationship($$[$0 - 8], $$[$0], $$[$0 - 4], $$[$0 - 5]); + yy.setClass([$$[$0 - 8]], $$[$0 - 6]); + yy.setClass([$$[$0 - 4]], $$[$0 - 2]); + break; + case 10: + yy.addEntity($$[$0 - 6]); + yy.addEntity($$[$0 - 2]); + yy.addRelationship($$[$0 - 6], $$[$0], $$[$0 - 2], $$[$0 - 3]); + yy.setClass([$$[$0 - 6]], $$[$0 - 4]); + break; + case 11: + yy.addEntity($$[$0 - 6]); + yy.addEntity($$[$0 - 4]); + yy.addRelationship($$[$0 - 6], $$[$0], $$[$0 - 4], $$[$0 - 5]); + yy.setClass([$$[$0 - 4]], $$[$0 - 2]); + break; + case 12: + yy.addEntity($$[$0 - 3]); + yy.addAttributes($$[$0 - 3], $$[$0 - 1]); + break; + case 13: + yy.addEntity($$[$0 - 5]); + yy.addAttributes($$[$0 - 5], $$[$0 - 1]); + yy.setClass([$$[$0 - 5]], $$[$0 - 3]); + break; + case 14: + yy.addEntity($$[$0 - 2]); + break; + case 15: + yy.addEntity($$[$0 - 4]); + yy.setClass([$$[$0 - 4]], $$[$0 - 2]); + break; + case 16: + yy.addEntity($$[$0]); + break; + case 17: + yy.addEntity($$[$0 - 2]); + yy.setClass([$$[$0 - 2]], $$[$0]); + break; + case 18: + yy.addEntity($$[$0 - 6], $$[$0 - 4]); + yy.addAttributes($$[$0 - 6], $$[$0 - 1]); + break; + case 19: + yy.addEntity($$[$0 - 8], $$[$0 - 6]); + yy.addAttributes($$[$0 - 8], $$[$0 - 1]); + yy.setClass([$$[$0 - 8]], $$[$0 - 3]); + break; + case 20: + yy.addEntity($$[$0 - 5], $$[$0 - 3]); + break; + case 21: + yy.addEntity($$[$0 - 7], $$[$0 - 5]); + yy.setClass([$$[$0 - 7]], $$[$0 - 2]); + break; + case 22: + yy.addEntity($$[$0 - 3], $$[$0 - 1]); + break; + case 23: + yy.addEntity($$[$0 - 5], $$[$0 - 3]); + yy.setClass([$$[$0 - 5]], $$[$0]); + break; + case 24: + case 25: + this.$ = $$[$0].trim(); + yy.setAccTitle(this.$); + break; + case 26: + case 27: + this.$ = $$[$0].trim(); + yy.setAccDescription(this.$); + break; + case 32: + yy.setDirection("TB"); + break; + case 33: + yy.setDirection("BT"); + break; + case 34: + yy.setDirection("RL"); + break; + case 35: + yy.setDirection("LR"); + break; + case 36: + this.$ = $$[$0 - 3]; + yy.addClass($$[$0 - 2], $$[$0 - 1]); + break; + case 37: + case 38: + case 56: + case 64: + this.$ = [$$[$0]]; + break; + case 39: + case 40: + this.$ = $$[$0 - 2].concat([$$[$0]]); + break; + case 41: + this.$ = $$[$0 - 2]; + yy.setClass($$[$0 - 1], $$[$0]); + break; + case 42: + ; + this.$ = $$[$0 - 3]; + yy.addCssStyles($$[$0 - 2], $$[$0 - 1]); + break; + case 43: + this.$ = [$$[$0]]; + break; + case 44: + $$[$0 - 2].push($$[$0]); + this.$ = $$[$0 - 2]; + break; + case 46: + this.$ = $$[$0 - 1] + $$[$0]; + break; + case 54: + case 76: + case 77: + this.$ = $$[$0].replace(/"/g, ""); + break; + case 55: + case 78: + this.$ = $$[$0]; + break; + case 57: + $$[$0].push($$[$0 - 1]); + this.$ = $$[$0]; + break; + case 58: + this.$ = { type: $$[$0 - 1], name: $$[$0] }; + break; + case 59: + this.$ = { type: $$[$0 - 2], name: $$[$0 - 1], keys: $$[$0] }; + break; + case 60: + this.$ = { type: $$[$0 - 2], name: $$[$0 - 1], comment: $$[$0] }; + break; + case 61: + this.$ = { type: $$[$0 - 3], name: $$[$0 - 2], keys: $$[$0 - 1], comment: $$[$0] }; + break; + case 62: + case 63: + case 66: + this.$ = $$[$0]; + break; + case 65: + $$[$0 - 2].push($$[$0]); + this.$ = $$[$0 - 2]; + break; + case 67: + this.$ = $$[$0].replace(/"/g, ""); + break; + case 68: + this.$ = { cardA: $$[$0], relType: $$[$0 - 1], cardB: $$[$0 - 2] }; + break; + case 69: + this.$ = yy.Cardinality.ZERO_OR_ONE; + break; + case 70: + this.$ = yy.Cardinality.ZERO_OR_MORE; + break; + case 71: + this.$ = yy.Cardinality.ONE_OR_MORE; + break; + case 72: + this.$ = yy.Cardinality.ONLY_ONE; + break; + case 73: + this.$ = yy.Cardinality.MD_PARENT; + break; + case 74: + this.$ = yy.Identification.NON_IDENTIFYING; + break; + case 75: + this.$ = yy.Identification.IDENTIFYING; + break; + } + }, "anonymous"), + table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, o2($V0, [2, 2], { 5: 3 }), { 6: [1, 4], 7: 5, 8: [1, 6], 9: 7, 10: [1, 8], 11: 9, 22: $V1, 24: $V2, 26: $V3, 28: $V4, 29: 14, 30: 15, 31: 16, 32: 17, 33: $V5, 34: $V6, 35: $V7, 36: $V8, 37: $V9, 40: $Va, 43: $Vb, 44: $Vc, 50: $Vd }, o2($V0, [2, 7], { 1: [2, 1] }), o2($V0, [2, 3]), { 9: 27, 11: 9, 22: $V1, 24: $V2, 26: $V3, 28: $V4, 29: 14, 30: 15, 31: 16, 32: 17, 33: $V5, 34: $V6, 35: $V7, 36: $V8, 37: $V9, 40: $Va, 43: $Vb, 44: $Vc, 50: $Vd }, o2($V0, [2, 5]), o2($V0, [2, 6]), o2($V0, [2, 16], { 12: 28, 61: 32, 15: [1, 29], 17: [1, 30], 20: [1, 31], 63: $Ve, 64: $Vf, 65: $Vg, 66: $Vh, 67: $Vi }), { 23: [1, 38] }, { 25: [1, 39] }, { 27: [1, 40] }, o2($V0, [2, 27]), o2($V0, [2, 28]), o2($V0, [2, 29]), o2($V0, [2, 30]), o2($V0, [2, 31]), o2($Vj, [2, 54]), o2($Vj, [2, 55]), o2($V0, [2, 32]), o2($V0, [2, 33]), o2($V0, [2, 34]), o2($V0, [2, 35]), { 16: 41, 40: $Vk, 41: $Vl }, { 16: 44, 40: $Vk, 41: $Vl }, { 16: 45, 40: $Vk, 41: $Vl }, o2($V0, [2, 4]), { 11: 46, 40: $Va, 50: $Vd }, { 16: 47, 40: $Vk, 41: $Vl }, { 18: 48, 19: [1, 49], 51: 50, 52: 51, 56: $Vm }, { 11: 53, 40: $Va, 50: $Vd }, { 62: 54, 68: [1, 55], 69: [1, 56] }, o2($Vn, [2, 69]), o2($Vn, [2, 70]), o2($Vn, [2, 71]), o2($Vn, [2, 72]), o2($Vn, [2, 73]), o2($V0, [2, 24]), o2($V0, [2, 25]), o2($V0, [2, 26]), { 13: $Vo, 38: 57, 41: $Vp, 42: $Vq, 45: 59, 46: 60, 48: $Vr, 49: $Vs }, o2($Vt, [2, 37]), o2($Vt, [2, 38]), { 16: 65, 40: $Vk, 41: $Vl, 42: $Vq }, { 13: $Vo, 38: 66, 41: $Vp, 42: $Vq, 45: 59, 46: 60, 48: $Vr, 49: $Vs }, { 13: [1, 67], 15: [1, 68] }, o2($V0, [2, 17], { 61: 32, 12: 69, 17: [1, 70], 42: $Vq, 63: $Ve, 64: $Vf, 65: $Vg, 66: $Vh, 67: $Vi }), { 19: [1, 71] }, o2($V0, [2, 14]), { 18: 72, 19: [2, 56], 51: 50, 52: 51, 56: $Vm }, { 53: 73, 56: [1, 74] }, { 56: [2, 62] }, { 21: [1, 75] }, { 61: 76, 63: $Ve, 64: $Vf, 65: $Vg, 66: $Vh, 67: $Vi }, o2($Vu, [2, 74]), o2($Vu, [2, 75]), { 6: $Vv, 10: $Vw, 39: 77, 42: $Vx, 47: $Vy }, { 40: [1, 82], 41: [1, 83] }, o2($Vz, [2, 43], { 46: 84, 13: $Vo, 41: $Vp, 48: $Vr, 49: $Vs }), o2($VA, [2, 45]), o2($VA, [2, 50]), o2($VA, [2, 51]), o2($VA, [2, 52]), o2($VA, [2, 53]), o2($V0, [2, 41], { 42: $Vq }), { 6: $Vv, 10: $Vw, 39: 85, 42: $Vx, 47: $Vy }, { 14: 86, 40: $VB, 50: $VC, 70: $VD }, { 16: 90, 40: $Vk, 41: $Vl }, { 11: 91, 40: $Va, 50: $Vd }, { 18: 92, 19: [1, 93], 51: 50, 52: 51, 56: $Vm }, o2($V0, [2, 12]), { 19: [2, 57] }, o2($VE, [2, 58], { 54: 94, 55: 95, 57: 96, 59: $VF, 60: $VG }), o2([19, 56, 59, 60], [2, 63]), o2($V0, [2, 22], { 15: [1, 100], 17: [1, 99] }), o2([40, 50], [2, 68]), o2($V0, [2, 36]), { 13: $Vo, 41: $Vp, 45: 101, 46: 60, 48: $Vr, 49: $Vs }, o2($V0, [2, 47]), o2($V0, [2, 48]), o2($V0, [2, 49]), o2($Vt, [2, 39]), o2($Vt, [2, 40]), o2($VA, [2, 46]), o2($V0, [2, 42]), o2($V0, [2, 8]), o2($V0, [2, 76]), o2($V0, [2, 77]), o2($V0, [2, 78]), { 13: [1, 102], 42: $Vq }, { 13: [1, 104], 15: [1, 103] }, { 19: [1, 105] }, o2($V0, [2, 15]), o2($VE, [2, 59], { 55: 106, 58: [1, 107], 60: $VG }), o2($VE, [2, 60]), o2($VH, [2, 64]), o2($VE, [2, 67]), o2($VH, [2, 66]), { 18: 108, 19: [1, 109], 51: 50, 52: 51, 56: $Vm }, { 16: 110, 40: $Vk, 41: $Vl }, o2($Vz, [2, 44], { 46: 84, 13: $Vo, 41: $Vp, 48: $Vr, 49: $Vs }), { 14: 111, 40: $VB, 50: $VC, 70: $VD }, { 16: 112, 40: $Vk, 41: $Vl }, { 14: 113, 40: $VB, 50: $VC, 70: $VD }, o2($V0, [2, 13]), o2($VE, [2, 61]), { 57: 114, 59: $VF }, { 19: [1, 115] }, o2($V0, [2, 20]), o2($V0, [2, 23], { 17: [1, 116], 42: $Vq }), o2($V0, [2, 11]), { 13: [1, 117], 42: $Vq }, o2($V0, [2, 10]), o2($VH, [2, 65]), o2($V0, [2, 18]), { 18: 118, 19: [1, 119], 51: 50, 52: 51, 56: $Vm }, { 14: 120, 40: $VB, 50: $VC, 70: $VD }, { 19: [1, 121] }, o2($V0, [2, 21]), o2($V0, [2, 9]), o2($V0, [2, 19])], + defaultActions: { 52: [2, 62], 72: [2, 57] }, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (hash.recoverable) { + this.trace(str2); + } else { + var error3 = new Error(str2); + error3.hash = hash; + throw error3; + } + }, "parseError"), + parse: /* @__PURE__ */ __name(function parse7(input) { + var self2 = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF2 = 1; + var args = lstack.slice.call(arguments, 1); + var lexer2 = Object.create(this.lexer); + var sharedState = { yy: {} }; + for (var k2 in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k2)) { + sharedState.yy[k2] = this.yy[k2]; + } + } + lexer2.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer2; + sharedState.yy.parser = this; + if (typeof lexer2.yylloc == "undefined") { + lexer2.yylloc = {}; + } + var yyloc = lexer2.yylloc; + lstack.push(yyloc); + var ranges = lexer2.options && lexer2.options.ranges; + if (typeof sharedState.yy.parseError === "function") { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + function popStack(n2) { + stack.length = stack.length - 2 * n2; + vstack.length = vstack.length - n2; + lstack.length = lstack.length - n2; + } + __name(popStack, "popStack"); + function lex() { + var token2; + token2 = tstack.pop() || lexer2.lex() || EOF2; + if (typeof token2 !== "number") { + if (token2 instanceof Array) { + tstack = token2; + token2 = tstack.pop(); + } + token2 = self2.symbols_[token2] || token2; + } + return token2; + } + __name(lex, "lex"); + var symbol, preErrorSymbol, state3, action, a2, r2, yyval = {}, p3, len, newState2, expected; + while (true) { + state3 = stack[stack.length - 1]; + if (this.defaultActions[state3]) { + action = this.defaultActions[state3]; + } else { + if (symbol === null || typeof symbol == "undefined") { + symbol = lex(); + } + action = table[state3] && table[state3][symbol]; + } + if (typeof action === "undefined" || !action.length || !action[0]) { + var errStr = ""; + expected = []; + for (p3 in table[state3]) { + if (this.terminals_[p3] && p3 > TERROR) { + expected.push("'" + this.terminals_[p3] + "'"); + } + } + if (lexer2.showPosition) { + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF2 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + this.parseError(errStr, { + text: lexer2.match, + token: this.terminals_[symbol] || symbol, + line: lexer2.yylineno, + loc: yyloc, + expected + }); + } + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state3 + ", token: " + symbol); + } + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(lexer2.yytext); + lstack.push(lexer2.yylloc); + stack.push(action[1]); + symbol = null; + if (!preErrorSymbol) { + yyleng = lexer2.yyleng; + yytext = lexer2.yytext; + yylineno = lexer2.yylineno; + yyloc = lexer2.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + if (ranges) { + yyval._$.range = [ + lstack[lstack.length - (len || 1)].range[0], + lstack[lstack.length - 1].range[1] + ]; + } + r2 = this.performAction.apply(yyval, [ + yytext, + yyleng, + yylineno, + sharedState.yy, + action[1], + vstack, + lstack + ].concat(args)); + if (typeof r2 !== "undefined") { + return r2; + } + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState2 = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState2); + break; + case 3: + return true; + } + } + return true; + }, "parse") + }; + var lexer = /* @__PURE__ */ (function() { + var lexer2 = { + EOF: 1, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str2, hash); + } else { + throw new Error(str2); + } + }, "parseError"), + // resets the lexer, sets new input + setInput: /* @__PURE__ */ __name(function(input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ""; + this.conditionStack = ["INITIAL"]; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + this.offset = 0; + return this; + }, "setInput"), + // consumes and returns one char from the input + input: /* @__PURE__ */ __name(function() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + this._input = this._input.slice(1); + return ch; + }, "input"), + // unshifts one char (or a string) into the input + unput: /* @__PURE__ */ __name(function(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r2 = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + if (this.options.ranges) { + this.yylloc.range = [r2[0], r2[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, "unput"), + // When called from action, caches matched text and appends it on next action + more: /* @__PURE__ */ __name(function() { + this._more = true; + return this; + }, "more"), + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: /* @__PURE__ */ __name(function() { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + return this; + }, "reject"), + // retain first n characters of the match + less: /* @__PURE__ */ __name(function(n2) { + this.unput(this.match.slice(n2)); + }, "less"), + // displays already matched input, i.e. for error messages + pastInput: /* @__PURE__ */ __name(function() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, ""); + }, "pastInput"), + // displays upcoming input, i.e. for error messages + upcomingInput: /* @__PURE__ */ __name(function() { + var next3 = this.match; + if (next3.length < 20) { + next3 += this._input.substr(0, 20 - next3.length); + } + return (next3.substr(0, 20) + (next3.length > 20 ? "..." : "")).replace(/\n/g, ""); + }, "upcomingInput"), + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: /* @__PURE__ */ __name(function() { + var pre = this.pastInput(); + var c3 = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c3 + "^"; + }, "showPosition"), + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: /* @__PURE__ */ __name(function(match2, indexed_rule) { + var token2, lines, backup; + if (this.options.backtrack_lexer) { + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + lines = match2[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match2[0].length + }; + this.yytext += match2[0]; + this.match += match2[0]; + this.matches = match2; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match2[0].length); + this.matched += match2[0]; + token2 = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token2) { + return token2; + } else if (this._backtrack) { + for (var k2 in backup) { + this[k2] = backup[k2]; + } + return false; + } + return false; + }, "test_match"), + // return next match in input + next: /* @__PURE__ */ __name(function() { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + var token2, match2, tempMatch, index; + if (!this._more) { + this.yytext = ""; + this.match = ""; + } + var rules = this._currentRules(); + for (var i2 = 0; i2 < rules.length; i2++) { + tempMatch = this._input.match(this.rules[rules[i2]]); + if (tempMatch && (!match2 || tempMatch[0].length > match2[0].length)) { + match2 = tempMatch; + index = i2; + if (this.options.backtrack_lexer) { + token2 = this.test_match(tempMatch, rules[i2]); + if (token2 !== false) { + return token2; + } else if (this._backtrack) { + match2 = false; + continue; + } else { + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match2) { + token2 = this.test_match(match2, rules[index]); + if (token2 !== false) { + return token2; + } + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, "next"), + // return next match that has a token + lex: /* @__PURE__ */ __name(function lex() { + var r2 = this.next(); + if (r2) { + return r2; + } else { + return this.lex(); + } + }, "lex"), + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: /* @__PURE__ */ __name(function begin(condition) { + this.conditionStack.push(condition); + }, "begin"), + // pop the previously active lexer condition state off the condition stack + popState: /* @__PURE__ */ __name(function popState() { + var n2 = this.conditionStack.length - 1; + if (n2 > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, "popState"), + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: /* @__PURE__ */ __name(function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, "_currentRules"), + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: /* @__PURE__ */ __name(function topState(n2) { + n2 = this.conditionStack.length - 1 - Math.abs(n2 || 0); + if (n2 >= 0) { + return this.conditionStack[n2]; + } else { + return "INITIAL"; + } + }, "topState"), + // alias for begin(condition) + pushState: /* @__PURE__ */ __name(function pushState(condition) { + this.begin(condition); + }, "pushState"), + // return the number of states currently on the stack + stateStackSize: /* @__PURE__ */ __name(function stateStackSize() { + return this.conditionStack.length; + }, "stateStackSize"), + options: { "case-insensitive": true }, + performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + var YYSTATE = YY_START; + switch ($avoiding_name_collisions) { + case 0: + this.begin("acc_title"); + return 24; + break; + case 1: + this.popState(); + return "acc_title_value"; + break; + case 2: + this.begin("acc_descr"); + return 26; + break; + case 3: + this.popState(); + return "acc_descr_value"; + break; + case 4: + this.begin("acc_descr_multiline"); + break; + case 5: + this.popState(); + break; + case 6: + return "acc_descr_multiline_value"; + break; + case 7: + return 33; + break; + case 8: + return 34; + break; + case 9: + return 35; + break; + case 10: + return 36; + break; + case 11: + return 10; + break; + case 12: + break; + case 13: + return 8; + break; + case 14: + return 50; + break; + case 15: + return 70; + break; + case 16: + return 4; + break; + case 17: + this.begin("block"); + return 17; + break; + case 18: + return 49; + break; + case 19: + return 49; + break; + case 20: + return 42; + break; + case 21: + return 15; + break; + case 22: + return 13; + break; + case 23: + break; + case 24: + return 59; + break; + case 25: + return 56; + break; + case 26: + return 56; + break; + case 27: + return 60; + break; + case 28: + break; + case 29: + this.popState(); + return 19; + break; + case 30: + return yy_.yytext[0]; + break; + case 31: + return 20; + break; + case 32: + return 21; + break; + case 33: + this.begin("style"); + return 44; + break; + case 34: + this.popState(); + return 10; + break; + case 35: + break; + case 36: + return 13; + break; + case 37: + return 42; + break; + case 38: + return 49; + break; + case 39: + this.begin("style"); + return 37; + break; + case 40: + return 43; + break; + case 41: + return 63; + break; + case 42: + return 65; + break; + case 43: + return 65; + break; + case 44: + return 65; + break; + case 45: + return 63; + break; + case 46: + return 63; + break; + case 47: + return 64; + break; + case 48: + return 64; + break; + case 49: + return 64; + break; + case 50: + return 64; + break; + case 51: + return 64; + break; + case 52: + return 65; + break; + case 53: + return 64; + break; + case 54: + return 65; + break; + case 55: + return 66; + break; + case 56: + return 66; + break; + case 57: + return 66; + break; + case 58: + return 66; + break; + case 59: + return 63; + break; + case 60: + return 64; + break; + case 61: + return 65; + break; + case 62: + return 67; + break; + case 63: + return 68; + break; + case 64: + return 69; + break; + case 65: + return 69; + break; + case 66: + return 68; + break; + case 67: + return 68; + break; + case 68: + return 68; + break; + case 69: + return 41; + break; + case 70: + return 47; + break; + case 71: + return 40; + break; + case 72: + return 48; + break; + case 73: + return yy_.yytext[0]; + break; + case 74: + return 6; + break; + } + }, "anonymous"), + rules: [/^(?:accTitle\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*\{\s*)/i, /^(?:[\}])/i, /^(?:[^\}]*)/i, /^(?:.*direction\s+TB[^\n]*)/i, /^(?:.*direction\s+BT[^\n]*)/i, /^(?:.*direction\s+RL[^\n]*)/i, /^(?:.*direction\s+LR[^\n]*)/i, /^(?:[\n]+)/i, /^(?:\s+)/i, /^(?:[\s]+)/i, /^(?:"[^"%\r\n\v\b\\]+")/i, /^(?:"[^"]*")/i, /^(?:erDiagram\b)/i, /^(?:\{)/i, /^(?:#)/i, /^(?:#)/i, /^(?:,)/i, /^(?::::)/i, /^(?::)/i, /^(?:\s+)/i, /^(?:\b((?:PK)|(?:FK)|(?:UK))\b)/i, /^(?:([^\s]*)[~].*[~]([^\s]*))/i, /^(?:([\*A-Za-z_\u00C0-\uFFFF][A-Za-z0-9\-\_\[\]\(\)\u00C0-\uFFFF\*]*))/i, /^(?:"[^"]*")/i, /^(?:[\n]+)/i, /^(?:\})/i, /^(?:.)/i, /^(?:\[)/i, /^(?:\])/i, /^(?:style\b)/i, /^(?:[\n]+)/i, /^(?:\s+)/i, /^(?::)/i, /^(?:,)/i, /^(?:#)/i, /^(?:classDef\b)/i, /^(?:class\b)/i, /^(?:one or zero\b)/i, /^(?:one or more\b)/i, /^(?:one or many\b)/i, /^(?:1\+)/i, /^(?:\|o\b)/i, /^(?:zero or one\b)/i, /^(?:zero or more\b)/i, /^(?:zero or many\b)/i, /^(?:0\+)/i, /^(?:\}o\b)/i, /^(?:many\(0\))/i, /^(?:many\(1\))/i, /^(?:many\b)/i, /^(?:\}\|)/i, /^(?:one\b)/i, /^(?:only one\b)/i, /^(?:1\b)/i, /^(?:\|\|)/i, /^(?:o\|)/i, /^(?:o\{)/i, /^(?:\|\{)/i, /^(?:\s*u\b)/i, /^(?:\.\.)/i, /^(?:--)/i, /^(?:to\b)/i, /^(?:optionally to\b)/i, /^(?:\.-)/i, /^(?:-\.)/i, /^(?:([^\x00-\x7F]|\w|-|\*)+)/i, /^(?:;)/i, /^(?:([^\x00-\x7F]|\w|-|\*)+)/i, /^(?:[0-9])/i, /^(?:.)/i, /^(?:$)/i], + conditions: { "style": { "rules": [34, 35, 36, 37, 38, 69, 70], "inclusive": false }, "acc_descr_multiline": { "rules": [5, 6], "inclusive": false }, "acc_descr": { "rules": [3], "inclusive": false }, "acc_title": { "rules": [1], "inclusive": false }, "block": { "rules": [23, 24, 25, 26, 27, 28, 29, 30], "inclusive": false }, "INITIAL": { "rules": [0, 2, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 31, 32, 33, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 71, 72, 73, 74], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser3.parser = parser3; + erDiagram_default = parser3; + } + }); + + // src/diagrams/er/erDb.ts + var ErDB; + var init_erDb = __esm({ + "src/diagrams/er/erDb.ts"() { + "use strict"; + init_logger(); + init_diagramAPI(); + init_commonDb(); + init_utils2(); + ErDB = class { + constructor() { + this.entities = /* @__PURE__ */ new Map(); + this.relationships = []; + this.classes = /* @__PURE__ */ new Map(); + this.direction = "TB"; + this.Cardinality = { + ZERO_OR_ONE: "ZERO_OR_ONE", + ZERO_OR_MORE: "ZERO_OR_MORE", + ONE_OR_MORE: "ONE_OR_MORE", + ONLY_ONE: "ONLY_ONE", + MD_PARENT: "MD_PARENT" + }; + this.Identification = { + NON_IDENTIFYING: "NON_IDENTIFYING", + IDENTIFYING: "IDENTIFYING" + }; + this.setAccTitle = setAccTitle; + this.getAccTitle = getAccTitle; + this.setAccDescription = setAccDescription; + this.getAccDescription = getAccDescription; + this.setDiagramTitle = setDiagramTitle; + this.getDiagramTitle = getDiagramTitle; + this.getConfig = /* @__PURE__ */ __name(() => getConfig2().er, "getConfig"); + this.clear(); + this.addEntity = this.addEntity.bind(this); + this.addAttributes = this.addAttributes.bind(this); + this.addRelationship = this.addRelationship.bind(this); + this.setDirection = this.setDirection.bind(this); + this.addCssStyles = this.addCssStyles.bind(this); + this.addClass = this.addClass.bind(this); + this.setClass = this.setClass.bind(this); + this.setAccTitle = this.setAccTitle.bind(this); + this.setAccDescription = this.setAccDescription.bind(this); + } + static { + __name(this, "ErDB"); + } + /** + * Add entity + * @param name - The name of the entity + * @param alias - The alias of the entity + */ + addEntity(name, alias = "") { + if (!this.entities.has(name)) { + this.entities.set(name, { + id: `entity-${name}-${this.entities.size}`, + label: name, + attributes: [], + alias, + shape: "erBox", + look: getConfig2().look ?? "default", + cssClasses: "default", + cssStyles: [] + }); + log.info("Added new entity :", name); + } else if (!this.entities.get(name)?.alias && alias) { + this.entities.get(name).alias = alias; + log.info(`Add alias '${alias}' to entity '${name}'`); + } + return this.entities.get(name); + } + getEntity(name) { + return this.entities.get(name); + } + getEntities() { + return this.entities; + } + getClasses() { + return this.classes; + } + addAttributes(entityName, attribs) { + const entity = this.addEntity(entityName); + let i2; + for (i2 = attribs.length - 1; i2 >= 0; i2--) { + if (!attribs[i2].keys) { + attribs[i2].keys = []; + } + if (!attribs[i2].comment) { + attribs[i2].comment = ""; + } + entity.attributes.push(attribs[i2]); + log.debug("Added attribute ", attribs[i2].name); + } + } + /** + * Add a relationship + * + * @param entA - The first entity in the relationship + * @param rolA - The role played by the first entity in relation to the second + * @param entB - The second entity in the relationship + * @param rSpec - The details of the relationship between the two entities + */ + addRelationship(entA, rolA, entB, rSpec) { + const entityA = this.entities.get(entA); + const entityB = this.entities.get(entB); + if (!entityA || !entityB) { + return; + } + const rel2 = { + entityA: entityA.id, + roleA: rolA, + entityB: entityB.id, + relSpec: rSpec + }; + this.relationships.push(rel2); + log.debug("Added new relationship :", rel2); + } + getRelationships() { + return this.relationships; + } + getDirection() { + return this.direction; + } + setDirection(dir2) { + this.direction = dir2; + } + getCompiledStyles(classDefs) { + let compiledStyles = []; + for (const customClass of classDefs) { + const cssClass = this.classes.get(customClass); + if (cssClass?.styles) { + compiledStyles = [...compiledStyles, ...cssClass.styles ?? []].map((s2) => s2.trim()); + } + if (cssClass?.textStyles) { + compiledStyles = [...compiledStyles, ...cssClass.textStyles ?? []].map((s2) => s2.trim()); + } + } + return compiledStyles; + } + addCssStyles(ids, styles4) { + for (const id30 of ids) { + const entity = this.entities.get(id30); + if (!styles4 || !entity) { + return; + } + for (const style3 of styles4) { + entity.cssStyles.push(style3); + } + } + } + addClass(ids, style3) { + ids.forEach((id30) => { + let classNode = this.classes.get(id30); + if (classNode === void 0) { + classNode = { id: id30, styles: [], textStyles: [] }; + this.classes.set(id30, classNode); + } + if (style3) { + style3.forEach(function(s2) { + if (/color/.exec(s2)) { + const newStyle = s2.replace("fill", "bgFill"); + classNode.textStyles.push(newStyle); + } + classNode.styles.push(s2); + }); + } + }); + } + setClass(ids, classNames) { + for (const id30 of ids) { + const entity = this.entities.get(id30); + if (entity) { + for (const className of classNames) { + entity.cssClasses += " " + className; + } + } + } + } + clear() { + this.entities = /* @__PURE__ */ new Map(); + this.classes = /* @__PURE__ */ new Map(); + this.relationships = []; + clear(); + } + getData() { + const nodes5 = []; + const edges3 = []; + const config5 = getConfig2(); + for (const entityKey of this.entities.keys()) { + const entityNode = this.entities.get(entityKey); + if (entityNode) { + entityNode.cssCompiledStyles = this.getCompiledStyles(entityNode.cssClasses.split(" ")); + nodes5.push(entityNode); + } + } + let count2 = 0; + for (const relationship of this.relationships) { + const edge = { + id: getEdgeId(relationship.entityA, relationship.entityB, { + prefix: "id", + counter: count2++ + }), + type: "normal", + curve: "basis", + start: relationship.entityA, + end: relationship.entityB, + label: relationship.roleA, + labelpos: "c", + thickness: "normal", + classes: "relationshipLine", + arrowTypeStart: relationship.relSpec.cardB.toLowerCase(), + arrowTypeEnd: relationship.relSpec.cardA.toLowerCase(), + pattern: relationship.relSpec.relType == "IDENTIFYING" ? "solid" : "dashed", + look: config5.look + }; + edges3.push(edge); + } + return { nodes: nodes5, edges: edges3, other: {}, config: config5, direction: "TB" }; + } + }; + } + }); + + // src/diagrams/er/erRenderer-unified.ts + var erRenderer_unified_exports = {}; + __export(erRenderer_unified_exports, { + draw: () => draw3 + }); + var draw3; + var init_erRenderer_unified = __esm({ + "src/diagrams/er/erRenderer-unified.ts"() { + "use strict"; + init_diagramAPI(); + init_logger(); + init_insertElementsForSize(); + init_render2(); + init_setupViewPortForSVG(); + init_utils2(); + init_src32(); + draw3 = /* @__PURE__ */ __name(async function(text4, id30, _version, diag) { + log.info("REF0:"); + log.info("Drawing er diagram (unified)", id30); + const { securityLevel, er: conf5, layout: layout6 } = getConfig2(); + const data4Layout = diag.db.getData(); + const svg2 = getDiagramElement(id30, securityLevel); + data4Layout.type = diag.type; + data4Layout.layoutAlgorithm = getRegisteredLayoutAlgorithm(layout6); + data4Layout.config.flowchart.nodeSpacing = conf5?.nodeSpacing || 140; + data4Layout.config.flowchart.rankSpacing = conf5?.rankSpacing || 80; + data4Layout.direction = diag.db.getDirection(); + data4Layout.markers = ["only_one", "zero_or_one", "one_or_more", "zero_or_more"]; + data4Layout.diagramId = id30; + await render6(data4Layout, svg2); + if (data4Layout.layoutAlgorithm === "elk") { + svg2.select(".edges").lower(); + } + const backgroundNodes = svg2.selectAll('[id*="-background"]'); + if (Array.from(backgroundNodes).length > 0) { + backgroundNodes.each(function() { + const backgroundNode = select_default2(this); + const backgroundId = backgroundNode.attr("id"); + const nonBackgroundId = backgroundId.replace("-background", ""); + const nonBackgroundNode = svg2.select(`#${CSS.escape(nonBackgroundId)}`); + if (!nonBackgroundNode.empty()) { + const transform8 = nonBackgroundNode.attr("transform"); + backgroundNode.attr("transform", transform8); + } + }); + } + const padding2 = 8; + utils_default2.insertTitle( + svg2, + "erDiagramTitleText", + conf5?.titleTopMargin ?? 25, + diag.db.getDiagramTitle() + ); + setupViewPortForSVG(svg2, padding2, "erDiagram", conf5?.useMaxWidth ?? true); + }, "draw"); + } + }); + + // src/diagrams/er/styles.ts + var fade2, getStyles4, styles_default4; + var init_styles4 = __esm({ + "src/diagrams/er/styles.ts"() { + "use strict"; + init_dist(); + fade2 = /* @__PURE__ */ __name((color2, opacity) => { + const channel2 = channel_default2; + const r2 = channel2(color2, "r"); + const g2 = channel2(color2, "g"); + const b3 = channel2(color2, "b"); + return rgba_default(r2, g2, b3, opacity); + }, "fade"); + getStyles4 = /* @__PURE__ */ __name((options2) => ` + .entityBox { + fill: ${options2.mainBkg}; + stroke: ${options2.nodeBorder}; + } + + .relationshipLabelBox { + fill: ${options2.tertiaryColor}; + opacity: 0.7; + background-color: ${options2.tertiaryColor}; + rect { + opacity: 0.5; + } + } + + .labelBkg { + background-color: ${fade2(options2.tertiaryColor, 0.5)}; + } + + .edgeLabel .label { + fill: ${options2.nodeBorder}; + font-size: 14px; + } + + .label { + font-family: ${options2.fontFamily}; + color: ${options2.nodeTextColor || options2.textColor}; + } + + .edge-pattern-dashed { + stroke-dasharray: 8,8; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon + { + fill: ${options2.mainBkg}; + stroke: ${options2.nodeBorder}; + stroke-width: 1px; + } + + .relationshipLine { + stroke: ${options2.lineColor}; + stroke-width: 1; + fill: none; + } + + .marker { + fill: none !important; + stroke: ${options2.lineColor} !important; + stroke-width: 1; + } +`, "getStyles"); + styles_default4 = getStyles4; + } + }); + + // src/diagrams/er/erDiagram.ts + var erDiagram_exports = {}; + __export(erDiagram_exports, { + diagram: () => diagram3 + }); + var diagram3; + var init_erDiagram2 = __esm({ + "src/diagrams/er/erDiagram.ts"() { + "use strict"; + init_erDiagram(); + init_erDb(); + init_erRenderer_unified(); + init_styles4(); + diagram3 = { + parser: erDiagram_default, + get db() { + return new ErDB(); + }, + renderer: erRenderer_unified_exports, + styles: styles_default4 + }; + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/syntax-tree.js + function isAstNode(obj) { + return typeof obj === "object" && obj !== null && typeof obj.$type === "string"; + } + function isReference(obj) { + return typeof obj === "object" && obj !== null && typeof obj.$refText === "string" && "ref" in obj; + } + function isMultiReference(obj) { + return typeof obj === "object" && obj !== null && typeof obj.$refText === "string" && "items" in obj; + } + function isAstNodeDescription(obj) { + return typeof obj === "object" && obj !== null && typeof obj.name === "string" && typeof obj.type === "string" && typeof obj.path === "string"; + } + function isLinkingError(obj) { + return typeof obj === "object" && obj !== null && typeof obj.info === "object" && typeof obj.message === "string"; + } + function isCompositeCstNode(node2) { + return typeof node2 === "object" && node2 !== null && Array.isArray(node2.content); + } + function isLeafCstNode(node2) { + return typeof node2 === "object" && node2 !== null && typeof node2.tokenType === "object"; + } + function isRootCstNode(node2) { + return isCompositeCstNode(node2) && typeof node2.fullText === "string"; + } + var AbstractAstReflection; + var init_syntax_tree = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/syntax-tree.js"() { + "use strict"; + __name(isAstNode, "isAstNode"); + __name(isReference, "isReference"); + __name(isMultiReference, "isMultiReference"); + __name(isAstNodeDescription, "isAstNodeDescription"); + __name(isLinkingError, "isLinkingError"); + AbstractAstReflection = class { + static { + __name(this, "AbstractAstReflection"); + } + constructor() { + this.subtypes = {}; + this.allSubtypes = {}; + } + getAllTypes() { + return Object.keys(this.types); + } + getReferenceType(refInfo) { + const metaData = this.types[refInfo.container.$type]; + if (!metaData) { + throw new Error(`Type ${refInfo.container.$type || "undefined"} not found.`); + } + const referenceType = metaData.properties[refInfo.property]?.referenceType; + if (!referenceType) { + throw new Error(`Property ${refInfo.property || "undefined"} of type ${refInfo.container.$type} is not a reference.`); + } + return referenceType; + } + getTypeMetaData(type3) { + const result = this.types[type3]; + if (!result) { + return { + name: type3, + properties: {}, + superTypes: [] + }; + } + return result; + } + isInstance(node2, type3) { + return isAstNode(node2) && this.isSubtype(node2.$type, type3); + } + isSubtype(subtype, supertype) { + if (subtype === supertype) { + return true; + } + let nested = this.subtypes[subtype]; + if (!nested) { + nested = this.subtypes[subtype] = {}; + } + const existing = nested[supertype]; + if (existing !== void 0) { + return existing; + } else { + const metaData = this.types[subtype]; + const result = metaData ? metaData.superTypes.some((s2) => this.isSubtype(s2, supertype)) : false; + nested[supertype] = result; + return result; + } + } + getAllSubTypes(type3) { + const existing = this.allSubtypes[type3]; + if (existing) { + return existing; + } else { + const allTypes = this.getAllTypes(); + const types = []; + for (const possibleSubType of allTypes) { + if (this.isSubtype(possibleSubType, type3)) { + types.push(possibleSubType); + } + } + this.allSubtypes[type3] = types; + return types; + } + } + }; + __name(isCompositeCstNode, "isCompositeCstNode"); + __name(isLeafCstNode, "isLeafCstNode"); + __name(isRootCstNode, "isRootCstNode"); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/stream.js + function toString5(item) { + if (typeof item === "string") { + return item; + } + if (typeof item === "undefined") { + return "undefined"; + } + if (typeof item.toString === "function") { + return item.toString(); + } + return Object.prototype.toString.call(item); + } + function isIterable(obj) { + return !!obj && typeof obj[Symbol.iterator] === "function"; + } + function stream(...collections) { + if (collections.length === 1) { + const collection4 = collections[0]; + if (collection4 instanceof StreamImpl) { + return collection4; + } + if (isIterable(collection4)) { + return new StreamImpl(() => collection4[Symbol.iterator](), (iterator) => iterator.next()); + } + if (typeof collection4.length === "number") { + return new StreamImpl(() => ({ index: 0 }), (state3) => { + if (state3.index < collection4.length) { + return { done: false, value: collection4[state3.index++] }; + } else { + return DONE_RESULT; + } + }); + } + } + if (collections.length > 1) { + return new StreamImpl(() => ({ collIndex: 0, arrIndex: 0 }), (state3) => { + do { + if (state3.iterator) { + const next3 = state3.iterator.next(); + if (!next3.done) { + return next3; + } + state3.iterator = void 0; + } + if (state3.array) { + if (state3.arrIndex < state3.array.length) { + return { done: false, value: state3.array[state3.arrIndex++] }; + } + state3.array = void 0; + state3.arrIndex = 0; + } + if (state3.collIndex < collections.length) { + const collection4 = collections[state3.collIndex++]; + if (isIterable(collection4)) { + state3.iterator = collection4[Symbol.iterator](); + } else if (collection4 && typeof collection4.length === "number") { + state3.array = collection4; + } + } + } while (state3.iterator || state3.array || state3.collIndex < collections.length); + return DONE_RESULT; + }); + } + return EMPTY_STREAM; + } + var StreamImpl, EMPTY_STREAM, DONE_RESULT, TreeStreamImpl, Reduction; + var init_stream = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/stream.js"() { + "use strict"; + StreamImpl = class _StreamImpl { + static { + __name(this, "StreamImpl"); + } + constructor(startFn, nextFn) { + this.startFn = startFn; + this.nextFn = nextFn; + } + iterator() { + const iterator = { + state: this.startFn(), + next: /* @__PURE__ */ __name(() => this.nextFn(iterator.state), "next"), + [Symbol.iterator]: () => iterator + }; + return iterator; + } + [Symbol.iterator]() { + return this.iterator(); + } + isEmpty() { + const iterator = this.iterator(); + return Boolean(iterator.next().done); + } + count() { + const iterator = this.iterator(); + let count2 = 0; + let next3 = iterator.next(); + while (!next3.done) { + count2++; + next3 = iterator.next(); + } + return count2; + } + toArray() { + const result = []; + const iterator = this.iterator(); + let next3; + do { + next3 = iterator.next(); + if (next3.value !== void 0) { + result.push(next3.value); + } + } while (!next3.done); + return result; + } + toSet() { + return new Set(this); + } + toMap(keyFn, valueFn) { + const entryStream = this.map((element3) => [ + keyFn ? keyFn(element3) : element3, + valueFn ? valueFn(element3) : element3 + ]); + return new Map(entryStream); + } + toString() { + return this.join(); + } + concat(other) { + return new _StreamImpl(() => ({ first: this.startFn(), firstDone: false, iterator: other[Symbol.iterator]() }), (state3) => { + let result; + if (!state3.firstDone) { + do { + result = this.nextFn(state3.first); + if (!result.done) { + return result; + } + } while (!result.done); + state3.firstDone = true; + } + do { + result = state3.iterator.next(); + if (!result.done) { + return result; + } + } while (!result.done); + return DONE_RESULT; + }); + } + join(separator = ",") { + const iterator = this.iterator(); + let value2 = ""; + let result; + let addSeparator = false; + do { + result = iterator.next(); + if (!result.done) { + if (addSeparator) { + value2 += separator; + } + value2 += toString5(result.value); + } + addSeparator = true; + } while (!result.done); + return value2; + } + indexOf(searchElement, fromIndex = 0) { + const iterator = this.iterator(); + let index = 0; + let next3 = iterator.next(); + while (!next3.done) { + if (index >= fromIndex && next3.value === searchElement) { + return index; + } + next3 = iterator.next(); + index++; + } + return -1; + } + every(predicate) { + const iterator = this.iterator(); + let next3 = iterator.next(); + while (!next3.done) { + if (!predicate(next3.value)) { + return false; + } + next3 = iterator.next(); + } + return true; + } + some(predicate) { + const iterator = this.iterator(); + let next3 = iterator.next(); + while (!next3.done) { + if (predicate(next3.value)) { + return true; + } + next3 = iterator.next(); + } + return false; + } + forEach(callbackfn) { + const iterator = this.iterator(); + let index = 0; + let next3 = iterator.next(); + while (!next3.done) { + callbackfn(next3.value, index); + next3 = iterator.next(); + index++; + } + } + map(callbackfn) { + return new _StreamImpl(this.startFn, (state3) => { + const { done, value: value2 } = this.nextFn(state3); + if (done) { + return DONE_RESULT; + } else { + return { done: false, value: callbackfn(value2) }; + } + }); + } + filter(predicate) { + return new _StreamImpl(this.startFn, (state3) => { + let result; + do { + result = this.nextFn(state3); + if (!result.done && predicate(result.value)) { + return result; + } + } while (!result.done); + return DONE_RESULT; + }); + } + nonNullable() { + return this.filter((e3) => e3 !== void 0 && e3 !== null); + } + reduce(callbackfn, initialValue) { + const iterator = this.iterator(); + let previousValue = initialValue; + let next3 = iterator.next(); + while (!next3.done) { + if (previousValue === void 0) { + previousValue = next3.value; + } else { + previousValue = callbackfn(previousValue, next3.value); + } + next3 = iterator.next(); + } + return previousValue; + } + reduceRight(callbackfn, initialValue) { + return this.recursiveReduce(this.iterator(), callbackfn, initialValue); + } + recursiveReduce(iterator, callbackfn, initialValue) { + const next3 = iterator.next(); + if (next3.done) { + return initialValue; + } + const previousValue = this.recursiveReduce(iterator, callbackfn, initialValue); + if (previousValue === void 0) { + return next3.value; + } + return callbackfn(previousValue, next3.value); + } + find(predicate) { + const iterator = this.iterator(); + let next3 = iterator.next(); + while (!next3.done) { + if (predicate(next3.value)) { + return next3.value; + } + next3 = iterator.next(); + } + return void 0; + } + findIndex(predicate) { + const iterator = this.iterator(); + let index = 0; + let next3 = iterator.next(); + while (!next3.done) { + if (predicate(next3.value)) { + return index; + } + next3 = iterator.next(); + index++; + } + return -1; + } + includes(searchElement) { + const iterator = this.iterator(); + let next3 = iterator.next(); + while (!next3.done) { + if (next3.value === searchElement) { + return true; + } + next3 = iterator.next(); + } + return false; + } + flatMap(callbackfn) { + return new _StreamImpl(() => ({ this: this.startFn() }), (state3) => { + do { + if (state3.iterator) { + const next3 = state3.iterator.next(); + if (next3.done) { + state3.iterator = void 0; + } else { + return next3; + } + } + const { done, value: value2 } = this.nextFn(state3.this); + if (!done) { + const mapped = callbackfn(value2); + if (isIterable(mapped)) { + state3.iterator = mapped[Symbol.iterator](); + } else { + return { done: false, value: mapped }; + } + } + } while (state3.iterator); + return DONE_RESULT; + }); + } + flat(depth) { + if (depth === void 0) { + depth = 1; + } + if (depth <= 0) { + return this; + } + const stream2 = depth > 1 ? this.flat(depth - 1) : this; + return new _StreamImpl(() => ({ this: stream2.startFn() }), (state3) => { + do { + if (state3.iterator) { + const next3 = state3.iterator.next(); + if (next3.done) { + state3.iterator = void 0; + } else { + return next3; + } + } + const { done, value: value2 } = stream2.nextFn(state3.this); + if (!done) { + if (isIterable(value2)) { + state3.iterator = value2[Symbol.iterator](); + } else { + return { done: false, value: value2 }; + } + } + } while (state3.iterator); + return DONE_RESULT; + }); + } + head() { + const iterator = this.iterator(); + const result = iterator.next(); + if (result.done) { + return void 0; + } + return result.value; + } + tail(skipCount = 1) { + return new _StreamImpl(() => { + const state3 = this.startFn(); + for (let i2 = 0; i2 < skipCount; i2++) { + const next3 = this.nextFn(state3); + if (next3.done) { + return state3; + } + } + return state3; + }, this.nextFn); + } + limit(maxSize) { + return new _StreamImpl(() => ({ size: 0, state: this.startFn() }), (state3) => { + state3.size++; + if (state3.size > maxSize) { + return DONE_RESULT; + } + return this.nextFn(state3.state); + }); + } + distinct(by) { + return new _StreamImpl(() => ({ set: /* @__PURE__ */ new Set(), internalState: this.startFn() }), (state3) => { + let result; + do { + result = this.nextFn(state3.internalState); + if (!result.done) { + const value2 = by ? by(result.value) : result.value; + if (!state3.set.has(value2)) { + state3.set.add(value2); + return result; + } + } + } while (!result.done); + return DONE_RESULT; + }); + } + exclude(other, key) { + const otherKeySet = /* @__PURE__ */ new Set(); + for (const item of other) { + const value2 = key ? key(item) : item; + otherKeySet.add(value2); + } + return this.filter((e3) => { + const ownKey = key ? key(e3) : e3; + return !otherKeySet.has(ownKey); + }); + } + }; + __name(toString5, "toString"); + __name(isIterable, "isIterable"); + EMPTY_STREAM = new StreamImpl(() => void 0, () => DONE_RESULT); + DONE_RESULT = Object.freeze({ done: true, value: void 0 }); + __name(stream, "stream"); + TreeStreamImpl = class extends StreamImpl { + static { + __name(this, "TreeStreamImpl"); + } + constructor(root3, children2, options2) { + super(() => ({ + iterators: options2?.includeRoot ? [[root3][Symbol.iterator]()] : [children2(root3)[Symbol.iterator]()], + pruned: false + }), (state3) => { + if (state3.pruned) { + state3.iterators.pop(); + state3.pruned = false; + } + while (state3.iterators.length > 0) { + const iterator = state3.iterators[state3.iterators.length - 1]; + const next3 = iterator.next(); + if (next3.done) { + state3.iterators.pop(); + } else { + state3.iterators.push(children2(next3.value)[Symbol.iterator]()); + return next3; + } + } + return DONE_RESULT; + }); + } + iterator() { + const iterator = { + state: this.startFn(), + next: /* @__PURE__ */ __name(() => this.nextFn(iterator.state), "next"), + prune: /* @__PURE__ */ __name(() => { + iterator.state.pruned = true; + }, "prune"), + [Symbol.iterator]: () => iterator + }; + return iterator; + } + }; + (function(Reduction2) { + function sum2(stream2) { + return stream2.reduce((a2, b3) => a2 + b3, 0); + } + __name(sum2, "sum"); + Reduction2.sum = sum2; + function product(stream2) { + return stream2.reduce((a2, b3) => a2 * b3, 0); + } + __name(product, "product"); + Reduction2.product = product; + function min9(stream2) { + return stream2.reduce((a2, b3) => Math.min(a2, b3)); + } + __name(min9, "min"); + Reduction2.min = min9; + function max10(stream2) { + return stream2.reduce((a2, b3) => Math.max(a2, b3)); + } + __name(max10, "max"); + Reduction2.max = max10; + })(Reduction || (Reduction = {})); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/ast-utils.js + var ast_utils_exports = {}; + __export(ast_utils_exports, { + assignMandatoryProperties: () => assignMandatoryProperties, + copyAstNode: () => copyAstNode, + findRootNode: () => findRootNode, + getContainerOfType: () => getContainerOfType, + getDocument: () => getDocument, + getReferenceNodes: () => getReferenceNodes, + hasContainerOfType: () => hasContainerOfType, + linkContentToContainer: () => linkContentToContainer, + streamAllContents: () => streamAllContents, + streamAst: () => streamAst, + streamContents: () => streamContents, + streamReferences: () => streamReferences + }); + function linkContentToContainer(node2, options2 = {}) { + for (const [name, value2] of Object.entries(node2)) { + if (!name.startsWith("$")) { + if (Array.isArray(value2)) { + value2.forEach((item, index) => { + if (isAstNode(item)) { + item.$container = node2; + item.$containerProperty = name; + item.$containerIndex = index; + if (options2.deep) { + linkContentToContainer(item, options2); + } + } + }); + } else if (isAstNode(value2)) { + value2.$container = node2; + value2.$containerProperty = name; + if (options2.deep) { + linkContentToContainer(value2, options2); + } + } + } + } + } + function getContainerOfType(node2, typePredicate) { + let item = node2; + while (item) { + if (typePredicate(item)) { + return item; + } + item = item.$container; + } + return void 0; + } + function hasContainerOfType(node2, predicate) { + let item = node2; + while (item) { + if (predicate(item)) { + return true; + } + item = item.$container; + } + return false; + } + function getDocument(node2) { + const rootNode = findRootNode(node2); + const result = rootNode.$document; + if (!result) { + throw new Error("AST node has no document."); + } + return result; + } + function findRootNode(node2) { + while (node2.$container) { + node2 = node2.$container; + } + return node2; + } + function getReferenceNodes(reference) { + if (isReference(reference)) { + return reference.ref ? [reference.ref] : []; + } else if (isMultiReference(reference)) { + return reference.items.map((item) => item.ref); + } + return []; + } + function streamContents(node2, options2) { + if (!node2) { + throw new Error("Node must be an AstNode."); + } + const range3 = options2?.range; + return new StreamImpl(() => ({ + keys: Object.keys(node2), + keyIndex: 0, + arrayIndex: 0 + }), (state3) => { + while (state3.keyIndex < state3.keys.length) { + const property2 = state3.keys[state3.keyIndex]; + if (!property2.startsWith("$")) { + const value2 = node2[property2]; + if (isAstNode(value2)) { + state3.keyIndex++; + if (isAstNodeInRange(value2, range3)) { + return { done: false, value: value2 }; + } + } else if (Array.isArray(value2)) { + while (state3.arrayIndex < value2.length) { + const index = state3.arrayIndex++; + const element3 = value2[index]; + if (isAstNode(element3) && isAstNodeInRange(element3, range3)) { + return { done: false, value: element3 }; + } + } + state3.arrayIndex = 0; + } + } + state3.keyIndex++; + } + return DONE_RESULT; + }); + } + function streamAllContents(root3, options2) { + if (!root3) { + throw new Error("Root node must be an AstNode."); + } + return new TreeStreamImpl(root3, (node2) => streamContents(node2, options2)); + } + function streamAst(root3, options2) { + if (!root3) { + throw new Error("Root node must be an AstNode."); + } else if (options2?.range && !isAstNodeInRange(root3, options2.range)) { + return new TreeStreamImpl(root3, () => []); + } + return new TreeStreamImpl(root3, (node2) => streamContents(node2, options2), { includeRoot: true }); + } + function isAstNodeInRange(astNode, range3) { + if (!range3) { + return true; + } + const nodeRange = astNode.$cstNode?.range; + if (!nodeRange) { + return false; + } + return inRange(nodeRange, range3); + } + function streamReferences(node2) { + return new StreamImpl(() => ({ + keys: Object.keys(node2), + keyIndex: 0, + arrayIndex: 0 + }), (state3) => { + while (state3.keyIndex < state3.keys.length) { + const property2 = state3.keys[state3.keyIndex]; + if (!property2.startsWith("$")) { + const value2 = node2[property2]; + if (isReference(value2) || isMultiReference(value2)) { + state3.keyIndex++; + return { done: false, value: { reference: value2, container: node2, property: property2 } }; + } else if (Array.isArray(value2)) { + while (state3.arrayIndex < value2.length) { + const index = state3.arrayIndex++; + const element3 = value2[index]; + if (isReference(element3) || isMultiReference(value2)) { + return { done: false, value: { reference: element3, container: node2, property: property2, index } }; + } + } + state3.arrayIndex = 0; + } + } + state3.keyIndex++; + } + return DONE_RESULT; + }); + } + function assignMandatoryProperties(reflection3, node2) { + const typeMetaData = reflection3.getTypeMetaData(node2.$type); + const genericNode = node2; + for (const property2 of Object.values(typeMetaData.properties)) { + if (property2.defaultValue !== void 0 && genericNode[property2.name] === void 0) { + genericNode[property2.name] = copyDefaultValue(property2.defaultValue); + } + } + } + function copyDefaultValue(propertyType) { + if (Array.isArray(propertyType)) { + return [...propertyType.map(copyDefaultValue)]; + } else { + return propertyType; + } + } + function copyAstNode(node2, buildReference, trace) { + const copy5 = { $type: node2.$type }; + if (trace) { + trace.set(node2, copy5); + trace.set(copy5, node2); + } + for (const [name, value2] of Object.entries(node2)) { + if (!name.startsWith("$")) { + if (isAstNode(value2)) { + copy5[name] = copyAstNode(value2, buildReference, trace); + } else if (isReference(value2)) { + copy5[name] = buildReference(copy5, name, value2.$refNode, value2.$refText, value2); + } else if (Array.isArray(value2)) { + const copiedArray = []; + for (const element3 of value2) { + if (isAstNode(element3)) { + copiedArray.push(copyAstNode(element3, buildReference, trace)); + } else if (isReference(element3)) { + copiedArray.push(buildReference(copy5, name, element3.$refNode, element3.$refText, element3)); + } else { + copiedArray.push(element3); + } + } + copy5[name] = copiedArray; + } else { + copy5[name] = value2; + } + } + } + linkContentToContainer(copy5, { deep: true }); + return copy5; + } + var init_ast_utils = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/ast-utils.js"() { + "use strict"; + init_syntax_tree(); + init_stream(); + init_cst_utils(); + __name(linkContentToContainer, "linkContentToContainer"); + __name(getContainerOfType, "getContainerOfType"); + __name(hasContainerOfType, "hasContainerOfType"); + __name(getDocument, "getDocument"); + __name(findRootNode, "findRootNode"); + __name(getReferenceNodes, "getReferenceNodes"); + __name(streamContents, "streamContents"); + __name(streamAllContents, "streamAllContents"); + __name(streamAst, "streamAst"); + __name(isAstNodeInRange, "isAstNodeInRange"); + __name(streamReferences, "streamReferences"); + __name(assignMandatoryProperties, "assignMandatoryProperties"); + __name(copyDefaultValue, "copyDefaultValue"); + __name(copyAstNode, "copyAstNode"); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/languages/generated/ast.js + var ast_exports = {}; + __export(ast_exports, { + AbstractElement: () => AbstractElement, + AbstractParserRule: () => AbstractParserRule, + AbstractRule: () => AbstractRule, + AbstractType: () => AbstractType, + Action: () => Action, + Alternatives: () => Alternatives, + ArrayLiteral: () => ArrayLiteral, + ArrayType: () => ArrayType, + Assignment: () => Assignment, + BooleanLiteral: () => BooleanLiteral, + CharacterRange: () => CharacterRange, + Condition: () => Condition, + Conjunction: () => Conjunction, + CrossReference: () => CrossReference, + Disjunction: () => Disjunction, + EndOfFile: () => EndOfFile, + Grammar: () => Grammar, + GrammarImport: () => GrammarImport, + Group: () => Group, + InferredType: () => InferredType, + InfixRule: () => InfixRule, + InfixRuleOperatorList: () => InfixRuleOperatorList, + InfixRuleOperators: () => InfixRuleOperators, + Interface: () => Interface, + Keyword: () => Keyword2, + LangiumGrammarAstReflection: () => LangiumGrammarAstReflection, + LangiumGrammarTerminals: () => LangiumGrammarTerminals, + NamedArgument: () => NamedArgument, + NegatedToken: () => NegatedToken, + Negation: () => Negation, + NumberLiteral: () => NumberLiteral, + Parameter: () => Parameter, + ParameterReference: () => ParameterReference, + ParserRule: () => ParserRule, + ReferenceType: () => ReferenceType, + RegexToken: () => RegexToken, + ReturnType: () => ReturnType, + RuleCall: () => RuleCall, + SimpleType: () => SimpleType, + StringLiteral: () => StringLiteral, + TerminalAlternatives: () => TerminalAlternatives, + TerminalElement: () => TerminalElement, + TerminalGroup: () => TerminalGroup, + TerminalRule: () => TerminalRule, + TerminalRuleCall: () => TerminalRuleCall, + Type: () => Type3, + TypeAttribute: () => TypeAttribute, + TypeDefinition: () => TypeDefinition, + UnionType: () => UnionType, + UnorderedGroup: () => UnorderedGroup, + UntilToken: () => UntilToken, + ValueLiteral: () => ValueLiteral, + Wildcard: () => Wildcard, + isAbstractElement: () => isAbstractElement, + isAbstractParserRule: () => isAbstractParserRule, + isAbstractRule: () => isAbstractRule, + isAbstractType: () => isAbstractType, + isAction: () => isAction, + isAlternatives: () => isAlternatives, + isArrayLiteral: () => isArrayLiteral, + isArrayType: () => isArrayType, + isAssignment: () => isAssignment, + isBooleanLiteral: () => isBooleanLiteral, + isCharacterRange: () => isCharacterRange, + isCondition: () => isCondition, + isConjunction: () => isConjunction, + isCrossReference: () => isCrossReference, + isDisjunction: () => isDisjunction, + isEndOfFile: () => isEndOfFile, + isGrammar: () => isGrammar, + isGrammarImport: () => isGrammarImport, + isGroup: () => isGroup, + isInferredType: () => isInferredType, + isInfixRule: () => isInfixRule, + isInfixRuleOperatorList: () => isInfixRuleOperatorList, + isInfixRuleOperators: () => isInfixRuleOperators, + isInterface: () => isInterface, + isKeyword: () => isKeyword, + isNamedArgument: () => isNamedArgument, + isNegatedToken: () => isNegatedToken, + isNegation: () => isNegation, + isNumberLiteral: () => isNumberLiteral, + isParameter: () => isParameter, + isParameterReference: () => isParameterReference, + isParserRule: () => isParserRule, + isReferenceType: () => isReferenceType, + isRegexToken: () => isRegexToken, + isReturnType: () => isReturnType, + isRuleCall: () => isRuleCall, + isSimpleType: () => isSimpleType, + isStringLiteral: () => isStringLiteral, + isTerminalAlternatives: () => isTerminalAlternatives, + isTerminalElement: () => isTerminalElement, + isTerminalGroup: () => isTerminalGroup, + isTerminalRule: () => isTerminalRule, + isTerminalRuleCall: () => isTerminalRuleCall, + isType: () => isType, + isTypeAttribute: () => isTypeAttribute, + isTypeDefinition: () => isTypeDefinition, + isUnionType: () => isUnionType, + isUnorderedGroup: () => isUnorderedGroup, + isUntilToken: () => isUntilToken, + isValueLiteral: () => isValueLiteral, + isWildcard: () => isWildcard, + reflection: () => reflection + }); + function isAbstractElement(item) { + return reflection.isInstance(item, AbstractElement.$type); + } + function isAbstractParserRule(item) { + return reflection.isInstance(item, AbstractParserRule.$type); + } + function isAbstractRule(item) { + return reflection.isInstance(item, AbstractRule.$type); + } + function isAbstractType(item) { + return reflection.isInstance(item, AbstractType.$type); + } + function isAction(item) { + return reflection.isInstance(item, Action.$type); + } + function isAlternatives(item) { + return reflection.isInstance(item, Alternatives.$type); + } + function isArrayLiteral(item) { + return reflection.isInstance(item, ArrayLiteral.$type); + } + function isArrayType(item) { + return reflection.isInstance(item, ArrayType.$type); + } + function isAssignment(item) { + return reflection.isInstance(item, Assignment.$type); + } + function isBooleanLiteral(item) { + return reflection.isInstance(item, BooleanLiteral.$type); + } + function isCharacterRange(item) { + return reflection.isInstance(item, CharacterRange.$type); + } + function isCondition(item) { + return reflection.isInstance(item, Condition.$type); + } + function isConjunction(item) { + return reflection.isInstance(item, Conjunction.$type); + } + function isCrossReference(item) { + return reflection.isInstance(item, CrossReference.$type); + } + function isDisjunction(item) { + return reflection.isInstance(item, Disjunction.$type); + } + function isEndOfFile(item) { + return reflection.isInstance(item, EndOfFile.$type); + } + function isGrammar(item) { + return reflection.isInstance(item, Grammar.$type); + } + function isGrammarImport(item) { + return reflection.isInstance(item, GrammarImport.$type); + } + function isGroup(item) { + return reflection.isInstance(item, Group.$type); + } + function isInferredType(item) { + return reflection.isInstance(item, InferredType.$type); + } + function isInfixRule(item) { + return reflection.isInstance(item, InfixRule.$type); + } + function isInfixRuleOperatorList(item) { + return reflection.isInstance(item, InfixRuleOperatorList.$type); + } + function isInfixRuleOperators(item) { + return reflection.isInstance(item, InfixRuleOperators.$type); + } + function isInterface(item) { + return reflection.isInstance(item, Interface.$type); + } + function isKeyword(item) { + return reflection.isInstance(item, Keyword2.$type); + } + function isNamedArgument(item) { + return reflection.isInstance(item, NamedArgument.$type); + } + function isNegatedToken(item) { + return reflection.isInstance(item, NegatedToken.$type); + } + function isNegation(item) { + return reflection.isInstance(item, Negation.$type); + } + function isNumberLiteral(item) { + return reflection.isInstance(item, NumberLiteral.$type); + } + function isParameter(item) { + return reflection.isInstance(item, Parameter.$type); + } + function isParameterReference(item) { + return reflection.isInstance(item, ParameterReference.$type); + } + function isParserRule(item) { + return reflection.isInstance(item, ParserRule.$type); + } + function isReferenceType(item) { + return reflection.isInstance(item, ReferenceType.$type); + } + function isRegexToken(item) { + return reflection.isInstance(item, RegexToken.$type); + } + function isReturnType(item) { + return reflection.isInstance(item, ReturnType.$type); + } + function isRuleCall(item) { + return reflection.isInstance(item, RuleCall.$type); + } + function isSimpleType(item) { + return reflection.isInstance(item, SimpleType.$type); + } + function isStringLiteral(item) { + return reflection.isInstance(item, StringLiteral.$type); + } + function isTerminalAlternatives(item) { + return reflection.isInstance(item, TerminalAlternatives.$type); + } + function isTerminalElement(item) { + return reflection.isInstance(item, TerminalElement.$type); + } + function isTerminalGroup(item) { + return reflection.isInstance(item, TerminalGroup.$type); + } + function isTerminalRule(item) { + return reflection.isInstance(item, TerminalRule.$type); + } + function isTerminalRuleCall(item) { + return reflection.isInstance(item, TerminalRuleCall.$type); + } + function isType(item) { + return reflection.isInstance(item, Type3.$type); + } + function isTypeAttribute(item) { + return reflection.isInstance(item, TypeAttribute.$type); + } + function isTypeDefinition(item) { + return reflection.isInstance(item, TypeDefinition.$type); + } + function isUnionType(item) { + return reflection.isInstance(item, UnionType.$type); + } + function isUnorderedGroup(item) { + return reflection.isInstance(item, UnorderedGroup.$type); + } + function isUntilToken(item) { + return reflection.isInstance(item, UntilToken.$type); + } + function isValueLiteral(item) { + return reflection.isInstance(item, ValueLiteral.$type); + } + function isWildcard(item) { + return reflection.isInstance(item, Wildcard.$type); + } + var LangiumGrammarTerminals, AbstractElement, AbstractParserRule, AbstractRule, AbstractType, Action, Alternatives, ArrayLiteral, ArrayType, Assignment, BooleanLiteral, CharacterRange, Condition, Conjunction, CrossReference, Disjunction, EndOfFile, Grammar, GrammarImport, Group, InferredType, InfixRule, InfixRuleOperatorList, InfixRuleOperators, Interface, Keyword2, NamedArgument, NegatedToken, Negation, NumberLiteral, Parameter, ParameterReference, ParserRule, ReferenceType, RegexToken, ReturnType, RuleCall, SimpleType, StringLiteral, TerminalAlternatives, TerminalElement, TerminalGroup, TerminalRule, TerminalRuleCall, Type3, TypeAttribute, TypeDefinition, UnionType, UnorderedGroup, UntilToken, ValueLiteral, Wildcard, LangiumGrammarAstReflection, reflection; + var init_ast = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/languages/generated/ast.js"() { + "use strict"; + init_syntax_tree(); + LangiumGrammarTerminals = { + ID: /\^?[_a-zA-Z][\w_]*/, + STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/, + NUMBER: /NaN|-?((\d*\.\d+|\d+)([Ee][+-]?\d+)?|Infinity)/, + RegexLiteral: /\/(?![*+?])(?:[^\r\n\[/\\]|\\.|\[(?:[^\r\n\]\\]|\\.)*\])+\/[a-z]*/, + WS: /\s+/, + ML_COMMENT: /\/\*[\s\S]*?\*\//, + SL_COMMENT: /\/\/[^\n\r]*/ + }; + AbstractElement = { + $type: "AbstractElement", + cardinality: "cardinality" + }; + __name(isAbstractElement, "isAbstractElement"); + AbstractParserRule = { + $type: "AbstractParserRule" + }; + __name(isAbstractParserRule, "isAbstractParserRule"); + AbstractRule = { + $type: "AbstractRule" + }; + __name(isAbstractRule, "isAbstractRule"); + AbstractType = { + $type: "AbstractType" + }; + __name(isAbstractType, "isAbstractType"); + Action = { + $type: "Action", + cardinality: "cardinality", + feature: "feature", + inferredType: "inferredType", + operator: "operator", + type: "type" + }; + __name(isAction, "isAction"); + Alternatives = { + $type: "Alternatives", + cardinality: "cardinality", + elements: "elements" + }; + __name(isAlternatives, "isAlternatives"); + ArrayLiteral = { + $type: "ArrayLiteral", + elements: "elements" + }; + __name(isArrayLiteral, "isArrayLiteral"); + ArrayType = { + $type: "ArrayType", + elementType: "elementType" + }; + __name(isArrayType, "isArrayType"); + Assignment = { + $type: "Assignment", + cardinality: "cardinality", + feature: "feature", + operator: "operator", + predicate: "predicate", + terminal: "terminal" + }; + __name(isAssignment, "isAssignment"); + BooleanLiteral = { + $type: "BooleanLiteral", + true: "true" + }; + __name(isBooleanLiteral, "isBooleanLiteral"); + CharacterRange = { + $type: "CharacterRange", + cardinality: "cardinality", + left: "left", + lookahead: "lookahead", + parenthesized: "parenthesized", + right: "right" + }; + __name(isCharacterRange, "isCharacterRange"); + Condition = { + $type: "Condition" + }; + __name(isCondition, "isCondition"); + Conjunction = { + $type: "Conjunction", + left: "left", + right: "right" + }; + __name(isConjunction, "isConjunction"); + CrossReference = { + $type: "CrossReference", + cardinality: "cardinality", + deprecatedSyntax: "deprecatedSyntax", + isMulti: "isMulti", + terminal: "terminal", + type: "type" + }; + __name(isCrossReference, "isCrossReference"); + Disjunction = { + $type: "Disjunction", + left: "left", + right: "right" + }; + __name(isDisjunction, "isDisjunction"); + EndOfFile = { + $type: "EndOfFile", + cardinality: "cardinality" + }; + __name(isEndOfFile, "isEndOfFile"); + Grammar = { + $type: "Grammar", + imports: "imports", + interfaces: "interfaces", + isDeclared: "isDeclared", + name: "name", + rules: "rules", + types: "types" + }; + __name(isGrammar, "isGrammar"); + GrammarImport = { + $type: "GrammarImport", + path: "path" + }; + __name(isGrammarImport, "isGrammarImport"); + Group = { + $type: "Group", + cardinality: "cardinality", + elements: "elements", + guardCondition: "guardCondition", + predicate: "predicate" + }; + __name(isGroup, "isGroup"); + InferredType = { + $type: "InferredType", + name: "name" + }; + __name(isInferredType, "isInferredType"); + InfixRule = { + $type: "InfixRule", + call: "call", + dataType: "dataType", + inferredType: "inferredType", + name: "name", + operators: "operators", + parameters: "parameters", + returnType: "returnType" + }; + __name(isInfixRule, "isInfixRule"); + InfixRuleOperatorList = { + $type: "InfixRuleOperatorList", + associativity: "associativity", + operators: "operators" + }; + __name(isInfixRuleOperatorList, "isInfixRuleOperatorList"); + InfixRuleOperators = { + $type: "InfixRuleOperators", + precedences: "precedences" + }; + __name(isInfixRuleOperators, "isInfixRuleOperators"); + Interface = { + $type: "Interface", + attributes: "attributes", + name: "name", + superTypes: "superTypes" + }; + __name(isInterface, "isInterface"); + Keyword2 = { + $type: "Keyword", + cardinality: "cardinality", + predicate: "predicate", + value: "value" + }; + __name(isKeyword, "isKeyword"); + NamedArgument = { + $type: "NamedArgument", + calledByName: "calledByName", + parameter: "parameter", + value: "value" + }; + __name(isNamedArgument, "isNamedArgument"); + NegatedToken = { + $type: "NegatedToken", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized", + terminal: "terminal" + }; + __name(isNegatedToken, "isNegatedToken"); + Negation = { + $type: "Negation", + value: "value" + }; + __name(isNegation, "isNegation"); + NumberLiteral = { + $type: "NumberLiteral", + value: "value" + }; + __name(isNumberLiteral, "isNumberLiteral"); + Parameter = { + $type: "Parameter", + name: "name" + }; + __name(isParameter, "isParameter"); + ParameterReference = { + $type: "ParameterReference", + parameter: "parameter" + }; + __name(isParameterReference, "isParameterReference"); + ParserRule = { + $type: "ParserRule", + dataType: "dataType", + definition: "definition", + entry: "entry", + fragment: "fragment", + inferredType: "inferredType", + name: "name", + parameters: "parameters", + returnType: "returnType" + }; + __name(isParserRule, "isParserRule"); + ReferenceType = { + $type: "ReferenceType", + isMulti: "isMulti", + referenceType: "referenceType" + }; + __name(isReferenceType, "isReferenceType"); + RegexToken = { + $type: "RegexToken", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized", + regex: "regex" + }; + __name(isRegexToken, "isRegexToken"); + ReturnType = { + $type: "ReturnType", + name: "name" + }; + __name(isReturnType, "isReturnType"); + RuleCall = { + $type: "RuleCall", + arguments: "arguments", + cardinality: "cardinality", + predicate: "predicate", + rule: "rule" + }; + __name(isRuleCall, "isRuleCall"); + SimpleType = { + $type: "SimpleType", + primitiveType: "primitiveType", + stringType: "stringType", + typeRef: "typeRef" + }; + __name(isSimpleType, "isSimpleType"); + StringLiteral = { + $type: "StringLiteral", + value: "value" + }; + __name(isStringLiteral, "isStringLiteral"); + TerminalAlternatives = { + $type: "TerminalAlternatives", + cardinality: "cardinality", + elements: "elements", + lookahead: "lookahead", + parenthesized: "parenthesized" + }; + __name(isTerminalAlternatives, "isTerminalAlternatives"); + TerminalElement = { + $type: "TerminalElement", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized" + }; + __name(isTerminalElement, "isTerminalElement"); + TerminalGroup = { + $type: "TerminalGroup", + cardinality: "cardinality", + elements: "elements", + lookahead: "lookahead", + parenthesized: "parenthesized" + }; + __name(isTerminalGroup, "isTerminalGroup"); + TerminalRule = { + $type: "TerminalRule", + definition: "definition", + fragment: "fragment", + hidden: "hidden", + name: "name", + type: "type" + }; + __name(isTerminalRule, "isTerminalRule"); + TerminalRuleCall = { + $type: "TerminalRuleCall", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized", + rule: "rule" + }; + __name(isTerminalRuleCall, "isTerminalRuleCall"); + Type3 = { + $type: "Type", + name: "name", + type: "type" + }; + __name(isType, "isType"); + TypeAttribute = { + $type: "TypeAttribute", + defaultValue: "defaultValue", + isOptional: "isOptional", + name: "name", + type: "type" + }; + __name(isTypeAttribute, "isTypeAttribute"); + TypeDefinition = { + $type: "TypeDefinition" + }; + __name(isTypeDefinition, "isTypeDefinition"); + UnionType = { + $type: "UnionType", + types: "types" + }; + __name(isUnionType, "isUnionType"); + UnorderedGroup = { + $type: "UnorderedGroup", + cardinality: "cardinality", + elements: "elements" + }; + __name(isUnorderedGroup, "isUnorderedGroup"); + UntilToken = { + $type: "UntilToken", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized", + terminal: "terminal" + }; + __name(isUntilToken, "isUntilToken"); + ValueLiteral = { + $type: "ValueLiteral" + }; + __name(isValueLiteral, "isValueLiteral"); + Wildcard = { + $type: "Wildcard", + cardinality: "cardinality", + lookahead: "lookahead", + parenthesized: "parenthesized" + }; + __name(isWildcard, "isWildcard"); + LangiumGrammarAstReflection = class extends AbstractAstReflection { + static { + __name(this, "LangiumGrammarAstReflection"); + } + constructor() { + super(...arguments); + this.types = { + AbstractElement: { + name: AbstractElement.$type, + properties: { + cardinality: { + name: AbstractElement.cardinality + } + }, + superTypes: [] + }, + AbstractParserRule: { + name: AbstractParserRule.$type, + properties: {}, + superTypes: [AbstractRule.$type, AbstractType.$type] + }, + AbstractRule: { + name: AbstractRule.$type, + properties: {}, + superTypes: [] + }, + AbstractType: { + name: AbstractType.$type, + properties: {}, + superTypes: [] + }, + Action: { + name: Action.$type, + properties: { + cardinality: { + name: Action.cardinality + }, + feature: { + name: Action.feature + }, + inferredType: { + name: Action.inferredType + }, + operator: { + name: Action.operator + }, + type: { + name: Action.type, + referenceType: AbstractType.$type + } + }, + superTypes: [AbstractElement.$type] + }, + Alternatives: { + name: Alternatives.$type, + properties: { + cardinality: { + name: Alternatives.cardinality + }, + elements: { + name: Alternatives.elements, + defaultValue: [] + } + }, + superTypes: [AbstractElement.$type] + }, + ArrayLiteral: { + name: ArrayLiteral.$type, + properties: { + elements: { + name: ArrayLiteral.elements, + defaultValue: [] + } + }, + superTypes: [ValueLiteral.$type] + }, + ArrayType: { + name: ArrayType.$type, + properties: { + elementType: { + name: ArrayType.elementType + } + }, + superTypes: [TypeDefinition.$type] + }, + Assignment: { + name: Assignment.$type, + properties: { + cardinality: { + name: Assignment.cardinality + }, + feature: { + name: Assignment.feature + }, + operator: { + name: Assignment.operator + }, + predicate: { + name: Assignment.predicate + }, + terminal: { + name: Assignment.terminal + } + }, + superTypes: [AbstractElement.$type] + }, + BooleanLiteral: { + name: BooleanLiteral.$type, + properties: { + true: { + name: BooleanLiteral.true, + defaultValue: false + } + }, + superTypes: [Condition.$type, ValueLiteral.$type] + }, + CharacterRange: { + name: CharacterRange.$type, + properties: { + cardinality: { + name: CharacterRange.cardinality + }, + left: { + name: CharacterRange.left + }, + lookahead: { + name: CharacterRange.lookahead + }, + parenthesized: { + name: CharacterRange.parenthesized, + defaultValue: false + }, + right: { + name: CharacterRange.right + } + }, + superTypes: [TerminalElement.$type] + }, + Condition: { + name: Condition.$type, + properties: {}, + superTypes: [] + }, + Conjunction: { + name: Conjunction.$type, + properties: { + left: { + name: Conjunction.left + }, + right: { + name: Conjunction.right + } + }, + superTypes: [Condition.$type] + }, + CrossReference: { + name: CrossReference.$type, + properties: { + cardinality: { + name: CrossReference.cardinality + }, + deprecatedSyntax: { + name: CrossReference.deprecatedSyntax, + defaultValue: false + }, + isMulti: { + name: CrossReference.isMulti, + defaultValue: false + }, + terminal: { + name: CrossReference.terminal + }, + type: { + name: CrossReference.type, + referenceType: AbstractType.$type + } + }, + superTypes: [AbstractElement.$type] + }, + Disjunction: { + name: Disjunction.$type, + properties: { + left: { + name: Disjunction.left + }, + right: { + name: Disjunction.right + } + }, + superTypes: [Condition.$type] + }, + EndOfFile: { + name: EndOfFile.$type, + properties: { + cardinality: { + name: EndOfFile.cardinality + } + }, + superTypes: [AbstractElement.$type] + }, + Grammar: { + name: Grammar.$type, + properties: { + imports: { + name: Grammar.imports, + defaultValue: [] + }, + interfaces: { + name: Grammar.interfaces, + defaultValue: [] + }, + isDeclared: { + name: Grammar.isDeclared, + defaultValue: false + }, + name: { + name: Grammar.name + }, + rules: { + name: Grammar.rules, + defaultValue: [] + }, + types: { + name: Grammar.types, + defaultValue: [] + } + }, + superTypes: [] + }, + GrammarImport: { + name: GrammarImport.$type, + properties: { + path: { + name: GrammarImport.path + } + }, + superTypes: [] + }, + Group: { + name: Group.$type, + properties: { + cardinality: { + name: Group.cardinality + }, + elements: { + name: Group.elements, + defaultValue: [] + }, + guardCondition: { + name: Group.guardCondition + }, + predicate: { + name: Group.predicate + } + }, + superTypes: [AbstractElement.$type] + }, + InferredType: { + name: InferredType.$type, + properties: { + name: { + name: InferredType.name + } + }, + superTypes: [AbstractType.$type] + }, + InfixRule: { + name: InfixRule.$type, + properties: { + call: { + name: InfixRule.call + }, + dataType: { + name: InfixRule.dataType + }, + inferredType: { + name: InfixRule.inferredType + }, + name: { + name: InfixRule.name + }, + operators: { + name: InfixRule.operators + }, + parameters: { + name: InfixRule.parameters, + defaultValue: [] + }, + returnType: { + name: InfixRule.returnType, + referenceType: AbstractType.$type + } + }, + superTypes: [AbstractParserRule.$type] + }, + InfixRuleOperatorList: { + name: InfixRuleOperatorList.$type, + properties: { + associativity: { + name: InfixRuleOperatorList.associativity + }, + operators: { + name: InfixRuleOperatorList.operators, + defaultValue: [] + } + }, + superTypes: [] + }, + InfixRuleOperators: { + name: InfixRuleOperators.$type, + properties: { + precedences: { + name: InfixRuleOperators.precedences, + defaultValue: [] + } + }, + superTypes: [] + }, + Interface: { + name: Interface.$type, + properties: { + attributes: { + name: Interface.attributes, + defaultValue: [] + }, + name: { + name: Interface.name + }, + superTypes: { + name: Interface.superTypes, + defaultValue: [], + referenceType: AbstractType.$type + } + }, + superTypes: [AbstractType.$type] + }, + Keyword: { + name: Keyword2.$type, + properties: { + cardinality: { + name: Keyword2.cardinality + }, + predicate: { + name: Keyword2.predicate + }, + value: { + name: Keyword2.value + } + }, + superTypes: [AbstractElement.$type] + }, + NamedArgument: { + name: NamedArgument.$type, + properties: { + calledByName: { + name: NamedArgument.calledByName, + defaultValue: false + }, + parameter: { + name: NamedArgument.parameter, + referenceType: Parameter.$type + }, + value: { + name: NamedArgument.value + } + }, + superTypes: [] + }, + NegatedToken: { + name: NegatedToken.$type, + properties: { + cardinality: { + name: NegatedToken.cardinality + }, + lookahead: { + name: NegatedToken.lookahead + }, + parenthesized: { + name: NegatedToken.parenthesized, + defaultValue: false + }, + terminal: { + name: NegatedToken.terminal + } + }, + superTypes: [TerminalElement.$type] + }, + Negation: { + name: Negation.$type, + properties: { + value: { + name: Negation.value + } + }, + superTypes: [Condition.$type] + }, + NumberLiteral: { + name: NumberLiteral.$type, + properties: { + value: { + name: NumberLiteral.value + } + }, + superTypes: [ValueLiteral.$type] + }, + Parameter: { + name: Parameter.$type, + properties: { + name: { + name: Parameter.name + } + }, + superTypes: [] + }, + ParameterReference: { + name: ParameterReference.$type, + properties: { + parameter: { + name: ParameterReference.parameter, + referenceType: Parameter.$type + } + }, + superTypes: [Condition.$type] + }, + ParserRule: { + name: ParserRule.$type, + properties: { + dataType: { + name: ParserRule.dataType + }, + definition: { + name: ParserRule.definition + }, + entry: { + name: ParserRule.entry, + defaultValue: false + }, + fragment: { + name: ParserRule.fragment, + defaultValue: false + }, + inferredType: { + name: ParserRule.inferredType + }, + name: { + name: ParserRule.name + }, + parameters: { + name: ParserRule.parameters, + defaultValue: [] + }, + returnType: { + name: ParserRule.returnType, + referenceType: AbstractType.$type + } + }, + superTypes: [AbstractParserRule.$type] + }, + ReferenceType: { + name: ReferenceType.$type, + properties: { + isMulti: { + name: ReferenceType.isMulti, + defaultValue: false + }, + referenceType: { + name: ReferenceType.referenceType + } + }, + superTypes: [TypeDefinition.$type] + }, + RegexToken: { + name: RegexToken.$type, + properties: { + cardinality: { + name: RegexToken.cardinality + }, + lookahead: { + name: RegexToken.lookahead + }, + parenthesized: { + name: RegexToken.parenthesized, + defaultValue: false + }, + regex: { + name: RegexToken.regex + } + }, + superTypes: [TerminalElement.$type] + }, + ReturnType: { + name: ReturnType.$type, + properties: { + name: { + name: ReturnType.name + } + }, + superTypes: [] + }, + RuleCall: { + name: RuleCall.$type, + properties: { + arguments: { + name: RuleCall.arguments, + defaultValue: [] + }, + cardinality: { + name: RuleCall.cardinality + }, + predicate: { + name: RuleCall.predicate + }, + rule: { + name: RuleCall.rule, + referenceType: AbstractRule.$type + } + }, + superTypes: [AbstractElement.$type] + }, + SimpleType: { + name: SimpleType.$type, + properties: { + primitiveType: { + name: SimpleType.primitiveType + }, + stringType: { + name: SimpleType.stringType + }, + typeRef: { + name: SimpleType.typeRef, + referenceType: AbstractType.$type + } + }, + superTypes: [TypeDefinition.$type] + }, + StringLiteral: { + name: StringLiteral.$type, + properties: { + value: { + name: StringLiteral.value + } + }, + superTypes: [ValueLiteral.$type] + }, + TerminalAlternatives: { + name: TerminalAlternatives.$type, + properties: { + cardinality: { + name: TerminalAlternatives.cardinality + }, + elements: { + name: TerminalAlternatives.elements, + defaultValue: [] + }, + lookahead: { + name: TerminalAlternatives.lookahead + }, + parenthesized: { + name: TerminalAlternatives.parenthesized, + defaultValue: false + } + }, + superTypes: [TerminalElement.$type] + }, + TerminalElement: { + name: TerminalElement.$type, + properties: { + cardinality: { + name: TerminalElement.cardinality + }, + lookahead: { + name: TerminalElement.lookahead + }, + parenthesized: { + name: TerminalElement.parenthesized, + defaultValue: false + } + }, + superTypes: [AbstractElement.$type] + }, + TerminalGroup: { + name: TerminalGroup.$type, + properties: { + cardinality: { + name: TerminalGroup.cardinality + }, + elements: { + name: TerminalGroup.elements, + defaultValue: [] + }, + lookahead: { + name: TerminalGroup.lookahead + }, + parenthesized: { + name: TerminalGroup.parenthesized, + defaultValue: false + } + }, + superTypes: [TerminalElement.$type] + }, + TerminalRule: { + name: TerminalRule.$type, + properties: { + definition: { + name: TerminalRule.definition + }, + fragment: { + name: TerminalRule.fragment, + defaultValue: false + }, + hidden: { + name: TerminalRule.hidden, + defaultValue: false + }, + name: { + name: TerminalRule.name + }, + type: { + name: TerminalRule.type + } + }, + superTypes: [AbstractRule.$type] + }, + TerminalRuleCall: { + name: TerminalRuleCall.$type, + properties: { + cardinality: { + name: TerminalRuleCall.cardinality + }, + lookahead: { + name: TerminalRuleCall.lookahead + }, + parenthesized: { + name: TerminalRuleCall.parenthesized, + defaultValue: false + }, + rule: { + name: TerminalRuleCall.rule, + referenceType: TerminalRule.$type + } + }, + superTypes: [TerminalElement.$type] + }, + Type: { + name: Type3.$type, + properties: { + name: { + name: Type3.name + }, + type: { + name: Type3.type + } + }, + superTypes: [AbstractType.$type] + }, + TypeAttribute: { + name: TypeAttribute.$type, + properties: { + defaultValue: { + name: TypeAttribute.defaultValue + }, + isOptional: { + name: TypeAttribute.isOptional, + defaultValue: false + }, + name: { + name: TypeAttribute.name + }, + type: { + name: TypeAttribute.type + } + }, + superTypes: [] + }, + TypeDefinition: { + name: TypeDefinition.$type, + properties: {}, + superTypes: [] + }, + UnionType: { + name: UnionType.$type, + properties: { + types: { + name: UnionType.types, + defaultValue: [] + } + }, + superTypes: [TypeDefinition.$type] + }, + UnorderedGroup: { + name: UnorderedGroup.$type, + properties: { + cardinality: { + name: UnorderedGroup.cardinality + }, + elements: { + name: UnorderedGroup.elements, + defaultValue: [] + } + }, + superTypes: [AbstractElement.$type] + }, + UntilToken: { + name: UntilToken.$type, + properties: { + cardinality: { + name: UntilToken.cardinality + }, + lookahead: { + name: UntilToken.lookahead + }, + parenthesized: { + name: UntilToken.parenthesized, + defaultValue: false + }, + terminal: { + name: UntilToken.terminal + } + }, + superTypes: [TerminalElement.$type] + }, + ValueLiteral: { + name: ValueLiteral.$type, + properties: {}, + superTypes: [] + }, + Wildcard: { + name: Wildcard.$type, + properties: { + cardinality: { + name: Wildcard.cardinality + }, + lookahead: { + name: Wildcard.lookahead + }, + parenthesized: { + name: Wildcard.parenthesized, + defaultValue: false + } + }, + superTypes: [TerminalElement.$type] + } + }; + } + }; + reflection = new LangiumGrammarAstReflection(); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/cst-utils.js + var cst_utils_exports = {}; + __export(cst_utils_exports, { + DefaultNameRegexp: () => DefaultNameRegexp, + RangeComparison: () => RangeComparison, + compareRange: () => compareRange, + findCommentNode: () => findCommentNode, + findDeclarationNodeAtOffset: () => findDeclarationNodeAtOffset, + findLeafNodeAtOffset: () => findLeafNodeAtOffset, + findLeafNodeBeforeOffset: () => findLeafNodeBeforeOffset, + flattenCst: () => flattenCst, + getDatatypeNode: () => getDatatypeNode, + getInteriorNodes: () => getInteriorNodes, + getNextNode: () => getNextNode, + getPreviousNode: () => getPreviousNode, + getStartlineNode: () => getStartlineNode, + inRange: () => inRange, + isChildNode: () => isChildNode, + isCommentNode: () => isCommentNode, + streamCst: () => streamCst, + toDocumentSegment: () => toDocumentSegment, + tokenToRange: () => tokenToRange + }); + function getDatatypeNode(cstNode) { + let current = cstNode; + let found = false; + while (current) { + const definingRule = getContainerOfType(current.grammarSource, isParserRule); + if (definingRule && definingRule.dataType) { + current = current.container; + found = true; + } else if (found) { + return current; + } else { + return void 0; + } + } + return void 0; + } + function streamCst(node2) { + return new TreeStreamImpl(node2, (element3) => { + if (isCompositeCstNode(element3)) { + return element3.content; + } else { + return []; + } + }, { includeRoot: true }); + } + function flattenCst(node2) { + return streamCst(node2).filter(isLeafCstNode); + } + function isChildNode(child, parent4) { + while (child.container) { + child = child.container; + if (child === parent4) { + return true; + } + } + return false; + } + function tokenToRange(token2) { + return { + start: { + character: token2.startColumn - 1, + line: token2.startLine - 1 + }, + end: { + character: token2.endColumn, + // endColumn uses the correct index + line: token2.endLine - 1 + } + }; + } + function toDocumentSegment(node2) { + if (!node2) { + return void 0; + } + const { offset, end: end2, range: range3 } = node2; + return { + range: range3, + offset, + end: end2, + length: end2 - offset + }; + } + function compareRange(range3, to) { + if (range3.end.line < to.start.line || range3.end.line === to.start.line && range3.end.character <= to.start.character) { + return RangeComparison.Before; + } else if (range3.start.line > to.end.line || range3.start.line === to.end.line && range3.start.character >= to.end.character) { + return RangeComparison.After; + } + const startInside = range3.start.line > to.start.line || range3.start.line === to.start.line && range3.start.character >= to.start.character; + const endInside = range3.end.line < to.end.line || range3.end.line === to.end.line && range3.end.character <= to.end.character; + if (startInside && endInside) { + return RangeComparison.Inside; + } else if (startInside) { + return RangeComparison.OverlapBack; + } else if (endInside) { + return RangeComparison.OverlapFront; + } else { + return RangeComparison.Outside; + } + } + function inRange(range3, to) { + const comparison = compareRange(range3, to); + return comparison > RangeComparison.After; + } + function findDeclarationNodeAtOffset(cstNode, offset, nameRegexp = DefaultNameRegexp) { + if (cstNode) { + if (offset > 0) { + const localOffset = offset - cstNode.offset; + const textAtOffset = cstNode.text.charAt(localOffset); + if (!nameRegexp.test(textAtOffset)) { + offset--; + } + } + return findLeafNodeAtOffset(cstNode, offset); + } + return void 0; + } + function findCommentNode(cstNode, commentNames) { + if (cstNode) { + const previous = getPreviousNode(cstNode, true); + if (previous && isCommentNode(previous, commentNames)) { + return previous; + } + if (isRootCstNode(cstNode)) { + const endIndex = cstNode.content.findIndex((e3) => !e3.hidden); + for (let i2 = endIndex - 1; i2 >= 0; i2--) { + const child = cstNode.content[i2]; + if (isCommentNode(child, commentNames)) { + return child; + } + } + } + } + return void 0; + } + function isCommentNode(cstNode, commentNames) { + return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name); + } + function findLeafNodeAtOffset(node2, offset) { + if (isLeafCstNode(node2)) { + return node2; + } else if (isCompositeCstNode(node2)) { + const searchResult = binarySearch(node2, offset, false); + if (searchResult) { + return findLeafNodeAtOffset(searchResult, offset); + } + } + return void 0; + } + function findLeafNodeBeforeOffset(node2, offset) { + if (isLeafCstNode(node2)) { + return node2; + } else if (isCompositeCstNode(node2)) { + const searchResult = binarySearch(node2, offset, true); + if (searchResult) { + return findLeafNodeBeforeOffset(searchResult, offset); + } + } + return void 0; + } + function binarySearch(node2, offset, closest) { + let left3 = 0; + let right3 = node2.content.length - 1; + let closestNode = void 0; + while (left3 <= right3) { + const middle = Math.floor((left3 + right3) / 2); + const middleNode = node2.content[middle]; + if (middleNode.offset <= offset && middleNode.end > offset) { + return middleNode; + } + if (middleNode.end <= offset) { + closestNode = closest ? middleNode : void 0; + left3 = middle + 1; + } else { + right3 = middle - 1; + } + } + return closestNode; + } + function getPreviousNode(node2, hidden = true) { + while (node2.container) { + const parent4 = node2.container; + let index = parent4.content.indexOf(node2); + while (index > 0) { + index--; + const previous = parent4.content[index]; + if (hidden || !previous.hidden) { + return previous; + } + } + node2 = parent4; + } + return void 0; + } + function getNextNode(node2, hidden = true) { + while (node2.container) { + const parent4 = node2.container; + let index = parent4.content.indexOf(node2); + const last3 = parent4.content.length - 1; + while (index < last3) { + index++; + const next3 = parent4.content[index]; + if (hidden || !next3.hidden) { + return next3; + } + } + node2 = parent4; + } + return void 0; + } + function getStartlineNode(node2) { + if (node2.range.start.character === 0) { + return node2; + } + const line2 = node2.range.start.line; + let last3 = node2; + let index; + while (node2.container) { + const parent4 = node2.container; + const selfIndex = index ?? parent4.content.indexOf(node2); + if (selfIndex === 0) { + node2 = parent4; + index = void 0; + } else { + index = selfIndex - 1; + node2 = parent4.content[index]; + } + if (node2.range.start.line !== line2) { + break; + } + last3 = node2; + } + return last3; + } + function getInteriorNodes(start3, end2) { + const commonParent = getCommonParent(start3, end2); + if (!commonParent) { + return []; + } + return commonParent.parent.content.slice(commonParent.a + 1, commonParent.b); + } + function getCommonParent(a2, b3) { + const aParents = getParentChain(a2); + const bParents = getParentChain(b3); + let current; + for (let i2 = 0; i2 < aParents.length && i2 < bParents.length; i2++) { + const aParent = aParents[i2]; + const bParent = bParents[i2]; + if (aParent.parent === bParent.parent) { + current = { + parent: aParent.parent, + a: aParent.index, + b: bParent.index + }; + } else { + break; + } + } + return current; + } + function getParentChain(node2) { + const chain = []; + while (node2.container) { + const parent4 = node2.container; + const index = parent4.content.indexOf(node2); + chain.push({ + parent: parent4, + index + }); + node2 = parent4; + } + return chain.reverse(); + } + var RangeComparison, DefaultNameRegexp; + var init_cst_utils = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/cst-utils.js"() { + "use strict"; + init_syntax_tree(); + init_stream(); + init_ast_utils(); + init_ast(); + __name(getDatatypeNode, "getDatatypeNode"); + __name(streamCst, "streamCst"); + __name(flattenCst, "flattenCst"); + __name(isChildNode, "isChildNode"); + __name(tokenToRange, "tokenToRange"); + __name(toDocumentSegment, "toDocumentSegment"); + (function(RangeComparison2) { + RangeComparison2[RangeComparison2["Before"] = 0] = "Before"; + RangeComparison2[RangeComparison2["After"] = 1] = "After"; + RangeComparison2[RangeComparison2["OverlapFront"] = 2] = "OverlapFront"; + RangeComparison2[RangeComparison2["OverlapBack"] = 3] = "OverlapBack"; + RangeComparison2[RangeComparison2["Inside"] = 4] = "Inside"; + RangeComparison2[RangeComparison2["Outside"] = 5] = "Outside"; + })(RangeComparison || (RangeComparison = {})); + __name(compareRange, "compareRange"); + __name(inRange, "inRange"); + DefaultNameRegexp = /^[\w\p{L}]$/u; + __name(findDeclarationNodeAtOffset, "findDeclarationNodeAtOffset"); + __name(findCommentNode, "findCommentNode"); + __name(isCommentNode, "isCommentNode"); + __name(findLeafNodeAtOffset, "findLeafNodeAtOffset"); + __name(findLeafNodeBeforeOffset, "findLeafNodeBeforeOffset"); + __name(binarySearch, "binarySearch"); + __name(getPreviousNode, "getPreviousNode"); + __name(getNextNode, "getNextNode"); + __name(getStartlineNode, "getStartlineNode"); + __name(getInteriorNodes, "getInteriorNodes"); + __name(getCommonParent, "getCommonParent"); + __name(getParentChain, "getParentChain"); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/errors.js + function assertUnreachable(_3, message = "Error: Got unexpected value.") { + throw new Error(message); + } + function assertCondition(condition, message = "Error: Condition is violated.") { + if (!condition) { + throw new Error(message); + } + } + var ErrorWithLocation; + var init_errors2 = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/errors.js"() { + "use strict"; + ErrorWithLocation = class extends Error { + static { + __name(this, "ErrorWithLocation"); + } + constructor(node2, message) { + super(node2 ? `${message} at ${node2.range.start.line}:${node2.range.start.character}` : message); + } + }; + __name(assertUnreachable, "assertUnreachable"); + __name(assertCondition, "assertCondition"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js + function cc(char2) { + return char2.charCodeAt(0); + } + function insertToSet(item, set5) { + if (Array.isArray(item)) { + item.forEach(function(subItem) { + set5.push(subItem); + }); + } else { + set5.push(item); + } + } + function addFlag(flagObj, flagKey) { + if (flagObj[flagKey] === true) { + throw "duplicate flag " + flagKey; + } + const x5 = flagObj[flagKey]; + flagObj[flagKey] = true; + } + function ASSERT_EXISTS(obj) { + if (obj === void 0) { + throw Error("Internal Error - Should never get here!"); + } + return true; + } + function ASSERT_NEVER_REACH_HERE() { + throw Error("Internal Error - Should never get here!"); + } + function isCharacter(obj) { + return obj["type"] === "Character"; + } + var init_utils3 = __esm({ + "../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/utils.js"() { + "use strict"; + __name(cc, "cc"); + __name(insertToSet, "insertToSet"); + __name(addFlag, "addFlag"); + __name(ASSERT_EXISTS, "ASSERT_EXISTS"); + __name(ASSERT_NEVER_REACH_HERE, "ASSERT_NEVER_REACH_HERE"); + __name(isCharacter, "isCharacter"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js + var digitsCharCodes, wordCharCodes, whitespaceCodes; + var init_character_classes = __esm({ + "../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/character-classes.js"() { + "use strict"; + init_utils3(); + digitsCharCodes = []; + for (let i2 = cc("0"); i2 <= cc("9"); i2++) { + digitsCharCodes.push(i2); + } + wordCharCodes = [cc("_")].concat(digitsCharCodes); + for (let i2 = cc("a"); i2 <= cc("z"); i2++) { + wordCharCodes.push(i2); + } + for (let i2 = cc("A"); i2 <= cc("Z"); i2++) { + wordCharCodes.push(i2); + } + whitespaceCodes = [ + cc(" "), + cc("\f"), + cc("\n"), + cc("\r"), + cc(" "), + cc("\v"), + cc(" "), + cc("\xA0"), + cc("\u1680"), + cc("\u2000"), + cc("\u2001"), + cc("\u2002"), + cc("\u2003"), + cc("\u2004"), + cc("\u2005"), + cc("\u2006"), + cc("\u2007"), + cc("\u2008"), + cc("\u2009"), + cc("\u200A"), + cc("\u2028"), + cc("\u2029"), + cc("\u202F"), + cc("\u205F"), + cc("\u3000"), + cc("\uFEFF") + ]; + } + }); + + // ../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js + var hexDigitPattern, decimalPattern, decimalPatternNoZero, RegExpParser; + var init_regexp_parser = __esm({ + "../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.js"() { + "use strict"; + init_utils3(); + init_character_classes(); + hexDigitPattern = /[0-9a-fA-F]/; + decimalPattern = /[0-9]/; + decimalPatternNoZero = /[1-9]/; + RegExpParser = class { + static { + __name(this, "RegExpParser"); + } + constructor() { + this.idx = 0; + this.input = ""; + this.groupIdx = 0; + } + saveState() { + return { + idx: this.idx, + input: this.input, + groupIdx: this.groupIdx + }; + } + restoreState(newState2) { + this.idx = newState2.idx; + this.input = newState2.input; + this.groupIdx = newState2.groupIdx; + } + pattern(input) { + this.idx = 0; + this.input = input; + this.groupIdx = 0; + this.consumeChar("/"); + const value2 = this.disjunction(); + this.consumeChar("/"); + const flags = { + type: "Flags", + loc: { begin: this.idx, end: input.length }, + global: false, + ignoreCase: false, + multiLine: false, + unicode: false, + sticky: false + }; + while (this.isRegExpFlag()) { + switch (this.popChar()) { + case "g": + addFlag(flags, "global"); + break; + case "i": + addFlag(flags, "ignoreCase"); + break; + case "m": + addFlag(flags, "multiLine"); + break; + case "u": + addFlag(flags, "unicode"); + break; + case "y": + addFlag(flags, "sticky"); + break; + } + } + if (this.idx !== this.input.length) { + throw Error("Redundant input: " + this.input.substring(this.idx)); + } + return { + type: "Pattern", + flags, + value: value2, + loc: this.loc(0) + }; + } + disjunction() { + const alts = []; + const begin = this.idx; + alts.push(this.alternative()); + while (this.peekChar() === "|") { + this.consumeChar("|"); + alts.push(this.alternative()); + } + return { type: "Disjunction", value: alts, loc: this.loc(begin) }; + } + alternative() { + const terms = []; + const begin = this.idx; + while (this.isTerm()) { + terms.push(this.term()); + } + return { type: "Alternative", value: terms, loc: this.loc(begin) }; + } + term() { + if (this.isAssertion()) { + return this.assertion(); + } else { + return this.atom(); + } + } + assertion() { + const begin = this.idx; + switch (this.popChar()) { + case "^": + return { + type: "StartAnchor", + loc: this.loc(begin) + }; + case "$": + return { type: "EndAnchor", loc: this.loc(begin) }; + // '\b' or '\B' + case "\\": + switch (this.popChar()) { + case "b": + return { + type: "WordBoundary", + loc: this.loc(begin) + }; + case "B": + return { + type: "NonWordBoundary", + loc: this.loc(begin) + }; + } + throw Error("Invalid Assertion Escape"); + // '(?=' or '(?!' + case "(": + this.consumeChar("?"); + let type3; + switch (this.popChar()) { + case "=": + type3 = "Lookahead"; + break; + case "!": + type3 = "NegativeLookahead"; + break; + case "<": { + switch (this.popChar()) { + case "=": + type3 = "Lookbehind"; + break; + case "!": + type3 = "NegativeLookbehind"; + } + break; + } + } + ASSERT_EXISTS(type3); + const disjunction = this.disjunction(); + this.consumeChar(")"); + return { + type: type3, + value: disjunction, + loc: this.loc(begin) + }; + } + return ASSERT_NEVER_REACH_HERE(); + } + quantifier(isBacktracking = false) { + let range3 = void 0; + const begin = this.idx; + switch (this.popChar()) { + case "*": + range3 = { + atLeast: 0, + atMost: Infinity + }; + break; + case "+": + range3 = { + atLeast: 1, + atMost: Infinity + }; + break; + case "?": + range3 = { + atLeast: 0, + atMost: 1 + }; + break; + case "{": + const atLeast = this.integerIncludingZero(); + switch (this.popChar()) { + case "}": + range3 = { + atLeast, + atMost: atLeast + }; + break; + case ",": + let atMost; + if (this.isDigit()) { + atMost = this.integerIncludingZero(); + range3 = { + atLeast, + atMost + }; + } else { + range3 = { + atLeast, + atMost: Infinity + }; + } + this.consumeChar("}"); + break; + } + if (isBacktracking === true && range3 === void 0) { + return void 0; + } + ASSERT_EXISTS(range3); + break; + } + if (isBacktracking === true && range3 === void 0) { + return void 0; + } + if (ASSERT_EXISTS(range3)) { + if (this.peekChar(0) === "?") { + this.consumeChar("?"); + range3.greedy = false; + } else { + range3.greedy = true; + } + range3.type = "Quantifier"; + range3.loc = this.loc(begin); + return range3; + } + } + atom() { + let atom2; + const begin = this.idx; + switch (this.peekChar()) { + case ".": + atom2 = this.dotAll(); + break; + case "\\": + atom2 = this.atomEscape(); + break; + case "[": + atom2 = this.characterClass(); + break; + case "(": + atom2 = this.group(); + break; + } + if (atom2 === void 0 && this.isPatternCharacter()) { + atom2 = this.patternCharacter(); + } + if (ASSERT_EXISTS(atom2)) { + atom2.loc = this.loc(begin); + if (this.isQuantifier()) { + atom2.quantifier = this.quantifier(); + } + return atom2; + } + return ASSERT_NEVER_REACH_HERE(); + } + dotAll() { + this.consumeChar("."); + return { + type: "Set", + complement: true, + value: [cc("\n"), cc("\r"), cc("\u2028"), cc("\u2029")] + }; + } + atomEscape() { + this.consumeChar("\\"); + switch (this.peekChar()) { + case "1": + case "2": + case "3": + case "4": + case "5": + case "6": + case "7": + case "8": + case "9": + return this.decimalEscapeAtom(); + case "d": + case "D": + case "s": + case "S": + case "w": + case "W": + return this.characterClassEscape(); + case "f": + case "n": + case "r": + case "t": + case "v": + return this.controlEscapeAtom(); + case "c": + return this.controlLetterEscapeAtom(); + case "0": + return this.nulCharacterAtom(); + case "x": + return this.hexEscapeSequenceAtom(); + case "u": + return this.regExpUnicodeEscapeSequenceAtom(); + default: + return this.identityEscapeAtom(); + } + } + decimalEscapeAtom() { + const value2 = this.positiveInteger(); + return { type: "GroupBackReference", value: value2 }; + } + characterClassEscape() { + let set5; + let complement = false; + switch (this.popChar()) { + case "d": + set5 = digitsCharCodes; + break; + case "D": + set5 = digitsCharCodes; + complement = true; + break; + case "s": + set5 = whitespaceCodes; + break; + case "S": + set5 = whitespaceCodes; + complement = true; + break; + case "w": + set5 = wordCharCodes; + break; + case "W": + set5 = wordCharCodes; + complement = true; + break; + } + if (ASSERT_EXISTS(set5)) { + return { type: "Set", value: set5, complement }; + } + return ASSERT_NEVER_REACH_HERE(); + } + controlEscapeAtom() { + let escapeCode; + switch (this.popChar()) { + case "f": + escapeCode = cc("\f"); + break; + case "n": + escapeCode = cc("\n"); + break; + case "r": + escapeCode = cc("\r"); + break; + case "t": + escapeCode = cc(" "); + break; + case "v": + escapeCode = cc("\v"); + break; + } + if (ASSERT_EXISTS(escapeCode)) { + return { type: "Character", value: escapeCode }; + } + return ASSERT_NEVER_REACH_HERE(); + } + controlLetterEscapeAtom() { + this.consumeChar("c"); + const letter = this.popChar(); + if (/[a-zA-Z]/.test(letter) === false) { + throw Error("Invalid "); + } + const letterCode = letter.toUpperCase().charCodeAt(0) - 64; + return { type: "Character", value: letterCode }; + } + nulCharacterAtom() { + this.consumeChar("0"); + return { type: "Character", value: cc("\0") }; + } + hexEscapeSequenceAtom() { + this.consumeChar("x"); + return this.parseHexDigits(2); + } + regExpUnicodeEscapeSequenceAtom() { + this.consumeChar("u"); + return this.parseHexDigits(4); + } + identityEscapeAtom() { + const escapedChar = this.popChar(); + return { type: "Character", value: cc(escapedChar) }; + } + classPatternCharacterAtom() { + switch (this.peekChar()) { + // istanbul ignore next + case "\n": + // istanbul ignore next + case "\r": + // istanbul ignore next + case "\u2028": + // istanbul ignore next + case "\u2029": + // istanbul ignore next + case "\\": + // istanbul ignore next + case "]": + throw Error("TBD"); + default: + const nextChar = this.popChar(); + return { type: "Character", value: cc(nextChar) }; + } + } + characterClass() { + const set5 = []; + let complement = false; + this.consumeChar("["); + if (this.peekChar(0) === "^") { + this.consumeChar("^"); + complement = true; + } + while (this.isClassAtom()) { + const from2 = this.classAtom(); + const isFromSingleChar = from2.type === "Character"; + if (isCharacter(from2) && this.isRangeDash()) { + this.consumeChar("-"); + const to = this.classAtom(); + const isToSingleChar = to.type === "Character"; + if (isCharacter(to)) { + if (to.value < from2.value) { + throw Error("Range out of order in character class"); + } + set5.push({ from: from2.value, to: to.value }); + } else { + insertToSet(from2.value, set5); + set5.push(cc("-")); + insertToSet(to.value, set5); + } + } else { + insertToSet(from2.value, set5); + } + } + this.consumeChar("]"); + return { type: "Set", complement, value: set5 }; + } + classAtom() { + switch (this.peekChar()) { + // istanbul ignore next + case "]": + // istanbul ignore next + case "\n": + // istanbul ignore next + case "\r": + // istanbul ignore next + case "\u2028": + // istanbul ignore next + case "\u2029": + throw Error("TBD"); + case "\\": + return this.classEscape(); + default: + return this.classPatternCharacterAtom(); + } + } + classEscape() { + this.consumeChar("\\"); + switch (this.peekChar()) { + // Matches a backspace. + // (Not to be confused with \b word boundary outside characterClass) + case "b": + this.consumeChar("b"); + return { type: "Character", value: cc("\b") }; + case "d": + case "D": + case "s": + case "S": + case "w": + case "W": + return this.characterClassEscape(); + case "f": + case "n": + case "r": + case "t": + case "v": + return this.controlEscapeAtom(); + case "c": + return this.controlLetterEscapeAtom(); + case "0": + return this.nulCharacterAtom(); + case "x": + return this.hexEscapeSequenceAtom(); + case "u": + return this.regExpUnicodeEscapeSequenceAtom(); + default: + return this.identityEscapeAtom(); + } + } + group() { + let capturing = true; + this.consumeChar("("); + switch (this.peekChar(0)) { + case "?": + this.consumeChar("?"); + this.consumeChar(":"); + capturing = false; + break; + default: + this.groupIdx++; + break; + } + const value2 = this.disjunction(); + this.consumeChar(")"); + const groupAst = { + type: "Group", + capturing, + value: value2 + }; + if (capturing) { + groupAst["idx"] = this.groupIdx; + } + return groupAst; + } + positiveInteger() { + let number7 = this.popChar(); + if (decimalPatternNoZero.test(number7) === false) { + throw Error("Expecting a positive integer"); + } + while (decimalPattern.test(this.peekChar(0))) { + number7 += this.popChar(); + } + return parseInt(number7, 10); + } + integerIncludingZero() { + let number7 = this.popChar(); + if (decimalPattern.test(number7) === false) { + throw Error("Expecting an integer"); + } + while (decimalPattern.test(this.peekChar(0))) { + number7 += this.popChar(); + } + return parseInt(number7, 10); + } + patternCharacter() { + const nextChar = this.popChar(); + switch (nextChar) { + // istanbul ignore next + case "\n": + // istanbul ignore next + case "\r": + // istanbul ignore next + case "\u2028": + // istanbul ignore next + case "\u2029": + // istanbul ignore next + case "^": + // istanbul ignore next + case "$": + // istanbul ignore next + case "\\": + // istanbul ignore next + case ".": + // istanbul ignore next + case "*": + // istanbul ignore next + case "+": + // istanbul ignore next + case "?": + // istanbul ignore next + case "(": + // istanbul ignore next + case ")": + // istanbul ignore next + case "[": + // istanbul ignore next + case "|": + throw Error("TBD"); + default: + return { type: "Character", value: cc(nextChar) }; + } + } + isRegExpFlag() { + switch (this.peekChar(0)) { + case "g": + case "i": + case "m": + case "u": + case "y": + return true; + default: + return false; + } + } + isRangeDash() { + return this.peekChar() === "-" && this.isClassAtom(1); + } + isDigit() { + return decimalPattern.test(this.peekChar(0)); + } + isClassAtom(howMuch = 0) { + switch (this.peekChar(howMuch)) { + case "]": + case "\n": + case "\r": + case "\u2028": + case "\u2029": + return false; + default: + return true; + } + } + isTerm() { + return this.isAtom() || this.isAssertion(); + } + isAtom() { + if (this.isPatternCharacter()) { + return true; + } + switch (this.peekChar(0)) { + case ".": + case "\\": + // atomEscape + case "[": + // characterClass + // TODO: isAtom must be called before isAssertion - disambiguate + case "(": + return true; + default: + return false; + } + } + isAssertion() { + switch (this.peekChar(0)) { + case "^": + case "$": + return true; + // '\b' or '\B' + case "\\": + switch (this.peekChar(1)) { + case "b": + case "B": + return true; + default: + return false; + } + // '(?=' or '(?!' or `(?<=` or `(?= this.input.length) { + throw Error("Unexpected end of input"); + } + this.idx++; + } + loc(begin) { + return { begin, end: this.idx }; + } + }; + } + }); + + // ../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js + var BaseRegExpVisitor; + var init_base_regexp_visitor = __esm({ + "../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.js"() { + "use strict"; + BaseRegExpVisitor = class { + static { + __name(this, "BaseRegExpVisitor"); + } + visitChildren(node2) { + for (const key in node2) { + const child = node2[key]; + if (node2.hasOwnProperty(key)) { + if (child.type !== void 0) { + this.visit(child); + } else if (Array.isArray(child)) { + child.forEach((subChild) => { + this.visit(subChild); + }, this); + } + } + } + } + visit(node2) { + switch (node2.type) { + case "Pattern": + this.visitPattern(node2); + break; + case "Flags": + this.visitFlags(node2); + break; + case "Disjunction": + this.visitDisjunction(node2); + break; + case "Alternative": + this.visitAlternative(node2); + break; + case "StartAnchor": + this.visitStartAnchor(node2); + break; + case "EndAnchor": + this.visitEndAnchor(node2); + break; + case "WordBoundary": + this.visitWordBoundary(node2); + break; + case "NonWordBoundary": + this.visitNonWordBoundary(node2); + break; + case "Lookahead": + this.visitLookahead(node2); + break; + case "NegativeLookahead": + this.visitNegativeLookahead(node2); + break; + case "Lookbehind": + this.visitLookbehind(node2); + break; + case "NegativeLookbehind": + this.visitNegativeLookbehind(node2); + break; + case "Character": + this.visitCharacter(node2); + break; + case "Set": + this.visitSet(node2); + break; + case "Group": + this.visitGroup(node2); + break; + case "GroupBackReference": + this.visitGroupBackReference(node2); + break; + case "Quantifier": + this.visitQuantifier(node2); + break; + } + this.visitChildren(node2); + } + visitPattern(node2) { + } + visitFlags(node2) { + } + visitDisjunction(node2) { + } + visitAlternative(node2) { + } + // Assertion + visitStartAnchor(node2) { + } + visitEndAnchor(node2) { + } + visitWordBoundary(node2) { + } + visitNonWordBoundary(node2) { + } + visitLookahead(node2) { + } + visitNegativeLookahead(node2) { + } + visitLookbehind(node2) { + } + visitNegativeLookbehind(node2) { + } + // atoms + visitCharacter(node2) { + } + visitSet(node2) { + } + visitGroup(node2) { + } + visitGroupBackReference(node2) { + } + visitQuantifier(node2) { + } + }; + } + }); + + // ../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/api.js + var init_api = __esm({ + "../../node_modules/.pnpm/@chevrotain+regexp-to-ast@11.1.1/node_modules/@chevrotain/regexp-to-ast/lib/src/api.js"() { + "use strict"; + init_regexp_parser(); + init_base_regexp_visitor(); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/regexp-utils.js + var regexp_utils_exports = {}; + __export(regexp_utils_exports, { + NEWLINE_REGEXP: () => NEWLINE_REGEXP, + escapeRegExp: () => escapeRegExp, + getTerminalParts: () => getTerminalParts, + isMultilineComment: () => isMultilineComment, + isWhitespace: () => isWhitespace2, + partialMatches: () => partialMatches, + partialRegExp: () => partialRegExp, + whitespaceCharacters: () => whitespaceCharacters + }); + function getTerminalParts(regexp) { + try { + if (typeof regexp !== "string") { + regexp = regexp.source; + } + regexp = `/${regexp}/`; + const pattern = regexpParser.pattern(regexp); + const parts = []; + for (const alternative of pattern.value.value) { + visitor.reset(regexp); + visitor.visit(alternative); + parts.push({ + start: visitor.startRegexp, + end: visitor.endRegex + }); + } + return parts; + } catch { + return []; + } + } + function isMultilineComment(regexp) { + try { + if (typeof regexp === "string") { + regexp = new RegExp(regexp); + } + regexp = regexp.toString(); + visitor.reset(regexp); + visitor.visit(regexpParser.pattern(regexp)); + return visitor.multiline; + } catch { + return false; + } + } + function isWhitespace2(value2) { + const regexp = typeof value2 === "string" ? new RegExp(value2) : value2; + return whitespaceCharacters.some((ws) => regexp.test(ws)); + } + function escapeRegExp(value2) { + return value2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + function partialMatches(regex2, input) { + const partial = partialRegExp(regex2); + const match2 = input.match(partial); + return !!match2 && match2[0].length > 0; + } + function partialRegExp(regex2) { + if (typeof regex2 === "string") { + regex2 = new RegExp(regex2); + } + const re3 = regex2, source = regex2.source; + let i2 = 0; + function process2() { + let result = "", tmp; + function appendRaw(nbChars) { + result += source.substr(i2, nbChars); + i2 += nbChars; + } + __name(appendRaw, "appendRaw"); + function appendOptional(nbChars) { + result += "(?:" + source.substr(i2, nbChars) + "|$)"; + i2 += nbChars; + } + __name(appendOptional, "appendOptional"); + while (i2 < source.length) { + switch (source[i2]) { + case "\\": + switch (source[i2 + 1]) { + case "c": + appendOptional(3); + break; + case "x": + appendOptional(4); + break; + case "u": + if (re3.unicode) { + if (source[i2 + 2] === "{") { + appendOptional(source.indexOf("}", i2) - i2 + 1); + } else { + appendOptional(6); + } + } else { + appendOptional(2); + } + break; + case "p": + case "P": + if (re3.unicode) { + appendOptional(source.indexOf("}", i2) - i2 + 1); + } else { + appendOptional(2); + } + break; + case "k": + appendOptional(source.indexOf(">", i2) - i2 + 1); + break; + default: + appendOptional(2); + break; + } + break; + case "[": + tmp = /\[(?:\\.|.)*?\]/g; + tmp.lastIndex = i2; + tmp = tmp.exec(source) || []; + appendOptional(tmp[0].length); + break; + case "|": + case "^": + case "$": + case "*": + case "+": + case "?": + appendRaw(1); + break; + case "{": + tmp = /\{\d+,?\d*\}/g; + tmp.lastIndex = i2; + tmp = tmp.exec(source); + if (tmp) { + appendRaw(tmp[0].length); + } else { + appendOptional(1); + } + break; + case "(": + if (source[i2 + 1] === "?") { + switch (source[i2 + 2]) { + case ":": + result += "(?:"; + i2 += 3; + result += process2() + "|$)"; + break; + case "=": + result += "(?="; + i2 += 3; + result += process2() + ")"; + break; + case "!": + tmp = i2; + i2 += 3; + process2(); + result += source.substr(tmp, i2 - tmp); + break; + case "<": + switch (source[i2 + 3]) { + case "=": + case "!": + tmp = i2; + i2 += 4; + process2(); + result += source.substr(tmp, i2 - tmp); + break; + default: + appendRaw(source.indexOf(">", i2) - i2 + 1); + result += process2() + "|$)"; + break; + } + break; + } + } else { + appendRaw(1); + result += process2() + "|$)"; + } + break; + case ")": + ++i2; + return result; + default: + appendOptional(1); + break; + } + } + return result; + } + __name(process2, "process"); + return new RegExp(process2(), regex2.flags); + } + var NEWLINE_REGEXP, regexpParser, TerminalRegExpVisitor, visitor, whitespaceCharacters; + var init_regexp_utils = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/regexp-utils.js"() { + "use strict"; + init_api(); + NEWLINE_REGEXP = /\r?\n/gm; + regexpParser = new RegExpParser(); + TerminalRegExpVisitor = class extends BaseRegExpVisitor { + static { + __name(this, "TerminalRegExpVisitor"); + } + constructor() { + super(...arguments); + this.isStarting = true; + this.endRegexpStack = []; + this.multiline = false; + } + get endRegex() { + return this.endRegexpStack.join(""); + } + reset(regex2) { + this.multiline = false; + this.regex = regex2; + this.startRegexp = ""; + this.isStarting = true; + this.endRegexpStack = []; + } + visitGroup(node2) { + if (node2.quantifier) { + this.isStarting = false; + this.endRegexpStack = []; + } + } + visitCharacter(node2) { + const char2 = String.fromCharCode(node2.value); + if (!this.multiline && char2 === "\n") { + this.multiline = true; + } + if (node2.quantifier) { + this.isStarting = false; + this.endRegexpStack = []; + } else { + const escapedChar = escapeRegExp(char2); + this.endRegexpStack.push(escapedChar); + if (this.isStarting) { + this.startRegexp += escapedChar; + } + } + } + visitSet(node2) { + if (!this.multiline) { + const set5 = this.regex.substring(node2.loc.begin, node2.loc.end); + const regex2 = new RegExp(set5); + this.multiline = Boolean("\n".match(regex2)); + } + if (node2.quantifier) { + this.isStarting = false; + this.endRegexpStack = []; + } else { + const set5 = this.regex.substring(node2.loc.begin, node2.loc.end); + this.endRegexpStack.push(set5); + if (this.isStarting) { + this.startRegexp += set5; + } + } + } + visitChildren(node2) { + if (node2.type === "Group") { + const group2 = node2; + if (group2.quantifier) { + return; + } + } + super.visitChildren(node2); + } + }; + visitor = new TerminalRegExpVisitor(); + __name(getTerminalParts, "getTerminalParts"); + __name(isMultilineComment, "isMultilineComment"); + whitespaceCharacters = "\f\n\r \v \xA0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF".split(""); + __name(isWhitespace2, "isWhitespace"); + __name(escapeRegExp, "escapeRegExp"); + __name(partialMatches, "partialMatches"); + __name(partialRegExp, "partialRegExp"); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/grammar-utils.js + var grammar_utils_exports = {}; + __export(grammar_utils_exports, { + findAssignment: () => findAssignment, + findNameAssignment: () => findNameAssignment, + findNodeForKeyword: () => findNodeForKeyword, + findNodeForProperty: () => findNodeForProperty, + findNodesForKeyword: () => findNodesForKeyword, + findNodesForKeywordInternal: () => findNodesForKeywordInternal, + findNodesForProperty: () => findNodesForProperty, + getActionAtElement: () => getActionAtElement, + getActionType: () => getActionType, + getAllReachableRules: () => getAllReachableRules, + getAllRulesUsedForCrossReferences: () => getAllRulesUsedForCrossReferences, + getCrossReferenceTerminal: () => getCrossReferenceTerminal, + getEntryRule: () => getEntryRule, + getExplicitRuleType: () => getExplicitRuleType, + getHiddenRules: () => getHiddenRules, + getRuleType: () => getRuleType, + getRuleTypeName: () => getRuleTypeName, + getTypeName: () => getTypeName, + isArrayCardinality: () => isArrayCardinality, + isArrayOperator: () => isArrayOperator, + isCommentTerminal: () => isCommentTerminal, + isDataType: () => isDataType, + isDataTypeRule: () => isDataTypeRule, + isOptionalCardinality: () => isOptionalCardinality, + terminalRegex: () => terminalRegex + }); + function getEntryRule(grammar) { + return grammar.rules.find((e3) => isParserRule(e3) && e3.entry); + } + function getHiddenRules(grammar) { + return grammar.rules.filter((e3) => isTerminalRule(e3) && e3.hidden); + } + function getAllReachableRules(grammar, allTerminals) { + const ruleNames = /* @__PURE__ */ new Set(); + const entryRule = getEntryRule(grammar); + if (!entryRule) { + return new Set(grammar.rules); + } + const topMostRules = [entryRule].concat(getHiddenRules(grammar)); + for (const rule of topMostRules) { + ruleDfs(rule, ruleNames, allTerminals); + } + const rules = /* @__PURE__ */ new Set(); + for (const rule of grammar.rules) { + if (ruleNames.has(rule.name) || isTerminalRule(rule) && rule.hidden) { + rules.add(rule); + } + } + return rules; + } + function ruleDfs(rule, visitedSet, allTerminals) { + visitedSet.add(rule.name); + streamAllContents(rule).forEach((node2) => { + if (isRuleCall(node2) || allTerminals && isTerminalRuleCall(node2)) { + const refRule = node2.rule.ref; + if (refRule && !visitedSet.has(refRule.name)) { + ruleDfs(refRule, visitedSet, allTerminals); + } + } + }); + } + function getAllRulesUsedForCrossReferences(grammar) { + const result = /* @__PURE__ */ new Set(); + streamAllContents(grammar).forEach((node2) => { + if (isCrossReference(node2)) { + if (isParserRule(node2.type.ref)) { + result.add(node2.type.ref); + } + if (isInferredType(node2.type.ref) && isParserRule(node2.type.ref.$container)) { + result.add(node2.type.ref.$container); + } + } + }); + return result; + } + function getCrossReferenceTerminal(crossRef) { + if (crossRef.terminal) { + return crossRef.terminal; + } else if (crossRef.type.ref) { + const nameAssigment = findNameAssignment(crossRef.type.ref); + return nameAssigment?.terminal; + } + return void 0; + } + function isCommentTerminal(terminalRule) { + return terminalRule.hidden && !isWhitespace2(terminalRegex(terminalRule)); + } + function findNodesForProperty(node2, property2) { + if (!node2 || !property2) { + return []; + } + return findNodesForPropertyInternal(node2, property2, node2.astNode, true); + } + function findNodeForProperty(node2, property2, index) { + if (!node2 || !property2) { + return void 0; + } + const nodes5 = findNodesForPropertyInternal(node2, property2, node2.astNode, true); + if (nodes5.length === 0) { + return void 0; + } + if (index !== void 0) { + index = Math.max(0, Math.min(index, nodes5.length - 1)); + } else { + index = 0; + } + return nodes5[index]; + } + function findNodesForPropertyInternal(node2, property2, element3, first3) { + if (!first3) { + const nodeFeature = getContainerOfType(node2.grammarSource, isAssignment); + if (nodeFeature && nodeFeature.feature === property2) { + return [node2]; + } + } + if (isCompositeCstNode(node2) && node2.astNode === element3) { + return node2.content.flatMap((e3) => findNodesForPropertyInternal(e3, property2, element3, false)); + } + return []; + } + function findNodesForKeyword(node2, keyword) { + if (!node2) { + return []; + } + return findNodesForKeywordInternal(node2, keyword, node2?.astNode); + } + function findNodeForKeyword(node2, keyword, index) { + if (!node2) { + return void 0; + } + const nodes5 = findNodesForKeywordInternal(node2, keyword, node2?.astNode); + if (nodes5.length === 0) { + return void 0; + } + if (index !== void 0) { + index = Math.max(0, Math.min(index, nodes5.length - 1)); + } else { + index = 0; + } + return nodes5[index]; + } + function findNodesForKeywordInternal(node2, keyword, element3) { + if (node2.astNode !== element3) { + return []; + } + if (isKeyword(node2.grammarSource) && node2.grammarSource.value === keyword) { + return [node2]; + } + const treeIterator = streamCst(node2).iterator(); + let result; + const keywordNodes = []; + do { + result = treeIterator.next(); + if (!result.done) { + const childNode = result.value; + if (childNode.astNode === element3) { + if (isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) { + keywordNodes.push(childNode); + } + } else { + treeIterator.prune(); + } + } + } while (!result.done); + return keywordNodes; + } + function findAssignment(cstNode) { + const astNode = cstNode.astNode; + while (astNode === cstNode.container?.astNode) { + const assignment = getContainerOfType(cstNode.grammarSource, isAssignment); + if (assignment) { + return assignment; + } + cstNode = cstNode.container; + } + return void 0; + } + function findNameAssignment(type3) { + let startNode = type3; + if (isInferredType(startNode)) { + if (isAction(startNode.$container)) { + startNode = startNode.$container.$container; + } else if (isAbstractParserRule(startNode.$container)) { + startNode = startNode.$container; + } else { + assertUnreachable(startNode.$container); + } + } + return findNameAssignmentInternal(type3, startNode, /* @__PURE__ */ new Map()); + } + function findNameAssignmentInternal(type3, startNode, cache3) { + function go(node2, refType) { + let childAssignment = void 0; + const parentAssignment = getContainerOfType(node2, isAssignment); + if (!parentAssignment) { + childAssignment = findNameAssignmentInternal(refType, refType, cache3); + } + cache3.set(type3, childAssignment); + return childAssignment; + } + __name(go, "go"); + if (cache3.has(type3)) { + return cache3.get(type3); + } + cache3.set(type3, void 0); + for (const node2 of streamAllContents(startNode)) { + if (isAssignment(node2) && node2.feature.toLowerCase() === "name") { + cache3.set(type3, node2); + return node2; + } else if (isRuleCall(node2) && isParserRule(node2.rule.ref)) { + return go(node2, node2.rule.ref); + } else if (isSimpleType(node2) && node2.typeRef?.ref) { + return go(node2, node2.typeRef.ref); + } + } + return void 0; + } + function getActionAtElement(element3) { + const parent4 = element3.$container; + if (isGroup(parent4)) { + const elements2 = parent4.elements; + const index = elements2.indexOf(element3); + for (let i2 = index - 1; i2 >= 0; i2--) { + const item = elements2[i2]; + if (isAction(item)) { + return item; + } else { + const action = streamAllContents(elements2[i2]).find(isAction); + if (action) { + return action; + } + } + } + } + if (isAbstractElement(parent4)) { + return getActionAtElement(parent4); + } else { + return void 0; + } + } + function isOptionalCardinality(cardinality, element3) { + return cardinality === "?" || cardinality === "*" || isGroup(element3) && Boolean(element3.guardCondition); + } + function isArrayCardinality(cardinality) { + return cardinality === "*" || cardinality === "+"; + } + function isArrayOperator(operator) { + return operator === "+="; + } + function isDataTypeRule(rule) { + return isDataTypeRuleInternal(rule, /* @__PURE__ */ new Set()); + } + function isDataTypeRuleInternal(rule, visited) { + if (visited.has(rule)) { + return true; + } else { + visited.add(rule); + } + for (const node2 of streamAllContents(rule)) { + if (isRuleCall(node2)) { + if (!node2.rule.ref) { + return false; + } + if (isParserRule(node2.rule.ref) && !isDataTypeRuleInternal(node2.rule.ref, visited)) { + return false; + } + if (isInfixRule(node2.rule.ref)) { + return false; + } + } else if (isAssignment(node2)) { + return false; + } else if (isAction(node2)) { + return false; + } + } + return Boolean(rule.definition); + } + function isDataType(type3) { + return isDataTypeInternal(type3.type, /* @__PURE__ */ new Set()); + } + function isDataTypeInternal(type3, visited) { + if (visited.has(type3)) { + return true; + } else { + visited.add(type3); + } + if (isArrayType(type3)) { + return false; + } else if (isReferenceType(type3)) { + return false; + } else if (isUnionType(type3)) { + return type3.types.every((e3) => isDataTypeInternal(e3, visited)); + } else if (isSimpleType(type3)) { + if (type3.primitiveType !== void 0) { + return true; + } else if (type3.stringType !== void 0) { + return true; + } else if (type3.typeRef !== void 0) { + const ref = type3.typeRef.ref; + if (isType(ref)) { + return isDataTypeInternal(ref.type, visited); + } else { + return false; + } + } else { + return false; + } + } else { + return false; + } + } + function getExplicitRuleType(rule) { + if (isTerminalRule(rule)) { + return void 0; + } + if (rule.inferredType) { + return rule.inferredType.name; + } else if (rule.dataType) { + return rule.dataType; + } else if (rule.returnType) { + const refType = rule.returnType.ref; + if (refType) { + return refType.name; + } + } + return void 0; + } + function getTypeName(type3) { + if (isAbstractParserRule(type3)) { + return isParserRule(type3) && isDataTypeRule(type3) ? type3.name : getExplicitRuleType(type3) ?? type3.name; + } else if (isInterface(type3) || isType(type3) || isReturnType(type3)) { + return type3.name; + } else if (isAction(type3)) { + const actionType = getActionType(type3); + if (actionType) { + return actionType; + } + } else if (isInferredType(type3)) { + return type3.name; + } + throw new Error("Cannot get name of Unknown Type"); + } + function getActionType(action) { + if (action.inferredType) { + return action.inferredType.name; + } else if (action.type?.ref) { + return getTypeName(action.type.ref); + } + return void 0; + } + function getRuleTypeName(rule) { + if (isTerminalRule(rule)) { + return rule.type?.name ?? "string"; + } else { + return isParserRule(rule) && isDataTypeRule(rule) ? rule.name : getExplicitRuleType(rule) ?? rule.name; + } + } + function getRuleType(rule) { + if (isTerminalRule(rule)) { + return rule.type?.name ?? "string"; + } else { + return getExplicitRuleType(rule) ?? rule.name; + } + } + function terminalRegex(terminalRule) { + const flags = { + s: false, + i: false, + u: false + }; + const source = abstractElementToRegex(terminalRule.definition, flags); + const flagText = Object.entries(flags).filter(([, value2]) => value2).map(([name]) => name).join(""); + return new RegExp(source, flagText); + } + function abstractElementToRegex(element3, flags) { + if (isTerminalAlternatives(element3)) { + return terminalAlternativesToRegex(element3); + } else if (isTerminalGroup(element3)) { + return terminalGroupToRegex(element3); + } else if (isCharacterRange(element3)) { + return characterRangeToRegex(element3); + } else if (isTerminalRuleCall(element3)) { + const rule = element3.rule.ref; + if (!rule) { + throw new Error("Missing rule reference."); + } + return withCardinality(abstractElementToRegex(rule.definition), { + cardinality: element3.cardinality, + lookahead: element3.lookahead, + parenthesized: element3.parenthesized + }); + } else if (isNegatedToken(element3)) { + return negateTokenToRegex(element3); + } else if (isUntilToken(element3)) { + return untilTokenToRegex(element3); + } else if (isRegexToken(element3)) { + const lastSlash = element3.regex.lastIndexOf("/"); + const source = element3.regex.substring(1, lastSlash); + const regexFlags = element3.regex.substring(lastSlash + 1); + if (flags) { + flags.i = regexFlags.includes("i"); + flags.s = regexFlags.includes("s"); + flags.u = regexFlags.includes("u"); + } + return withCardinality(source, { + cardinality: element3.cardinality, + lookahead: element3.lookahead, + parenthesized: element3.parenthesized, + wrap: false + }); + } else if (isWildcard(element3)) { + return withCardinality(WILDCARD, { + cardinality: element3.cardinality, + lookahead: element3.lookahead, + parenthesized: element3.parenthesized + }); + } else { + throw new Error(`Invalid terminal element: ${element3?.$type}, ${element3?.$cstNode?.text}`); + } + } + function terminalAlternativesToRegex(alternatives) { + return withCardinality(alternatives.elements.map((e3) => abstractElementToRegex(e3)).join("|"), { + cardinality: alternatives.cardinality, + lookahead: alternatives.lookahead, + parenthesized: alternatives.parenthesized, + wrap: false + // wrapping is not required for top level alternatives, and nested alternatives are already parenthesized according to the grammar + }); + } + function terminalGroupToRegex(group2) { + return withCardinality(group2.elements.map((e3) => abstractElementToRegex(e3)).join(""), { + cardinality: group2.cardinality, + lookahead: group2.lookahead, + parenthesized: group2.parenthesized, + wrap: false + // wrapping is not required for top level group, and nested group are already parenthesized according to the grammar + }); + } + function untilTokenToRegex(until) { + return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, { + cardinality: until.cardinality, + lookahead: until.lookahead, + parenthesized: until.parenthesized + }); + } + function negateTokenToRegex(negate2) { + return withCardinality(`(?!${abstractElementToRegex(negate2.terminal)})${WILDCARD}*?`, { + cardinality: negate2.cardinality, + lookahead: negate2.lookahead, + parenthesized: negate2.parenthesized + }); + } + function characterRangeToRegex(range3) { + if (range3.right) { + return withCardinality(`[${keywordToRegex(range3.left)}-${keywordToRegex(range3.right)}]`, { + cardinality: range3.cardinality, + lookahead: range3.lookahead, + parenthesized: range3.parenthesized, + wrap: false + }); + } + return withCardinality(keywordToRegex(range3.left), { + cardinality: range3.cardinality, + lookahead: range3.lookahead, + parenthesized: range3.parenthesized, + wrap: false + }); + } + function keywordToRegex(keyword) { + return escapeRegExp(keyword.value); + } + function withCardinality(regex2, options2) { + if (options2.parenthesized || options2.lookahead || options2.wrap !== false) { + const groupConfig = options2.lookahead ?? (options2.parenthesized ? "" : "?:"); + regex2 = `(${groupConfig}${regex2})`; + } + if (options2.cardinality) { + return `${regex2}${options2.cardinality}`; + } + return regex2; + } + var WILDCARD; + var init_grammar_utils = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/utils/grammar-utils.js"() { + "use strict"; + init_errors2(); + init_ast(); + init_syntax_tree(); + init_ast_utils(); + init_cst_utils(); + init_regexp_utils(); + __name(getEntryRule, "getEntryRule"); + __name(getHiddenRules, "getHiddenRules"); + __name(getAllReachableRules, "getAllReachableRules"); + __name(ruleDfs, "ruleDfs"); + __name(getAllRulesUsedForCrossReferences, "getAllRulesUsedForCrossReferences"); + __name(getCrossReferenceTerminal, "getCrossReferenceTerminal"); + __name(isCommentTerminal, "isCommentTerminal"); + __name(findNodesForProperty, "findNodesForProperty"); + __name(findNodeForProperty, "findNodeForProperty"); + __name(findNodesForPropertyInternal, "findNodesForPropertyInternal"); + __name(findNodesForKeyword, "findNodesForKeyword"); + __name(findNodeForKeyword, "findNodeForKeyword"); + __name(findNodesForKeywordInternal, "findNodesForKeywordInternal"); + __name(findAssignment, "findAssignment"); + __name(findNameAssignment, "findNameAssignment"); + __name(findNameAssignmentInternal, "findNameAssignmentInternal"); + __name(getActionAtElement, "getActionAtElement"); + __name(isOptionalCardinality, "isOptionalCardinality"); + __name(isArrayCardinality, "isArrayCardinality"); + __name(isArrayOperator, "isArrayOperator"); + __name(isDataTypeRule, "isDataTypeRule"); + __name(isDataTypeRuleInternal, "isDataTypeRuleInternal"); + __name(isDataType, "isDataType"); + __name(isDataTypeInternal, "isDataTypeInternal"); + __name(getExplicitRuleType, "getExplicitRuleType"); + __name(getTypeName, "getTypeName"); + __name(getActionType, "getActionType"); + __name(getRuleTypeName, "getRuleTypeName"); + __name(getRuleType, "getRuleType"); + __name(terminalRegex, "terminalRegex"); + WILDCARD = /[\s\S]/.source; + __name(abstractElementToRegex, "abstractElementToRegex"); + __name(terminalAlternativesToRegex, "terminalAlternativesToRegex"); + __name(terminalGroupToRegex, "terminalGroupToRegex"); + __name(untilTokenToRegex, "untilTokenToRegex"); + __name(negateTokenToRegex, "negateTokenToRegex"); + __name(characterRangeToRegex, "characterRangeToRegex"); + __name(keywordToRegex, "keywordToRegex"); + __name(withCardinality, "withCardinality"); + } + }); + + // ../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/languages/grammar-config.js + function createGrammarConfig(services) { + const rules = []; + const grammar = services.Grammar; + for (const rule of grammar.rules) { + if (isTerminalRule(rule) && isCommentTerminal(rule) && isMultilineComment(terminalRegex(rule))) { + rules.push(rule.name); + } + } + return { + multilineCommentRules: rules, + nameRegexp: DefaultNameRegexp + }; + } + var init_grammar_config = __esm({ + "../../node_modules/.pnpm/langium@4.2.0/node_modules/langium/lib/languages/grammar-config.js"() { + "use strict"; + init_cst_utils(); + init_grammar_utils(); + init_regexp_utils(); + init_ast(); + __name(createGrammarConfig, "createGrammarConfig"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/version.js + var init_version = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/version.js"() { + "use strict"; + } + }); + + // ../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/print.js + function PRINT_ERROR(msg) { + if (console && console.error) { + console.error(`Error: ${msg}`); + } + } + function PRINT_WARNING(msg) { + if (console && console.warn) { + console.warn(`Warning: ${msg}`); + } + } + var init_print = __esm({ + "../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/print.js"() { + "use strict"; + __name(PRINT_ERROR, "PRINT_ERROR"); + __name(PRINT_WARNING, "PRINT_WARNING"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/timer.js + function timer2(func) { + const start3 = (/* @__PURE__ */ new Date()).getTime(); + const val = func(); + const end2 = (/* @__PURE__ */ new Date()).getTime(); + const total = end2 - start3; + return { time: total, value: val }; + } + var init_timer2 = __esm({ + "../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/timer.js"() { + "use strict"; + __name(timer2, "timer"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js + function toFastProperties(toBecomeFast) { + function FakeConstructor() { + } + __name(FakeConstructor, "FakeConstructor"); + FakeConstructor.prototype = toBecomeFast; + const fakeInstance = new FakeConstructor(); + function fakeAccess() { + return typeof fakeInstance.bar; + } + __name(fakeAccess, "fakeAccess"); + fakeAccess(); + fakeAccess(); + if (1) + return toBecomeFast; + (0, eval)(toBecomeFast); + } + var init_to_fast_properties = __esm({ + "../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/to-fast-properties.js"() { + "use strict"; + __name(toFastProperties, "toFastProperties"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/api.js + var init_api2 = __esm({ + "../../node_modules/.pnpm/@chevrotain+utils@11.1.1/node_modules/@chevrotain/utils/lib/src/api.js"() { + "use strict"; + init_print(); + init_timer2(); + init_to_fast_properties(); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/model.js + function tokenLabel(tokType) { + if (hasTokenLabel(tokType)) { + return tokType.LABEL; + } else { + return tokType.name; + } + } + function hasTokenLabel(obj) { + return isString_default(obj.LABEL) && obj.LABEL !== ""; + } + function serializeGrammar(topRules) { + return map_default(topRules, serializeProduction); + } + function serializeProduction(node2) { + function convertDefinition(definition) { + return map_default(definition, serializeProduction); + } + __name(convertDefinition, "convertDefinition"); + if (node2 instanceof NonTerminal) { + const serializedNonTerminal = { + type: "NonTerminal", + name: node2.nonTerminalName, + idx: node2.idx + }; + if (isString_default(node2.label)) { + serializedNonTerminal.label = node2.label; + } + return serializedNonTerminal; + } else if (node2 instanceof Alternative) { + return { + type: "Alternative", + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof Option2) { + return { + type: "Option", + idx: node2.idx, + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof RepetitionMandatory) { + return { + type: "RepetitionMandatory", + idx: node2.idx, + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof RepetitionMandatoryWithSeparator) { + return { + type: "RepetitionMandatoryWithSeparator", + idx: node2.idx, + separator: serializeProduction(new Terminal({ terminalType: node2.separator })), + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof RepetitionWithSeparator) { + return { + type: "RepetitionWithSeparator", + idx: node2.idx, + separator: serializeProduction(new Terminal({ terminalType: node2.separator })), + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof Repetition) { + return { + type: "Repetition", + idx: node2.idx, + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof Alternation) { + return { + type: "Alternation", + idx: node2.idx, + definition: convertDefinition(node2.definition) + }; + } else if (node2 instanceof Terminal) { + const serializedTerminal = { + type: "Terminal", + name: node2.terminalType.name, + label: tokenLabel(node2.terminalType), + idx: node2.idx + }; + if (isString_default(node2.label)) { + serializedTerminal.terminalLabel = node2.label; + } + const pattern = node2.terminalType.PATTERN; + if (node2.terminalType.PATTERN) { + serializedTerminal.pattern = isRegExp_default(pattern) ? pattern.source : pattern; + } + return serializedTerminal; + } else if (node2 instanceof Rule) { + return { + type: "Rule", + name: node2.name, + orgText: node2.orgText, + definition: convertDefinition(node2.definition) + }; + } else { + throw Error("non exhaustive match"); + } + } + var AbstractProduction, NonTerminal, Rule, Alternative, Option2, RepetitionMandatory, RepetitionMandatoryWithSeparator, Repetition, RepetitionWithSeparator, Alternation, Terminal; + var init_model = __esm({ + "../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/model.js"() { + "use strict"; + init_lodash(); + __name(tokenLabel, "tokenLabel"); + __name(hasTokenLabel, "hasTokenLabel"); + AbstractProduction = class { + static { + __name(this, "AbstractProduction"); + } + get definition() { + return this._definition; + } + set definition(value2) { + this._definition = value2; + } + constructor(_definition) { + this._definition = _definition; + } + accept(visitor2) { + visitor2.visit(this); + forEach_default(this.definition, (prod) => { + prod.accept(visitor2); + }); + } + }; + NonTerminal = class extends AbstractProduction { + static { + __name(this, "NonTerminal"); + } + constructor(options2) { + super([]); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + set definition(definition) { + } + get definition() { + if (this.referencedRule !== void 0) { + return this.referencedRule.definition; + } + return []; + } + accept(visitor2) { + visitor2.visit(this); + } + }; + Rule = class extends AbstractProduction { + static { + __name(this, "Rule"); + } + constructor(options2) { + super(options2.definition); + this.orgText = ""; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + Alternative = class extends AbstractProduction { + static { + __name(this, "Alternative"); + } + constructor(options2) { + super(options2.definition); + this.ignoreAmbiguities = false; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + Option2 = class extends AbstractProduction { + static { + __name(this, "Option"); + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + RepetitionMandatory = class extends AbstractProduction { + static { + __name(this, "RepetitionMandatory"); + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + RepetitionMandatoryWithSeparator = class extends AbstractProduction { + static { + __name(this, "RepetitionMandatoryWithSeparator"); + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + Repetition = class extends AbstractProduction { + static { + __name(this, "Repetition"); + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + RepetitionWithSeparator = class extends AbstractProduction { + static { + __name(this, "RepetitionWithSeparator"); + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + Alternation = class extends AbstractProduction { + static { + __name(this, "Alternation"); + } + get definition() { + return this._definition; + } + set definition(value2) { + this._definition = value2; + } + constructor(options2) { + super(options2.definition); + this.idx = 1; + this.ignoreAmbiguities = false; + this.hasPredicates = false; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + }; + Terminal = class { + static { + __name(this, "Terminal"); + } + constructor(options2) { + this.idx = 1; + assign_default(this, pickBy_default(options2, (v3) => v3 !== void 0)); + } + accept(visitor2) { + visitor2.visit(this); + } + }; + __name(serializeGrammar, "serializeGrammar"); + __name(serializeProduction, "serializeProduction"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/visitor.js + var GAstVisitor; + var init_visitor = __esm({ + "../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/visitor.js"() { + "use strict"; + init_model(); + GAstVisitor = class { + static { + __name(this, "GAstVisitor"); + } + visit(node2) { + const nodeAny = node2; + switch (nodeAny.constructor) { + case NonTerminal: + return this.visitNonTerminal(nodeAny); + case Alternative: + return this.visitAlternative(nodeAny); + case Option2: + return this.visitOption(nodeAny); + case RepetitionMandatory: + return this.visitRepetitionMandatory(nodeAny); + case RepetitionMandatoryWithSeparator: + return this.visitRepetitionMandatoryWithSeparator(nodeAny); + case RepetitionWithSeparator: + return this.visitRepetitionWithSeparator(nodeAny); + case Repetition: + return this.visitRepetition(nodeAny); + case Alternation: + return this.visitAlternation(nodeAny); + case Terminal: + return this.visitTerminal(nodeAny); + case Rule: + return this.visitRule(nodeAny); + /* c8 ignore next 2 */ + default: + throw Error("non exhaustive match"); + } + } + /* c8 ignore next */ + visitNonTerminal(node2) { + } + /* c8 ignore next */ + visitAlternative(node2) { + } + /* c8 ignore next */ + visitOption(node2) { + } + /* c8 ignore next */ + visitRepetition(node2) { + } + /* c8 ignore next */ + visitRepetitionMandatory(node2) { + } + /* c8 ignore next 3 */ + visitRepetitionMandatoryWithSeparator(node2) { + } + /* c8 ignore next */ + visitRepetitionWithSeparator(node2) { + } + /* c8 ignore next */ + visitAlternation(node2) { + } + /* c8 ignore next */ + visitTerminal(node2) { + } + /* c8 ignore next */ + visitRule(node2) { + } + }; + } + }); + + // ../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/helpers.js + function isSequenceProd(prod) { + return prod instanceof Alternative || prod instanceof Option2 || prod instanceof Repetition || prod instanceof RepetitionMandatory || prod instanceof RepetitionMandatoryWithSeparator || prod instanceof RepetitionWithSeparator || prod instanceof Terminal || prod instanceof Rule; + } + function isOptionalProd(prod, alreadyVisited = []) { + const isDirectlyOptional = prod instanceof Option2 || prod instanceof Repetition || prod instanceof RepetitionWithSeparator; + if (isDirectlyOptional) { + return true; + } + if (prod instanceof Alternation) { + return some_default(prod.definition, (subProd) => { + return isOptionalProd(subProd, alreadyVisited); + }); + } else if (prod instanceof NonTerminal && includes_default(alreadyVisited, prod)) { + return false; + } else if (prod instanceof AbstractProduction) { + if (prod instanceof NonTerminal) { + alreadyVisited.push(prod); + } + return every_default(prod.definition, (subProd) => { + return isOptionalProd(subProd, alreadyVisited); + }); + } else { + return false; + } + } + function isBranchingProd(prod) { + return prod instanceof Alternation; + } + function getProductionDslName(prod) { + if (prod instanceof NonTerminal) { + return "SUBRULE"; + } else if (prod instanceof Option2) { + return "OPTION"; + } else if (prod instanceof Alternation) { + return "OR"; + } else if (prod instanceof RepetitionMandatory) { + return "AT_LEAST_ONE"; + } else if (prod instanceof RepetitionMandatoryWithSeparator) { + return "AT_LEAST_ONE_SEP"; + } else if (prod instanceof RepetitionWithSeparator) { + return "MANY_SEP"; + } else if (prod instanceof Repetition) { + return "MANY"; + } else if (prod instanceof Terminal) { + return "CONSUME"; + } else { + throw Error("non exhaustive match"); + } + } + var init_helpers = __esm({ + "../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/helpers.js"() { + "use strict"; + init_lodash(); + init_model(); + __name(isSequenceProd, "isSequenceProd"); + __name(isOptionalProd, "isOptionalProd"); + __name(isBranchingProd, "isBranchingProd"); + __name(getProductionDslName, "getProductionDslName"); + } + }); + + // ../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/api.js + var init_api3 = __esm({ + "../../node_modules/.pnpm/@chevrotain+gast@11.1.1/node_modules/@chevrotain/gast/lib/src/api.js"() { + "use strict"; + init_model(); + init_visitor(); + init_helpers(); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/rest.js + function restForRepetitionWithSeparator(repSepProd, currRest, prevRest) { + const repSepRest = [ + new Option2({ + definition: [ + new Terminal({ terminalType: repSepProd.separator }) + ].concat(repSepProd.definition) + }) + ]; + const fullRepSepRest = repSepRest.concat(currRest, prevRest); + return fullRepSepRest; + } + var RestWalker; + var init_rest = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/rest.js"() { + "use strict"; + init_lodash(); + init_api3(); + RestWalker = class { + static { + __name(this, "RestWalker"); + } + walk(prod, prevRest = []) { + forEach_default(prod.definition, (subProd, index) => { + const currRest = drop_default(prod.definition, index + 1); + if (subProd instanceof NonTerminal) { + this.walkProdRef(subProd, currRest, prevRest); + } else if (subProd instanceof Terminal) { + this.walkTerminal(subProd, currRest, prevRest); + } else if (subProd instanceof Alternative) { + this.walkFlat(subProd, currRest, prevRest); + } else if (subProd instanceof Option2) { + this.walkOption(subProd, currRest, prevRest); + } else if (subProd instanceof RepetitionMandatory) { + this.walkAtLeastOne(subProd, currRest, prevRest); + } else if (subProd instanceof RepetitionMandatoryWithSeparator) { + this.walkAtLeastOneSep(subProd, currRest, prevRest); + } else if (subProd instanceof RepetitionWithSeparator) { + this.walkManySep(subProd, currRest, prevRest); + } else if (subProd instanceof Repetition) { + this.walkMany(subProd, currRest, prevRest); + } else if (subProd instanceof Alternation) { + this.walkOr(subProd, currRest, prevRest); + } else { + throw Error("non exhaustive match"); + } + }); + } + walkTerminal(terminal, currRest, prevRest) { + } + walkProdRef(refProd, currRest, prevRest) { + } + walkFlat(flatProd, currRest, prevRest) { + const fullOrRest = currRest.concat(prevRest); + this.walk(flatProd, fullOrRest); + } + walkOption(optionProd, currRest, prevRest) { + const fullOrRest = currRest.concat(prevRest); + this.walk(optionProd, fullOrRest); + } + walkAtLeastOne(atLeastOneProd, currRest, prevRest) { + const fullAtLeastOneRest = [ + new Option2({ definition: atLeastOneProd.definition }) + ].concat(currRest, prevRest); + this.walk(atLeastOneProd, fullAtLeastOneRest); + } + walkAtLeastOneSep(atLeastOneSepProd, currRest, prevRest) { + const fullAtLeastOneSepRest = restForRepetitionWithSeparator(atLeastOneSepProd, currRest, prevRest); + this.walk(atLeastOneSepProd, fullAtLeastOneSepRest); + } + walkMany(manyProd, currRest, prevRest) { + const fullManyRest = [ + new Option2({ definition: manyProd.definition }) + ].concat(currRest, prevRest); + this.walk(manyProd, fullManyRest); + } + walkManySep(manySepProd, currRest, prevRest) { + const fullManySepRest = restForRepetitionWithSeparator(manySepProd, currRest, prevRest); + this.walk(manySepProd, fullManySepRest); + } + walkOr(orProd, currRest, prevRest) { + const fullOrRest = currRest.concat(prevRest); + forEach_default(orProd.definition, (alt) => { + const prodWrapper = new Alternative({ definition: [alt] }); + this.walk(prodWrapper, fullOrRest); + }); + } + }; + __name(restForRepetitionWithSeparator, "restForRepetitionWithSeparator"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/first.js + function first2(prod) { + if (prod instanceof NonTerminal) { + return first2(prod.referencedRule); + } else if (prod instanceof Terminal) { + return firstForTerminal(prod); + } else if (isSequenceProd(prod)) { + return firstForSequence(prod); + } else if (isBranchingProd(prod)) { + return firstForBranching(prod); + } else { + throw Error("non exhaustive match"); + } + } + function firstForSequence(prod) { + let firstSet = []; + const seq2 = prod.definition; + let nextSubProdIdx = 0; + let hasInnerProdsRemaining = seq2.length > nextSubProdIdx; + let currSubProd; + let isLastInnerProdOptional = true; + while (hasInnerProdsRemaining && isLastInnerProdOptional) { + currSubProd = seq2[nextSubProdIdx]; + isLastInnerProdOptional = isOptionalProd(currSubProd); + firstSet = firstSet.concat(first2(currSubProd)); + nextSubProdIdx = nextSubProdIdx + 1; + hasInnerProdsRemaining = seq2.length > nextSubProdIdx; + } + return uniq_default(firstSet); + } + function firstForBranching(prod) { + const allAlternativesFirsts = map_default(prod.definition, (innerProd) => { + return first2(innerProd); + }); + return uniq_default(flatten_default(allAlternativesFirsts)); + } + function firstForTerminal(terminal) { + return [terminal.terminalType]; + } + var init_first2 = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/first.js"() { + "use strict"; + init_lodash(); + init_api3(); + __name(first2, "first"); + __name(firstForSequence, "firstForSequence"); + __name(firstForBranching, "firstForBranching"); + __name(firstForTerminal, "firstForTerminal"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/constants.js + var IN; + var init_constants2 = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/constants.js"() { + "use strict"; + IN = "_~IN~_"; + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/follow.js + function computeAllProdsFollows(topProductions) { + const reSyncFollows = {}; + forEach_default(topProductions, (topProd) => { + const currRefsFollow = new ResyncFollowsWalker(topProd).startWalking(); + assign_default(reSyncFollows, currRefsFollow); + }); + return reSyncFollows; + } + function buildBetweenProdsFollowPrefix(inner2, occurenceInParent) { + return inner2.name + occurenceInParent + IN; + } + var ResyncFollowsWalker; + var init_follow = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/parse/grammar/follow.js"() { + "use strict"; + init_rest(); + init_first2(); + init_lodash(); + init_constants2(); + init_api3(); + ResyncFollowsWalker = class extends RestWalker { + static { + __name(this, "ResyncFollowsWalker"); + } + constructor(topProd) { + super(); + this.topProd = topProd; + this.follows = {}; + } + startWalking() { + this.walk(this.topProd); + return this.follows; + } + walkTerminal(terminal, currRest, prevRest) { + } + walkProdRef(refProd, currRest, prevRest) { + const followName = buildBetweenProdsFollowPrefix(refProd.referencedRule, refProd.idx) + this.topProd.name; + const fullRest = currRest.concat(prevRest); + const restProd = new Alternative({ definition: fullRest }); + const t_in_topProd_follows = first2(restProd); + this.follows[followName] = t_in_topProd_follows; + } + }; + __name(computeAllProdsFollows, "computeAllProdsFollows"); + __name(buildBetweenProdsFollowPrefix, "buildBetweenProdsFollowPrefix"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js + function getRegExpAst(regExp) { + const regExpStr = regExp.toString(); + if (regExpAstCache.hasOwnProperty(regExpStr)) { + return regExpAstCache[regExpStr]; + } else { + const regExpAst = regExpParser.pattern(regExpStr); + regExpAstCache[regExpStr] = regExpAst; + return regExpAst; + } + } + function clearRegExpParserCache() { + regExpAstCache = {}; + } + var regExpAstCache, regExpParser; + var init_reg_exp_parser = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp_parser.js"() { + "use strict"; + init_api(); + regExpAstCache = {}; + regExpParser = new RegExpParser(); + __name(getRegExpAst, "getRegExpAst"); + __name(clearRegExpParserCache, "clearRegExpParserCache"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp.js + function getOptimizedStartCodesIndices(regExp, ensureOptimizations = false) { + try { + const ast = getRegExpAst(regExp); + const firstChars = firstCharOptimizedIndices(ast.value, {}, ast.flags.ignoreCase); + return firstChars; + } catch (e3) { + if (e3.message === complementErrorMessage) { + if (ensureOptimizations) { + PRINT_WARNING(`${failedOptimizationPrefixMsg} Unable to optimize: < ${regExp.toString()} > + Complement Sets cannot be automatically optimized. + This will disable the lexer's first char optimizations. + See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#COMPLEMENT for details.`); + } + } else { + let msgSuffix = ""; + if (ensureOptimizations) { + msgSuffix = "\n This will disable the lexer's first char optimizations.\n See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#REGEXP_PARSING for details."; + } + PRINT_ERROR(`${failedOptimizationPrefixMsg} + Failed parsing: < ${regExp.toString()} > + Using the @chevrotain/regexp-to-ast library + Please open an issue at: https://github.com/chevrotain/chevrotain/issues` + msgSuffix); + } + } + return []; + } + function firstCharOptimizedIndices(ast, result, ignoreCase) { + switch (ast.type) { + case "Disjunction": + for (let i2 = 0; i2 < ast.value.length; i2++) { + firstCharOptimizedIndices(ast.value[i2], result, ignoreCase); + } + break; + case "Alternative": + const terms = ast.value; + for (let i2 = 0; i2 < terms.length; i2++) { + const term = terms[i2]; + switch (term.type) { + case "EndAnchor": + // A group back reference cannot affect potential starting char. + // because if a back reference is the first production than automatically + // the group being referenced has had to come BEFORE so its codes have already been added + case "GroupBackReference": + // assertions do not affect potential starting codes + case "Lookahead": + case "NegativeLookahead": + case "Lookbehind": + case "NegativeLookbehind": + case "StartAnchor": + case "WordBoundary": + case "NonWordBoundary": + continue; + } + const atom2 = term; + switch (atom2.type) { + case "Character": + addOptimizedIdxToResult(atom2.value, result, ignoreCase); + break; + case "Set": + if (atom2.complement === true) { + throw Error(complementErrorMessage); + } + forEach_default(atom2.value, (code) => { + if (typeof code === "number") { + addOptimizedIdxToResult(code, result, ignoreCase); + } else { + const range3 = code; + if (ignoreCase === true) { + for (let rangeCode = range3.from; rangeCode <= range3.to; rangeCode++) { + addOptimizedIdxToResult(rangeCode, result, ignoreCase); + } + } else { + for (let rangeCode = range3.from; rangeCode <= range3.to && rangeCode < minOptimizationVal; rangeCode++) { + addOptimizedIdxToResult(rangeCode, result, ignoreCase); + } + if (range3.to >= minOptimizationVal) { + const minUnOptVal = range3.from >= minOptimizationVal ? range3.from : minOptimizationVal; + const maxUnOptVal = range3.to; + const minOptIdx = charCodeToOptimizedIndex(minUnOptVal); + const maxOptIdx = charCodeToOptimizedIndex(maxUnOptVal); + for (let currOptIdx = minOptIdx; currOptIdx <= maxOptIdx; currOptIdx++) { + result[currOptIdx] = currOptIdx; + } + } + } + } + }); + break; + case "Group": + firstCharOptimizedIndices(atom2.value, result, ignoreCase); + break; + /* istanbul ignore next */ + default: + throw Error("Non Exhaustive Match"); + } + const isOptionalQuantifier = atom2.quantifier !== void 0 && atom2.quantifier.atLeast === 0; + if ( + // A group may be optional due to empty contents /(?:)/ + // or if everything inside it is optional /((a)?)/ + atom2.type === "Group" && isWholeOptional(atom2) === false || // If this term is not a group it may only be optional if it has an optional quantifier + atom2.type !== "Group" && isOptionalQuantifier === false + ) { + break; + } + } + break; + /* istanbul ignore next */ + default: + throw Error("non exhaustive match!"); + } + return values_default(result); + } + function addOptimizedIdxToResult(code, result, ignoreCase) { + const optimizedCharIdx = charCodeToOptimizedIndex(code); + result[optimizedCharIdx] = optimizedCharIdx; + if (ignoreCase === true) { + handleIgnoreCase(code, result); + } + } + function handleIgnoreCase(code, result) { + const char2 = String.fromCharCode(code); + const upperChar = char2.toUpperCase(); + if (upperChar !== char2) { + const optimizedCharIdx = charCodeToOptimizedIndex(upperChar.charCodeAt(0)); + result[optimizedCharIdx] = optimizedCharIdx; + } else { + const lowerChar = char2.toLowerCase(); + if (lowerChar !== char2) { + const optimizedCharIdx = charCodeToOptimizedIndex(lowerChar.charCodeAt(0)); + result[optimizedCharIdx] = optimizedCharIdx; + } + } + } + function findCode(setNode, targetCharCodes) { + return find_default2(setNode.value, (codeOrRange) => { + if (typeof codeOrRange === "number") { + return includes_default(targetCharCodes, codeOrRange); + } else { + const range3 = codeOrRange; + return find_default2(targetCharCodes, (targetCode) => range3.from <= targetCode && targetCode <= range3.to) !== void 0; + } + }); + } + function isWholeOptional(ast) { + const quantifier = ast.quantifier; + if (quantifier && quantifier.atLeast === 0) { + return true; + } + if (!ast.value) { + return false; + } + return isArray_default(ast.value) ? every_default(ast.value, isWholeOptional) : isWholeOptional(ast.value); + } + function canMatchCharCode(charCodes, pattern) { + if (pattern instanceof RegExp) { + const ast = getRegExpAst(pattern); + const charCodeFinder = new CharCodeFinder(charCodes); + charCodeFinder.visit(ast); + return charCodeFinder.found; + } else { + return find_default2(pattern, (char2) => { + return includes_default(charCodes, char2.charCodeAt(0)); + }) !== void 0; + } + } + var complementErrorMessage, failedOptimizationPrefixMsg, CharCodeFinder; + var init_reg_exp = __esm({ + "../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/reg_exp.js"() { + "use strict"; + init_api(); + init_lodash(); + init_api2(); + init_reg_exp_parser(); + init_lexer(); + complementErrorMessage = "Complement Sets are not supported for first char optimization"; + failedOptimizationPrefixMsg = 'Unable to use "first char" lexer optimizations:\n'; + __name(getOptimizedStartCodesIndices, "getOptimizedStartCodesIndices"); + __name(firstCharOptimizedIndices, "firstCharOptimizedIndices"); + __name(addOptimizedIdxToResult, "addOptimizedIdxToResult"); + __name(handleIgnoreCase, "handleIgnoreCase"); + __name(findCode, "findCode"); + __name(isWholeOptional, "isWholeOptional"); + CharCodeFinder = class extends BaseRegExpVisitor { + static { + __name(this, "CharCodeFinder"); + } + constructor(targetCharCodes) { + super(); + this.targetCharCodes = targetCharCodes; + this.found = false; + } + visitChildren(node2) { + if (this.found === true) { + return; + } + switch (node2.type) { + case "Lookahead": + this.visitLookahead(node2); + return; + case "NegativeLookahead": + this.visitNegativeLookahead(node2); + return; + case "Lookbehind": + this.visitLookbehind(node2); + return; + case "NegativeLookbehind": + this.visitNegativeLookbehind(node2); + return; + } + super.visitChildren(node2); + } + visitCharacter(node2) { + if (includes_default(this.targetCharCodes, node2.value)) { + this.found = true; + } + } + visitSet(node2) { + if (node2.complement) { + if (findCode(node2, this.targetCharCodes) === void 0) { + this.found = true; + } + } else { + if (findCode(node2, this.targetCharCodes) !== void 0) { + this.found = true; + } + } + } + }; + __name(canMatchCharCode, "canMatchCharCode"); + } + }); + + // ../../node_modules/.pnpm/chevrotain@11.1.1/node_modules/chevrotain/lib/src/scan/lexer.js + function analyzeTokenTypes(tokenTypes, options2) { + options2 = defaults_default(options2, { + useSticky: SUPPORT_STICKY, + debug: false, + safeMode: false, + positionTracking: "full", + lineTerminatorCharacters: ["\r", "\n"], + tracer: /* @__PURE__ */ __name((msg, action) => action(), "tracer") + }); + const tracer = options2.tracer; + tracer("initCharCodeToOptimizedIndexMap", () => { + initCharCodeToOptimizedIndexMap(); + }); + let onlyRelevantTypes; + tracer("Reject Lexer.NA", () => { + onlyRelevantTypes = reject_default(tokenTypes, (currType) => { + return currType[PATTERN] === Lexer2.NA; + }); + }); + let hasCustom = false; + let allTransformedPatterns; + tracer("Transform Patterns", () => { + hasCustom = false; + allTransformedPatterns = map_default(onlyRelevantTypes, (currType) => { + const currPattern = currType[PATTERN]; + if (isRegExp_default(currPattern)) { + const regExpSource = currPattern.source; + if (regExpSource.length === 1 && // only these regExp meta characters which can appear in a length one regExp + regExpSource !== "^" && regExpSource !== "$" && regExpSource !== "." && !currPattern.ignoreCase) { + return regExpSource; + } else if (regExpSource.length === 2 && regExpSource[0] === "\\" && // not a meta character + !includes_default([ + "d", + "D", + "s", + "S", + "t", + "r", + "n", + "t", + "0", + "c", + "b", + "B", + "f", + "v", + "w", + "W" + ], regExpSource[1])) { + return regExpSource[1]; + } else { + return options2.useSticky ? addStickyFlag(currPattern) : addStartOfInput(currPattern); + } + } else if (isFunction_default(currPattern)) { + hasCustom = true; + return { exec: currPattern }; + } else if (typeof currPattern === "object") { + hasCustom = true; + return currPattern; + } else if (typeof currPattern === "string") { + if (currPattern.length === 1) { + return currPattern; + } else { + const escapedRegExpString = currPattern.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&"); + const wrappedRegExp = new RegExp(escapedRegExpString); + return options2.useSticky ? addStickyFlag(wrappedRegExp) : addStartOfInput(wrappedRegExp); + } + } else { + throw Error("non exhaustive match"); + } + }); + }); + let patternIdxToType; + let patternIdxToGroup; + let patternIdxToLongerAltIdxArr; + let patternIdxToPushMode; + let patternIdxToPopMode; + tracer("misc mapping", () => { + patternIdxToType = map_default(onlyRelevantTypes, (currType) => currType.tokenTypeIdx); + patternIdxToGroup = map_default(onlyRelevantTypes, (clazz) => { + const groupName = clazz.GROUP; + if (groupName === Lexer2.SKIPPED) { + return void 0; + } else if (isString_default(groupName)) { + return groupName; + } else if (isUndefined_default(groupName)) { + return false; + } else { + throw Error("non exhaustive match"); + } + }); + patternIdxToLongerAltIdxArr = map_default(onlyRelevantTypes, (clazz) => { + const longerAltType = clazz.LONGER_ALT; + if (longerAltType) { + const longerAltIdxArr = isArray_default(longerAltType) ? map_default(longerAltType, (type3) => indexOf_default(onlyRelevantTypes, type3)) : [indexOf_default(onlyRelevantTypes, longerAltType)]; + return longerAltIdxArr; + } + }); + patternIdxToPushMode = map_default(onlyRelevantTypes, (clazz) => clazz.PUSH_MODE); + patternIdxToPopMode = map_default(onlyRelevantTypes, (clazz) => has_default(clazz, "POP_MODE")); + }); + let patternIdxToCanLineTerminator; + tracer("Line Terminator Handling", () => { + const lineTerminatorCharCodes = getCharCodes(options2.lineTerminatorCharacters); + patternIdxToCanLineTerminator = map_default(onlyRelevantTypes, (tokType) => false); + if (options2.positionTracking !== "onlyOffset") { + patternIdxToCanLineTerminator = map_default(onlyRelevantTypes, (tokType) => { + if (has_default(tokType, "LINE_BREAKS")) { + return !!tokType.LINE_BREAKS; + } else { + return checkLineBreaksIssues(tokType, lineTerminatorCharCodes) === false && canMatchCharCode(lineTerminatorCharCodes, tokType.PATTERN); + } + }); + } + }); + let patternIdxToIsCustom; + let patternIdxToShort; + let emptyGroups; + let patternIdxToConfig; + tracer("Misc Mapping #2", () => { + patternIdxToIsCustom = map_default(onlyRelevantTypes, isCustomPattern); + patternIdxToShort = map_default(allTransformedPatterns, isShortPattern); + emptyGroups = reduce_default(onlyRelevantTypes, (acc, clazz) => { + const groupName = clazz.GROUP; + if (isString_default(groupName) && !(groupName === Lexer2.SKIPPED)) { + acc[groupName] = []; + } + return acc; + }, {}); + patternIdxToConfig = map_default(allTransformedPatterns, (x5, idx) => { + return { + pattern: allTransformedPatterns[idx], + longerAlt: patternIdxToLongerAltIdxArr[idx], + canLineTerminator: patternIdxToCanLineTerminator[idx], + isCustom: patternIdxToIsCustom[idx], + short: patternIdxToShort[idx], + group: patternIdxToGroup[idx], + push: patternIdxToPushMode[idx], + pop: patternIdxToPopMode[idx], + tokenTypeIdx: patternIdxToType[idx], + tokenType: onlyRelevantTypes[idx] + }; + }); + }); + let canBeOptimized = true; + let charCodeToPatternIdxToConfig = []; + if (!options2.safeMode) { + tracer("First Char Optimization", () => { + charCodeToPatternIdxToConfig = reduce_default(onlyRelevantTypes, (result, currTokType, idx) => { + if (typeof currTokType.PATTERN === "string") { + const charCode = currTokType.PATTERN.charCodeAt(0); + const optimizedIdx = charCodeToOptimizedIndex(charCode); + addToMapOfArrays(result, optimizedIdx, patternIdxToConfig[idx]); + } else if (isArray_default(currTokType.START_CHARS_HINT)) { + let lastOptimizedIdx; + forEach_default(currTokType.START_CHARS_HINT, (charOrInt) => { + const charCode = typeof charOrInt === "string" ? charOrInt.charCodeAt(0) : charOrInt; + const currOptimizedIdx = charCodeToOptimizedIndex(charCode); + if (lastOptimizedIdx !== currOptimizedIdx) { + lastOptimizedIdx = currOptimizedIdx; + addToMapOfArrays(result, currOptimizedIdx, patternIdxToConfig[idx]); + } + }); + } else if (isRegExp_default(currTokType.PATTERN)) { + if (currTokType.PATTERN.unicode) { + canBeOptimized = false; + if (options2.ensureOptimizations) { + PRINT_ERROR(`${failedOptimizationPrefixMsg} Unable to analyze < ${currTokType.PATTERN.toString()} > pattern. + The regexp unicode flag is not currently supported by the regexp-to-ast library. + This will disable the lexer's first char optimizations. + For details See: https://chevrotain.io/docs/guide/resolving_lexer_errors.html#UNICODE_OPTIMIZE`); + } + } else { + const optimizedCodes = getOptimizedStartCodesIndices(currTokType.PATTERN, options2.ensureOptimizations); + if (isEmpty_default(optimizedCodes)) { + canBeOptimized = false; + } + forEach_default(optimizedCodes, (code) => { + addToMapOfArrays(result, code, patternIdxToConfig[idx]); + }); + } + } else { + if (options2.ensureOptimizations) { + PRINT_ERROR(`${failedOptimizationPrefixMsg} TokenType: <${currTokType.name}> is using a custom token pattern without providing
")); + el.classed("hover", true); + }).on("mouseout", (event3) => { + tooltipElem.transition().duration(500).style("opacity", 0); + const el = select_default2(event3.currentTarget); + el.classed("hover", false); + }); + }, "setupToolTips"); + this.direction = "TB"; + this.setAccTitle = setAccTitle; + this.getAccTitle = getAccTitle; + this.setAccDescription = setAccDescription; + this.getAccDescription = getAccDescription; + this.setDiagramTitle = setDiagramTitle; + this.getDiagramTitle = getDiagramTitle; + this.getConfig = /* @__PURE__ */ __name(() => getConfig2().class, "getConfig"); + this.functions.push(this.setupToolTips.bind(this)); + this.clear(); + this.addRelation = this.addRelation.bind(this); + this.addClassesToNamespace = this.addClassesToNamespace.bind(this); + this.addNamespace = this.addNamespace.bind(this); + this.setCssClass = this.setCssClass.bind(this); + this.addMembers = this.addMembers.bind(this); + this.addClass = this.addClass.bind(this); + this.setClassLabel = this.setClassLabel.bind(this); + this.addAnnotation = this.addAnnotation.bind(this); + this.addMember = this.addMember.bind(this); + this.cleanupLabel = this.cleanupLabel.bind(this); + this.addNote = this.addNote.bind(this); + this.defineClass = this.defineClass.bind(this); + this.setDirection = this.setDirection.bind(this); + this.setLink = this.setLink.bind(this); + this.bindFunctions = this.bindFunctions.bind(this); + this.clear = this.clear.bind(this); + this.setTooltip = this.setTooltip.bind(this); + this.setClickEvent = this.setClickEvent.bind(this); + this.setCssStyle = this.setCssStyle.bind(this); + } + static { + __name(this, "ClassDB"); + } + splitClassNameAndType(_id) { + const id30 = common_default.sanitizeText(_id, getConfig2()); + let genericType = ""; + let className = id30; + if (id30.indexOf("~") > 0) { + const split = id30.split("~"); + className = sanitizeText4(split[0]); + genericType = sanitizeText4(split[1]); + } + return { className, type: genericType }; + } + setClassLabel(_id, label) { + const id30 = common_default.sanitizeText(_id, getConfig2()); + if (label) { + label = sanitizeText4(label); + } + const { className } = this.splitClassNameAndType(id30); + this.classes.get(className).label = label; + this.classes.get(className).text = `${label}${this.classes.get(className).type ? `<${this.classes.get(className).type}>` : ""}`; + } + /** + * Function called by parser when a node definition has been found. + * + * @param id - ID of the class to add + * @public + */ + addClass(_id) { + const id30 = common_default.sanitizeText(_id, getConfig2()); + const { className, type: type3 } = this.splitClassNameAndType(id30); + if (this.classes.has(className)) { + return; + } + const name = common_default.sanitizeText(className, getConfig2()); + this.classes.set(name, { + id: name, + type: type3, + label: name, + text: `${name}${type3 ? `<${type3}>` : ""}`, + shape: "classBox", + cssClasses: "default", + methods: [], + members: [], + annotations: [], + styles: [], + domId: MERMAID_DOM_ID_PREFIX2 + name + "-" + classCounter + }); + classCounter++; + } + addInterface(label, classId) { + const classInterface = { + id: `interface${this.interfaces.length}`, + label, + classId + }; + this.interfaces.push(classInterface); + } + /** + * Function to lookup domId from id in the graph definition. + * + * @param id - class ID to lookup + * @public + */ + lookUpDomId(_id) { + const id30 = common_default.sanitizeText(_id, getConfig2()); + if (this.classes.has(id30)) { + return this.classes.get(id30).domId; + } + throw new Error("Class not found: " + id30); + } + clear() { + this.relations = []; + this.classes = /* @__PURE__ */ new Map(); + this.notes = []; + this.interfaces = []; + this.functions = []; + this.functions.push(this.setupToolTips.bind(this)); + this.namespaces = /* @__PURE__ */ new Map(); + this.namespaceCounter = 0; + this.direction = "TB"; + clear(); + } + getClass(id30) { + return this.classes.get(id30); + } + getClasses() { + return this.classes; + } + getRelations() { + return this.relations; + } + getNotes() { + return this.notes; + } + addRelation(classRelation) { + log.debug("Adding relation: " + JSON.stringify(classRelation)); + const invalidTypes = [ + this.relationType.LOLLIPOP, + this.relationType.AGGREGATION, + this.relationType.COMPOSITION, + this.relationType.DEPENDENCY, + this.relationType.EXTENSION + ]; + if (classRelation.relation.type1 === this.relationType.LOLLIPOP && !invalidTypes.includes(classRelation.relation.type2)) { + this.addClass(classRelation.id2); + this.addInterface(classRelation.id1, classRelation.id2); + classRelation.id1 = `interface${this.interfaces.length - 1}`; + } else if (classRelation.relation.type2 === this.relationType.LOLLIPOP && !invalidTypes.includes(classRelation.relation.type1)) { + this.addClass(classRelation.id1); + this.addInterface(classRelation.id2, classRelation.id1); + classRelation.id2 = `interface${this.interfaces.length - 1}`; + } else { + this.addClass(classRelation.id1); + this.addClass(classRelation.id2); + } + classRelation.id1 = this.splitClassNameAndType(classRelation.id1).className; + classRelation.id2 = this.splitClassNameAndType(classRelation.id2).className; + classRelation.relationTitle1 = common_default.sanitizeText( + classRelation.relationTitle1.trim(), + getConfig2() + ); + classRelation.relationTitle2 = common_default.sanitizeText( + classRelation.relationTitle2.trim(), + getConfig2() + ); + this.relations.push(classRelation); + } + /** + * Adds an annotation to the specified class Annotations mark special properties of the given type + * (like 'interface' or 'service') + * + * @param className - The class name + * @param annotation - The name of the annotation without any brackets + * @public + */ + addAnnotation(className, annotation) { + const validatedClassName = this.splitClassNameAndType(className).className; + this.classes.get(validatedClassName).annotations.push(annotation); + } + /** + * Adds a member to the specified class + * + * @param className - The class name + * @param member - The full name of the member. If the member is enclosed in `<
"); + text4 = text4.replace(/\n/g, "
"); + const lines = text4.split(common_default.lineBreakRegex); + let tHeight = 1.25 * getConfig2().state.noteMargin; + for (const line2 of lines) { + const txt = line2.trim(); + if (txt.length > 0) { + const span = textElem.append("tspan"); + span.text(txt); + if (tHeight === 0) { + const textBounds = span.node().getBBox(); + tHeight += textBounds.height; + } + textHeight += tHeight; + span.attr("x", x5 + getConfig2().state.noteMargin); + span.attr("y", y6 + textHeight + 1.25 * getConfig2().state.noteMargin); + } + } + return { textWidth: textElem.node().getBBox().width, textHeight }; + }, "_drawLongText"); + drawNote2 = /* @__PURE__ */ __name((text4, g2) => { + g2.attr("class", "state-note"); + const note3 = g2.append("rect").attr("x", 0).attr("y", getConfig2().state.padding); + const rectElem = g2.append("g"); + const { textWidth, textHeight } = _drawLongText(text4, 0, 0, rectElem); + note3.attr("height", textHeight + 2 * getConfig2().state.noteMargin); + note3.attr("width", textWidth + getConfig2().state.noteMargin * 2); + return note3; + }, "drawNote"); + drawState = /* @__PURE__ */ __name(function(elem, stateDef) { + const id30 = stateDef.id; + const stateInfo = { + id: id30, + label: stateDef.id, + width: 0, + height: 0 + }; + const g2 = elem.append("g").attr("id", id30).attr("class", "stateGroup"); + if (stateDef.type === "start") { + drawStartState(g2); + } + if (stateDef.type === "end") { + drawEndState(g2); + } + if (stateDef.type === "fork" || stateDef.type === "join") { + drawForkJoinState(g2, stateDef); + } + if (stateDef.type === "note") { + drawNote2(stateDef.note.text, g2); + } + if (stateDef.type === "divider") { + drawDivider(g2); + } + if (stateDef.type === "default" && stateDef.descriptions.length === 0) { + drawSimpleState(g2, stateDef); + } + if (stateDef.type === "default" && stateDef.descriptions.length > 0) { + drawDescrState(g2, stateDef); + } + const stateBox = g2.node().getBBox(); + stateInfo.width = stateBox.width + 2 * getConfig2().state.padding; + stateInfo.height = stateBox.height + 2 * getConfig2().state.padding; + return stateInfo; + }, "drawState"); + edgeCount = 0; + drawEdge = /* @__PURE__ */ __name(function(elem, path4, relation) { + const getRelationType = /* @__PURE__ */ __name(function(type3) { + switch (type3) { + case StateDB.relationType.AGGREGATION: + return "aggregation"; + case StateDB.relationType.EXTENSION: + return "extension"; + case StateDB.relationType.COMPOSITION: + return "composition"; + case StateDB.relationType.DEPENDENCY: + return "dependency"; + } + }, "getRelationType"); + path4.points = path4.points.filter((p3) => !Number.isNaN(p3.y)); + const lineData = path4.points; + const lineFunction = line_default().x(function(d3) { + return d3.x; + }).y(function(d3) { + return d3.y; + }).curve(basis_default2); + const svgPath = elem.append("path").attr("d", lineFunction(lineData)).attr("id", "edge" + edgeCount).attr("class", "transition"); + let url = ""; + if (getConfig2().state.arrowMarkerAbsolute) { + url = getUrl(true); + } + svgPath.attr( + "marker-end", + "url(" + url + "#" + getRelationType(StateDB.relationType.DEPENDENCY) + "End)" + ); + if (relation.title !== void 0) { + const label = elem.append("g").attr("class", "stateLabel"); + const { x: x5, y: y6 } = utils_default2.calcLabelPosition(path4.points); + const rows = common_default.getRows(relation.title); + let titleHeight = 0; + const titleRows = []; + let maxWidth2 = 0; + let minX = 0; + for (let i2 = 0; i2 <= rows.length; i2++) { + const title2 = label.append("text").attr("text-anchor", "middle").text(rows[i2]).attr("x", x5).attr("y", y6 + titleHeight); + const boundsTmp = title2.node().getBBox(); + maxWidth2 = Math.max(maxWidth2, boundsTmp.width); + minX = Math.min(minX, boundsTmp.x); + log.info(boundsTmp.x, x5, y6 + titleHeight); + if (titleHeight === 0) { + const titleBox = title2.node().getBBox(); + titleHeight = titleBox.height; + log.info("Title height", titleHeight, y6); + } + titleRows.push(title2); + } + let boxHeight = titleHeight * rows.length; + if (rows.length > 1) { + const heightAdj = (rows.length - 1) * titleHeight * 0.5; + titleRows.forEach((title2, i2) => title2.attr("y", y6 + i2 * titleHeight - heightAdj)); + boxHeight = titleHeight * rows.length; + } + const bounds4 = label.node().getBBox(); + label.insert("rect", ":first-child").attr("class", "box").attr("x", x5 - maxWidth2 / 2 - getConfig2().state.padding / 2).attr("y", y6 - boxHeight / 2 - getConfig2().state.padding / 2 - 3.5).attr("width", maxWidth2 + getConfig2().state.padding).attr("height", boxHeight + getConfig2().state.padding); + log.info(bounds4); + } + edgeCount++; + }, "drawEdge"); + } + }); + + // src/diagrams/state/stateRenderer.js + var conf3, transformationLog, setConf4, insertMarkers2, draw14, getLabelWidth, renderDoc, stateRenderer_default; + var init_stateRenderer = __esm({ + "src/diagrams/state/stateRenderer.js"() { + "use strict"; + init_src32(); + init_dagre(); + init_graphlib(); + init_logger(); + init_common(); + init_shapes2(); + init_diagramAPI(); + init_setupGraphViewbox(); + transformationLog = {}; + setConf4 = /* @__PURE__ */ __name(function() { + }, "setConf"); + insertMarkers2 = /* @__PURE__ */ __name(function(elem) { + elem.append("defs").append("marker").attr("id", "dependencyEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z"); + }, "insertMarkers"); + draw14 = /* @__PURE__ */ __name(function(text4, id30, _version, diagObj) { + conf3 = getConfig2().state; + const securityLevel = getConfig2().securityLevel; + let sandboxElement; + if (securityLevel === "sandbox") { + sandboxElement = select_default2("#i" + id30); + } + const root3 = securityLevel === "sandbox" ? select_default2(sandboxElement.nodes()[0].contentDocument.body) : select_default2("body"); + const doc = securityLevel === "sandbox" ? sandboxElement.nodes()[0].contentDocument : document; + log.debug("Rendering diagram " + text4); + const diagram27 = root3.select(`[id='${id30}']`); + insertMarkers2(diagram27); + const rootDoc = diagObj.db.getRootDoc(); + renderDoc(rootDoc, diagram27, void 0, false, root3, doc, diagObj); + const padding2 = conf3.padding; + const bounds4 = diagram27.node().getBBox(); + const width3 = bounds4.width + padding2 * 2; + const height2 = bounds4.height + padding2 * 2; + const svgWidth = width3 * 1.75; + configureSvgSize(diagram27, height2, svgWidth, conf3.useMaxWidth); + diagram27.attr( + "viewBox", + `${bounds4.x - conf3.padding} ${bounds4.y - conf3.padding} ` + width3 + " " + height2 + ); + }, "draw"); + getLabelWidth = /* @__PURE__ */ __name((text4) => { + return text4 ? text4.length * conf3.fontSizeFactor : 1; + }, "getLabelWidth"); + renderDoc = /* @__PURE__ */ __name((doc, diagram27, parentId, altBkg, root3, domDocument, diagObj) => { + const graph = new Graph({ + compound: true, + multigraph: true + }); + let i2; + let edgeFreeDoc = true; + for (i2 = 0; i2 < doc.length; i2++) { + if (doc[i2].stmt === "relation") { + edgeFreeDoc = false; + break; + } + } + if (parentId) { + graph.setGraph({ + rankdir: "LR", + multigraph: true, + compound: true, + // acyclicer: 'greedy', + ranker: "tight-tree", + ranksep: edgeFreeDoc ? 1 : conf3.edgeLengthFactor, + nodeSep: edgeFreeDoc ? 1 : 50, + isMultiGraph: true + // ranksep: 5, + // nodesep: 1 + }); + } else { + graph.setGraph({ + rankdir: "TB", + multigraph: true, + compound: true, + // isCompound: true, + // acyclicer: 'greedy', + // ranker: 'longest-path' + ranksep: edgeFreeDoc ? 1 : conf3.edgeLengthFactor, + nodeSep: edgeFreeDoc ? 1 : 50, + ranker: "tight-tree", + // ranker: 'network-simplex' + isMultiGraph: true + }); + } + graph.setDefaultEdgeLabel(function() { + return {}; + }); + const states = diagObj.db.getStates(); + const relations = diagObj.db.getRelations(); + const keys2 = Object.keys(states); + let first3 = true; + for (const key of keys2) { + const stateDef = states[key]; + if (parentId) { + stateDef.parentId = parentId; + } + let node2; + if (stateDef.doc) { + let sub2 = diagram27.append("g").attr("id", stateDef.id).attr("class", "stateGroup"); + node2 = renderDoc(stateDef.doc, sub2, stateDef.id, !altBkg, root3, domDocument, diagObj); + if (first3) { + sub2 = addTitleAndBox(sub2, stateDef, altBkg); + let boxBounds = sub2.node().getBBox(); + node2.width = boxBounds.width; + node2.height = boxBounds.height + conf3.padding / 2; + transformationLog[stateDef.id] = { y: conf3.compositTitleSize }; + } else { + let boxBounds = sub2.node().getBBox(); + node2.width = boxBounds.width; + node2.height = boxBounds.height; + } + } else { + node2 = drawState(diagram27, stateDef, graph); + } + if (stateDef.note) { + const noteDef = { + descriptions: [], + id: stateDef.id + "-note", + note: stateDef.note, + type: "note" + }; + const note3 = drawState(diagram27, noteDef, graph); + if (stateDef.note.position === "left of") { + graph.setNode(node2.id + "-note", note3); + graph.setNode(node2.id, node2); + } else { + graph.setNode(node2.id, node2); + graph.setNode(node2.id + "-note", note3); + } + graph.setParent(node2.id, node2.id + "-group"); + graph.setParent(node2.id + "-note", node2.id + "-group"); + } else { + graph.setNode(node2.id, node2); + } + } + log.debug("Count=", graph.nodeCount(), graph); + let cnt4 = 0; + relations.forEach(function(relation) { + cnt4++; + log.debug("Setting edge", relation); + graph.setEdge( + relation.id1, + relation.id2, + { + relation, + width: getLabelWidth(relation.title), + height: conf3.labelHeight * common_default.getRows(relation.title).length, + labelpos: "c" + }, + "id" + cnt4 + ); + }); + layout(graph); + log.debug("Graph after layout", graph.nodes()); + const svgElem = diagram27.node(); + graph.nodes().forEach(function(v3) { + if (v3 !== void 0 && graph.node(v3) !== void 0) { + log.warn("Node " + v3 + ": " + JSON.stringify(graph.node(v3))); + root3.select("#" + svgElem.id + " #" + v3).attr( + "transform", + "translate(" + (graph.node(v3).x - graph.node(v3).width / 2) + "," + (graph.node(v3).y + (transformationLog[v3] ? transformationLog[v3].y : 0) - graph.node(v3).height / 2) + " )" + ); + root3.select("#" + svgElem.id + " #" + v3).attr("data-x-shift", graph.node(v3).x - graph.node(v3).width / 2); + const dividers = domDocument.querySelectorAll("#" + svgElem.id + " #" + v3 + " .divider"); + dividers.forEach((divider2) => { + const parent4 = divider2.parentElement; + let pWidth = 0; + let pShift = 0; + if (parent4) { + if (parent4.parentElement) { + pWidth = parent4.parentElement.getBBox().width; + } + pShift = parseInt(parent4.getAttribute("data-x-shift"), 10); + if (Number.isNaN(pShift)) { + pShift = 0; + } + } + divider2.setAttribute("x1", 0 - pShift + 8); + divider2.setAttribute("x2", pWidth - pShift - 8); + }); + } else { + log.debug("No Node " + v3 + ": " + JSON.stringify(graph.node(v3))); + } + }); + let stateBox = svgElem.getBBox(); + graph.edges().forEach(function(e3) { + if (e3 !== void 0 && graph.edge(e3) !== void 0) { + log.debug("Edge " + e3.v + " -> " + e3.w + ": " + JSON.stringify(graph.edge(e3))); + drawEdge(diagram27, graph.edge(e3), graph.edge(e3).relation); + } + }); + stateBox = svgElem.getBBox(); + const stateInfo = { + id: parentId ? parentId : "root", + label: parentId ? parentId : "root", + width: 0, + height: 0 + }; + stateInfo.width = stateBox.width + 2 * conf3.padding; + stateInfo.height = stateBox.height + 2 * conf3.padding; + log.debug("Doc rendered", stateInfo, graph); + return stateInfo; + }, "renderDoc"); + stateRenderer_default = { + setConf: setConf4, + draw: draw14 + }; + } + }); + + // src/diagrams/state/stateDiagram.ts + var stateDiagram_exports = {}; + __export(stateDiagram_exports, { + diagram: () => diagram14 + }); + var diagram14; + var init_stateDiagram2 = __esm({ + "src/diagrams/state/stateDiagram.ts"() { + "use strict"; + init_stateDiagram(); + init_stateDb(); + init_styles10(); + init_stateRenderer(); + diagram14 = { + parser: stateDiagram_default, + get db() { + return new StateDB(1); + }, + renderer: stateRenderer_default, + styles: styles_default10, + init: /* @__PURE__ */ __name((cnf) => { + if (!cnf.state) { + cnf.state = {}; + } + cnf.state.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute; + }, "init") + }; + } + }); + + // src/diagrams/state/stateDiagram-v2.ts + var stateDiagram_v2_exports = {}; + __export(stateDiagram_v2_exports, { + diagram: () => diagram15 + }); + var diagram15; + var init_stateDiagram_v2 = __esm({ + "src/diagrams/state/stateDiagram-v2.ts"() { + "use strict"; + init_stateDiagram(); + init_stateDb(); + init_styles10(); + init_stateRenderer_v3_unified(); + diagram15 = { + parser: stateDiagram_default, + get db() { + return new StateDB(2); + }, + renderer: stateRenderer_v3_unified_default, + styles: styles_default10, + init: /* @__PURE__ */ __name((cnf) => { + if (!cnf.state) { + cnf.state = {}; + } + cnf.state.arrowMarkerAbsolute = cnf.arrowMarkerAbsolute; + }, "init") + }; + } + }); + + // src/diagrams/user-journey/parser/journey.jison + var parser14, journey_default; + var init_journey = __esm({ + "src/diagrams/user-journey/parser/journey.jison"() { + "use strict"; + parser14 = (function() { + var o2 = /* @__PURE__ */ __name(function(k2, v3, o3, l4) { + for (o3 = o3 || {}, l4 = k2.length; l4--; o3[k2[l4]] = v3) ; + return o3; + }, "o"), $V0 = [6, 8, 10, 11, 12, 14, 16, 17, 18], $V1 = [1, 9], $V2 = [1, 10], $V3 = [1, 11], $V4 = [1, 12], $V5 = [1, 13], $V6 = [1, 14]; + var parser24 = { + trace: /* @__PURE__ */ __name(function trace() { + }, "trace"), + yy: {}, + symbols_: { "error": 2, "start": 3, "journey": 4, "document": 5, "EOF": 6, "line": 7, "SPACE": 8, "statement": 9, "NEWLINE": 10, "title": 11, "acc_title": 12, "acc_title_value": 13, "acc_descr": 14, "acc_descr_value": 15, "acc_descr_multiline_value": 16, "section": 17, "taskName": 18, "taskData": 19, "$accept": 0, "$end": 1 }, + terminals_: { 2: "error", 4: "journey", 6: "EOF", 8: "SPACE", 10: "NEWLINE", 11: "title", 12: "acc_title", 13: "acc_title_value", 14: "acc_descr", 15: "acc_descr_value", 16: "acc_descr_multiline_value", 17: "section", 18: "taskName", 19: "taskData" }, + productions_: [0, [3, 3], [5, 0], [5, 2], [7, 2], [7, 1], [7, 1], [7, 1], [9, 1], [9, 2], [9, 2], [9, 1], [9, 1], [9, 2]], + performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { + var $0 = $$.length - 1; + switch (yystate) { + case 1: + return $$[$0 - 1]; + break; + case 2: + this.$ = []; + break; + case 3: + $$[$0 - 1].push($$[$0]); + this.$ = $$[$0 - 1]; + break; + case 4: + case 5: + this.$ = $$[$0]; + break; + case 6: + case 7: + this.$ = []; + break; + case 8: + yy.setDiagramTitle($$[$0].substr(6)); + this.$ = $$[$0].substr(6); + break; + case 9: + this.$ = $$[$0].trim(); + yy.setAccTitle(this.$); + break; + case 10: + case 11: + this.$ = $$[$0].trim(); + yy.setAccDescription(this.$); + break; + case 12: + yy.addSection($$[$0].substr(8)); + this.$ = $$[$0].substr(8); + break; + case 13: + yy.addTask($$[$0 - 1], $$[$0]); + this.$ = "task"; + break; + } + }, "anonymous"), + table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, o2($V0, [2, 2], { 5: 3 }), { 6: [1, 4], 7: 5, 8: [1, 6], 9: 7, 10: [1, 8], 11: $V1, 12: $V2, 14: $V3, 16: $V4, 17: $V5, 18: $V6 }, o2($V0, [2, 7], { 1: [2, 1] }), o2($V0, [2, 3]), { 9: 15, 11: $V1, 12: $V2, 14: $V3, 16: $V4, 17: $V5, 18: $V6 }, o2($V0, [2, 5]), o2($V0, [2, 6]), o2($V0, [2, 8]), { 13: [1, 16] }, { 15: [1, 17] }, o2($V0, [2, 11]), o2($V0, [2, 12]), { 19: [1, 18] }, o2($V0, [2, 4]), o2($V0, [2, 9]), o2($V0, [2, 10]), o2($V0, [2, 13])], + defaultActions: {}, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (hash.recoverable) { + this.trace(str2); + } else { + var error3 = new Error(str2); + error3.hash = hash; + throw error3; + } + }, "parseError"), + parse: /* @__PURE__ */ __name(function parse7(input) { + var self2 = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF2 = 1; + var args = lstack.slice.call(arguments, 1); + var lexer2 = Object.create(this.lexer); + var sharedState = { yy: {} }; + for (var k2 in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k2)) { + sharedState.yy[k2] = this.yy[k2]; + } + } + lexer2.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer2; + sharedState.yy.parser = this; + if (typeof lexer2.yylloc == "undefined") { + lexer2.yylloc = {}; + } + var yyloc = lexer2.yylloc; + lstack.push(yyloc); + var ranges = lexer2.options && lexer2.options.ranges; + if (typeof sharedState.yy.parseError === "function") { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + function popStack(n2) { + stack.length = stack.length - 2 * n2; + vstack.length = vstack.length - n2; + lstack.length = lstack.length - n2; + } + __name(popStack, "popStack"); + function lex() { + var token2; + token2 = tstack.pop() || lexer2.lex() || EOF2; + if (typeof token2 !== "number") { + if (token2 instanceof Array) { + tstack = token2; + token2 = tstack.pop(); + } + token2 = self2.symbols_[token2] || token2; + } + return token2; + } + __name(lex, "lex"); + var symbol, preErrorSymbol, state3, action, a2, r2, yyval = {}, p3, len, newState2, expected; + while (true) { + state3 = stack[stack.length - 1]; + if (this.defaultActions[state3]) { + action = this.defaultActions[state3]; + } else { + if (symbol === null || typeof symbol == "undefined") { + symbol = lex(); + } + action = table[state3] && table[state3][symbol]; + } + if (typeof action === "undefined" || !action.length || !action[0]) { + var errStr = ""; + expected = []; + for (p3 in table[state3]) { + if (this.terminals_[p3] && p3 > TERROR) { + expected.push("'" + this.terminals_[p3] + "'"); + } + } + if (lexer2.showPosition) { + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF2 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + this.parseError(errStr, { + text: lexer2.match, + token: this.terminals_[symbol] || symbol, + line: lexer2.yylineno, + loc: yyloc, + expected + }); + } + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state3 + ", token: " + symbol); + } + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(lexer2.yytext); + lstack.push(lexer2.yylloc); + stack.push(action[1]); + symbol = null; + if (!preErrorSymbol) { + yyleng = lexer2.yyleng; + yytext = lexer2.yytext; + yylineno = lexer2.yylineno; + yyloc = lexer2.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + if (ranges) { + yyval._$.range = [ + lstack[lstack.length - (len || 1)].range[0], + lstack[lstack.length - 1].range[1] + ]; + } + r2 = this.performAction.apply(yyval, [ + yytext, + yyleng, + yylineno, + sharedState.yy, + action[1], + vstack, + lstack + ].concat(args)); + if (typeof r2 !== "undefined") { + return r2; + } + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState2 = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState2); + break; + case 3: + return true; + } + } + return true; + }, "parse") + }; + var lexer = /* @__PURE__ */ (function() { + var lexer2 = { + EOF: 1, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str2, hash); + } else { + throw new Error(str2); + } + }, "parseError"), + // resets the lexer, sets new input + setInput: /* @__PURE__ */ __name(function(input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ""; + this.conditionStack = ["INITIAL"]; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + this.offset = 0; + return this; + }, "setInput"), + // consumes and returns one char from the input + input: /* @__PURE__ */ __name(function() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + this._input = this._input.slice(1); + return ch; + }, "input"), + // unshifts one char (or a string) into the input + unput: /* @__PURE__ */ __name(function(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r2 = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + if (this.options.ranges) { + this.yylloc.range = [r2[0], r2[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, "unput"), + // When called from action, caches matched text and appends it on next action + more: /* @__PURE__ */ __name(function() { + this._more = true; + return this; + }, "more"), + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: /* @__PURE__ */ __name(function() { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + return this; + }, "reject"), + // retain first n characters of the match + less: /* @__PURE__ */ __name(function(n2) { + this.unput(this.match.slice(n2)); + }, "less"), + // displays already matched input, i.e. for error messages + pastInput: /* @__PURE__ */ __name(function() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, ""); + }, "pastInput"), + // displays upcoming input, i.e. for error messages + upcomingInput: /* @__PURE__ */ __name(function() { + var next3 = this.match; + if (next3.length < 20) { + next3 += this._input.substr(0, 20 - next3.length); + } + return (next3.substr(0, 20) + (next3.length > 20 ? "..." : "")).replace(/\n/g, ""); + }, "upcomingInput"), + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: /* @__PURE__ */ __name(function() { + var pre = this.pastInput(); + var c3 = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c3 + "^"; + }, "showPosition"), + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: /* @__PURE__ */ __name(function(match2, indexed_rule) { + var token2, lines, backup; + if (this.options.backtrack_lexer) { + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + lines = match2[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match2[0].length + }; + this.yytext += match2[0]; + this.match += match2[0]; + this.matches = match2; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match2[0].length); + this.matched += match2[0]; + token2 = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token2) { + return token2; + } else if (this._backtrack) { + for (var k2 in backup) { + this[k2] = backup[k2]; + } + return false; + } + return false; + }, "test_match"), + // return next match in input + next: /* @__PURE__ */ __name(function() { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + var token2, match2, tempMatch, index; + if (!this._more) { + this.yytext = ""; + this.match = ""; + } + var rules = this._currentRules(); + for (var i2 = 0; i2 < rules.length; i2++) { + tempMatch = this._input.match(this.rules[rules[i2]]); + if (tempMatch && (!match2 || tempMatch[0].length > match2[0].length)) { + match2 = tempMatch; + index = i2; + if (this.options.backtrack_lexer) { + token2 = this.test_match(tempMatch, rules[i2]); + if (token2 !== false) { + return token2; + } else if (this._backtrack) { + match2 = false; + continue; + } else { + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match2) { + token2 = this.test_match(match2, rules[index]); + if (token2 !== false) { + return token2; + } + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, "next"), + // return next match that has a token + lex: /* @__PURE__ */ __name(function lex() { + var r2 = this.next(); + if (r2) { + return r2; + } else { + return this.lex(); + } + }, "lex"), + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: /* @__PURE__ */ __name(function begin(condition) { + this.conditionStack.push(condition); + }, "begin"), + // pop the previously active lexer condition state off the condition stack + popState: /* @__PURE__ */ __name(function popState() { + var n2 = this.conditionStack.length - 1; + if (n2 > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, "popState"), + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: /* @__PURE__ */ __name(function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, "_currentRules"), + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: /* @__PURE__ */ __name(function topState(n2) { + n2 = this.conditionStack.length - 1 - Math.abs(n2 || 0); + if (n2 >= 0) { + return this.conditionStack[n2]; + } else { + return "INITIAL"; + } + }, "topState"), + // alias for begin(condition) + pushState: /* @__PURE__ */ __name(function pushState(condition) { + this.begin(condition); + }, "pushState"), + // return the number of states currently on the stack + stateStackSize: /* @__PURE__ */ __name(function stateStackSize() { + return this.conditionStack.length; + }, "stateStackSize"), + options: { "case-insensitive": true }, + performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + var YYSTATE = YY_START; + switch ($avoiding_name_collisions) { + case 0: + break; + case 1: + break; + case 2: + return 10; + break; + case 3: + break; + case 4: + break; + case 5: + return 4; + break; + case 6: + return 11; + break; + case 7: + this.begin("acc_title"); + return 12; + break; + case 8: + this.popState(); + return "acc_title_value"; + break; + case 9: + this.begin("acc_descr"); + return 14; + break; + case 10: + this.popState(); + return "acc_descr_value"; + break; + case 11: + this.begin("acc_descr_multiline"); + break; + case 12: + this.popState(); + break; + case 13: + return "acc_descr_multiline_value"; + break; + case 14: + return 17; + break; + case 15: + return 18; + break; + case 16: + return 19; + break; + case 17: + return ":"; + break; + case 18: + return 6; + break; + case 19: + return "INVALID"; + break; + } + }, "anonymous"), + rules: [/^(?:%(?!\{)[^\n]*)/i, /^(?:[^\}]%%[^\n]*)/i, /^(?:[\n]+)/i, /^(?:\s+)/i, /^(?:#[^\n]*)/i, /^(?:journey\b)/i, /^(?:title\s[^#\n;]+)/i, /^(?:accTitle\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*\{\s*)/i, /^(?:[\}])/i, /^(?:[^\}]*)/i, /^(?:section\s[^#:\n;]+)/i, /^(?:[^#:\n;]+)/i, /^(?::[^#\n;]+)/i, /^(?::)/i, /^(?:$)/i, /^(?:.)/i], + conditions: { "acc_descr_multiline": { "rules": [12, 13], "inclusive": false }, "acc_descr": { "rules": [10], "inclusive": false }, "acc_title": { "rules": [8], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 14, 15, 16, 17, 18, 19], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser14.parser = parser14; + journey_default = parser14; + } + }); + + // src/diagrams/user-journey/journeyDb.js + var currentSection2, sections3, tasks2, rawTasks2, clear13, addSection3, getSections3, getTasks2, updateActors, addTask2, addTaskOrg2, compileTasks2, getActors, journeyDb_default; + var init_journeyDb = __esm({ + "src/diagrams/user-journey/journeyDb.js"() { + "use strict"; + init_diagramAPI(); + init_commonDb(); + currentSection2 = ""; + sections3 = []; + tasks2 = []; + rawTasks2 = []; + clear13 = /* @__PURE__ */ __name(function() { + sections3.length = 0; + tasks2.length = 0; + currentSection2 = ""; + rawTasks2.length = 0; + clear(); + }, "clear"); + addSection3 = /* @__PURE__ */ __name(function(txt) { + currentSection2 = txt; + sections3.push(txt); + }, "addSection"); + getSections3 = /* @__PURE__ */ __name(function() { + return sections3; + }, "getSections"); + getTasks2 = /* @__PURE__ */ __name(function() { + let allItemsProcessed = compileTasks2(); + const maxDepth = 100; + let iterationCount = 0; + while (!allItemsProcessed && iterationCount < maxDepth) { + allItemsProcessed = compileTasks2(); + iterationCount++; + } + tasks2.push(...rawTasks2); + return tasks2; + }, "getTasks"); + updateActors = /* @__PURE__ */ __name(function() { + const tempActors = []; + tasks2.forEach((task) => { + if (task.people) { + tempActors.push(...task.people); + } + }); + const unique = new Set(tempActors); + return [...unique].sort(); + }, "updateActors"); + addTask2 = /* @__PURE__ */ __name(function(descr, taskData) { + const pieces = taskData.substr(1).split(":"); + let score = 0; + let peeps = []; + if (pieces.length === 1) { + score = Number(pieces[0]); + peeps = []; + } else { + score = Number(pieces[0]); + peeps = pieces[1].split(","); + } + const peopleList = peeps.map((s2) => s2.trim()); + const rawTask = { + section: currentSection2, + type: currentSection2, + people: peopleList, + task: descr, + score + }; + rawTasks2.push(rawTask); + }, "addTask"); + addTaskOrg2 = /* @__PURE__ */ __name(function(descr) { + const newTask = { + section: currentSection2, + type: currentSection2, + description: descr, + task: descr, + classes: [] + }; + tasks2.push(newTask); + }, "addTaskOrg"); + compileTasks2 = /* @__PURE__ */ __name(function() { + const compileTask = /* @__PURE__ */ __name(function(pos) { + return rawTasks2[pos].processed; + }, "compileTask"); + let allProcessed = true; + for (const [i2, rawTask] of rawTasks2.entries()) { + compileTask(i2); + allProcessed = allProcessed && rawTask.processed; + } + return allProcessed; + }, "compileTasks"); + getActors = /* @__PURE__ */ __name(function() { + return updateActors(); + }, "getActors"); + journeyDb_default = { + getConfig: /* @__PURE__ */ __name(() => getConfig2().journey, "getConfig"), + clear: clear13, + setDiagramTitle, + getDiagramTitle, + setAccTitle, + getAccTitle, + setAccDescription, + getAccDescription, + addSection: addSection3, + getSections: getSections3, + getTasks: getTasks2, + addTask: addTask2, + addTaskOrg: addTaskOrg2, + getActors + }; + } + }); + + // src/diagrams/user-journey/styles.js + var getStyles12, styles_default11; + var init_styles11 = __esm({ + "src/diagrams/user-journey/styles.js"() { + "use strict"; + init_globalStyles(); + getStyles12 = /* @__PURE__ */ __name((options2) => `.label { + font-family: ${options2.fontFamily}; + color: ${options2.textColor}; + } + .mouth { + stroke: #666; + } + + line { + stroke: ${options2.textColor} + } + + .legend { + fill: ${options2.textColor}; + font-family: ${options2.fontFamily}; + } + + .label text { + fill: #333; + } + .label { + color: ${options2.textColor} + } + + .face { + ${options2.faceColor ? `fill: ${options2.faceColor}` : "fill: #FFF8DC"}; + stroke: #999; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${options2.mainBkg}; + stroke: ${options2.nodeBorder}; + stroke-width: 1px; + } + + .node .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + .arrowheadPath { + fill: ${options2.arrowheadColor}; + } + + .edgePath .path { + stroke: ${options2.lineColor}; + stroke-width: 1.5px; + } + + .flowchart-link { + stroke: ${options2.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${options2.edgeLabelBackground}; + rect { + opacity: 0.5; + } + text-align: center; + } + + .cluster rect { + } + + .cluster text { + fill: ${options2.titleColor}; + } + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${options2.fontFamily}; + font-size: 12px; + background: ${options2.tertiaryColor}; + border: 1px solid ${options2.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .task-type-0, .section-type-0 { + ${options2.fillType0 ? `fill: ${options2.fillType0}` : ""}; + } + .task-type-1, .section-type-1 { + ${options2.fillType0 ? `fill: ${options2.fillType1}` : ""}; + } + .task-type-2, .section-type-2 { + ${options2.fillType0 ? `fill: ${options2.fillType2}` : ""}; + } + .task-type-3, .section-type-3 { + ${options2.fillType0 ? `fill: ${options2.fillType3}` : ""}; + } + .task-type-4, .section-type-4 { + ${options2.fillType0 ? `fill: ${options2.fillType4}` : ""}; + } + .task-type-5, .section-type-5 { + ${options2.fillType0 ? `fill: ${options2.fillType5}` : ""}; + } + .task-type-6, .section-type-6 { + ${options2.fillType0 ? `fill: ${options2.fillType6}` : ""}; + } + .task-type-7, .section-type-7 { + ${options2.fillType0 ? `fill: ${options2.fillType7}` : ""}; + } + + .actor-0 { + ${options2.actor0 ? `fill: ${options2.actor0}` : ""}; + } + .actor-1 { + ${options2.actor1 ? `fill: ${options2.actor1}` : ""}; + } + .actor-2 { + ${options2.actor2 ? `fill: ${options2.actor2}` : ""}; + } + .actor-3 { + ${options2.actor3 ? `fill: ${options2.actor3}` : ""}; + } + .actor-4 { + ${options2.actor4 ? `fill: ${options2.actor4}` : ""}; + } + .actor-5 { + ${options2.actor5 ? `fill: ${options2.actor5}` : ""}; + } + ${getIconStyles()} +`, "getStyles"); + styles_default11 = getStyles12; + } + }); + + // src/diagrams/user-journey/svgDraw.js + var drawRect5, drawFace, drawCircle, drawText4, drawLabel2, drawSection, taskCount, drawTask, drawBackgroundRect3, _drawTextCandidateFunc3, initGraphics, svgDraw_default3; + var init_svgDraw3 = __esm({ + "src/diagrams/user-journey/svgDraw.js"() { + "use strict"; + init_src32(); + init_svgDrawCommon(); + drawRect5 = /* @__PURE__ */ __name(function(elem, rectData) { + return drawRect(elem, rectData); + }, "drawRect"); + drawFace = /* @__PURE__ */ __name(function(element3, faceData) { + const radius2 = 15; + const circleElement = element3.append("circle").attr("cx", faceData.cx).attr("cy", faceData.cy).attr("class", "face").attr("r", radius2).attr("stroke-width", 2).attr("overflow", "visible"); + const face = element3.append("g"); + face.append("circle").attr("cx", faceData.cx - radius2 / 3).attr("cy", faceData.cy - radius2 / 3).attr("r", 1.5).attr("stroke-width", 2).attr("fill", "#666").attr("stroke", "#666"); + face.append("circle").attr("cx", faceData.cx + radius2 / 3).attr("cy", faceData.cy - radius2 / 3).attr("r", 1.5).attr("stroke-width", 2).attr("fill", "#666").attr("stroke", "#666"); + function smile(face2) { + const arc = arc_default().startAngle(Math.PI / 2).endAngle(3 * (Math.PI / 2)).innerRadius(radius2 / 2).outerRadius(radius2 / 2.2); + face2.append("path").attr("class", "mouth").attr("d", arc).attr("transform", "translate(" + faceData.cx + "," + (faceData.cy + 2) + ")"); + } + __name(smile, "smile"); + function sad(face2) { + const arc = arc_default().startAngle(3 * Math.PI / 2).endAngle(5 * (Math.PI / 2)).innerRadius(radius2 / 2).outerRadius(radius2 / 2.2); + face2.append("path").attr("class", "mouth").attr("d", arc).attr("transform", "translate(" + faceData.cx + "," + (faceData.cy + 7) + ")"); + } + __name(sad, "sad"); + function ambivalent(face2) { + face2.append("line").attr("class", "mouth").attr("stroke", 2).attr("x1", faceData.cx - 5).attr("y1", faceData.cy + 7).attr("x2", faceData.cx + 5).attr("y2", faceData.cy + 7).attr("class", "mouth").attr("stroke-width", "1px").attr("stroke", "#666"); + } + __name(ambivalent, "ambivalent"); + if (faceData.score > 3) { + smile(face); + } else if (faceData.score < 3) { + sad(face); + } else { + ambivalent(face); + } + return circleElement; + }, "drawFace"); + drawCircle = /* @__PURE__ */ __name(function(element3, circleData) { + const circleElement = element3.append("circle"); + circleElement.attr("cx", circleData.cx); + circleElement.attr("cy", circleData.cy); + circleElement.attr("class", "actor-" + circleData.pos); + circleElement.attr("fill", circleData.fill); + circleElement.attr("stroke", circleData.stroke); + circleElement.attr("r", circleData.r); + if (circleElement.class !== void 0) { + circleElement.attr("class", circleElement.class); + } + if (circleData.title !== void 0) { + circleElement.append("title").text(circleData.title); + } + return circleElement; + }, "drawCircle"); + drawText4 = /* @__PURE__ */ __name(function(elem, textData) { + return drawText(elem, textData); + }, "drawText"); + drawLabel2 = /* @__PURE__ */ __name(function(elem, txtObject) { + function genPoints(x5, y6, width3, height2, cut) { + return x5 + "," + y6 + " " + (x5 + width3) + "," + y6 + " " + (x5 + width3) + "," + (y6 + height2 - cut) + " " + (x5 + width3 - cut * 1.2) + "," + (y6 + height2) + " " + x5 + "," + (y6 + height2); + } + __name(genPoints, "genPoints"); + const polygon2 = elem.append("polygon"); + polygon2.attr("points", genPoints(txtObject.x, txtObject.y, 50, 20, 7)); + polygon2.attr("class", "labelBox"); + txtObject.y = txtObject.y + txtObject.labelMargin; + txtObject.x = txtObject.x + 0.5 * txtObject.labelMargin; + drawText4(elem, txtObject); + }, "drawLabel"); + drawSection = /* @__PURE__ */ __name(function(elem, section, conf5) { + const g2 = elem.append("g"); + const rect3 = getNoteRect(); + rect3.x = section.x; + rect3.y = section.y; + rect3.fill = section.fill; + rect3.width = conf5.width * section.taskCount + // width of the tasks + conf5.diagramMarginX * (section.taskCount - 1); + rect3.height = conf5.height; + rect3.class = "journey-section section-type-" + section.num; + rect3.rx = 3; + rect3.ry = 3; + drawRect5(g2, rect3); + _drawTextCandidateFunc3(conf5)( + section.text, + g2, + rect3.x, + rect3.y, + rect3.width, + rect3.height, + { class: "journey-section section-type-" + section.num }, + conf5, + section.colour + ); + }, "drawSection"); + taskCount = -1; + drawTask = /* @__PURE__ */ __name(function(elem, task, conf5) { + const center4 = task.x + conf5.width / 2; + const g2 = elem.append("g"); + taskCount++; + const maxHeight = 300 + 5 * 30; + g2.append("line").attr("id", "task" + taskCount).attr("x1", center4).attr("y1", task.y).attr("x2", center4).attr("y2", maxHeight).attr("class", "task-line").attr("stroke-width", "1px").attr("stroke-dasharray", "4 2").attr("stroke", "#666"); + drawFace(g2, { + cx: center4, + cy: 300 + (5 - task.score) * 30, + score: task.score + }); + const rect3 = getNoteRect(); + rect3.x = task.x; + rect3.y = task.y; + rect3.fill = task.fill; + rect3.width = conf5.width; + rect3.height = conf5.height; + rect3.class = "task task-type-" + task.num; + rect3.rx = 3; + rect3.ry = 3; + drawRect5(g2, rect3); + let xPos = task.x + 14; + task.people.forEach((person) => { + const colour = task.actors[person].color; + const circle6 = { + cx: xPos, + cy: task.y, + r: 7, + fill: colour, + stroke: "#000", + title: person, + pos: task.actors[person].position + }; + drawCircle(g2, circle6); + xPos += 10; + }); + _drawTextCandidateFunc3(conf5)( + task.task, + g2, + rect3.x, + rect3.y, + rect3.width, + rect3.height, + { class: "task" }, + conf5, + task.colour + ); + }, "drawTask"); + drawBackgroundRect3 = /* @__PURE__ */ __name(function(elem, bounds4) { + drawBackgroundRect(elem, bounds4); + }, "drawBackgroundRect"); + _drawTextCandidateFunc3 = /* @__PURE__ */ (function() { + function byText(content, g2, x5, y6, width3, height2, textAttrs, colour) { + const text4 = g2.append("text").attr("x", x5 + width3 / 2).attr("y", y6 + height2 / 2 + 5).style("font-color", colour).style("text-anchor", "middle").text(content); + _setTextAttrs(text4, textAttrs); + } + __name(byText, "byText"); + function byTspan(content, g2, x5, y6, width3, height2, textAttrs, conf5, colour) { + const { taskFontSize, taskFontFamily } = conf5; + const lines = content.split(/
)/).reverse(), word, line2 = [], lineHeight = 1.1, y6 = text5.attr("y"), dy = parseFloat(text5.attr("dy")), tspan = text5.text(null).append("tspan").attr("x", 0).attr("y", y6).attr("dy", dy + "em"); + for (let j3 = 0; j3 < words.length; j3++) { + word = words[words.length - 1 - j3]; + line2.push(word); + tspan.text(line2.join(" ").trim()); + if (tspan.node().getComputedTextLength() > width3 || word === "
") { + line2.pop(); + tspan.text(line2.join(" ").trim()); + if (word === "
") { + line2 = [""]; + } else { + line2 = [word]; + } + tspan = text5.append("tspan").attr("x", 0).attr("y", y6).attr("dy", lineHeight + "em").text(word); + } + } + }); + } + var MAX_SECTIONS, drawRect6, drawFace2, drawCircle2, drawText5, drawLabel3, drawSection2, taskCount2, drawTask2, drawBackgroundRect4, getTextObj4, getNoteRect3, _drawTextCandidateFunc4, initGraphics2, drawNode, getVirtualNodeHeight, defaultBkg, svgDraw_default4; + var init_svgDraw4 = __esm({ + "src/diagrams/timeline/svgDraw.js"() { + "use strict"; + init_src32(); + MAX_SECTIONS = 12; + drawRect6 = /* @__PURE__ */ __name(function(elem, rectData) { + const rectElem = elem.append("rect"); + rectElem.attr("x", rectData.x); + rectElem.attr("y", rectData.y); + rectElem.attr("fill", rectData.fill); + rectElem.attr("stroke", rectData.stroke); + rectElem.attr("width", rectData.width); + rectElem.attr("height", rectData.height); + rectElem.attr("rx", rectData.rx); + rectElem.attr("ry", rectData.ry); + if (rectData.class !== void 0) { + rectElem.attr("class", rectData.class); + } + return rectElem; + }, "drawRect"); + drawFace2 = /* @__PURE__ */ __name(function(element3, faceData) { + const radius2 = 15; + const circleElement = element3.append("circle").attr("cx", faceData.cx).attr("cy", faceData.cy).attr("class", "face").attr("r", radius2).attr("stroke-width", 2).attr("overflow", "visible"); + const face = element3.append("g"); + face.append("circle").attr("cx", faceData.cx - radius2 / 3).attr("cy", faceData.cy - radius2 / 3).attr("r", 1.5).attr("stroke-width", 2).attr("fill", "#666").attr("stroke", "#666"); + face.append("circle").attr("cx", faceData.cx + radius2 / 3).attr("cy", faceData.cy - radius2 / 3).attr("r", 1.5).attr("stroke-width", 2).attr("fill", "#666").attr("stroke", "#666"); + function smile(face2) { + const arc = arc_default().startAngle(Math.PI / 2).endAngle(3 * (Math.PI / 2)).innerRadius(radius2 / 2).outerRadius(radius2 / 2.2); + face2.append("path").attr("class", "mouth").attr("d", arc).attr("transform", "translate(" + faceData.cx + "," + (faceData.cy + 2) + ")"); + } + __name(smile, "smile"); + function sad(face2) { + const arc = arc_default().startAngle(3 * Math.PI / 2).endAngle(5 * (Math.PI / 2)).innerRadius(radius2 / 2).outerRadius(radius2 / 2.2); + face2.append("path").attr("class", "mouth").attr("d", arc).attr("transform", "translate(" + faceData.cx + "," + (faceData.cy + 7) + ")"); + } + __name(sad, "sad"); + function ambivalent(face2) { + face2.append("line").attr("class", "mouth").attr("stroke", 2).attr("x1", faceData.cx - 5).attr("y1", faceData.cy + 7).attr("x2", faceData.cx + 5).attr("y2", faceData.cy + 7).attr("class", "mouth").attr("stroke-width", "1px").attr("stroke", "#666"); + } + __name(ambivalent, "ambivalent"); + if (faceData.score > 3) { + smile(face); + } else if (faceData.score < 3) { + sad(face); + } else { + ambivalent(face); + } + return circleElement; + }, "drawFace"); + drawCircle2 = /* @__PURE__ */ __name(function(element3, circleData) { + const circleElement = element3.append("circle"); + circleElement.attr("cx", circleData.cx); + circleElement.attr("cy", circleData.cy); + circleElement.attr("class", "actor-" + circleData.pos); + circleElement.attr("fill", circleData.fill); + circleElement.attr("stroke", circleData.stroke); + circleElement.attr("r", circleData.r); + if (circleElement.class !== void 0) { + circleElement.attr("class", circleElement.class); + } + if (circleData.title !== void 0) { + circleElement.append("title").text(circleData.title); + } + return circleElement; + }, "drawCircle"); + drawText5 = /* @__PURE__ */ __name(function(elem, textData) { + const nText = textData.text.replace(/
"); + return 24; + break; + case 4: + return 24; + break; + case 5: + this.popState(); + break; + case 6: + yy.getLogger().trace("Found comment", yy_.yytext); + return 6; + break; + case 7: + return 8; + break; + case 8: + this.begin("CLASS"); + break; + case 9: + this.popState(); + return 17; + break; + case 10: + this.popState(); + break; + case 11: + yy.getLogger().trace("Begin icon"); + this.begin("ICON"); + break; + case 12: + yy.getLogger().trace("SPACELINE"); + return 6; + break; + case 13: + return 7; + break; + case 14: + return 16; + break; + case 15: + yy.getLogger().trace("end icon"); + this.popState(); + break; + case 16: + yy.getLogger().trace("Exploding node"); + this.begin("NODE"); + return 20; + break; + case 17: + yy.getLogger().trace("Cloud"); + this.begin("NODE"); + return 20; + break; + case 18: + yy.getLogger().trace("Explosion Bang"); + this.begin("NODE"); + return 20; + break; + case 19: + yy.getLogger().trace("Cloud Bang"); + this.begin("NODE"); + return 20; + break; + case 20: + this.begin("NODE"); + return 20; + break; + case 21: + this.begin("NODE"); + return 20; + break; + case 22: + this.begin("NODE"); + return 20; + break; + case 23: + this.begin("NODE"); + return 20; + break; + case 24: + return 13; + break; + case 25: + return 23; + break; + case 26: + return 11; + break; + case 27: + this.begin("NSTR2"); + break; + case 28: + return "NODE_DESCR"; + break; + case 29: + this.popState(); + break; + case 30: + yy.getLogger().trace("Starting NSTR"); + this.begin("NSTR"); + break; + case 31: + yy.getLogger().trace("description:", yy_.yytext); + return "NODE_DESCR"; + break; + case 32: + this.popState(); + break; + case 33: + this.popState(); + yy.getLogger().trace("node end ))"); + return "NODE_DEND"; + break; + case 34: + this.popState(); + yy.getLogger().trace("node end )"); + return "NODE_DEND"; + break; + case 35: + this.popState(); + yy.getLogger().trace("node end ...", yy_.yytext); + return "NODE_DEND"; + break; + case 36: + this.popState(); + yy.getLogger().trace("node end (("); + return "NODE_DEND"; + break; + case 37: + this.popState(); + yy.getLogger().trace("node end (-"); + return "NODE_DEND"; + break; + case 38: + this.popState(); + yy.getLogger().trace("node end (-"); + return "NODE_DEND"; + break; + case 39: + this.popState(); + yy.getLogger().trace("node end (("); + return "NODE_DEND"; + break; + case 40: + this.popState(); + yy.getLogger().trace("node end (("); + return "NODE_DEND"; + break; + case 41: + yy.getLogger().trace("Long description:", yy_.yytext); + return 21; + break; + case 42: + yy.getLogger().trace("Long description:", yy_.yytext); + return 21; + break; + } + }, "anonymous"), + rules: [/^(?:@\{)/i, /^(?:["])/i, /^(?:["])/i, /^(?:[^\"]+)/i, /^(?:[^}^"]+)/i, /^(?:\})/i, /^(?:\s*%%.*)/i, /^(?:kanban\b)/i, /^(?::::)/i, /^(?:.+)/i, /^(?:\n)/i, /^(?:::icon\()/i, /^(?:[\s]+[\n])/i, /^(?:[\n]+)/i, /^(?:[^\)]+)/i, /^(?:\))/i, /^(?:-\))/i, /^(?:\(-)/i, /^(?:\)\))/i, /^(?:\))/i, /^(?:\(\()/i, /^(?:\{\{)/i, /^(?:\()/i, /^(?:\[)/i, /^(?:[\s]+)/i, /^(?:[^\(\[\n\)\{\}@]+)/i, /^(?:$)/i, /^(?:["][`])/i, /^(?:[^`"]+)/i, /^(?:[`]["])/i, /^(?:["])/i, /^(?:[^"]+)/i, /^(?:["])/i, /^(?:[\)]\))/i, /^(?:[\)])/i, /^(?:[\]])/i, /^(?:\}\})/i, /^(?:\(-)/i, /^(?:-\))/i, /^(?:\(\()/i, /^(?:\()/i, /^(?:[^\)\]\(\}]+)/i, /^(?:.+(?!\(\())/i], + conditions: { "shapeDataEndBracket": { "rules": [], "inclusive": false }, "shapeDataStr": { "rules": [2, 3], "inclusive": false }, "shapeData": { "rules": [1, 4, 5], "inclusive": false }, "CLASS": { "rules": [9, 10], "inclusive": false }, "ICON": { "rules": [14, 15], "inclusive": false }, "NSTR2": { "rules": [28, 29], "inclusive": false }, "NSTR": { "rules": [31, 32], "inclusive": false }, "NODE": { "rules": [27, 30, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42], "inclusive": false }, "INITIAL": { "rules": [0, 6, 7, 8, 11, 12, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser17.parser = parser17; + kanban_default = parser17; + } + }); + + // src/diagrams/kanban/kanbanDb.ts + var nodes3, sections5, cnt2, elements, clear15, getSection, getSections5, getData, addNode, nodeType2, getType, setElementForId, decorateNode, type2Str, getLogger, getElementById2, db4, kanbanDb_default; + var init_kanbanDb = __esm({ + "src/diagrams/kanban/kanbanDb.ts"() { + "use strict"; + init_diagramAPI(); + init_common(); + init_logger(); + init_defaultConfig(); + init_js_yaml(); + nodes3 = []; + sections5 = []; + cnt2 = 0; + elements = {}; + clear15 = /* @__PURE__ */ __name(() => { + nodes3 = []; + sections5 = []; + cnt2 = 0; + elements = {}; + }, "clear"); + getSection = /* @__PURE__ */ __name((level) => { + if (nodes3.length === 0) { + return null; + } + const sectionLevel = nodes3[0].level; + let lastSection = null; + for (let i2 = nodes3.length - 1; i2 >= 0; i2--) { + if (nodes3[i2].level === sectionLevel && !lastSection) { + lastSection = nodes3[i2]; + } + if (nodes3[i2].level < sectionLevel) { + throw new Error('Items without section detected, found section ("' + nodes3[i2].label + '")'); + } + } + if (level === lastSection?.level) { + return null; + } + return lastSection; + }, "getSection"); + getSections5 = /* @__PURE__ */ __name(function() { + return sections5; + }, "getSections"); + getData = /* @__PURE__ */ __name(function() { + const edges3 = []; + const _nodes = []; + const sections6 = getSections5(); + const conf5 = getConfig2(); + for (const section of sections6) { + const node2 = { + id: section.id, + label: sanitizeText(section.label ?? "", conf5), + isGroup: true, + ticket: section.ticket, + shape: "kanbanSection", + level: section.level, + look: conf5.look + }; + _nodes.push(node2); + const children2 = nodes3.filter((n2) => n2.parentId === section.id); + for (const item of children2) { + const childNode = { + id: item.id, + parentId: section.id, + label: sanitizeText(item.label ?? "", conf5), + isGroup: false, + ticket: item?.ticket, + priority: item?.priority, + assigned: item?.assigned, + icon: item?.icon, + shape: "kanbanItem", + level: item.level, + rx: 5, + ry: 5, + cssStyles: ["text-align: left"] + }; + _nodes.push(childNode); + } + } + return { nodes: _nodes, edges: edges3, other: {}, config: getConfig2() }; + }, "getData"); + addNode = /* @__PURE__ */ __name((level, id30, descr, type3, shapeData) => { + const conf5 = getConfig2(); + let padding2 = conf5.mindmap?.padding ?? defaultConfig_default.mindmap.padding; + switch (type3) { + case nodeType2.ROUNDED_RECT: + case nodeType2.RECT: + case nodeType2.HEXAGON: + padding2 *= 2; + } + const node2 = { + id: sanitizeText(id30, conf5) || "kbn" + cnt2++, + level, + label: sanitizeText(descr, conf5), + width: conf5.mindmap?.maxNodeWidth ?? defaultConfig_default.mindmap.maxNodeWidth, + padding: padding2, + isGroup: false + }; + if (shapeData !== void 0) { + let yamlData; + if (!shapeData.includes("\n")) { + yamlData = "{\n" + shapeData + "\n}"; + } else { + yamlData = shapeData + "\n"; + } + const doc = load(yamlData, { schema: JSON_SCHEMA }); + if (doc.shape && (doc.shape !== doc.shape.toLowerCase() || doc.shape.includes("_"))) { + throw new Error(`No such shape: ${doc.shape}. Shape names should be lowercase.`); + } + if (doc?.shape && doc.shape === "kanbanItem") { + node2.shape = doc?.shape; + } + if (doc?.label) { + node2.label = doc?.label; + } + if (doc?.icon) { + node2.icon = doc?.icon.toString(); + } + if (doc?.assigned) { + node2.assigned = doc?.assigned.toString(); + } + if (doc?.ticket) { + node2.ticket = doc?.ticket.toString(); + } + if (doc?.priority) { + node2.priority = doc?.priority; + } + } + const section = getSection(level); + if (section) { + node2.parentId = section.id || "kbn" + cnt2++; + } else { + sections5.push(node2); + } + nodes3.push(node2); + }, "addNode"); + nodeType2 = { + DEFAULT: 0, + NO_BORDER: 0, + ROUNDED_RECT: 1, + RECT: 2, + CIRCLE: 3, + CLOUD: 4, + BANG: 5, + HEXAGON: 6 + }; + getType = /* @__PURE__ */ __name((startStr, endStr) => { + log.debug("In get type", startStr, endStr); + switch (startStr) { + case "[": + return nodeType2.RECT; + case "(": + return endStr === ")" ? nodeType2.ROUNDED_RECT : nodeType2.CLOUD; + case "((": + return nodeType2.CIRCLE; + case ")": + return nodeType2.CLOUD; + case "))": + return nodeType2.BANG; + case "{{": + return nodeType2.HEXAGON; + default: + return nodeType2.DEFAULT; + } + }, "getType"); + setElementForId = /* @__PURE__ */ __name((id30, element3) => { + elements[id30] = element3; + }, "setElementForId"); + decorateNode = /* @__PURE__ */ __name((decoration) => { + if (!decoration) { + return; + } + const config5 = getConfig2(); + const node2 = nodes3[nodes3.length - 1]; + if (decoration.icon) { + node2.icon = sanitizeText(decoration.icon, config5); + } + if (decoration.class) { + node2.cssClasses = sanitizeText(decoration.class, config5); + } + }, "decorateNode"); + type2Str = /* @__PURE__ */ __name((type3) => { + switch (type3) { + case nodeType2.DEFAULT: + return "no-border"; + case nodeType2.RECT: + return "rect"; + case nodeType2.ROUNDED_RECT: + return "rounded-rect"; + case nodeType2.CIRCLE: + return "circle"; + case nodeType2.CLOUD: + return "cloud"; + case nodeType2.BANG: + return "bang"; + case nodeType2.HEXAGON: + return "hexgon"; + // cspell: disable-line + default: + return "no-border"; + } + }, "type2Str"); + getLogger = /* @__PURE__ */ __name(() => log, "getLogger"); + getElementById2 = /* @__PURE__ */ __name((id30) => elements[id30], "getElementById"); + db4 = { + clear: clear15, + addNode, + getSections: getSections5, + getData, + nodeType: nodeType2, + getType, + setElementForId, + decorateNode, + type2Str, + getLogger, + getElementById: getElementById2 + }; + kanbanDb_default = db4; + } + }); + + // src/diagrams/kanban/kanbanRenderer.ts + var draw19, kanbanRenderer_default; + var init_kanbanRenderer = __esm({ + "src/diagrams/kanban/kanbanRenderer.ts"() { + "use strict"; + init_diagramAPI(); + init_logger(); + init_selectSvgElement(); + init_setupGraphViewbox(); + init_defaultConfig(); + init_clusters(); + init_nodes2(); + draw19 = /* @__PURE__ */ __name(async (text4, id30, _version, diagObj) => { + log.debug("Rendering kanban diagram\n" + text4); + const db7 = diagObj.db; + const data4Layout = db7.getData(); + const conf5 = getConfig2(); + conf5.htmlLabels = false; + const svg2 = selectSvgElement(id30); + const sectionsElem = svg2.append("g"); + sectionsElem.attr("class", "sections"); + const nodesElem = svg2.append("g"); + nodesElem.attr("class", "items"); + const sections6 = data4Layout.nodes.filter( + // TODO: TypeScript 5.5 will infer this predicate automatically + (node2) => node2.isGroup + ); + let cnt4 = 0; + const padding2 = 10; + const sectionObjects = []; + let maxLabelHeight = 25; + for (const section of sections6) { + const WIDTH = conf5?.kanban?.sectionWidth || 200; + cnt4 = cnt4 + 1; + section.x = WIDTH * cnt4 + (cnt4 - 1) * padding2 / 2; + section.width = WIDTH; + section.y = 0; + section.height = WIDTH * 3; + section.rx = 5; + section.ry = 5; + section.cssClasses = section.cssClasses + " section-" + cnt4; + const sectionObj = await insertCluster(sectionsElem, section); + maxLabelHeight = Math.max(maxLabelHeight, sectionObj?.labelBBox?.height); + sectionObjects.push(sectionObj); + } + let i2 = 0; + for (const section of sections6) { + const sectionObj = sectionObjects[i2]; + i2 = i2 + 1; + const WIDTH = conf5?.kanban?.sectionWidth || 200; + const top2 = -WIDTH * 3 / 2 + maxLabelHeight; + let y6 = top2; + const sectionItems = data4Layout.nodes.filter((node2) => node2.parentId === section.id); + for (const item of sectionItems) { + if (item.isGroup) { + throw new Error("Groups within groups are not allowed in Kanban diagrams"); + } + item.x = section.x; + item.width = WIDTH - 1.5 * padding2; + const nodeEl = await insertNode(nodesElem, item, { config: conf5 }); + const bbox = nodeEl.node().getBBox(); + item.y = y6 + bbox.height / 2; + await positionNode(item); + y6 = item.y + bbox.height / 2 + padding2 / 2; + } + const rect3 = sectionObj.cluster.select("rect"); + const height2 = Math.max(y6 - top2 + 3 * padding2, 50) + (maxLabelHeight - 25); + rect3.attr("height", height2); + } + setupGraphViewbox( + void 0, + svg2, + conf5.mindmap?.padding ?? defaultConfig_default.kanban.padding, + conf5.mindmap?.useMaxWidth ?? defaultConfig_default.kanban.useMaxWidth + ); + }, "draw"); + kanbanRenderer_default = { + draw: draw19 + }; + } + }); + + // src/diagrams/kanban/styles.ts + var genSections3, getStyles15, styles_default14; + var init_styles14 = __esm({ + "src/diagrams/kanban/styles.ts"() { + "use strict"; + init_dist(); + init_globalStyles(); + genSections3 = /* @__PURE__ */ __name((options2) => { + let sections6 = ""; + for (let i2 = 0; i2 < options2.THEME_COLOR_LIMIT; i2++) { + options2["lineColor" + i2] = options2["lineColor" + i2] || options2["cScaleInv" + i2]; + if (is_dark_default(options2["lineColor" + i2])) { + options2["lineColor" + i2] = lighten_default(options2["lineColor" + i2], 20); + } else { + options2["lineColor" + i2] = darken_default(options2["lineColor" + i2], 20); + } + } + const adjuster = /* @__PURE__ */ __name((color2, level) => options2.darkMode ? darken_default(color2, level) : lighten_default(color2, level), "adjuster"); + for (let i2 = 0; i2 < options2.THEME_COLOR_LIMIT; i2++) { + const sw = "" + (17 - 3 * i2); + sections6 += ` + .section-${i2 - 1} rect, .section-${i2 - 1} path, .section-${i2 - 1} circle, .section-${i2 - 1} polygon, .section-${i2 - 1} path { + fill: ${adjuster(options2["cScale" + i2], 10)}; + stroke: ${adjuster(options2["cScale" + i2], 10)}; + + } + .section-${i2 - 1} text { + fill: ${options2["cScaleLabel" + i2]}; + } + .node-icon-${i2 - 1} { + font-size: 40px; + color: ${options2["cScaleLabel" + i2]}; + } + .section-edge-${i2 - 1}{ + stroke: ${options2["cScale" + i2]}; + } + .edge-depth-${i2 - 1}{ + stroke-width: ${sw}; + } + .section-${i2 - 1} line { + stroke: ${options2["cScaleInv" + i2]} ; + stroke-width: 3; + } + + .disabled, .disabled circle, .disabled text { + fill: lightgray; + } + .disabled text { + fill: #efefef; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${options2.background}; + stroke: ${options2.nodeBorder}; + stroke-width: 1px; + } + + .kanban-ticket-link { + fill: ${options2.background}; + stroke: ${options2.nodeBorder}; + text-decoration: underline; + } + `; + } + return sections6; + }, "genSections"); + getStyles15 = /* @__PURE__ */ __name((options2) => ` + .edge { + stroke-width: 3; + } + ${genSections3(options2)} + .section-root rect, .section-root path, .section-root circle, .section-root polygon { + fill: ${options2.git0}; + } + .section-root text { + fill: ${options2.gitBranchLabel0}; + } + .icon-container { + height:100%; + display: flex; + justify-content: center; + align-items: center; + } + .edge { + fill: none; + } + .cluster-label, .label { + color: ${options2.textColor}; + fill: ${options2.textColor}; + } + .kanban-label { + dy: 1em; + alignment-baseline: middle; + text-anchor: middle; + dominant-baseline: middle; + text-align: center; + } + ${getIconStyles()} +`, "getStyles"); + styles_default14 = getStyles15; + } + }); + + // src/diagrams/kanban/kanban-definition.ts + var kanban_definition_exports = {}; + __export(kanban_definition_exports, { + diagram: () => diagram20 + }); + var diagram20; + var init_kanban_definition = __esm({ + "src/diagrams/kanban/kanban-definition.ts"() { + "use strict"; + init_kanban(); + init_kanbanDb(); + init_kanbanRenderer(); + init_styles14(); + diagram20 = { + db: kanbanDb_default, + renderer: kanbanRenderer_default, + parser: kanban_default, + styles: styles_default14 + }; + } + }); + + // src/diagrams/sankey/parser/sankey.jison + var parser18, sankey_default; + var init_sankey = __esm({ + "src/diagrams/sankey/parser/sankey.jison"() { + "use strict"; + parser18 = (function() { + var o2 = /* @__PURE__ */ __name(function(k2, v3, o3, l4) { + for (o3 = o3 || {}, l4 = k2.length; l4--; o3[k2[l4]] = v3) ; + return o3; + }, "o"), $V0 = [1, 9], $V1 = [1, 10], $V2 = [1, 5, 10, 12]; + var parser24 = { + trace: /* @__PURE__ */ __name(function trace() { + }, "trace"), + yy: {}, + symbols_: { "error": 2, "start": 3, "SANKEY": 4, "NEWLINE": 5, "csv": 6, "opt_eof": 7, "record": 8, "csv_tail": 9, "EOF": 10, "field[source]": 11, "COMMA": 12, "field[target]": 13, "field[value]": 14, "field": 15, "escaped": 16, "non_escaped": 17, "DQUOTE": 18, "ESCAPED_TEXT": 19, "NON_ESCAPED_TEXT": 20, "$accept": 0, "$end": 1 }, + terminals_: { 2: "error", 4: "SANKEY", 5: "NEWLINE", 10: "EOF", 11: "field[source]", 12: "COMMA", 13: "field[target]", 14: "field[value]", 18: "DQUOTE", 19: "ESCAPED_TEXT", 20: "NON_ESCAPED_TEXT" }, + productions_: [0, [3, 4], [6, 2], [9, 2], [9, 0], [7, 1], [7, 0], [8, 5], [15, 1], [15, 1], [16, 3], [17, 1]], + performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { + var $0 = $$.length - 1; + switch (yystate) { + case 7: + const source = yy.findOrCreateNode($$[$0 - 4].trim().replaceAll('""', '"')); + const target = yy.findOrCreateNode($$[$0 - 2].trim().replaceAll('""', '"')); + const value2 = parseFloat($$[$0].trim()); + yy.addLink(source, target, value2); + break; + case 8: + case 9: + case 11: + this.$ = $$[$0]; + break; + case 10: + this.$ = $$[$0 - 1]; + break; + } + }, "anonymous"), + table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, { 5: [1, 3] }, { 6: 4, 8: 5, 15: 6, 16: 7, 17: 8, 18: $V0, 20: $V1 }, { 1: [2, 6], 7: 11, 10: [1, 12] }, o2($V1, [2, 4], { 9: 13, 5: [1, 14] }), { 12: [1, 15] }, o2($V2, [2, 8]), o2($V2, [2, 9]), { 19: [1, 16] }, o2($V2, [2, 11]), { 1: [2, 1] }, { 1: [2, 5] }, o2($V1, [2, 2]), { 6: 17, 8: 5, 15: 6, 16: 7, 17: 8, 18: $V0, 20: $V1 }, { 15: 18, 16: 7, 17: 8, 18: $V0, 20: $V1 }, { 18: [1, 19] }, o2($V1, [2, 3]), { 12: [1, 20] }, o2($V2, [2, 10]), { 15: 21, 16: 7, 17: 8, 18: $V0, 20: $V1 }, o2([1, 5, 10], [2, 7])], + defaultActions: { 11: [2, 1], 12: [2, 5] }, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (hash.recoverable) { + this.trace(str2); + } else { + var error3 = new Error(str2); + error3.hash = hash; + throw error3; + } + }, "parseError"), + parse: /* @__PURE__ */ __name(function parse7(input) { + var self2 = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF2 = 1; + var args = lstack.slice.call(arguments, 1); + var lexer2 = Object.create(this.lexer); + var sharedState = { yy: {} }; + for (var k2 in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k2)) { + sharedState.yy[k2] = this.yy[k2]; + } + } + lexer2.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer2; + sharedState.yy.parser = this; + if (typeof lexer2.yylloc == "undefined") { + lexer2.yylloc = {}; + } + var yyloc = lexer2.yylloc; + lstack.push(yyloc); + var ranges = lexer2.options && lexer2.options.ranges; + if (typeof sharedState.yy.parseError === "function") { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + function popStack(n2) { + stack.length = stack.length - 2 * n2; + vstack.length = vstack.length - n2; + lstack.length = lstack.length - n2; + } + __name(popStack, "popStack"); + function lex() { + var token2; + token2 = tstack.pop() || lexer2.lex() || EOF2; + if (typeof token2 !== "number") { + if (token2 instanceof Array) { + tstack = token2; + token2 = tstack.pop(); + } + token2 = self2.symbols_[token2] || token2; + } + return token2; + } + __name(lex, "lex"); + var symbol, preErrorSymbol, state3, action, a2, r2, yyval = {}, p3, len, newState2, expected; + while (true) { + state3 = stack[stack.length - 1]; + if (this.defaultActions[state3]) { + action = this.defaultActions[state3]; + } else { + if (symbol === null || typeof symbol == "undefined") { + symbol = lex(); + } + action = table[state3] && table[state3][symbol]; + } + if (typeof action === "undefined" || !action.length || !action[0]) { + var errStr = ""; + expected = []; + for (p3 in table[state3]) { + if (this.terminals_[p3] && p3 > TERROR) { + expected.push("'" + this.terminals_[p3] + "'"); + } + } + if (lexer2.showPosition) { + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF2 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + this.parseError(errStr, { + text: lexer2.match, + token: this.terminals_[symbol] || symbol, + line: lexer2.yylineno, + loc: yyloc, + expected + }); + } + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state3 + ", token: " + symbol); + } + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(lexer2.yytext); + lstack.push(lexer2.yylloc); + stack.push(action[1]); + symbol = null; + if (!preErrorSymbol) { + yyleng = lexer2.yyleng; + yytext = lexer2.yytext; + yylineno = lexer2.yylineno; + yyloc = lexer2.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + if (ranges) { + yyval._$.range = [ + lstack[lstack.length - (len || 1)].range[0], + lstack[lstack.length - 1].range[1] + ]; + } + r2 = this.performAction.apply(yyval, [ + yytext, + yyleng, + yylineno, + sharedState.yy, + action[1], + vstack, + lstack + ].concat(args)); + if (typeof r2 !== "undefined") { + return r2; + } + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState2 = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState2); + break; + case 3: + return true; + } + } + return true; + }, "parse") + }; + var lexer = /* @__PURE__ */ (function() { + var lexer2 = { + EOF: 1, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str2, hash); + } else { + throw new Error(str2); + } + }, "parseError"), + // resets the lexer, sets new input + setInput: /* @__PURE__ */ __name(function(input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ""; + this.conditionStack = ["INITIAL"]; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + this.offset = 0; + return this; + }, "setInput"), + // consumes and returns one char from the input + input: /* @__PURE__ */ __name(function() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + this._input = this._input.slice(1); + return ch; + }, "input"), + // unshifts one char (or a string) into the input + unput: /* @__PURE__ */ __name(function(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r2 = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + if (this.options.ranges) { + this.yylloc.range = [r2[0], r2[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, "unput"), + // When called from action, caches matched text and appends it on next action + more: /* @__PURE__ */ __name(function() { + this._more = true; + return this; + }, "more"), + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: /* @__PURE__ */ __name(function() { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + return this; + }, "reject"), + // retain first n characters of the match + less: /* @__PURE__ */ __name(function(n2) { + this.unput(this.match.slice(n2)); + }, "less"), + // displays already matched input, i.e. for error messages + pastInput: /* @__PURE__ */ __name(function() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, ""); + }, "pastInput"), + // displays upcoming input, i.e. for error messages + upcomingInput: /* @__PURE__ */ __name(function() { + var next3 = this.match; + if (next3.length < 20) { + next3 += this._input.substr(0, 20 - next3.length); + } + return (next3.substr(0, 20) + (next3.length > 20 ? "..." : "")).replace(/\n/g, ""); + }, "upcomingInput"), + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: /* @__PURE__ */ __name(function() { + var pre = this.pastInput(); + var c3 = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c3 + "^"; + }, "showPosition"), + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: /* @__PURE__ */ __name(function(match2, indexed_rule) { + var token2, lines, backup; + if (this.options.backtrack_lexer) { + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + lines = match2[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match2[0].length + }; + this.yytext += match2[0]; + this.match += match2[0]; + this.matches = match2; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match2[0].length); + this.matched += match2[0]; + token2 = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token2) { + return token2; + } else if (this._backtrack) { + for (var k2 in backup) { + this[k2] = backup[k2]; + } + return false; + } + return false; + }, "test_match"), + // return next match in input + next: /* @__PURE__ */ __name(function() { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + var token2, match2, tempMatch, index; + if (!this._more) { + this.yytext = ""; + this.match = ""; + } + var rules = this._currentRules(); + for (var i2 = 0; i2 < rules.length; i2++) { + tempMatch = this._input.match(this.rules[rules[i2]]); + if (tempMatch && (!match2 || tempMatch[0].length > match2[0].length)) { + match2 = tempMatch; + index = i2; + if (this.options.backtrack_lexer) { + token2 = this.test_match(tempMatch, rules[i2]); + if (token2 !== false) { + return token2; + } else if (this._backtrack) { + match2 = false; + continue; + } else { + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match2) { + token2 = this.test_match(match2, rules[index]); + if (token2 !== false) { + return token2; + } + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, "next"), + // return next match that has a token + lex: /* @__PURE__ */ __name(function lex() { + var r2 = this.next(); + if (r2) { + return r2; + } else { + return this.lex(); + } + }, "lex"), + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: /* @__PURE__ */ __name(function begin(condition) { + this.conditionStack.push(condition); + }, "begin"), + // pop the previously active lexer condition state off the condition stack + popState: /* @__PURE__ */ __name(function popState() { + var n2 = this.conditionStack.length - 1; + if (n2 > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, "popState"), + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: /* @__PURE__ */ __name(function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, "_currentRules"), + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: /* @__PURE__ */ __name(function topState(n2) { + n2 = this.conditionStack.length - 1 - Math.abs(n2 || 0); + if (n2 >= 0) { + return this.conditionStack[n2]; + } else { + return "INITIAL"; + } + }, "topState"), + // alias for begin(condition) + pushState: /* @__PURE__ */ __name(function pushState(condition) { + this.begin(condition); + }, "pushState"), + // return the number of states currently on the stack + stateStackSize: /* @__PURE__ */ __name(function stateStackSize() { + return this.conditionStack.length; + }, "stateStackSize"), + options: { "case-insensitive": true }, + performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + var YYSTATE = YY_START; + switch ($avoiding_name_collisions) { + case 0: + this.pushState("csv"); + return 4; + break; + case 1: + this.pushState("csv"); + return 4; + break; + case 2: + return 10; + break; + case 3: + return 5; + break; + case 4: + return 12; + break; + case 5: + this.pushState("escaped_text"); + return 18; + break; + case 6: + return 20; + break; + case 7: + this.popState("escaped_text"); + return 18; + break; + case 8: + return 19; + break; + } + }, "anonymous"), + rules: [/^(?:sankey-beta\b)/i, /^(?:sankey\b)/i, /^(?:$)/i, /^(?:((\u000D\u000A)|(\u000A)))/i, /^(?:(\u002C))/i, /^(?:(\u0022))/i, /^(?:([\u0020-\u0021\u0023-\u002B\u002D-\u007E])*)/i, /^(?:(\u0022)(?!(\u0022)))/i, /^(?:(([\u0020-\u0021\u0023-\u002B\u002D-\u007E])|(\u002C)|(\u000D)|(\u000A)|(\u0022)(\u0022))*)/i], + conditions: { "csv": { "rules": [2, 3, 4, 5, 6, 7, 8], "inclusive": false }, "escaped_text": { "rules": [7, 8], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser18.parser = parser18; + sankey_default = parser18; + } + }); + + // src/diagrams/sankey/sankeyDB.ts + var links2, nodes4, nodesMap, clear16, SankeyLink, addLink, SankeyNode, findOrCreateNode, getNodes, getLinks2, getGraph, sankeyDB_default; + var init_sankeyDB = __esm({ + "src/diagrams/sankey/sankeyDB.ts"() { + "use strict"; + init_diagramAPI(); + init_common(); + init_commonDb(); + links2 = []; + nodes4 = []; + nodesMap = /* @__PURE__ */ new Map(); + clear16 = /* @__PURE__ */ __name(() => { + links2 = []; + nodes4 = []; + nodesMap = /* @__PURE__ */ new Map(); + clear(); + }, "clear"); + SankeyLink = class { + constructor(source, target, value2 = 0) { + this.source = source; + this.target = target; + this.value = value2; + } + static { + __name(this, "SankeyLink"); + } + }; + addLink = /* @__PURE__ */ __name((source, target, value2) => { + links2.push(new SankeyLink(source, target, value2)); + }, "addLink"); + SankeyNode = class { + constructor(ID) { + this.ID = ID; + } + static { + __name(this, "SankeyNode"); + } + }; + findOrCreateNode = /* @__PURE__ */ __name((ID) => { + ID = common_default.sanitizeText(ID, getConfig2()); + let node2 = nodesMap.get(ID); + if (node2 === void 0) { + node2 = new SankeyNode(ID); + nodesMap.set(ID, node2); + nodes4.push(node2); + } + return node2; + }, "findOrCreateNode"); + getNodes = /* @__PURE__ */ __name(() => nodes4, "getNodes"); + getLinks2 = /* @__PURE__ */ __name(() => links2, "getLinks"); + getGraph = /* @__PURE__ */ __name(() => ({ + nodes: nodes4.map((node2) => ({ id: node2.ID })), + links: links2.map((link2) => ({ + source: link2.source.ID, + target: link2.target.ID, + value: link2.value + })) + }), "getGraph"); + sankeyDB_default = { + nodesMap, + getConfig: /* @__PURE__ */ __name(() => getConfig2().sankey, "getConfig"), + getNodes, + getLinks: getLinks2, + getGraph, + addLink, + findOrCreateNode, + getAccTitle, + setAccTitle, + getAccDescription, + setAccDescription, + getDiagramTitle, + setDiagramTitle, + clear: clear16 + }; + } + }); + + // ../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/max.js + function max9(values2, valueof) { + let max10; + if (valueof === void 0) { + for (const value2 of values2) { + if (value2 != null && (max10 < value2 || max10 === void 0 && value2 >= value2)) { + max10 = value2; + } + } + } else { + let index = -1; + for (let value2 of values2) { + if ((value2 = valueof(value2, ++index, values2)) != null && (max10 < value2 || max10 === void 0 && value2 >= value2)) { + max10 = value2; + } + } + } + return max10; + } + var init_max3 = __esm({ + "../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/max.js"() { + "use strict"; + __name(max9, "max"); + } + }); + + // ../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/min.js + function min8(values2, valueof) { + let min9; + if (valueof === void 0) { + for (const value2 of values2) { + if (value2 != null && (min9 > value2 || min9 === void 0 && value2 >= value2)) { + min9 = value2; + } + } + } else { + let index = -1; + for (let value2 of values2) { + if ((value2 = valueof(value2, ++index, values2)) != null && (min9 > value2 || min9 === void 0 && value2 >= value2)) { + min9 = value2; + } + } + } + return min9; + } + var init_min3 = __esm({ + "../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/min.js"() { + "use strict"; + __name(min8, "min"); + } + }); + + // ../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/sum.js + function sum(values2, valueof) { + let sum2 = 0; + if (valueof === void 0) { + for (let value2 of values2) { + if (value2 = +value2) { + sum2 += value2; + } + } + } else { + let index = -1; + for (let value2 of values2) { + if (value2 = +valueof(value2, ++index, values2)) { + sum2 += value2; + } + } + } + return sum2; + } + var init_sum2 = __esm({ + "../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/sum.js"() { + "use strict"; + __name(sum, "sum"); + } + }); + + // ../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/index.js + var init_src33 = __esm({ + "../../node_modules/.pnpm/d3-array@2.12.1/node_modules/d3-array/src/index.js"() { + "use strict"; + init_max3(); + init_min3(); + init_sum2(); + } + }); + + // ../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/align.js + function targetDepth(d3) { + return d3.target.depth; + } + function left2(node2) { + return node2.depth; + } + function right2(node2, n2) { + return n2 - 1 - node2.height; + } + function justify(node2, n2) { + return node2.sourceLinks.length ? node2.depth : n2 - 1; + } + function center3(node2) { + return node2.targetLinks.length ? node2.depth : node2.sourceLinks.length ? min8(node2.sourceLinks, targetDepth) - 1 : 0; + } + var init_align = __esm({ + "../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/align.js"() { + "use strict"; + init_src33(); + __name(targetDepth, "targetDepth"); + __name(left2, "left"); + __name(right2, "right"); + __name(justify, "justify"); + __name(center3, "center"); + } + }); + + // ../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/constant.js + function constant2(x5) { + return function() { + return x5; + }; + } + var init_constant9 = __esm({ + "../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/constant.js"() { + "use strict"; + __name(constant2, "constant"); + } + }); + + // ../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankey.js + function ascendingSourceBreadth(a2, b3) { + return ascendingBreadth(a2.source, b3.source) || a2.index - b3.index; + } + function ascendingTargetBreadth(a2, b3) { + return ascendingBreadth(a2.target, b3.target) || a2.index - b3.index; + } + function ascendingBreadth(a2, b3) { + return a2.y0 - b3.y0; + } + function value(d3) { + return d3.value; + } + function defaultId(d3) { + return d3.index; + } + function defaultNodes(graph) { + return graph.nodes; + } + function defaultLinks(graph) { + return graph.links; + } + function find3(nodeById, id30) { + const node2 = nodeById.get(id30); + if (!node2) throw new Error("missing: " + id30); + return node2; + } + function computeLinkBreadths({ nodes: nodes5 }) { + for (const node2 of nodes5) { + let y0 = node2.y0; + let y1 = y0; + for (const link2 of node2.sourceLinks) { + link2.y0 = y0 + link2.width / 2; + y0 += link2.width; + } + for (const link2 of node2.targetLinks) { + link2.y1 = y1 + link2.width / 2; + y1 += link2.width; + } + } + } + function Sankey() { + let x0 = 0, y0 = 0, x1 = 1, y1 = 1; + let dx = 24; + let dy = 8, py; + let id30 = defaultId; + let align = justify; + let sort3; + let linkSort; + let nodes5 = defaultNodes; + let links3 = defaultLinks; + let iterations = 6; + function sankey() { + const graph = { nodes: nodes5.apply(null, arguments), links: links3.apply(null, arguments) }; + computeNodeLinks(graph); + computeNodeValues(graph); + computeNodeDepths(graph); + computeNodeHeights(graph); + computeNodeBreadths(graph); + computeLinkBreadths(graph); + return graph; + } + __name(sankey, "sankey"); + sankey.update = function(graph) { + computeLinkBreadths(graph); + return graph; + }; + sankey.nodeId = function(_3) { + return arguments.length ? (id30 = typeof _3 === "function" ? _3 : constant2(_3), sankey) : id30; + }; + sankey.nodeAlign = function(_3) { + return arguments.length ? (align = typeof _3 === "function" ? _3 : constant2(_3), sankey) : align; + }; + sankey.nodeSort = function(_3) { + return arguments.length ? (sort3 = _3, sankey) : sort3; + }; + sankey.nodeWidth = function(_3) { + return arguments.length ? (dx = +_3, sankey) : dx; + }; + sankey.nodePadding = function(_3) { + return arguments.length ? (dy = py = +_3, sankey) : dy; + }; + sankey.nodes = function(_3) { + return arguments.length ? (nodes5 = typeof _3 === "function" ? _3 : constant2(_3), sankey) : nodes5; + }; + sankey.links = function(_3) { + return arguments.length ? (links3 = typeof _3 === "function" ? _3 : constant2(_3), sankey) : links3; + }; + sankey.linkSort = function(_3) { + return arguments.length ? (linkSort = _3, sankey) : linkSort; + }; + sankey.size = function(_3) { + return arguments.length ? (x0 = y0 = 0, x1 = +_3[0], y1 = +_3[1], sankey) : [x1 - x0, y1 - y0]; + }; + sankey.extent = function(_3) { + return arguments.length ? (x0 = +_3[0][0], x1 = +_3[1][0], y0 = +_3[0][1], y1 = +_3[1][1], sankey) : [[x0, y0], [x1, y1]]; + }; + sankey.iterations = function(_3) { + return arguments.length ? (iterations = +_3, sankey) : iterations; + }; + function computeNodeLinks({ nodes: nodes6, links: links4 }) { + for (const [i2, node2] of nodes6.entries()) { + node2.index = i2; + node2.sourceLinks = []; + node2.targetLinks = []; + } + const nodeById = new Map(nodes6.map((d3, i2) => [id30(d3, i2, nodes6), d3])); + for (const [i2, link2] of links4.entries()) { + link2.index = i2; + let { source, target } = link2; + if (typeof source !== "object") source = link2.source = find3(nodeById, source); + if (typeof target !== "object") target = link2.target = find3(nodeById, target); + source.sourceLinks.push(link2); + target.targetLinks.push(link2); + } + if (linkSort != null) { + for (const { sourceLinks, targetLinks } of nodes6) { + sourceLinks.sort(linkSort); + targetLinks.sort(linkSort); + } + } + } + __name(computeNodeLinks, "computeNodeLinks"); + function computeNodeValues({ nodes: nodes6 }) { + for (const node2 of nodes6) { + node2.value = node2.fixedValue === void 0 ? Math.max(sum(node2.sourceLinks, value), sum(node2.targetLinks, value)) : node2.fixedValue; + } + } + __name(computeNodeValues, "computeNodeValues"); + function computeNodeDepths({ nodes: nodes6 }) { + const n2 = nodes6.length; + let current = new Set(nodes6); + let next3 = /* @__PURE__ */ new Set(); + let x5 = 0; + while (current.size) { + for (const node2 of current) { + node2.depth = x5; + for (const { target } of node2.sourceLinks) { + next3.add(target); + } + } + if (++x5 > n2) throw new Error("circular link"); + current = next3; + next3 = /* @__PURE__ */ new Set(); + } + } + __name(computeNodeDepths, "computeNodeDepths"); + function computeNodeHeights({ nodes: nodes6 }) { + const n2 = nodes6.length; + let current = new Set(nodes6); + let next3 = /* @__PURE__ */ new Set(); + let x5 = 0; + while (current.size) { + for (const node2 of current) { + node2.height = x5; + for (const { source } of node2.targetLinks) { + next3.add(source); + } + } + if (++x5 > n2) throw new Error("circular link"); + current = next3; + next3 = /* @__PURE__ */ new Set(); + } + } + __name(computeNodeHeights, "computeNodeHeights"); + function computeNodeLayers({ nodes: nodes6 }) { + const x5 = max9(nodes6, (d3) => d3.depth) + 1; + const kx = (x1 - x0 - dx) / (x5 - 1); + const columns = new Array(x5); + for (const node2 of nodes6) { + const i2 = Math.max(0, Math.min(x5 - 1, Math.floor(align.call(null, node2, x5)))); + node2.layer = i2; + node2.x0 = x0 + i2 * kx; + node2.x1 = node2.x0 + dx; + if (columns[i2]) columns[i2].push(node2); + else columns[i2] = [node2]; + } + if (sort3) for (const column2 of columns) { + column2.sort(sort3); + } + return columns; + } + __name(computeNodeLayers, "computeNodeLayers"); + function initializeNodeBreadths(columns) { + const ky = min8(columns, (c3) => (y1 - y0 - (c3.length - 1) * py) / sum(c3, value)); + for (const nodes6 of columns) { + let y6 = y0; + for (const node2 of nodes6) { + node2.y0 = y6; + node2.y1 = y6 + node2.value * ky; + y6 = node2.y1 + py; + for (const link2 of node2.sourceLinks) { + link2.width = link2.value * ky; + } + } + y6 = (y1 - y6 + py) / (nodes6.length + 1); + for (let i2 = 0; i2 < nodes6.length; ++i2) { + const node2 = nodes6[i2]; + node2.y0 += y6 * (i2 + 1); + node2.y1 += y6 * (i2 + 1); + } + reorderLinks(nodes6); + } + } + __name(initializeNodeBreadths, "initializeNodeBreadths"); + function computeNodeBreadths(graph) { + const columns = computeNodeLayers(graph); + py = Math.min(dy, (y1 - y0) / (max9(columns, (c3) => c3.length) - 1)); + initializeNodeBreadths(columns); + for (let i2 = 0; i2 < iterations; ++i2) { + const alpha = Math.pow(0.99, i2); + const beta = Math.max(1 - alpha, (i2 + 1) / iterations); + relaxRightToLeft(columns, alpha, beta); + relaxLeftToRight(columns, alpha, beta); + } + } + __name(computeNodeBreadths, "computeNodeBreadths"); + function relaxLeftToRight(columns, alpha, beta) { + for (let i2 = 1, n2 = columns.length; i2 < n2; ++i2) { + const column2 = columns[i2]; + for (const target of column2) { + let y6 = 0; + let w4 = 0; + for (const { source, value: value2 } of target.targetLinks) { + let v3 = value2 * (target.layer - source.layer); + y6 += targetTop(source, target) * v3; + w4 += v3; + } + if (!(w4 > 0)) continue; + let dy2 = (y6 / w4 - target.y0) * alpha; + target.y0 += dy2; + target.y1 += dy2; + reorderNodeLinks(target); + } + if (sort3 === void 0) column2.sort(ascendingBreadth); + resolveCollisions(column2, beta); + } + } + __name(relaxLeftToRight, "relaxLeftToRight"); + function relaxRightToLeft(columns, alpha, beta) { + for (let n2 = columns.length, i2 = n2 - 2; i2 >= 0; --i2) { + const column2 = columns[i2]; + for (const source of column2) { + let y6 = 0; + let w4 = 0; + for (const { target, value: value2 } of source.sourceLinks) { + let v3 = value2 * (target.layer - source.layer); + y6 += sourceTop(source, target) * v3; + w4 += v3; + } + if (!(w4 > 0)) continue; + let dy2 = (y6 / w4 - source.y0) * alpha; + source.y0 += dy2; + source.y1 += dy2; + reorderNodeLinks(source); + } + if (sort3 === void 0) column2.sort(ascendingBreadth); + resolveCollisions(column2, beta); + } + } + __name(relaxRightToLeft, "relaxRightToLeft"); + function resolveCollisions(nodes6, alpha) { + const i2 = nodes6.length >> 1; + const subject = nodes6[i2]; + resolveCollisionsBottomToTop(nodes6, subject.y0 - py, i2 - 1, alpha); + resolveCollisionsTopToBottom(nodes6, subject.y1 + py, i2 + 1, alpha); + resolveCollisionsBottomToTop(nodes6, y1, nodes6.length - 1, alpha); + resolveCollisionsTopToBottom(nodes6, y0, 0, alpha); + } + __name(resolveCollisions, "resolveCollisions"); + function resolveCollisionsTopToBottom(nodes6, y6, i2, alpha) { + for (; i2 < nodes6.length; ++i2) { + const node2 = nodes6[i2]; + const dy2 = (y6 - node2.y0) * alpha; + if (dy2 > 1e-6) node2.y0 += dy2, node2.y1 += dy2; + y6 = node2.y1 + py; + } + } + __name(resolveCollisionsTopToBottom, "resolveCollisionsTopToBottom"); + function resolveCollisionsBottomToTop(nodes6, y6, i2, alpha) { + for (; i2 >= 0; --i2) { + const node2 = nodes6[i2]; + const dy2 = (node2.y1 - y6) * alpha; + if (dy2 > 1e-6) node2.y0 -= dy2, node2.y1 -= dy2; + y6 = node2.y0 - py; + } + } + __name(resolveCollisionsBottomToTop, "resolveCollisionsBottomToTop"); + function reorderNodeLinks({ sourceLinks, targetLinks }) { + if (linkSort === void 0) { + for (const { source: { sourceLinks: sourceLinks2 } } of targetLinks) { + sourceLinks2.sort(ascendingTargetBreadth); + } + for (const { target: { targetLinks: targetLinks2 } } of sourceLinks) { + targetLinks2.sort(ascendingSourceBreadth); + } + } + } + __name(reorderNodeLinks, "reorderNodeLinks"); + function reorderLinks(nodes6) { + if (linkSort === void 0) { + for (const { sourceLinks, targetLinks } of nodes6) { + sourceLinks.sort(ascendingTargetBreadth); + targetLinks.sort(ascendingSourceBreadth); + } + } + } + __name(reorderLinks, "reorderLinks"); + function targetTop(source, target) { + let y6 = source.y0 - (source.sourceLinks.length - 1) * py / 2; + for (const { target: node2, width: width3 } of source.sourceLinks) { + if (node2 === target) break; + y6 += width3 + py; + } + for (const { source: node2, width: width3 } of target.targetLinks) { + if (node2 === source) break; + y6 -= width3; + } + return y6; + } + __name(targetTop, "targetTop"); + function sourceTop(source, target) { + let y6 = target.y0 - (target.targetLinks.length - 1) * py / 2; + for (const { source: node2, width: width3 } of target.targetLinks) { + if (node2 === source) break; + y6 += width3 + py; + } + for (const { target: node2, width: width3 } of source.sourceLinks) { + if (node2 === target) break; + y6 -= width3; + } + return y6; + } + __name(sourceTop, "sourceTop"); + return sankey; + } + var init_sankey2 = __esm({ + "../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankey.js"() { + "use strict"; + init_src33(); + init_align(); + init_constant9(); + __name(ascendingSourceBreadth, "ascendingSourceBreadth"); + __name(ascendingTargetBreadth, "ascendingTargetBreadth"); + __name(ascendingBreadth, "ascendingBreadth"); + __name(value, "value"); + __name(defaultId, "defaultId"); + __name(defaultNodes, "defaultNodes"); + __name(defaultLinks, "defaultLinks"); + __name(find3, "find"); + __name(computeLinkBreadths, "computeLinkBreadths"); + __name(Sankey, "Sankey"); + } + }); + + // ../../node_modules/.pnpm/d3-path@1.0.9/node_modules/d3-path/src/path.js + function Path2() { + this._x0 = this._y0 = // start of current subpath + this._x1 = this._y1 = null; + this._ = ""; + } + function path3() { + return new Path2(); + } + var pi3, tau3, epsilon5, tauEpsilon2, path_default2; + var init_path4 = __esm({ + "../../node_modules/.pnpm/d3-path@1.0.9/node_modules/d3-path/src/path.js"() { + "use strict"; + pi3 = Math.PI; + tau3 = 2 * pi3; + epsilon5 = 1e-6; + tauEpsilon2 = tau3 - epsilon5; + __name(Path2, "Path"); + __name(path3, "path"); + Path2.prototype = path3.prototype = { + constructor: Path2, + moveTo: /* @__PURE__ */ __name(function(x5, y6) { + this._ += "M" + (this._x0 = this._x1 = +x5) + "," + (this._y0 = this._y1 = +y6); + }, "moveTo"), + closePath: /* @__PURE__ */ __name(function() { + if (this._x1 !== null) { + this._x1 = this._x0, this._y1 = this._y0; + this._ += "Z"; + } + }, "closePath"), + lineTo: /* @__PURE__ */ __name(function(x5, y6) { + this._ += "L" + (this._x1 = +x5) + "," + (this._y1 = +y6); + }, "lineTo"), + quadraticCurveTo: /* @__PURE__ */ __name(function(x1, y1, x5, y6) { + this._ += "Q" + +x1 + "," + +y1 + "," + (this._x1 = +x5) + "," + (this._y1 = +y6); + }, "quadraticCurveTo"), + bezierCurveTo: /* @__PURE__ */ __name(function(x1, y1, x22, y22, x5, y6) { + this._ += "C" + +x1 + "," + +y1 + "," + +x22 + "," + +y22 + "," + (this._x1 = +x5) + "," + (this._y1 = +y6); + }, "bezierCurveTo"), + arcTo: /* @__PURE__ */ __name(function(x1, y1, x22, y22, r2) { + x1 = +x1, y1 = +y1, x22 = +x22, y22 = +y22, r2 = +r2; + var x0 = this._x1, y0 = this._y1, x21 = x22 - x1, y21 = y22 - y1, x01 = x0 - x1, y01 = y0 - y1, l01_2 = x01 * x01 + y01 * y01; + if (r2 < 0) throw new Error("negative radius: " + r2); + if (this._x1 === null) { + this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1); + } else if (!(l01_2 > epsilon5)) ; + else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon5) || !r2) { + this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1); + } else { + var x20 = x22 - x0, y20 = y22 - y0, l21_2 = x21 * x21 + y21 * y21, l20_2 = x20 * x20 + y20 * y20, l21 = Math.sqrt(l21_2), l01 = Math.sqrt(l01_2), l4 = r2 * Math.tan((pi3 - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2), t01 = l4 / l01, t21 = l4 / l21; + if (Math.abs(t01 - 1) > epsilon5) { + this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01); + } + this._ += "A" + r2 + "," + r2 + ",0,0," + +(y01 * x20 > x01 * y20) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21); + } + }, "arcTo"), + arc: /* @__PURE__ */ __name(function(x5, y6, r2, a0, a1, ccw) { + x5 = +x5, y6 = +y6, r2 = +r2, ccw = !!ccw; + var dx = r2 * Math.cos(a0), dy = r2 * Math.sin(a0), x0 = x5 + dx, y0 = y6 + dy, cw = 1 ^ ccw, da = ccw ? a0 - a1 : a1 - a0; + if (r2 < 0) throw new Error("negative radius: " + r2); + if (this._x1 === null) { + this._ += "M" + x0 + "," + y0; + } else if (Math.abs(this._x1 - x0) > epsilon5 || Math.abs(this._y1 - y0) > epsilon5) { + this._ += "L" + x0 + "," + y0; + } + if (!r2) return; + if (da < 0) da = da % tau3 + tau3; + if (da > tauEpsilon2) { + this._ += "A" + r2 + "," + r2 + ",0,1," + cw + "," + (x5 - dx) + "," + (y6 - dy) + "A" + r2 + "," + r2 + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0); + } else if (da > epsilon5) { + this._ += "A" + r2 + "," + r2 + ",0," + +(da >= pi3) + "," + cw + "," + (this._x1 = x5 + r2 * Math.cos(a1)) + "," + (this._y1 = y6 + r2 * Math.sin(a1)); + } + }, "arc"), + rect: /* @__PURE__ */ __name(function(x5, y6, w4, h3) { + this._ += "M" + (this._x0 = this._x1 = +x5) + "," + (this._y0 = this._y1 = +y6) + "h" + +w4 + "v" + +h3 + "h" + -w4 + "Z"; + }, "rect"), + toString: /* @__PURE__ */ __name(function() { + return this._; + }, "toString") + }; + path_default2 = path3; + } + }); + + // ../../node_modules/.pnpm/d3-path@1.0.9/node_modules/d3-path/src/index.js + var init_src34 = __esm({ + "../../node_modules/.pnpm/d3-path@1.0.9/node_modules/d3-path/src/index.js"() { + "use strict"; + init_path4(); + } + }); + + // ../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/constant.js + function constant_default8(x5) { + return /* @__PURE__ */ __name(function constant3() { + return x5; + }, "constant"); + } + var init_constant10 = __esm({ + "../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/constant.js"() { + "use strict"; + __name(constant_default8, "default"); + } + }); + + // ../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/point.js + function x4(p3) { + return p3[0]; + } + function y5(p3) { + return p3[1]; + } + var init_point2 = __esm({ + "../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/point.js"() { + "use strict"; + __name(x4, "x"); + __name(y5, "y"); + } + }); + + // ../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/array.js + var slice3; + var init_array4 = __esm({ + "../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/array.js"() { + "use strict"; + slice3 = Array.prototype.slice; + } + }); + + // ../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/link/index.js + function linkSource(d3) { + return d3.source; + } + function linkTarget(d3) { + return d3.target; + } + function link(curve) { + var source = linkSource, target = linkTarget, x5 = x4, y6 = y5, context = null; + function link2() { + var buffer, argv = slice3.call(arguments), s2 = source.apply(this, argv), t4 = target.apply(this, argv); + if (!context) context = buffer = path_default2(); + curve(context, +x5.apply(this, (argv[0] = s2, argv)), +y6.apply(this, argv), +x5.apply(this, (argv[0] = t4, argv)), +y6.apply(this, argv)); + if (buffer) return context = null, buffer + "" || null; + } + __name(link2, "link"); + link2.source = function(_3) { + return arguments.length ? (source = _3, link2) : source; + }; + link2.target = function(_3) { + return arguments.length ? (target = _3, link2) : target; + }; + link2.x = function(_3) { + return arguments.length ? (x5 = typeof _3 === "function" ? _3 : constant_default8(+_3), link2) : x5; + }; + link2.y = function(_3) { + return arguments.length ? (y6 = typeof _3 === "function" ? _3 : constant_default8(+_3), link2) : y6; + }; + link2.context = function(_3) { + return arguments.length ? (context = _3 == null ? null : _3, link2) : context; + }; + return link2; + } + function curveHorizontal(context, x0, y0, x1, y1) { + context.moveTo(x0, y0); + context.bezierCurveTo(x0 = (x0 + x1) / 2, y0, x0, y1, x1, y1); + } + function linkHorizontal() { + return link(curveHorizontal); + } + var init_link = __esm({ + "../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/link/index.js"() { + "use strict"; + init_src34(); + init_array4(); + init_constant10(); + init_point2(); + __name(linkSource, "linkSource"); + __name(linkTarget, "linkTarget"); + __name(link, "link"); + __name(curveHorizontal, "curveHorizontal"); + __name(linkHorizontal, "linkHorizontal"); + } + }); + + // ../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/index.js + var init_src35 = __esm({ + "../../node_modules/.pnpm/d3-shape@1.3.7/node_modules/d3-shape/src/index.js"() { + "use strict"; + init_link(); + } + }); + + // ../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankeyLinkHorizontal.js + function horizontalSource(d3) { + return [d3.source.x1, d3.y0]; + } + function horizontalTarget(d3) { + return [d3.target.x0, d3.y1]; + } + function sankeyLinkHorizontal_default() { + return linkHorizontal().source(horizontalSource).target(horizontalTarget); + } + var init_sankeyLinkHorizontal = __esm({ + "../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/sankeyLinkHorizontal.js"() { + "use strict"; + init_src35(); + __name(horizontalSource, "horizontalSource"); + __name(horizontalTarget, "horizontalTarget"); + __name(sankeyLinkHorizontal_default, "default"); + } + }); + + // ../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/index.js + var init_src36 = __esm({ + "../../node_modules/.pnpm/d3-sankey@0.12.3/node_modules/d3-sankey/src/index.js"() { + "use strict"; + init_sankey2(); + init_align(); + init_sankeyLinkHorizontal(); + } + }); + + // src/rendering-util/uid.ts + var Uid; + var init_uid = __esm({ + "src/rendering-util/uid.ts"() { + "use strict"; + Uid = class _Uid { + static { + __name(this, "Uid"); + } + static { + this.count = 0; + } + static next(name) { + return new _Uid(name + ++_Uid.count); + } + constructor(id30) { + this.id = id30; + this.href = `#${id30}`; + } + toString() { + return "url(" + this.href + ")"; + } + }; + } + }); + + // src/diagrams/sankey/sankeyRenderer.ts + var alignmentsMap, draw20, sankeyRenderer_default; + var init_sankeyRenderer = __esm({ + "src/diagrams/sankey/sankeyRenderer.ts"() { + "use strict"; + init_diagramAPI(); + init_src32(); + init_src36(); + init_setupGraphViewbox(); + init_uid(); + alignmentsMap = { + left: left2, + right: right2, + center: center3, + justify + }; + draw20 = /* @__PURE__ */ __name(function(text4, id30, _version, diagObj) { + const { securityLevel, sankey: conf5 } = getConfig2(); + const defaultSankeyConfig = defaultConfig2.sankey; + let sandboxElement; + if (securityLevel === "sandbox") { + sandboxElement = select_default2("#i" + id30); + } + const root3 = securityLevel === "sandbox" ? select_default2(sandboxElement.nodes()[0].contentDocument.body) : select_default2("body"); + const svg2 = securityLevel === "sandbox" ? root3.select(`[id="${id30}"]`) : select_default2(`[id="${id30}"]`); + const width3 = conf5?.width ?? defaultSankeyConfig.width; + const height2 = conf5?.height ?? defaultSankeyConfig.width; + const useMaxWidth = conf5?.useMaxWidth ?? defaultSankeyConfig.useMaxWidth; + const nodeAlignment = conf5?.nodeAlignment ?? defaultSankeyConfig.nodeAlignment; + const prefix = conf5?.prefix ?? defaultSankeyConfig.prefix; + const suffix = conf5?.suffix ?? defaultSankeyConfig.suffix; + const showValues = conf5?.showValues ?? defaultSankeyConfig.showValues; + const graph = diagObj.db.getGraph(); + const nodeAlign = alignmentsMap[nodeAlignment]; + const nodeWidth = 10; + const sankey = Sankey().nodeId((d3) => d3.id).nodeWidth(nodeWidth).nodePadding(10 + (showValues ? 15 : 0)).nodeAlign(nodeAlign).extent([ + [0, 0], + [width3, height2] + ]); + sankey(graph); + const colorScheme = ordinal(Tableau10_default); + svg2.append("g").attr("class", "nodes").selectAll(".node").data(graph.nodes).join("g").attr("class", "node").attr("id", (d3) => (d3.uid = Uid.next("node-")).id).attr("transform", function(d3) { + return "translate(" + d3.x0 + "," + d3.y0 + ")"; + }).attr("x", (d3) => d3.x0).attr("y", (d3) => d3.y0).append("rect").attr("height", (d3) => { + return d3.y1 - d3.y0; + }).attr("width", (d3) => d3.x1 - d3.x0).attr("fill", (d3) => colorScheme(d3.id)); + const getText = /* @__PURE__ */ __name(({ id: id31, value: value2 }) => { + if (!showValues) { + return id31; + } + return `${id31} +${prefix}${Math.round(value2 * 100) / 100}${suffix}`; + }, "getText"); + svg2.append("g").attr("class", "node-labels").attr("font-size", 14).selectAll("text").data(graph.nodes).join("text").attr("x", (d3) => d3.x0 < width3 / 2 ? d3.x1 + 6 : d3.x0 - 6).attr("y", (d3) => (d3.y1 + d3.y0) / 2).attr("dy", `${showValues ? "0" : "0.35"}em`).attr("text-anchor", (d3) => d3.x0 < width3 / 2 ? "start" : "end").text(getText); + const link2 = svg2.append("g").attr("class", "links").attr("fill", "none").attr("stroke-opacity", 0.5).selectAll(".link").data(graph.links).join("g").attr("class", "link").style("mix-blend-mode", "multiply"); + const linkColor = conf5?.linkColor ?? "gradient"; + if (linkColor === "gradient") { + const gradient = link2.append("linearGradient").attr("id", (d3) => (d3.uid = Uid.next("linearGradient-")).id).attr("gradientUnits", "userSpaceOnUse").attr("x1", (d3) => d3.source.x1).attr("x2", (d3) => d3.target.x0); + gradient.append("stop").attr("offset", "0%").attr("stop-color", (d3) => colorScheme(d3.source.id)); + gradient.append("stop").attr("offset", "100%").attr("stop-color", (d3) => colorScheme(d3.target.id)); + } + let coloring; + switch (linkColor) { + case "gradient": + coloring = /* @__PURE__ */ __name((d3) => d3.uid, "coloring"); + break; + case "source": + coloring = /* @__PURE__ */ __name((d3) => colorScheme(d3.source.id), "coloring"); + break; + case "target": + coloring = /* @__PURE__ */ __name((d3) => colorScheme(d3.target.id), "coloring"); + break; + default: + coloring = linkColor; + } + link2.append("path").attr("d", sankeyLinkHorizontal_default()).attr("stroke", coloring).attr("stroke-width", (d3) => Math.max(1, d3.width)); + setupGraphViewbox(void 0, svg2, 0, useMaxWidth); + }, "draw"); + sankeyRenderer_default = { + draw: draw20 + }; + } + }); + + // src/diagrams/sankey/sankeyUtils.ts + var prepareTextForParsing; + var init_sankeyUtils = __esm({ + "src/diagrams/sankey/sankeyUtils.ts"() { + "use strict"; + prepareTextForParsing = /* @__PURE__ */ __name((text4) => { + const textToParse = text4.replaceAll(/^[^\S\n\r]+|[^\S\n\r]+$/g, "").replaceAll(/([\n\r])+/g, "\n").trim(); + return textToParse; + }, "prepareTextForParsing"); + } + }); + + // src/diagrams/sankey/styles.js + var getStyles16, styles_default15; + var init_styles15 = __esm({ + "src/diagrams/sankey/styles.js"() { + "use strict"; + getStyles16 = /* @__PURE__ */ __name((options2) => `.label { + font-family: ${options2.fontFamily}; + }`, "getStyles"); + styles_default15 = getStyles16; + } + }); + + // src/diagrams/sankey/sankeyDiagram.ts + var sankeyDiagram_exports = {}; + __export(sankeyDiagram_exports, { + diagram: () => diagram21 + }); + var originalParse, diagram21; + var init_sankeyDiagram = __esm({ + "src/diagrams/sankey/sankeyDiagram.ts"() { + "use strict"; + init_sankey(); + init_sankeyDB(); + init_sankeyRenderer(); + init_sankeyUtils(); + init_styles15(); + originalParse = sankey_default.parse.bind(sankey_default); + sankey_default.parse = (text4) => originalParse(prepareTextForParsing(text4)); + diagram21 = { + styles: styles_default15, + parser: sankey_default, + db: sankeyDB_default, + renderer: sankeyRenderer_default + }; + } + }); + + // src/diagrams/packet/db.ts + var DEFAULT_PACKET_CONFIG, PacketDB; + var init_db = __esm({ + "src/diagrams/packet/db.ts"() { + "use strict"; + init_config(); + init_defaultConfig(); + init_utils2(); + init_commonDb(); + DEFAULT_PACKET_CONFIG = defaultConfig_default.packet; + PacketDB = class { + constructor() { + this.packet = []; + this.setAccTitle = setAccTitle; + this.getAccTitle = getAccTitle; + this.setDiagramTitle = setDiagramTitle; + this.getDiagramTitle = getDiagramTitle; + this.getAccDescription = getAccDescription; + this.setAccDescription = setAccDescription; + } + static { + __name(this, "PacketDB"); + } + getConfig() { + const config5 = cleanAndMerge({ + ...DEFAULT_PACKET_CONFIG, + ...getConfig().packet + }); + if (config5.showBits) { + config5.paddingY += 10; + } + return config5; + } + getPacket() { + return this.packet; + } + pushWord(word) { + if (word.length > 0) { + this.packet.push(word); + } + } + clear() { + clear(); + this.packet = []; + } + }; + } + }); + + // src/diagrams/packet/parser.ts + var maxPacketSize, populate16, getNextFittingBlock, parser19; + var init_parser3 = __esm({ + "src/diagrams/packet/parser.ts"() { + "use strict"; + init_mermaid_parser_core(); + init_logger(); + init_populateCommonDb(); + init_db(); + maxPacketSize = 1e4; + populate16 = /* @__PURE__ */ __name((ast, db7) => { + populateCommonDb(ast, db7); + let lastBit = -1; + let word = []; + let row = 1; + const { bitsPerRow } = db7.getConfig(); + for (let { start: start3, end: end2, bits, label } of ast.blocks) { + if (start3 !== void 0 && end2 !== void 0 && end2 < start3) { + throw new Error(`Packet block ${start3} - ${end2} is invalid. End must be greater than start.`); + } + start3 ??= lastBit + 1; + if (start3 !== lastBit + 1) { + throw new Error( + `Packet block ${start3} - ${end2 ?? start3} is not contiguous. It should start from ${lastBit + 1}.` + ); + } + if (bits === 0) { + throw new Error(`Packet block ${start3} is invalid. Cannot have a zero bit field.`); + } + end2 ??= start3 + (bits ?? 1) - 1; + bits ??= end2 - start3 + 1; + lastBit = end2; + log.debug(`Packet block ${start3} - ${lastBit} with label ${label}`); + while (word.length <= bitsPerRow + 1 && db7.getPacket().length < maxPacketSize) { + const [block2, nextBlock] = getNextFittingBlock({ start: start3, end: end2, bits, label }, row, bitsPerRow); + word.push(block2); + if (block2.end + 1 === row * bitsPerRow) { + db7.pushWord(word); + word = []; + row++; + } + if (!nextBlock) { + break; + } + ({ start: start3, end: end2, bits, label } = nextBlock); + } + } + db7.pushWord(word); + }, "populate"); + getNextFittingBlock = /* @__PURE__ */ __name((block2, row, bitsPerRow) => { + if (block2.start === void 0) { + throw new Error("start should have been set during first phase"); + } + if (block2.end === void 0) { + throw new Error("end should have been set during first phase"); + } + if (block2.start > block2.end) { + throw new Error(`Block start ${block2.start} is greater than block end ${block2.end}.`); + } + if (block2.end + 1 <= row * bitsPerRow) { + return [block2, void 0]; + } + const rowEnd = row * bitsPerRow - 1; + const rowStart = row * bitsPerRow; + return [ + { + start: block2.start, + end: rowEnd, + label: block2.label, + bits: rowEnd - block2.start + }, + { + start: rowStart, + end: block2.end, + label: block2.label, + bits: block2.end - rowStart + } + ]; + }, "getNextFittingBlock"); + parser19 = { + // @ts-expect-error - PacketDB is not assignable to DiagramDB + parser: { yy: void 0 }, + parse: /* @__PURE__ */ __name(async (input) => { + const ast = await parse3("packet", input); + const db7 = parser19.parser?.yy; + if (!(db7 instanceof PacketDB)) { + throw new Error( + "parser.parser?.yy was not a PacketDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues." + ); + } + log.debug(ast); + populate16(ast, db7); + }, "parse") + }; + } + }); + + // src/diagrams/packet/renderer.ts + var draw21, drawWord, renderer6; + var init_renderer = __esm({ + "src/diagrams/packet/renderer.ts"() { + "use strict"; + init_selectSvgElement(); + init_setupGraphViewbox(); + draw21 = /* @__PURE__ */ __name((_text, id30, _version, diagram27) => { + const db7 = diagram27.db; + const config5 = db7.getConfig(); + const { rowHeight, paddingY, bitWidth, bitsPerRow } = config5; + const words = db7.getPacket(); + const title2 = db7.getDiagramTitle(); + const totalRowHeight = rowHeight + paddingY; + const svgHeight = totalRowHeight * (words.length + 1) - (title2 ? 0 : rowHeight); + const svgWidth = bitWidth * bitsPerRow + 2; + const svg2 = selectSvgElement(id30); + svg2.attr("viewbox", `0 0 ${svgWidth} ${svgHeight}`); + configureSvgSize(svg2, svgHeight, svgWidth, config5.useMaxWidth); + for (const [word, packet2] of words.entries()) { + drawWord(svg2, packet2, word, config5); + } + svg2.append("text").text(title2).attr("x", svgWidth / 2).attr("y", svgHeight - totalRowHeight / 2).attr("dominant-baseline", "middle").attr("text-anchor", "middle").attr("class", "packetTitle"); + }, "draw"); + drawWord = /* @__PURE__ */ __name((svg2, word, rowNumber, { rowHeight, paddingX, paddingY, bitWidth, bitsPerRow, showBits }) => { + const group2 = svg2.append("g"); + const wordY = rowNumber * (rowHeight + paddingY) + paddingY; + for (const block2 of word) { + const blockX = block2.start % bitsPerRow * bitWidth + 1; + const width3 = (block2.end - block2.start + 1) * bitWidth - paddingX; + group2.append("rect").attr("x", blockX).attr("y", wordY).attr("width", width3).attr("height", rowHeight).attr("class", "packetBlock"); + group2.append("text").attr("x", blockX + width3 / 2).attr("y", wordY + rowHeight / 2).attr("class", "packetLabel").attr("dominant-baseline", "middle").attr("text-anchor", "middle").text(block2.label); + if (!showBits) { + continue; + } + const isSingleBlock = block2.end === block2.start; + const bitNumberY = wordY - 2; + group2.append("text").attr("x", blockX + (isSingleBlock ? width3 / 2 : 0)).attr("y", bitNumberY).attr("class", "packetByte start").attr("dominant-baseline", "auto").attr("text-anchor", isSingleBlock ? "middle" : "start").text(block2.start); + if (!isSingleBlock) { + group2.append("text").attr("x", blockX + width3).attr("y", bitNumberY).attr("class", "packetByte end").attr("dominant-baseline", "auto").attr("text-anchor", "end").text(block2.end); + } + } + }, "drawWord"); + renderer6 = { draw: draw21 }; + } + }); + + // src/diagrams/packet/styles.ts + var defaultPacketStyleOptions, styles2; + var init_styles16 = __esm({ + "src/diagrams/packet/styles.ts"() { + "use strict"; + init_utils2(); + defaultPacketStyleOptions = { + byteFontSize: "10px", + startByteColor: "black", + endByteColor: "black", + labelColor: "black", + labelFontSize: "12px", + titleColor: "black", + titleFontSize: "14px", + blockStrokeColor: "black", + blockStrokeWidth: "1", + blockFillColor: "#efefef" + }; + styles2 = /* @__PURE__ */ __name(({ packet: packet2 } = {}) => { + const options2 = cleanAndMerge(defaultPacketStyleOptions, packet2); + return ` + .packetByte { + font-size: ${options2.byteFontSize}; + } + .packetByte.start { + fill: ${options2.startByteColor}; + } + .packetByte.end { + fill: ${options2.endByteColor}; + } + .packetLabel { + fill: ${options2.labelColor}; + font-size: ${options2.labelFontSize}; + } + .packetTitle { + fill: ${options2.titleColor}; + font-size: ${options2.titleFontSize}; + } + .packetBlock { + stroke: ${options2.blockStrokeColor}; + stroke-width: ${options2.blockStrokeWidth}; + fill: ${options2.blockFillColor}; + } + `; + }, "styles"); + } + }); + + // src/diagrams/packet/diagram.ts + var diagram_exports = {}; + __export(diagram_exports, { + diagram: () => diagram22 + }); + var diagram22; + var init_diagram = __esm({ + "src/diagrams/packet/diagram.ts"() { + "use strict"; + init_db(); + init_parser3(); + init_renderer(); + init_styles16(); + diagram22 = { + parser: parser19, + get db() { + return new PacketDB(); + }, + renderer: renderer6, + styles: styles2 + }; + } + }); + + // src/diagrams/radar/db.ts + var defaultOptions, defaultRadarData, data4, DEFAULT_RADAR_CONFIG, getConfig5, getAxes, getCurves, getOptions2, setAxes, setCurves, computeCurveEntries, setOptions7, clear17, db5; + var init_db2 = __esm({ + "src/diagrams/radar/db.ts"() { + "use strict"; + init_config(); + init_defaultConfig(); + init_utils2(); + init_commonDb(); + defaultOptions = { + showLegend: true, + ticks: 5, + max: null, + min: 0, + graticule: "circle" + }; + defaultRadarData = { + axes: [], + curves: [], + options: defaultOptions + }; + data4 = structuredClone(defaultRadarData); + DEFAULT_RADAR_CONFIG = defaultConfig_default.radar; + getConfig5 = /* @__PURE__ */ __name(() => { + const config5 = cleanAndMerge({ + ...DEFAULT_RADAR_CONFIG, + ...getConfig().radar + }); + return config5; + }, "getConfig"); + getAxes = /* @__PURE__ */ __name(() => data4.axes, "getAxes"); + getCurves = /* @__PURE__ */ __name(() => data4.curves, "getCurves"); + getOptions2 = /* @__PURE__ */ __name(() => data4.options, "getOptions"); + setAxes = /* @__PURE__ */ __name((axes) => { + data4.axes = axes.map((axis2) => { + return { + name: axis2.name, + label: axis2.label ?? axis2.name + }; + }); + }, "setAxes"); + setCurves = /* @__PURE__ */ __name((curves) => { + data4.curves = curves.map((curve) => { + return { + name: curve.name, + label: curve.label ?? curve.name, + entries: computeCurveEntries(curve.entries) + }; + }); + }, "setCurves"); + computeCurveEntries = /* @__PURE__ */ __name((entries2) => { + if (entries2[0].axis == void 0) { + return entries2.map((entry) => entry.value); + } + const axes = getAxes(); + if (axes.length === 0) { + throw new Error("Axes must be populated before curves for reference entries"); + } + return axes.map((axis2) => { + const entry = entries2.find((entry2) => entry2.axis?.$refText === axis2.name); + if (entry === void 0) { + throw new Error("Missing entry for axis " + axis2.label); + } + return entry.value; + }); + }, "computeCurveEntries"); + setOptions7 = /* @__PURE__ */ __name((options2) => { + const optionMap = options2.reduce( + (acc, option2) => { + acc[option2.name] = option2; + return acc; + }, + {} + ); + data4.options = { + showLegend: optionMap.showLegend?.value ?? defaultOptions.showLegend, + ticks: optionMap.ticks?.value ?? defaultOptions.ticks, + max: optionMap.max?.value ?? defaultOptions.max, + min: optionMap.min?.value ?? defaultOptions.min, + graticule: optionMap.graticule?.value ?? defaultOptions.graticule + }; + }, "setOptions"); + clear17 = /* @__PURE__ */ __name(() => { + clear(); + data4 = structuredClone(defaultRadarData); + }, "clear"); + db5 = { + getAxes, + getCurves, + getOptions: getOptions2, + setAxes, + setCurves, + setOptions: setOptions7, + getConfig: getConfig5, + clear: clear17, + setAccTitle, + getAccTitle, + setDiagramTitle, + getDiagramTitle, + getAccDescription, + setAccDescription + }; + } + }); + + // src/diagrams/radar/parser.ts + var populate17, parser20; + var init_parser4 = __esm({ + "src/diagrams/radar/parser.ts"() { + "use strict"; + init_mermaid_parser_core(); + init_logger(); + init_populateCommonDb(); + init_db2(); + populate17 = /* @__PURE__ */ __name((ast) => { + populateCommonDb(ast, db5); + const { axes, curves, options: options2 } = ast; + db5.setAxes(axes); + db5.setCurves(curves); + db5.setOptions(options2); + }, "populate"); + parser20 = { + parse: /* @__PURE__ */ __name(async (input) => { + const ast = await parse3("radar", input); + log.debug(ast); + populate17(ast); + }, "parse") + }; + } + }); + + // src/diagrams/radar/renderer.ts + function drawCurves(g2, axes, curves, minValue, maxValue, graticule, config5) { + const numAxes = axes.length; + const radius2 = Math.min(config5.width, config5.height) / 2; + curves.forEach((curve, index) => { + if (curve.entries.length !== numAxes) { + return; + } + const points = curve.entries.map((entry, i2) => { + const angle2 = 2 * Math.PI * i2 / numAxes - Math.PI / 2; + const r2 = relativeRadius(entry, minValue, maxValue, radius2); + const x5 = r2 * Math.cos(angle2); + const y6 = r2 * Math.sin(angle2); + return { x: x5, y: y6 }; + }); + if (graticule === "circle") { + g2.append("path").attr("d", closedRoundCurve(points, config5.curveTension)).attr("class", `radarCurve-${index}`); + } else if (graticule === "polygon") { + g2.append("polygon").attr("points", points.map((p3) => `${p3.x},${p3.y}`).join(" ")).attr("class", `radarCurve-${index}`); + } + }); + } + function relativeRadius(value2, minValue, maxValue, radius2) { + const clippedValue = Math.min(Math.max(value2, minValue), maxValue); + return radius2 * (clippedValue - minValue) / (maxValue - minValue); + } + function closedRoundCurve(points, tension) { + const numPoints = points.length; + let d3 = `M${points[0].x},${points[0].y}`; + for (let i2 = 0; i2 < numPoints; i2++) { + const p0 = points[(i2 - 1 + numPoints) % numPoints]; + const p1 = points[i2]; + const p22 = points[(i2 + 1) % numPoints]; + const p3 = points[(i2 + 2) % numPoints]; + const cp1 = { + x: p1.x + (p22.x - p0.x) * tension, + y: p1.y + (p22.y - p0.y) * tension + }; + const cp2 = { + x: p22.x - (p3.x - p1.x) * tension, + y: p22.y - (p3.y - p1.y) * tension + }; + d3 += ` C${cp1.x},${cp1.y} ${cp2.x},${cp2.y} ${p22.x},${p22.y}`; + } + return `${d3} Z`; + } + function drawLegend(g2, curves, showLegend, config5) { + if (!showLegend) { + return; + } + const legendX = (config5.width / 2 + config5.marginRight) * 3 / 4; + const legendY = -(config5.height / 2 + config5.marginTop) * 3 / 4; + const lineHeight = 20; + curves.forEach((curve, index) => { + const itemGroup = g2.append("g").attr("transform", `translate(${legendX}, ${legendY + index * lineHeight})`); + itemGroup.append("rect").attr("width", 12).attr("height", 12).attr("class", `radarLegendBox-${index}`); + itemGroup.append("text").attr("x", 16).attr("y", 0).attr("class", "radarLegendText").text(curve.label); + }); + } + var draw22, drawFrame, drawGraticule, drawAxes2, renderer7; + var init_renderer2 = __esm({ + "src/diagrams/radar/renderer.ts"() { + "use strict"; + init_selectSvgElement(); + draw22 = /* @__PURE__ */ __name((_text, id30, _version, diagram27) => { + const db7 = diagram27.db; + const axes = db7.getAxes(); + const curves = db7.getCurves(); + const options2 = db7.getOptions(); + const config5 = db7.getConfig(); + const title2 = db7.getDiagramTitle(); + const svg2 = selectSvgElement(id30); + const g2 = drawFrame(svg2, config5); + const maxValue = options2.max ?? Math.max(...curves.map((curve) => Math.max(...curve.entries))); + const minValue = options2.min; + const radius2 = Math.min(config5.width, config5.height) / 2; + drawGraticule(g2, axes, radius2, options2.ticks, options2.graticule); + drawAxes2(g2, axes, radius2, config5); + drawCurves(g2, axes, curves, minValue, maxValue, options2.graticule, config5); + drawLegend(g2, curves, options2.showLegend, config5); + g2.append("text").attr("class", "radarTitle").text(title2).attr("x", 0).attr("y", -config5.height / 2 - config5.marginTop); + }, "draw"); + drawFrame = /* @__PURE__ */ __name((svg2, config5) => { + const totalWidth = config5.width + config5.marginLeft + config5.marginRight; + const totalHeight = config5.height + config5.marginTop + config5.marginBottom; + const center4 = { + x: config5.marginLeft + config5.width / 2, + y: config5.marginTop + config5.height / 2 + }; + svg2.attr("viewbox", `0 0 ${totalWidth} ${totalHeight}`).attr("width", totalWidth).attr("height", totalHeight); + return svg2.append("g").attr("transform", `translate(${center4.x}, ${center4.y})`); + }, "drawFrame"); + drawGraticule = /* @__PURE__ */ __name((g2, axes, radius2, ticks2, graticule) => { + if (graticule === "circle") { + for (let i2 = 0; i2 < ticks2; i2++) { + const r2 = radius2 * (i2 + 1) / ticks2; + g2.append("circle").attr("r", r2).attr("class", "radarGraticule"); + } + } else if (graticule === "polygon") { + const numAxes = axes.length; + for (let i2 = 0; i2 < ticks2; i2++) { + const r2 = radius2 * (i2 + 1) / ticks2; + const points = axes.map((_3, j3) => { + const angle2 = 2 * j3 * Math.PI / numAxes - Math.PI / 2; + const x5 = r2 * Math.cos(angle2); + const y6 = r2 * Math.sin(angle2); + return `${x5},${y6}`; + }).join(" "); + g2.append("polygon").attr("points", points).attr("class", "radarGraticule"); + } + } + }, "drawGraticule"); + drawAxes2 = /* @__PURE__ */ __name((g2, axes, radius2, config5) => { + const numAxes = axes.length; + for (let i2 = 0; i2 < numAxes; i2++) { + const label = axes[i2].label; + const angle2 = 2 * i2 * Math.PI / numAxes - Math.PI / 2; + g2.append("line").attr("x1", 0).attr("y1", 0).attr("x2", radius2 * config5.axisScaleFactor * Math.cos(angle2)).attr("y2", radius2 * config5.axisScaleFactor * Math.sin(angle2)).attr("class", "radarAxisLine"); + g2.append("text").text(label).attr("x", radius2 * config5.axisLabelFactor * Math.cos(angle2)).attr("y", radius2 * config5.axisLabelFactor * Math.sin(angle2)).attr("class", "radarAxisLabel"); + } + }, "drawAxes"); + __name(drawCurves, "drawCurves"); + __name(relativeRadius, "relativeRadius"); + __name(closedRoundCurve, "closedRoundCurve"); + __name(drawLegend, "drawLegend"); + renderer7 = { draw: draw22 }; + } + }); + + // src/diagrams/radar/styles.ts + var genIndexStyles, buildRadarStyleOptions, styles3; + var init_styles17 = __esm({ + "src/diagrams/radar/styles.ts"() { + "use strict"; + init_utils2(); + init_theme_default(); + init_config(); + genIndexStyles = /* @__PURE__ */ __name((themeVariables, radarOptions) => { + let sections6 = ""; + for (let i2 = 0; i2 < themeVariables.THEME_COLOR_LIMIT; i2++) { + const indexColor = themeVariables[`cScale${i2}`]; + sections6 += ` + .radarCurve-${i2} { + color: ${indexColor}; + fill: ${indexColor}; + fill-opacity: ${radarOptions.curveOpacity}; + stroke: ${indexColor}; + stroke-width: ${radarOptions.curveStrokeWidth}; + } + .radarLegendBox-${i2} { + fill: ${indexColor}; + fill-opacity: ${radarOptions.curveOpacity}; + stroke: ${indexColor}; + } + `; + } + return sections6; + }, "genIndexStyles"); + buildRadarStyleOptions = /* @__PURE__ */ __name((radar2) => { + const defaultThemeVariables2 = getThemeVariables3(); + const currentConfig2 = getConfig(); + const themeVariables = cleanAndMerge(defaultThemeVariables2, currentConfig2.themeVariables); + const radarOptions = cleanAndMerge(themeVariables.radar, radar2); + return { themeVariables, radarOptions }; + }, "buildRadarStyleOptions"); + styles3 = /* @__PURE__ */ __name(({ radar: radar2 } = {}) => { + const { themeVariables, radarOptions } = buildRadarStyleOptions(radar2); + return ` + .radarTitle { + font-size: ${themeVariables.fontSize}; + color: ${themeVariables.titleColor}; + dominant-baseline: hanging; + text-anchor: middle; + } + .radarAxisLine { + stroke: ${radarOptions.axisColor}; + stroke-width: ${radarOptions.axisStrokeWidth}; + } + .radarAxisLabel { + dominant-baseline: middle; + text-anchor: middle; + font-size: ${radarOptions.axisLabelFontSize}px; + color: ${radarOptions.axisColor}; + } + .radarGraticule { + fill: ${radarOptions.graticuleColor}; + fill-opacity: ${radarOptions.graticuleOpacity}; + stroke: ${radarOptions.graticuleColor}; + stroke-width: ${radarOptions.graticuleStrokeWidth}; + } + .radarLegendText { + text-anchor: start; + font-size: ${radarOptions.legendFontSize}px; + dominant-baseline: hanging; + } + ${genIndexStyles(themeVariables, radarOptions)} + `; + }, "styles"); + } + }); + + // src/diagrams/radar/diagram.ts + var diagram_exports2 = {}; + __export(diagram_exports2, { + diagram: () => diagram23 + }); + var diagram23; + var init_diagram2 = __esm({ + "src/diagrams/radar/diagram.ts"() { + "use strict"; + init_db2(); + init_parser4(); + init_renderer2(); + init_styles17(); + diagram23 = { + parser: parser20, + db: db5, + renderer: renderer7, + styles: styles3 + }; + } + }); + + // src/diagrams/block/parser/block.jison + var parser21, block_default; + var init_block = __esm({ + "src/diagrams/block/parser/block.jison"() { + "use strict"; + parser21 = (function() { + var o2 = /* @__PURE__ */ __name(function(k2, v3, o3, l4) { + for (o3 = o3 || {}, l4 = k2.length; l4--; o3[k2[l4]] = v3) ; + return o3; + }, "o"), $V0 = [1, 15], $V1 = [1, 7], $V2 = [1, 13], $V3 = [1, 14], $V4 = [1, 19], $V5 = [1, 16], $V6 = [1, 17], $V7 = [1, 18], $V8 = [8, 30], $V9 = [8, 10, 21, 28, 29, 30, 31, 39, 43, 46], $Va = [1, 23], $Vb = [1, 24], $Vc = [8, 10, 15, 16, 21, 28, 29, 30, 31, 39, 43, 46], $Vd = [8, 10, 15, 16, 21, 27, 28, 29, 30, 31, 39, 43, 46], $Ve = [1, 49]; + var parser24 = { + trace: /* @__PURE__ */ __name(function trace() { + }, "trace"), + yy: {}, + symbols_: { "error": 2, "spaceLines": 3, "SPACELINE": 4, "NL": 5, "separator": 6, "SPACE": 7, "EOF": 8, "start": 9, "BLOCK_DIAGRAM_KEY": 10, "document": 11, "stop": 12, "statement": 13, "link": 14, "LINK": 15, "START_LINK": 16, "LINK_LABEL": 17, "STR": 18, "nodeStatement": 19, "columnsStatement": 20, "SPACE_BLOCK": 21, "blockStatement": 22, "classDefStatement": 23, "cssClassStatement": 24, "styleStatement": 25, "node": 26, "SIZE": 27, "COLUMNS": 28, "id-block": 29, "end": 30, "NODE_ID": 31, "nodeShapeNLabel": 32, "dirList": 33, "DIR": 34, "NODE_DSTART": 35, "NODE_DEND": 36, "BLOCK_ARROW_START": 37, "BLOCK_ARROW_END": 38, "classDef": 39, "CLASSDEF_ID": 40, "CLASSDEF_STYLEOPTS": 41, "DEFAULT": 42, "class": 43, "CLASSENTITY_IDS": 44, "STYLECLASS": 45, "style": 46, "STYLE_ENTITY_IDS": 47, "STYLE_DEFINITION_DATA": 48, "$accept": 0, "$end": 1 }, + terminals_: { 2: "error", 4: "SPACELINE", 5: "NL", 7: "SPACE", 8: "EOF", 10: "BLOCK_DIAGRAM_KEY", 15: "LINK", 16: "START_LINK", 17: "LINK_LABEL", 18: "STR", 21: "SPACE_BLOCK", 27: "SIZE", 28: "COLUMNS", 29: "id-block", 30: "end", 31: "NODE_ID", 34: "DIR", 35: "NODE_DSTART", 36: "NODE_DEND", 37: "BLOCK_ARROW_START", 38: "BLOCK_ARROW_END", 39: "classDef", 40: "CLASSDEF_ID", 41: "CLASSDEF_STYLEOPTS", 42: "DEFAULT", 43: "class", 44: "CLASSENTITY_IDS", 45: "STYLECLASS", 46: "style", 47: "STYLE_ENTITY_IDS", 48: "STYLE_DEFINITION_DATA" }, + productions_: [0, [3, 1], [3, 2], [3, 2], [6, 1], [6, 1], [6, 1], [9, 3], [12, 1], [12, 1], [12, 2], [12, 2], [11, 1], [11, 2], [14, 1], [14, 4], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [13, 1], [19, 3], [19, 2], [19, 1], [20, 1], [22, 4], [22, 3], [26, 1], [26, 2], [33, 1], [33, 2], [32, 3], [32, 4], [23, 3], [23, 3], [24, 3], [25, 3]], + performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) { + var $0 = $$.length - 1; + switch (yystate) { + case 4: + yy.getLogger().debug("Rule: separator (NL) "); + break; + case 5: + yy.getLogger().debug("Rule: separator (Space) "); + break; + case 6: + yy.getLogger().debug("Rule: separator (EOF) "); + break; + case 7: + yy.getLogger().debug("Rule: hierarchy: ", $$[$0 - 1]); + yy.setHierarchy($$[$0 - 1]); + break; + case 8: + yy.getLogger().debug("Stop NL "); + break; + case 9: + yy.getLogger().debug("Stop EOF "); + break; + case 10: + yy.getLogger().debug("Stop NL2 "); + break; + case 11: + yy.getLogger().debug("Stop EOF2 "); + break; + case 12: + yy.getLogger().debug("Rule: statement: ", $$[$0]); + typeof $$[$0].length === "number" ? this.$ = $$[$0] : this.$ = [$$[$0]]; + break; + case 13: + yy.getLogger().debug("Rule: statement #2: ", $$[$0 - 1]); + this.$ = [$$[$0 - 1]].concat($$[$0]); + break; + case 14: + yy.getLogger().debug("Rule: link: ", $$[$0], yytext); + this.$ = { edgeTypeStr: $$[$0], label: "" }; + break; + case 15: + yy.getLogger().debug("Rule: LABEL link: ", $$[$0 - 3], $$[$0 - 1], $$[$0]); + this.$ = { edgeTypeStr: $$[$0], label: $$[$0 - 1] }; + break; + case 18: + const num = parseInt($$[$0]); + const spaceId = yy.generateId(); + this.$ = { id: spaceId, type: "space", label: "", width: num, children: [] }; + break; + case 23: + yy.getLogger().debug("Rule: (nodeStatement link node) ", $$[$0 - 2], $$[$0 - 1], $$[$0], " typestr: ", $$[$0 - 1].edgeTypeStr); + const edgeData2 = yy.edgeStrToEdgeData($$[$0 - 1].edgeTypeStr); + this.$ = [ + { id: $$[$0 - 2].id, label: $$[$0 - 2].label, type: $$[$0 - 2].type, directions: $$[$0 - 2].directions }, + { id: $$[$0 - 2].id + "-" + $$[$0].id, start: $$[$0 - 2].id, end: $$[$0].id, label: $$[$0 - 1].label, type: "edge", directions: $$[$0].directions, arrowTypeEnd: edgeData2, arrowTypeStart: "arrow_open" }, + { id: $$[$0].id, label: $$[$0].label, type: yy.typeStr2Type($$[$0].typeStr), directions: $$[$0].directions } + ]; + break; + case 24: + yy.getLogger().debug("Rule: nodeStatement (abc88 node size) ", $$[$0 - 1], $$[$0]); + this.$ = { id: $$[$0 - 1].id, label: $$[$0 - 1].label, type: yy.typeStr2Type($$[$0 - 1].typeStr), directions: $$[$0 - 1].directions, widthInColumns: parseInt($$[$0], 10) }; + break; + case 25: + yy.getLogger().debug("Rule: nodeStatement (node) ", $$[$0]); + this.$ = { id: $$[$0].id, label: $$[$0].label, type: yy.typeStr2Type($$[$0].typeStr), directions: $$[$0].directions, widthInColumns: 1 }; + break; + case 26: + yy.getLogger().debug("APA123", this ? this : "na"); + yy.getLogger().debug("COLUMNS: ", $$[$0]); + this.$ = { type: "column-setting", columns: $$[$0] === "auto" ? -1 : parseInt($$[$0]) }; + break; + case 27: + yy.getLogger().debug("Rule: id-block statement : ", $$[$0 - 2], $$[$0 - 1]); + const id210 = yy.generateId(); + this.$ = { ...$$[$0 - 2], type: "composite", children: $$[$0 - 1] }; + break; + case 28: + yy.getLogger().debug("Rule: blockStatement : ", $$[$0 - 2], $$[$0 - 1], $$[$0]); + const id30 = yy.generateId(); + this.$ = { id: id30, type: "composite", label: "", children: $$[$0 - 1] }; + break; + case 29: + yy.getLogger().debug("Rule: node (NODE_ID separator): ", $$[$0]); + this.$ = { id: $$[$0] }; + break; + case 30: + yy.getLogger().debug("Rule: node (NODE_ID nodeShapeNLabel separator): ", $$[$0 - 1], $$[$0]); + this.$ = { id: $$[$0 - 1], label: $$[$0].label, typeStr: $$[$0].typeStr, directions: $$[$0].directions }; + break; + case 31: + yy.getLogger().debug("Rule: dirList: ", $$[$0]); + this.$ = [$$[$0]]; + break; + case 32: + yy.getLogger().debug("Rule: dirList: ", $$[$0 - 1], $$[$0]); + this.$ = [$$[$0 - 1]].concat($$[$0]); + break; + case 33: + yy.getLogger().debug("Rule: nodeShapeNLabel: ", $$[$0 - 2], $$[$0 - 1], $$[$0]); + this.$ = { typeStr: $$[$0 - 2] + $$[$0], label: $$[$0 - 1] }; + break; + case 34: + yy.getLogger().debug("Rule: BLOCK_ARROW nodeShapeNLabel: ", $$[$0 - 3], $$[$0 - 2], " #3:", $$[$0 - 1], $$[$0]); + this.$ = { typeStr: $$[$0 - 3] + $$[$0], label: $$[$0 - 2], directions: $$[$0 - 1] }; + break; + case 35: + case 36: + this.$ = { type: "classDef", id: $$[$0 - 1].trim(), css: $$[$0].trim() }; + break; + case 37: + this.$ = { type: "applyClass", id: $$[$0 - 1].trim(), styleClass: $$[$0].trim() }; + break; + case 38: + this.$ = { type: "applyStyles", id: $$[$0 - 1].trim(), stylesStr: $$[$0].trim() }; + break; + } + }, "anonymous"), + table: [{ 9: 1, 10: [1, 2] }, { 1: [3] }, { 10: $V0, 11: 3, 13: 4, 19: 5, 20: 6, 21: $V1, 22: 8, 23: 9, 24: 10, 25: 11, 26: 12, 28: $V2, 29: $V3, 31: $V4, 39: $V5, 43: $V6, 46: $V7 }, { 8: [1, 20] }, o2($V8, [2, 12], { 13: 4, 19: 5, 20: 6, 22: 8, 23: 9, 24: 10, 25: 11, 26: 12, 11: 21, 10: $V0, 21: $V1, 28: $V2, 29: $V3, 31: $V4, 39: $V5, 43: $V6, 46: $V7 }), o2($V9, [2, 16], { 14: 22, 15: $Va, 16: $Vb }), o2($V9, [2, 17]), o2($V9, [2, 18]), o2($V9, [2, 19]), o2($V9, [2, 20]), o2($V9, [2, 21]), o2($V9, [2, 22]), o2($Vc, [2, 25], { 27: [1, 25] }), o2($V9, [2, 26]), { 19: 26, 26: 12, 31: $V4 }, { 10: $V0, 11: 27, 13: 4, 19: 5, 20: 6, 21: $V1, 22: 8, 23: 9, 24: 10, 25: 11, 26: 12, 28: $V2, 29: $V3, 31: $V4, 39: $V5, 43: $V6, 46: $V7 }, { 40: [1, 28], 42: [1, 29] }, { 44: [1, 30] }, { 47: [1, 31] }, o2($Vd, [2, 29], { 32: 32, 35: [1, 33], 37: [1, 34] }), { 1: [2, 7] }, o2($V8, [2, 13]), { 26: 35, 31: $V4 }, { 31: [2, 14] }, { 17: [1, 36] }, o2($Vc, [2, 24]), { 10: $V0, 11: 37, 13: 4, 14: 22, 15: $Va, 16: $Vb, 19: 5, 20: 6, 21: $V1, 22: 8, 23: 9, 24: 10, 25: 11, 26: 12, 28: $V2, 29: $V3, 31: $V4, 39: $V5, 43: $V6, 46: $V7 }, { 30: [1, 38] }, { 41: [1, 39] }, { 41: [1, 40] }, { 45: [1, 41] }, { 48: [1, 42] }, o2($Vd, [2, 30]), { 18: [1, 43] }, { 18: [1, 44] }, o2($Vc, [2, 23]), { 18: [1, 45] }, { 30: [1, 46] }, o2($V9, [2, 28]), o2($V9, [2, 35]), o2($V9, [2, 36]), o2($V9, [2, 37]), o2($V9, [2, 38]), { 36: [1, 47] }, { 33: 48, 34: $Ve }, { 15: [1, 50] }, o2($V9, [2, 27]), o2($Vd, [2, 33]), { 38: [1, 51] }, { 33: 52, 34: $Ve, 38: [2, 31] }, { 31: [2, 15] }, o2($Vd, [2, 34]), { 38: [2, 32] }], + defaultActions: { 20: [2, 7], 23: [2, 14], 50: [2, 15], 52: [2, 32] }, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (hash.recoverable) { + this.trace(str2); + } else { + var error3 = new Error(str2); + error3.hash = hash; + throw error3; + } + }, "parseError"), + parse: /* @__PURE__ */ __name(function parse7(input) { + var self2 = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF2 = 1; + var args = lstack.slice.call(arguments, 1); + var lexer2 = Object.create(this.lexer); + var sharedState = { yy: {} }; + for (var k2 in this.yy) { + if (Object.prototype.hasOwnProperty.call(this.yy, k2)) { + sharedState.yy[k2] = this.yy[k2]; + } + } + lexer2.setInput(input, sharedState.yy); + sharedState.yy.lexer = lexer2; + sharedState.yy.parser = this; + if (typeof lexer2.yylloc == "undefined") { + lexer2.yylloc = {}; + } + var yyloc = lexer2.yylloc; + lstack.push(yyloc); + var ranges = lexer2.options && lexer2.options.ranges; + if (typeof sharedState.yy.parseError === "function") { + this.parseError = sharedState.yy.parseError; + } else { + this.parseError = Object.getPrototypeOf(this).parseError; + } + function popStack(n2) { + stack.length = stack.length - 2 * n2; + vstack.length = vstack.length - n2; + lstack.length = lstack.length - n2; + } + __name(popStack, "popStack"); + function lex() { + var token2; + token2 = tstack.pop() || lexer2.lex() || EOF2; + if (typeof token2 !== "number") { + if (token2 instanceof Array) { + tstack = token2; + token2 = tstack.pop(); + } + token2 = self2.symbols_[token2] || token2; + } + return token2; + } + __name(lex, "lex"); + var symbol, preErrorSymbol, state3, action, a2, r2, yyval = {}, p3, len, newState2, expected; + while (true) { + state3 = stack[stack.length - 1]; + if (this.defaultActions[state3]) { + action = this.defaultActions[state3]; + } else { + if (symbol === null || typeof symbol == "undefined") { + symbol = lex(); + } + action = table[state3] && table[state3][symbol]; + } + if (typeof action === "undefined" || !action.length || !action[0]) { + var errStr = ""; + expected = []; + for (p3 in table[state3]) { + if (this.terminals_[p3] && p3 > TERROR) { + expected.push("'" + this.terminals_[p3] + "'"); + } + } + if (lexer2.showPosition) { + errStr = "Parse error on line " + (yylineno + 1) + ":\n" + lexer2.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'"; + } else { + errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == EOF2 ? "end of input" : "'" + (this.terminals_[symbol] || symbol) + "'"); + } + this.parseError(errStr, { + text: lexer2.match, + token: this.terminals_[symbol] || symbol, + line: lexer2.yylineno, + loc: yyloc, + expected + }); + } + if (action[0] instanceof Array && action.length > 1) { + throw new Error("Parse Error: multiple actions possible at state: " + state3 + ", token: " + symbol); + } + switch (action[0]) { + case 1: + stack.push(symbol); + vstack.push(lexer2.yytext); + lstack.push(lexer2.yylloc); + stack.push(action[1]); + symbol = null; + if (!preErrorSymbol) { + yyleng = lexer2.yyleng; + yytext = lexer2.yytext; + yylineno = lexer2.yylineno; + yyloc = lexer2.yylloc; + if (recovering > 0) { + recovering--; + } + } else { + symbol = preErrorSymbol; + preErrorSymbol = null; + } + break; + case 2: + len = this.productions_[action[1]][1]; + yyval.$ = vstack[vstack.length - len]; + yyval._$ = { + first_line: lstack[lstack.length - (len || 1)].first_line, + last_line: lstack[lstack.length - 1].last_line, + first_column: lstack[lstack.length - (len || 1)].first_column, + last_column: lstack[lstack.length - 1].last_column + }; + if (ranges) { + yyval._$.range = [ + lstack[lstack.length - (len || 1)].range[0], + lstack[lstack.length - 1].range[1] + ]; + } + r2 = this.performAction.apply(yyval, [ + yytext, + yyleng, + yylineno, + sharedState.yy, + action[1], + vstack, + lstack + ].concat(args)); + if (typeof r2 !== "undefined") { + return r2; + } + if (len) { + stack = stack.slice(0, -1 * len * 2); + vstack = vstack.slice(0, -1 * len); + lstack = lstack.slice(0, -1 * len); + } + stack.push(this.productions_[action[1]][0]); + vstack.push(yyval.$); + lstack.push(yyval._$); + newState2 = table[stack[stack.length - 2]][stack[stack.length - 1]]; + stack.push(newState2); + break; + case 3: + return true; + } + } + return true; + }, "parse") + }; + var lexer = /* @__PURE__ */ (function() { + var lexer2 = { + EOF: 1, + parseError: /* @__PURE__ */ __name(function parseError(str2, hash) { + if (this.yy.parser) { + this.yy.parser.parseError(str2, hash); + } else { + throw new Error(str2); + } + }, "parseError"), + // resets the lexer, sets new input + setInput: /* @__PURE__ */ __name(function(input, yy) { + this.yy = yy || this.yy || {}; + this._input = input; + this._more = this._backtrack = this.done = false; + this.yylineno = this.yyleng = 0; + this.yytext = this.matched = this.match = ""; + this.conditionStack = ["INITIAL"]; + this.yylloc = { + first_line: 1, + first_column: 0, + last_line: 1, + last_column: 0 + }; + if (this.options.ranges) { + this.yylloc.range = [0, 0]; + } + this.offset = 0; + return this; + }, "setInput"), + // consumes and returns one char from the input + input: /* @__PURE__ */ __name(function() { + var ch = this._input[0]; + this.yytext += ch; + this.yyleng++; + this.offset++; + this.match += ch; + this.matched += ch; + var lines = ch.match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno++; + this.yylloc.last_line++; + } else { + this.yylloc.last_column++; + } + if (this.options.ranges) { + this.yylloc.range[1]++; + } + this._input = this._input.slice(1); + return ch; + }, "input"), + // unshifts one char (or a string) into the input + unput: /* @__PURE__ */ __name(function(ch) { + var len = ch.length; + var lines = ch.split(/(?:\r\n?|\n)/g); + this._input = ch + this._input; + this.yytext = this.yytext.substr(0, this.yytext.length - len); + this.offset -= len; + var oldLines = this.match.split(/(?:\r\n?|\n)/g); + this.match = this.match.substr(0, this.match.length - 1); + this.matched = this.matched.substr(0, this.matched.length - 1); + if (lines.length - 1) { + this.yylineno -= lines.length - 1; + } + var r2 = this.yylloc.range; + this.yylloc = { + first_line: this.yylloc.first_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.first_column, + last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len + }; + if (this.options.ranges) { + this.yylloc.range = [r2[0], r2[0] + this.yyleng - len]; + } + this.yyleng = this.yytext.length; + return this; + }, "unput"), + // When called from action, caches matched text and appends it on next action + more: /* @__PURE__ */ __name(function() { + this._more = true; + return this; + }, "more"), + // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead. + reject: /* @__PURE__ */ __name(function() { + if (this.options.backtrack_lexer) { + this._backtrack = true; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + return this; + }, "reject"), + // retain first n characters of the match + less: /* @__PURE__ */ __name(function(n2) { + this.unput(this.match.slice(n2)); + }, "less"), + // displays already matched input, i.e. for error messages + pastInput: /* @__PURE__ */ __name(function() { + var past = this.matched.substr(0, this.matched.length - this.match.length); + return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, ""); + }, "pastInput"), + // displays upcoming input, i.e. for error messages + upcomingInput: /* @__PURE__ */ __name(function() { + var next3 = this.match; + if (next3.length < 20) { + next3 += this._input.substr(0, 20 - next3.length); + } + return (next3.substr(0, 20) + (next3.length > 20 ? "..." : "")).replace(/\n/g, ""); + }, "upcomingInput"), + // displays the character position where the lexing error occurred, i.e. for error messages + showPosition: /* @__PURE__ */ __name(function() { + var pre = this.pastInput(); + var c3 = new Array(pre.length + 1).join("-"); + return pre + this.upcomingInput() + "\n" + c3 + "^"; + }, "showPosition"), + // test the lexed token: return FALSE when not a match, otherwise return token + test_match: /* @__PURE__ */ __name(function(match2, indexed_rule) { + var token2, lines, backup; + if (this.options.backtrack_lexer) { + backup = { + yylineno: this.yylineno, + yylloc: { + first_line: this.yylloc.first_line, + last_line: this.last_line, + first_column: this.yylloc.first_column, + last_column: this.yylloc.last_column + }, + yytext: this.yytext, + match: this.match, + matches: this.matches, + matched: this.matched, + yyleng: this.yyleng, + offset: this.offset, + _more: this._more, + _input: this._input, + yy: this.yy, + conditionStack: this.conditionStack.slice(0), + done: this.done + }; + if (this.options.ranges) { + backup.yylloc.range = this.yylloc.range.slice(0); + } + } + lines = match2[0].match(/(?:\r\n?|\n).*/g); + if (lines) { + this.yylineno += lines.length; + } + this.yylloc = { + first_line: this.yylloc.last_line, + last_line: this.yylineno + 1, + first_column: this.yylloc.last_column, + last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match2[0].length + }; + this.yytext += match2[0]; + this.match += match2[0]; + this.matches = match2; + this.yyleng = this.yytext.length; + if (this.options.ranges) { + this.yylloc.range = [this.offset, this.offset += this.yyleng]; + } + this._more = false; + this._backtrack = false; + this._input = this._input.slice(match2[0].length); + this.matched += match2[0]; + token2 = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]); + if (this.done && this._input) { + this.done = false; + } + if (token2) { + return token2; + } else if (this._backtrack) { + for (var k2 in backup) { + this[k2] = backup[k2]; + } + return false; + } + return false; + }, "test_match"), + // return next match in input + next: /* @__PURE__ */ __name(function() { + if (this.done) { + return this.EOF; + } + if (!this._input) { + this.done = true; + } + var token2, match2, tempMatch, index; + if (!this._more) { + this.yytext = ""; + this.match = ""; + } + var rules = this._currentRules(); + for (var i2 = 0; i2 < rules.length; i2++) { + tempMatch = this._input.match(this.rules[rules[i2]]); + if (tempMatch && (!match2 || tempMatch[0].length > match2[0].length)) { + match2 = tempMatch; + index = i2; + if (this.options.backtrack_lexer) { + token2 = this.test_match(tempMatch, rules[i2]); + if (token2 !== false) { + return token2; + } else if (this._backtrack) { + match2 = false; + continue; + } else { + return false; + } + } else if (!this.options.flex) { + break; + } + } + } + if (match2) { + token2 = this.test_match(match2, rules[index]); + if (token2 !== false) { + return token2; + } + return false; + } + if (this._input === "") { + return this.EOF; + } else { + return this.parseError("Lexical error on line " + (this.yylineno + 1) + ". Unrecognized text.\n" + this.showPosition(), { + text: "", + token: null, + line: this.yylineno + }); + } + }, "next"), + // return next match that has a token + lex: /* @__PURE__ */ __name(function lex() { + var r2 = this.next(); + if (r2) { + return r2; + } else { + return this.lex(); + } + }, "lex"), + // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack) + begin: /* @__PURE__ */ __name(function begin(condition) { + this.conditionStack.push(condition); + }, "begin"), + // pop the previously active lexer condition state off the condition stack + popState: /* @__PURE__ */ __name(function popState() { + var n2 = this.conditionStack.length - 1; + if (n2 > 0) { + return this.conditionStack.pop(); + } else { + return this.conditionStack[0]; + } + }, "popState"), + // produce the lexer rule set which is active for the currently active lexer condition state + _currentRules: /* @__PURE__ */ __name(function _currentRules() { + if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) { + return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules; + } else { + return this.conditions["INITIAL"].rules; + } + }, "_currentRules"), + // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available + topState: /* @__PURE__ */ __name(function topState(n2) { + n2 = this.conditionStack.length - 1 - Math.abs(n2 || 0); + if (n2 >= 0) { + return this.conditionStack[n2]; + } else { + return "INITIAL"; + } + }, "topState"), + // alias for begin(condition) + pushState: /* @__PURE__ */ __name(function pushState(condition) { + this.begin(condition); + }, "pushState"), + // return the number of states currently on the stack + stateStackSize: /* @__PURE__ */ __name(function stateStackSize() { + return this.conditionStack.length; + }, "stateStackSize"), + options: {}, + performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) { + var YYSTATE = YY_START; + switch ($avoiding_name_collisions) { + case 0: + yy.getLogger().debug("Found block-beta"); + return 10; + break; + case 1: + yy.getLogger().debug("Found id-block"); + return 29; + break; + case 2: + yy.getLogger().debug("Found block"); + return 10; + break; + case 3: + yy.getLogger().debug(".", yy_.yytext); + break; + case 4: + yy.getLogger().debug("_", yy_.yytext); + break; + case 5: + return 5; + break; + case 6: + yy_.yytext = -1; + return 28; + break; + case 7: + yy_.yytext = yy_.yytext.replace(/columns\s+/, ""); + yy.getLogger().debug("COLUMNS (LEX)", yy_.yytext); + return 28; + break; + case 8: + this.pushState("md_string"); + break; + case 9: + return "MD_STR"; + break; + case 10: + this.popState(); + break; + case 11: + this.pushState("string"); + break; + case 12: + yy.getLogger().debug("LEX: POPPING STR:", yy_.yytext); + this.popState(); + break; + case 13: + yy.getLogger().debug("LEX: STR end:", yy_.yytext); + return "STR"; + break; + case 14: + yy_.yytext = yy_.yytext.replace(/space\:/, ""); + yy.getLogger().debug("SPACE NUM (LEX)", yy_.yytext); + return 21; + break; + case 15: + yy_.yytext = "1"; + yy.getLogger().debug("COLUMNS (LEX)", yy_.yytext); + return 21; + break; + case 16: + return 42; + break; + case 17: + return "LINKSTYLE"; + break; + case 18: + return "INTERPOLATE"; + break; + case 19: + this.pushState("CLASSDEF"); + return 39; + break; + case 20: + this.popState(); + this.pushState("CLASSDEFID"); + return "DEFAULT_CLASSDEF_ID"; + break; + case 21: + this.popState(); + this.pushState("CLASSDEFID"); + return 40; + break; + case 22: + this.popState(); + return 41; + break; + case 23: + this.pushState("CLASS"); + return 43; + break; + case 24: + this.popState(); + this.pushState("CLASS_STYLE"); + return 44; + break; + case 25: + this.popState(); + return 45; + break; + case 26: + this.pushState("STYLE_STMNT"); + return 46; + break; + case 27: + this.popState(); + this.pushState("STYLE_DEFINITION"); + return 47; + break; + case 28: + this.popState(); + return 48; + break; + case 29: + this.pushState("acc_title"); + return "acc_title"; + break; + case 30: + this.popState(); + return "acc_title_value"; + break; + case 31: + this.pushState("acc_descr"); + return "acc_descr"; + break; + case 32: + this.popState(); + return "acc_descr_value"; + break; + case 33: + this.pushState("acc_descr_multiline"); + break; + case 34: + this.popState(); + break; + case 35: + return "acc_descr_multiline_value"; + break; + case 36: + return 30; + break; + case 37: + this.popState(); + yy.getLogger().debug("Lex: (("); + return "NODE_DEND"; + break; + case 38: + this.popState(); + yy.getLogger().debug("Lex: (("); + return "NODE_DEND"; + break; + case 39: + this.popState(); + yy.getLogger().debug("Lex: ))"); + return "NODE_DEND"; + break; + case 40: + this.popState(); + yy.getLogger().debug("Lex: (("); + return "NODE_DEND"; + break; + case 41: + this.popState(); + yy.getLogger().debug("Lex: (("); + return "NODE_DEND"; + break; + case 42: + this.popState(); + yy.getLogger().debug("Lex: (-"); + return "NODE_DEND"; + break; + case 43: + this.popState(); + yy.getLogger().debug("Lex: -)"); + return "NODE_DEND"; + break; + case 44: + this.popState(); + yy.getLogger().debug("Lex: (("); + return "NODE_DEND"; + break; + case 45: + this.popState(); + yy.getLogger().debug("Lex: ]]"); + return "NODE_DEND"; + break; + case 46: + this.popState(); + yy.getLogger().debug("Lex: ("); + return "NODE_DEND"; + break; + case 47: + this.popState(); + yy.getLogger().debug("Lex: ])"); + return "NODE_DEND"; + break; + case 48: + this.popState(); + yy.getLogger().debug("Lex: /]"); + return "NODE_DEND"; + break; + case 49: + this.popState(); + yy.getLogger().debug("Lex: /]"); + return "NODE_DEND"; + break; + case 50: + this.popState(); + yy.getLogger().debug("Lex: )]"); + return "NODE_DEND"; + break; + case 51: + this.popState(); + yy.getLogger().debug("Lex: )"); + return "NODE_DEND"; + break; + case 52: + this.popState(); + yy.getLogger().debug("Lex: ]>"); + return "NODE_DEND"; + break; + case 53: + this.popState(); + yy.getLogger().debug("Lex: ]"); + return "NODE_DEND"; + break; + case 54: + yy.getLogger().debug("Lexa: -)"); + this.pushState("NODE"); + return 35; + break; + case 55: + yy.getLogger().debug("Lexa: (-"); + this.pushState("NODE"); + return 35; + break; + case 56: + yy.getLogger().debug("Lexa: ))"); + this.pushState("NODE"); + return 35; + break; + case 57: + yy.getLogger().debug("Lexa: )"); + this.pushState("NODE"); + return 35; + break; + case 58: + yy.getLogger().debug("Lex: ((("); + this.pushState("NODE"); + return 35; + break; + case 59: + yy.getLogger().debug("Lexa: )"); + this.pushState("NODE"); + return 35; + break; + case 60: + yy.getLogger().debug("Lexa: )"); + this.pushState("NODE"); + return 35; + break; + case 61: + yy.getLogger().debug("Lexa: )"); + this.pushState("NODE"); + return 35; + break; + case 62: + yy.getLogger().debug("Lexc: >"); + this.pushState("NODE"); + return 35; + break; + case 63: + yy.getLogger().debug("Lexa: (["); + this.pushState("NODE"); + return 35; + break; + case 64: + yy.getLogger().debug("Lexa: )"); + this.pushState("NODE"); + return 35; + break; + case 65: + this.pushState("NODE"); + return 35; + break; + case 66: + this.pushState("NODE"); + return 35; + break; + case 67: + this.pushState("NODE"); + return 35; + break; + case 68: + this.pushState("NODE"); + return 35; + break; + case 69: + this.pushState("NODE"); + return 35; + break; + case 70: + this.pushState("NODE"); + return 35; + break; + case 71: + this.pushState("NODE"); + return 35; + break; + case 72: + yy.getLogger().debug("Lexa: ["); + this.pushState("NODE"); + return 35; + break; + case 73: + this.pushState("BLOCK_ARROW"); + yy.getLogger().debug("LEX ARR START"); + return 37; + break; + case 74: + yy.getLogger().debug("Lex: NODE_ID", yy_.yytext); + return 31; + break; + case 75: + yy.getLogger().debug("Lex: EOF", yy_.yytext); + return 8; + break; + case 76: + this.pushState("md_string"); + break; + case 77: + this.pushState("md_string"); + break; + case 78: + return "NODE_DESCR"; + break; + case 79: + this.popState(); + break; + case 80: + yy.getLogger().debug("Lex: Starting string"); + this.pushState("string"); + break; + case 81: + yy.getLogger().debug("LEX ARR: Starting string"); + this.pushState("string"); + break; + case 82: + yy.getLogger().debug("LEX: NODE_DESCR:", yy_.yytext); + return "NODE_DESCR"; + break; + case 83: + yy.getLogger().debug("LEX POPPING"); + this.popState(); + break; + case 84: + yy.getLogger().debug("Lex: =>BAE"); + this.pushState("ARROW_DIR"); + break; + case 85: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (right): dir:", yy_.yytext); + return "DIR"; + break; + case 86: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (left):", yy_.yytext); + return "DIR"; + break; + case 87: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (x):", yy_.yytext); + return "DIR"; + break; + case 88: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (y):", yy_.yytext); + return "DIR"; + break; + case 89: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (up):", yy_.yytext); + return "DIR"; + break; + case 90: + yy_.yytext = yy_.yytext.replace(/^,\s*/, ""); + yy.getLogger().debug("Lex (down):", yy_.yytext); + return "DIR"; + break; + case 91: + yy_.yytext = "]>"; + yy.getLogger().debug("Lex (ARROW_DIR end):", yy_.yytext); + this.popState(); + this.popState(); + return "BLOCK_ARROW_END"; + break; + case 92: + yy.getLogger().debug("Lex: LINK", "#" + yy_.yytext + "#"); + return 15; + break; + case 93: + yy.getLogger().debug("Lex: LINK", yy_.yytext); + return 15; + break; + case 94: + yy.getLogger().debug("Lex: LINK", yy_.yytext); + return 15; + break; + case 95: + yy.getLogger().debug("Lex: LINK", yy_.yytext); + return 15; + break; + case 96: + yy.getLogger().debug("Lex: START_LINK", yy_.yytext); + this.pushState("LLABEL"); + return 16; + break; + case 97: + yy.getLogger().debug("Lex: START_LINK", yy_.yytext); + this.pushState("LLABEL"); + return 16; + break; + case 98: + yy.getLogger().debug("Lex: START_LINK", yy_.yytext); + this.pushState("LLABEL"); + return 16; + break; + case 99: + this.pushState("md_string"); + break; + case 100: + yy.getLogger().debug("Lex: Starting string"); + this.pushState("string"); + return "LINK_LABEL"; + break; + case 101: + this.popState(); + yy.getLogger().debug("Lex: LINK", "#" + yy_.yytext + "#"); + return 15; + break; + case 102: + this.popState(); + yy.getLogger().debug("Lex: LINK", yy_.yytext); + return 15; + break; + case 103: + this.popState(); + yy.getLogger().debug("Lex: LINK", yy_.yytext); + return 15; + break; + case 104: + yy.getLogger().debug("Lex: COLON", yy_.yytext); + yy_.yytext = yy_.yytext.slice(1); + return 27; + break; + } + }, "anonymous"), + rules: [/^(?:block-beta\b)/, /^(?:block:)/, /^(?:block\b)/, /^(?:[\s]+)/, /^(?:[\n]+)/, /^(?:((\u000D\u000A)|(\u000A)))/, /^(?:columns\s+auto\b)/, /^(?:columns\s+[\d]+)/, /^(?:["][`])/, /^(?:[^`"]+)/, /^(?:[`]["])/, /^(?:["])/, /^(?:["])/, /^(?:[^"]*)/, /^(?:space[:]\d+)/, /^(?:space\b)/, /^(?:default\b)/, /^(?:linkStyle\b)/, /^(?:interpolate\b)/, /^(?:classDef\s+)/, /^(?:DEFAULT\s+)/, /^(?:\w+\s+)/, /^(?:[^\n]*)/, /^(?:class\s+)/, /^(?:(\w+)+((,\s*\w+)*))/, /^(?:[^\n]*)/, /^(?:style\s+)/, /^(?:(\w+)+((,\s*\w+)*))/, /^(?:[^\n]*)/, /^(?:accTitle\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*:\s*)/, /^(?:(?!\n||)*[^\n]*)/, /^(?:accDescr\s*\{\s*)/, /^(?:[\}])/, /^(?:[^\}]*)/, /^(?:end\b\s*)/, /^(?:\(\(\()/, /^(?:\)\)\))/, /^(?:[\)]\))/, /^(?:\}\})/, /^(?:\})/, /^(?:\(-)/, /^(?:-\))/, /^(?:\(\()/, /^(?:\]\])/, /^(?:\()/, /^(?:\]\))/, /^(?:\\\])/, /^(?:\/\])/, /^(?:\)\])/, /^(?:[\)])/, /^(?:\]>)/, /^(?:[\]])/, /^(?:-\))/, /^(?:\(-)/, /^(?:\)\))/, /^(?:\))/, /^(?:\(\(\()/, /^(?:\(\()/, /^(?:\{\{)/, /^(?:\{)/, /^(?:>)/, /^(?:\(\[)/, /^(?:\()/, /^(?:\[\[)/, /^(?:\[\|)/, /^(?:\[\()/, /^(?:\)\)\))/, /^(?:\[\\)/, /^(?:\[\/)/, /^(?:\[\\)/, /^(?:\[)/, /^(?:<\[)/, /^(?:[^\(\[\n\-\)\{\}\s\<\>:]+)/, /^(?:$)/, /^(?:["][`])/, /^(?:["][`])/, /^(?:[^`"]+)/, /^(?:[`]["])/, /^(?:["])/, /^(?:["])/, /^(?:[^"]+)/, /^(?:["])/, /^(?:\]>\s*\()/, /^(?:,?\s*right\s*)/, /^(?:,?\s*left\s*)/, /^(?:,?\s*x\s*)/, /^(?:,?\s*y\s*)/, /^(?:,?\s*up\s*)/, /^(?:,?\s*down\s*)/, /^(?:\)\s*)/, /^(?:\s*[xo<]?--+[-xo>]\s*)/, /^(?:\s*[xo<]?==+[=xo>]\s*)/, /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/, /^(?:\s*~~[\~]+\s*)/, /^(?:\s*[xo<]?--\s*)/, /^(?:\s*[xo<]?==\s*)/, /^(?:\s*[xo<]?-\.\s*)/, /^(?:["][`])/, /^(?:["])/, /^(?:\s*[xo<]?--+[-xo>]\s*)/, /^(?:\s*[xo<]?==+[=xo>]\s*)/, /^(?:\s*[xo<]?-?\.+-[xo>]?\s*)/, /^(?::\d+)/], + conditions: { "STYLE_DEFINITION": { "rules": [28], "inclusive": false }, "STYLE_STMNT": { "rules": [27], "inclusive": false }, "CLASSDEFID": { "rules": [22], "inclusive": false }, "CLASSDEF": { "rules": [20, 21], "inclusive": false }, "CLASS_STYLE": { "rules": [25], "inclusive": false }, "CLASS": { "rules": [24], "inclusive": false }, "LLABEL": { "rules": [99, 100, 101, 102, 103], "inclusive": false }, "ARROW_DIR": { "rules": [85, 86, 87, 88, 89, 90, 91], "inclusive": false }, "BLOCK_ARROW": { "rules": [76, 81, 84], "inclusive": false }, "NODE": { "rules": [37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 77, 80], "inclusive": false }, "md_string": { "rules": [9, 10, 78, 79], "inclusive": false }, "space": { "rules": [], "inclusive": false }, "string": { "rules": [12, 13, 82, 83], "inclusive": false }, "acc_descr_multiline": { "rules": [34, 35], "inclusive": false }, "acc_descr": { "rules": [32], "inclusive": false }, "acc_title": { "rules": [30], "inclusive": false }, "INITIAL": { "rules": [0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 14, 15, 16, 17, 18, 19, 23, 26, 29, 31, 33, 36, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 92, 93, 94, 95, 96, 97, 98, 104], "inclusive": true } } + }; + return lexer2; + })(); + parser24.lexer = lexer; + function Parser3() { + this.yy = {}; + } + __name(Parser3, "Parser"); + Parser3.prototype = parser24; + parser24.Parser = Parser3; + return new Parser3(); + })(); + parser21.parser = parser21; + block_default = parser21; + } + }); + + // src/diagrams/block/blockDB.ts + function typeStr2Type(typeStr) { + log.debug("typeStr2Type", typeStr); + switch (typeStr) { + case "[]": + return "square"; + case "()": + log.debug("we have a round"); + return "round"; + case "(())": + return "circle"; + case ">]": + return "rect_left_inv_arrow"; + case "{}": + return "diamond"; + case "{{}}": + return "hexagon"; + case "([])": + return "stadium"; + case "[[]]": + return "subroutine"; + case "[()]": + return "cylinder"; + case "((()))": + return "doublecircle"; + case "[//]": + return "lean_right"; + case "[\\\\]": + return "lean_left"; + case "[/\\]": + return "trapezoid"; + case "[\\/]": + return "inv_trapezoid"; + case "<[]>": + return "block_arrow"; + default: + return "na"; + } + } + function edgeTypeStr2Type(typeStr) { + log.debug("typeStr2Type", typeStr); + switch (typeStr) { + case "==": + return "thick"; + default: + return "normal"; + } + } + function edgeStrToEdgeData(typeStr) { + switch (typeStr.replace(/^[\s-]+|[\s-]+$/g, "")) { + case "x": + return "arrow_cross"; + case "o": + return "arrow_circle"; + case ">": + return "arrow_point"; + default: + return ""; + } + } + var blockDatabase, edgeList, edgeCount2, COLOR_KEYWORD, FILL_KEYWORD, BG_FILL, STYLECLASS_SEP, config4, classes2, sanitizeText5, addStyleClass, addStyle2Node, setCssClass, populateBlockDatabase, blocks, rootBlock, clear18, cnt3, generateId2, setHierarchy, getColumns, getBlocksFlat, getBlocks, getEdges, getBlock, setBlock, getLogger2, getClasses4, db6, blockDB_default; + var init_blockDB = __esm({ + "src/diagrams/block/blockDB.ts"() { + "use strict"; + init_clone2(); + init_config(); + init_diagramAPI(); + init_logger(); + init_common(); + init_commonDb(); + blockDatabase = /* @__PURE__ */ new Map(); + edgeList = []; + edgeCount2 = /* @__PURE__ */ new Map(); + COLOR_KEYWORD = "color"; + FILL_KEYWORD = "fill"; + BG_FILL = "bgFill"; + STYLECLASS_SEP = ","; + config4 = getConfig2(); + classes2 = /* @__PURE__ */ new Map(); + sanitizeText5 = /* @__PURE__ */ __name((txt) => common_default.sanitizeText(txt, config4), "sanitizeText"); + addStyleClass = /* @__PURE__ */ __name(function(id30, styleAttributes = "") { + let foundClass = classes2.get(id30); + if (!foundClass) { + foundClass = { id: id30, styles: [], textStyles: [] }; + classes2.set(id30, foundClass); + } + if (styleAttributes !== void 0 && styleAttributes !== null) { + styleAttributes.split(STYLECLASS_SEP).forEach((attrib) => { + const fixedAttrib = attrib.replace(/([^;]*);/, "$1").trim(); + if (RegExp(COLOR_KEYWORD).exec(attrib)) { + const newStyle1 = fixedAttrib.replace(FILL_KEYWORD, BG_FILL); + const newStyle2 = newStyle1.replace(COLOR_KEYWORD, FILL_KEYWORD); + foundClass.textStyles.push(newStyle2); + } + foundClass.styles.push(fixedAttrib); + }); + } + }, "addStyleClass"); + addStyle2Node = /* @__PURE__ */ __name(function(id30, styles4 = "") { + const foundBlock = blockDatabase.get(id30); + if (styles4 !== void 0 && styles4 !== null) { + foundBlock.styles = styles4.split(STYLECLASS_SEP); + } + }, "addStyle2Node"); + setCssClass = /* @__PURE__ */ __name(function(itemIds, cssClassName) { + itemIds.split(",").forEach(function(id30) { + let foundBlock = blockDatabase.get(id30); + if (foundBlock === void 0) { + const trimmedId = id30.trim(); + foundBlock = { id: trimmedId, type: "na", children: [] }; + blockDatabase.set(trimmedId, foundBlock); + } + if (!foundBlock.classes) { + foundBlock.classes = []; + } + foundBlock.classes.push(cssClassName); + }); + }, "setCssClass"); + populateBlockDatabase = /* @__PURE__ */ __name((_blockList, parent4) => { + const blockList = _blockList.flat(); + const children2 = []; + const columnSettingBlock = blockList.find((b3) => b3?.type === "column-setting"); + const column2 = columnSettingBlock?.columns ?? -1; + for (const block2 of blockList) { + if (typeof column2 === "number" && column2 > 0 && block2.type !== "column-setting" && typeof block2.widthInColumns === "number" && block2.widthInColumns > column2) { + log.warn( + `Block ${block2.id} width ${block2.widthInColumns} exceeds configured column width ${column2}` + ); + } + if (block2.label) { + block2.label = sanitizeText5(block2.label); + } + if (block2.type === "classDef") { + addStyleClass(block2.id, block2.css); + continue; + } + if (block2.type === "applyClass") { + setCssClass(block2.id, block2?.styleClass ?? ""); + continue; + } + if (block2.type === "applyStyles") { + if (block2?.stylesStr) { + addStyle2Node(block2.id, block2?.stylesStr); + } + continue; + } + if (block2.type === "column-setting") { + parent4.columns = block2.columns ?? -1; + } else if (block2.type === "edge") { + const count2 = (edgeCount2.get(block2.id) ?? 0) + 1; + edgeCount2.set(block2.id, count2); + block2.id = count2 + "-" + block2.id; + edgeList.push(block2); + } else { + if (!block2.label) { + if (block2.type === "composite") { + block2.label = ""; + } else { + block2.label = block2.id; + } + } + const existingBlock = blockDatabase.get(block2.id); + if (existingBlock === void 0) { + blockDatabase.set(block2.id, block2); + } else { + if (block2.type !== "na") { + existingBlock.type = block2.type; + } + if (block2.label !== block2.id) { + existingBlock.label = block2.label; + } + } + if (block2.children) { + populateBlockDatabase(block2.children, block2); + } + if (block2.type === "space") { + const w4 = block2.width ?? 1; + for (let j3 = 0; j3 < w4; j3++) { + const newBlock = clone_default2(block2); + newBlock.id = newBlock.id + "-" + j3; + blockDatabase.set(newBlock.id, newBlock); + children2.push(newBlock); + } + } else if (existingBlock === void 0) { + children2.push(block2); + } + } + } + parent4.children = children2; + }, "populateBlockDatabase"); + blocks = []; + rootBlock = { id: "root", type: "composite", children: [], columns: -1 }; + clear18 = /* @__PURE__ */ __name(() => { + log.debug("Clear called"); + clear(); + rootBlock = { id: "root", type: "composite", children: [], columns: -1 }; + blockDatabase = /* @__PURE__ */ new Map([["root", rootBlock]]); + blocks = []; + classes2 = /* @__PURE__ */ new Map(); + edgeList = []; + edgeCount2 = /* @__PURE__ */ new Map(); + }, "clear"); + __name(typeStr2Type, "typeStr2Type"); + __name(edgeTypeStr2Type, "edgeTypeStr2Type"); + __name(edgeStrToEdgeData, "edgeStrToEdgeData"); + cnt3 = 0; + generateId2 = /* @__PURE__ */ __name(() => { + cnt3++; + return "id-" + Math.random().toString(36).substr(2, 12) + "-" + cnt3; + }, "generateId"); + setHierarchy = /* @__PURE__ */ __name((block2) => { + rootBlock.children = block2; + populateBlockDatabase(block2, rootBlock); + blocks = rootBlock.children; + }, "setHierarchy"); + getColumns = /* @__PURE__ */ __name((blockId) => { + const block2 = blockDatabase.get(blockId); + if (!block2) { + return -1; + } + if (block2.columns) { + return block2.columns; + } + if (!block2.children) { + return -1; + } + return block2.children.length; + }, "getColumns"); + getBlocksFlat = /* @__PURE__ */ __name(() => { + return [...blockDatabase.values()]; + }, "getBlocksFlat"); + getBlocks = /* @__PURE__ */ __name(() => { + return blocks || []; + }, "getBlocks"); + getEdges = /* @__PURE__ */ __name(() => { + return edgeList; + }, "getEdges"); + getBlock = /* @__PURE__ */ __name((id30) => { + return blockDatabase.get(id30); + }, "getBlock"); + setBlock = /* @__PURE__ */ __name((block2) => { + blockDatabase.set(block2.id, block2); + }, "setBlock"); + getLogger2 = /* @__PURE__ */ __name(() => log, "getLogger"); + getClasses4 = /* @__PURE__ */ __name(function() { + return classes2; + }, "getClasses"); + db6 = { + getConfig: /* @__PURE__ */ __name(() => getConfig().block, "getConfig"), + typeStr2Type, + edgeTypeStr2Type, + edgeStrToEdgeData, + getLogger: getLogger2, + getBlocksFlat, + getBlocks, + getEdges, + setHierarchy, + getBlock, + setBlock, + getColumns, + getClasses: getClasses4, + clear: clear18, + generateId: generateId2 + }; + blockDB_default = db6; + } + }); + + // src/diagrams/block/styles.ts + var fade3, getStyles17, styles_default16; + var init_styles18 = __esm({ + "src/diagrams/block/styles.ts"() { + "use strict"; + init_dist(); + init_globalStyles(); + fade3 = /* @__PURE__ */ __name((color2, opacity) => { + const channel2 = channel_default2; + const r2 = channel2(color2, "r"); + const g2 = channel2(color2, "g"); + const b3 = channel2(color2, "b"); + return rgba_default(r2, g2, b3, opacity); + }, "fade"); + getStyles17 = /* @__PURE__ */ __name((options2) => `.label { + font-family: ${options2.fontFamily}; + color: ${options2.nodeTextColor || options2.textColor}; + } + .cluster-label text { + fill: ${options2.titleColor}; + } + .cluster-label span,p { + color: ${options2.titleColor}; + } + + + + .label text,span,p { + fill: ${options2.nodeTextColor || options2.textColor}; + color: ${options2.nodeTextColor || options2.textColor}; + } + + .node rect, + .node circle, + .node ellipse, + .node polygon, + .node path { + fill: ${options2.mainBkg}; + stroke: ${options2.nodeBorder}; + stroke-width: 1px; + } + .flowchart-label text { + text-anchor: middle; + } + // .flowchart-label .text-outer-tspan { + // text-anchor: middle; + // } + // .flowchart-label .text-inner-tspan { + // text-anchor: start; + // } + + .node .label { + text-align: center; + } + .node.clickable { + cursor: pointer; + } + + .arrowheadPath { + fill: ${options2.arrowheadColor}; + } + + .edgePath .path { + stroke: ${options2.lineColor}; + stroke-width: 2.0px; + } + + .flowchart-link { + stroke: ${options2.lineColor}; + fill: none; + } + + .edgeLabel { + background-color: ${options2.edgeLabelBackground}; + rect { + opacity: 0.5; + background-color: ${options2.edgeLabelBackground}; + fill: ${options2.edgeLabelBackground}; + } + text-align: center; + } + + /* For html labels only */ + .labelBkg { + background-color: ${fade3(options2.edgeLabelBackground, 0.5)}; + // background-color: + } + + .node .cluster { + // fill: ${fade3(options2.mainBkg, 0.5)}; + fill: ${fade3(options2.clusterBkg, 0.5)}; + stroke: ${fade3(options2.clusterBorder, 0.2)}; + box-shadow: rgba(50, 50, 93, 0.25) 0px 13px 27px -5px, rgba(0, 0, 0, 0.3) 0px 8px 16px -8px; + stroke-width: 1px; + } + + .cluster text { + fill: ${options2.titleColor}; + } + + .cluster span,p { + color: ${options2.titleColor}; + } + /* .cluster div { + color: ${options2.titleColor}; + } */ + + div.mermaidTooltip { + position: absolute; + text-align: center; + max-width: 200px; + padding: 2px; + font-family: ${options2.fontFamily}; + font-size: 12px; + background: ${options2.tertiaryColor}; + border: 1px solid ${options2.border2}; + border-radius: 2px; + pointer-events: none; + z-index: 100; + } + + .flowchartTitleText { + text-anchor: middle; + font-size: 18px; + fill: ${options2.textColor}; + } + ${getIconStyles()} +`, "getStyles"); + styles_default16 = getStyles17; + } + }); + + // src/dagre-wrapper/markers.js + var insertMarkers3, extension4, composition2, aggregation2, dependency2, lollipop2, point7, circle4, cross2, barb2, markers2, markers_default2; + var init_markers2 = __esm({ + "src/dagre-wrapper/markers.js"() { + "use strict"; + init_logger(); + insertMarkers3 = /* @__PURE__ */ __name((elem, markerArray, type3, id30) => { + markerArray.forEach((markerName) => { + markers2[markerName](elem, type3, id30); + }); + }, "insertMarkers"); + extension4 = /* @__PURE__ */ __name((elem, type3, id30) => { + log.trace("Making markers for ", id30); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-extensionStart").attr("class", "marker extension " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 1,7 L18,13 V 1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-extensionEnd").attr("class", "marker extension " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 1,1 V 13 L18,7 Z"); + }, "extension"); + composition2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-compositionStart").attr("class", "marker composition " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-compositionEnd").attr("class", "marker composition " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + }, "composition"); + aggregation2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-aggregationStart").attr("class", "marker aggregation " + type3).attr("refX", 18).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-aggregationEnd").attr("class", "marker aggregation " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L1,7 L9,1 Z"); + }, "aggregation"); + dependency2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-dependencyStart").attr("class", "marker dependency " + type3).attr("refX", 6).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("path").attr("d", "M 5,7 L9,13 L1,7 L9,1 Z"); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-dependencyEnd").attr("class", "marker dependency " + type3).attr("refX", 13).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 18,7 L9,13 L14,7 L9,1 Z"); + }, "dependency"); + lollipop2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-lollipopStart").attr("class", "marker lollipop " + type3).attr("refX", 13).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-lollipopEnd").attr("class", "marker lollipop " + type3).attr("refX", 1).attr("refY", 7).attr("markerWidth", 190).attr("markerHeight", 240).attr("orient", "auto").append("circle").attr("stroke", "black").attr("fill", "transparent").attr("cx", 7).attr("cy", 7).attr("r", 6); + }, "lollipop"); + point7 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-pointEnd").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 6).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 0 L 10 5 L 0 10 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-pointStart").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 4.5).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 12).attr("markerHeight", 12).attr("orient", "auto").append("path").attr("d", "M 0 5 L 10 10 L 10 0 z").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + }, "point"); + circle4 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-circleEnd").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", 11).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-circleStart").attr("class", "marker " + type3).attr("viewBox", "0 0 10 10").attr("refX", -1).attr("refY", 5).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("circle").attr("cx", "5").attr("cy", "5").attr("r", "5").attr("class", "arrowMarkerPath").style("stroke-width", 1).style("stroke-dasharray", "1,0"); + }, "circle"); + cross2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("marker").attr("id", id30 + "_" + type3 + "-crossEnd").attr("class", "marker cross " + type3).attr("viewBox", "0 0 11 11").attr("refX", 12).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); + elem.append("marker").attr("id", id30 + "_" + type3 + "-crossStart").attr("class", "marker cross " + type3).attr("viewBox", "0 0 11 11").attr("refX", -1).attr("refY", 5.2).attr("markerUnits", "userSpaceOnUse").attr("markerWidth", 11).attr("markerHeight", 11).attr("orient", "auto").append("path").attr("d", "M 1,1 l 9,9 M 10,1 l -9,9").attr("class", "arrowMarkerPath").style("stroke-width", 2).style("stroke-dasharray", "1,0"); + }, "cross"); + barb2 = /* @__PURE__ */ __name((elem, type3, id30) => { + elem.append("defs").append("marker").attr("id", id30 + "_" + type3 + "-barbEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 14).attr("markerUnits", "strokeWidth").attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z"); + }, "barb"); + markers2 = { + extension: extension4, + composition: composition2, + aggregation: aggregation2, + dependency: dependency2, + lollipop: lollipop2, + point: point7, + circle: circle4, + cross: cross2, + barb: barb2 + }; + markers_default2 = insertMarkers3; + } + }); + + // src/diagrams/block/layout.ts + function calculateBlockPosition(columns, position5) { + if (columns === 0 || !Number.isInteger(columns)) { + throw new Error("Columns must be an integer !== 0."); + } + if (position5 < 0 || !Number.isInteger(position5)) { + throw new Error("Position must be a non-negative integer." + position5); + } + if (columns < 0) { + return { px: position5, py: 0 }; + } + if (columns === 1) { + return { px: 0, py: position5 }; + } + const px = position5 % columns; + const py = Math.floor(position5 / columns); + return { px, py }; + } + function setBlockSizes(block2, db7, siblingWidth = 0, siblingHeight = 0) { + log.debug( + "setBlockSizes abc95 (start)", + block2.id, + block2?.size?.x, + "block width =", + block2?.size, + "siblingWidth", + siblingWidth + ); + if (!block2?.size?.width) { + block2.size = { + width: siblingWidth, + height: siblingHeight, + x: 0, + y: 0 + }; + } + let maxWidth2 = 0; + let maxHeight = 0; + if (block2.children?.length > 0) { + for (const child of block2.children) { + setBlockSizes(child, db7); + } + const childSize = getMaxChildSize(block2); + maxWidth2 = childSize.width; + maxHeight = childSize.height; + log.debug("setBlockSizes abc95 maxWidth of", block2.id, ":s children is ", maxWidth2, maxHeight); + for (const child of block2.children) { + if (child.size) { + log.debug( + `abc95 Setting size of children of ${block2.id} id=${child.id} ${maxWidth2} ${maxHeight} ${JSON.stringify(child.size)}` + ); + child.size.width = maxWidth2 * (child.widthInColumns ?? 1) + padding * ((child.widthInColumns ?? 1) - 1); + child.size.height = maxHeight; + child.size.x = 0; + child.size.y = 0; + log.debug( + `abc95 updating size of ${block2.id} children child:${child.id} maxWidth:${maxWidth2} maxHeight:${maxHeight}` + ); + } + } + for (const child of block2.children) { + setBlockSizes(child, db7, maxWidth2, maxHeight); + } + const columns = block2.columns ?? -1; + let numItems = 0; + for (const child of block2.children) { + numItems += child.widthInColumns ?? 1; + } + let xSize = block2.children.length; + if (columns > 0 && columns < numItems) { + xSize = columns; + } + const ySize = Math.ceil(numItems / xSize); + let width3 = xSize * (maxWidth2 + padding) + padding; + let height2 = ySize * (maxHeight + padding) + padding; + if (width3 < siblingWidth) { + log.debug( + `Detected to small sibling: abc95 ${block2.id} siblingWidth ${siblingWidth} siblingHeight ${siblingHeight} width ${width3}` + ); + width3 = siblingWidth; + height2 = siblingHeight; + const childWidth = (siblingWidth - xSize * padding - padding) / xSize; + const childHeight = (siblingHeight - ySize * padding - padding) / ySize; + log.debug("Size indata abc88", block2.id, "childWidth", childWidth, "maxWidth", maxWidth2); + log.debug("Size indata abc88", block2.id, "childHeight", childHeight, "maxHeight", maxHeight); + log.debug("Size indata abc88 xSize", xSize, "padding", padding); + for (const child of block2.children) { + if (child.size) { + child.size.width = childWidth; + child.size.height = childHeight; + child.size.x = 0; + child.size.y = 0; + } + } + } + log.debug( + `abc95 (finale calc) ${block2.id} xSize ${xSize} ySize ${ySize} columns ${columns}${block2.children.length} width=${Math.max(width3, block2.size?.width || 0)}` + ); + if (width3 < (block2?.size?.width || 0)) { + width3 = block2?.size?.width || 0; + const num = columns > 0 ? Math.min(block2.children.length, columns) : block2.children.length; + if (num > 0) { + const childWidth = (width3 - num * padding - padding) / num; + log.debug("abc95 (growing to fit) width", block2.id, width3, block2.size?.width, childWidth); + for (const child of block2.children) { + if (child.size) { + child.size.width = childWidth; + } + } + } + } + block2.size = { + width: width3, + height: height2, + x: 0, + y: 0 + }; + } + log.debug( + "setBlockSizes abc94 (done)", + block2.id, + block2?.size?.x, + block2?.size?.width, + block2?.size?.y, + block2?.size?.height + ); + } + function layoutBlocks(block2, db7) { + log.debug( + `abc85 layout blocks (=>layoutBlocks) ${block2.id} x: ${block2?.size?.x} y: ${block2?.size?.y} width: ${block2?.size?.width}` + ); + const columns = block2.columns ?? -1; + log.debug("layoutBlocks columns abc95", block2.id, "=>", columns, block2); + if (block2.children && // find max width of children + block2.children.length > 0) { + const width3 = block2?.children[0]?.size?.width ?? 0; + const widthOfChildren = block2.children.length * width3 + (block2.children.length - 1) * padding; + log.debug("widthOfChildren 88", widthOfChildren, "posX"); + let columnPos = 0; + log.debug("abc91 block?.size?.x", block2.id, block2?.size?.x); + let startingPosX = block2?.size?.x ? block2?.size?.x + (-block2?.size?.width / 2 || 0) : -padding; + let rowPos = 0; + for (const child of block2.children) { + const parent4 = block2; + if (!child.size) { + continue; + } + const { width: width4, height: height2 } = child.size; + const { px, py } = calculateBlockPosition(columns, columnPos); + if (py != rowPos) { + rowPos = py; + startingPosX = block2?.size?.x ? block2?.size?.x + (-block2?.size?.width / 2 || 0) : -padding; + log.debug("New row in layout for block", block2.id, " and child ", child.id, rowPos); + } + log.debug( + `abc89 layout blocks (child) id: ${child.id} Pos: ${columnPos} (px, py) ${px},${py} (${parent4?.size?.x},${parent4?.size?.y}) parent: ${parent4.id} width: ${width4}${padding}` + ); + if (parent4.size) { + const halfWidth = width4 / 2; + child.size.x = startingPosX + padding + halfWidth; + log.debug( + `abc91 layout blocks (calc) px, pyid:${child.id} startingPos=X${startingPosX} new startingPosX${child.size.x} ${halfWidth} padding=${padding} width=${width4} halfWidth=${halfWidth} => x:${child.size.x} y:${child.size.y} ${child.widthInColumns} (width * (child?.w || 1)) / 2 ${width4 * (child?.widthInColumns ?? 1) / 2}` + ); + startingPosX = child.size.x + halfWidth; + child.size.y = parent4.size.y - parent4.size.height / 2 + py * (height2 + padding) + height2 / 2 + padding; + log.debug( + `abc88 layout blocks (calc) px, pyid:${child.id}startingPosX${startingPosX}${padding}${halfWidth}=>x:${child.size.x}y:${child.size.y}${child.widthInColumns}(width * (child?.w || 1)) / 2${width4 * (child?.widthInColumns ?? 1) / 2}` + ); + } + if (child.children) { + layoutBlocks(child, db7); + } + let columnsFilled = child?.widthInColumns ?? 1; + if (columns > 0) { + columnsFilled = Math.min(columnsFilled, columns - columnPos % columns); + } + columnPos += columnsFilled; + log.debug("abc88 columnsPos", child, columnPos); + } + } + log.debug( + `layout blocks (<==layoutBlocks) ${block2.id} x: ${block2?.size?.x} y: ${block2?.size?.y} width: ${block2?.size?.width}` + ); + } + function findBounds(block2, { minX, minY, maxX, maxY } = { minX: 0, minY: 0, maxX: 0, maxY: 0 }) { + if (block2.size && block2.id !== "root") { + const { x: x5, y: y6, width: width3, height: height2 } = block2.size; + if (x5 - width3 / 2 < minX) { + minX = x5 - width3 / 2; + } + if (y6 - height2 / 2 < minY) { + minY = y6 - height2 / 2; + } + if (x5 + width3 / 2 > maxX) { + maxX = x5 + width3 / 2; + } + if (y6 + height2 / 2 > maxY) { + maxY = y6 + height2 / 2; + } + } + if (block2.children) { + for (const child of block2.children) { + ({ minX, minY, maxX, maxY } = findBounds(child, { minX, minY, maxX, maxY })); + } + } + return { minX, minY, maxX, maxY }; + } + function layout5(db7) { + const root3 = db7.getBlock("root"); + if (!root3) { + return; + } + setBlockSizes(root3, db7, 0, 0); + layoutBlocks(root3, db7); + log.debug("getBlocks", JSON.stringify(root3, null, 2)); + const { minX, minY, maxX, maxY } = findBounds(root3); + const height2 = maxY - minY; + const width3 = maxX - minX; + return { x: minX, y: minY, width: width3, height: height2 }; + } + var padding, getMaxChildSize; + var init_layout3 = __esm({ + "src/diagrams/block/layout.ts"() { + "use strict"; + init_logger(); + init_diagramAPI(); + padding = getConfig2()?.block?.padding ?? 8; + __name(calculateBlockPosition, "calculateBlockPosition"); + getMaxChildSize = /* @__PURE__ */ __name((block2) => { + let maxWidth2 = 0; + let maxHeight = 0; + for (const child of block2.children) { + const { width: width3, height: height2, x: x5, y: y6 } = child.size ?? { width: 0, height: 0, x: 0, y: 0 }; + log.debug( + "getMaxChildSize abc95 child:", + child.id, + "width:", + width3, + "height:", + height2, + "x:", + x5, + "y:", + y6, + child.type + ); + if (child.type === "space") { + continue; + } + if (width3 > maxWidth2) { + maxWidth2 = width3 / (block2.widthInColumns ?? 1); + } + if (height2 > maxHeight) { + maxHeight = height2; + } + } + return { width: maxWidth2, height: maxHeight }; + }, "getMaxChildSize"); + __name(setBlockSizes, "setBlockSizes"); + __name(layoutBlocks, "layoutBlocks"); + __name(findBounds, "findBounds"); + __name(layout5, "layout"); + } + }); + + // src/dagre-wrapper/createLabel.js + function applyStyle3(dom, styleFn) { + if (styleFn) { + dom.attr("style", styleFn); + } + } + function addHtmlLabel2(node2, config5) { + const fo = select_default2(document.createElementNS("http://www.w3.org/2000/svg", "foreignObject")); + const div = fo.append("xhtml:div"); + const label = node2.label; + const labelClass = node2.isNode ? "nodeLabel" : "edgeLabel"; + const span = div.append("span"); + span.html(sanitizeText(label, config5)); + applyStyle3(span, node2.labelStyle); + span.attr("class", labelClass); + applyStyle3(div, node2.labelStyle); + div.style("display", "inline-block"); + div.style("white-space", "nowrap"); + div.attr("xmlns", "http://www.w3.org/1999/xhtml"); + return fo.node(); + } + var createLabel2, createLabel_default2; + var init_createLabel2 = __esm({ + "src/dagre-wrapper/createLabel.js"() { + "use strict"; + init_src32(); + init_diagramAPI(); + init_common(); + init_logger(); + init_createText(); + init_utils2(); + __name(applyStyle3, "applyStyle"); + __name(addHtmlLabel2, "addHtmlLabel"); + createLabel2 = /* @__PURE__ */ __name(async (_vertexText, style3, isTitle, isNode2) => { + let vertexText = _vertexText || ""; + if (typeof vertexText === "object") { + vertexText = vertexText[0]; + } + const config5 = getConfig2(); + if (evaluate(config5.flowchart.htmlLabels)) { + vertexText = vertexText.replace(/\\n|\n/g, "
"); + log.debug("vertexText" + vertexText); + const label = await replaceIconSubstring(decodeEntities(vertexText)); + const node2 = { + isNode: isNode2, + label, + labelStyle: style3.replace("fill:", "color:") + }; + let vertexNode = addHtmlLabel2(node2, config5); + return vertexNode; + } else { + const svgLabel = document.createElementNS("http://www.w3.org/2000/svg", "text"); + svgLabel.setAttribute("style", style3.replace("color:", "fill:")); + let rows = []; + if (typeof vertexText === "string") { + rows = vertexText.split(/\\n|\n|
") : textRows, + node2.labelStyle, + true, + true + ) + ); + if (evaluate(getConfig2().flowchart.htmlLabels)) { + const div = descr.children[0]; + const dv = select_default2(descr); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + const halfPadding = node2.padding / 2; + select_default2(descr).attr( + "transform", + "translate( " + // (titleBox.width - bbox.width) / 2 + + (bbox.width > titleBox.width ? 0 : (titleBox.width - bbox.width) / 2) + ", " + (titleBox.height + halfPadding + 5) + ")" + ); + select_default2(text4).attr( + "transform", + "translate( " + // (titleBox.width - bbox.width) / 2 + + (bbox.width < titleBox.width ? 0 : -(titleBox.width - bbox.width) / 2) + ", 0)" + ); + bbox = label.node().getBBox(); + label.attr( + "transform", + "translate(" + -bbox.width / 2 + ", " + (-bbox.height / 2 - halfPadding + 3) + ")" + ); + rect3.attr("class", "outer title-state").attr("x", -bbox.width / 2 - halfPadding).attr("y", -bbox.height / 2 - halfPadding).attr("width", bbox.width + node2.padding).attr("height", bbox.height + node2.padding); + innerLine.attr("class", "divider").attr("x1", -bbox.width / 2 - halfPadding).attr("x2", bbox.width / 2 + halfPadding).attr("y1", -bbox.height / 2 - halfPadding + titleBox.height + halfPadding).attr("y2", -bbox.height / 2 - halfPadding + titleBox.height + halfPadding); + updateNodeBounds2(node2, rect3); + node2.intersect = function(point8) { + return intersect_default2.rect(node2, point8); + }; + return shapeSvg; + }, "rectWithTitle"); + stadium2 = /* @__PURE__ */ __name(async (parent4, node2) => { + const { shapeSvg, bbox } = await labelHelper2( + parent4, + node2, + getClassesFromNode(node2, void 0), + true + ); + const h3 = bbox.height + node2.padding; + const w4 = bbox.width + h3 / 4 + node2.padding; + const rect3 = shapeSvg.insert("rect", ":first-child").attr("style", node2.style).attr("rx", h3 / 2).attr("ry", h3 / 2).attr("x", -w4 / 2).attr("y", -h3 / 2).attr("width", w4).attr("height", h3); + updateNodeBounds2(node2, rect3); + node2.intersect = function(point8) { + return intersect_default2.rect(node2, point8); + }; + return shapeSvg; + }, "stadium"); + circle5 = /* @__PURE__ */ __name(async (parent4, node2) => { + const { shapeSvg, bbox, halfPadding } = await labelHelper2( + parent4, + node2, + getClassesFromNode(node2, void 0), + true + ); + const circle6 = shapeSvg.insert("circle", ":first-child"); + circle6.attr("style", node2.style).attr("rx", node2.rx).attr("ry", node2.ry).attr("r", bbox.width / 2 + halfPadding).attr("width", bbox.width + node2.padding).attr("height", bbox.height + node2.padding); + log.info("Circle main"); + updateNodeBounds2(node2, circle6); + node2.intersect = function(point8) { + log.info("Circle intersect", node2, bbox.width / 2 + halfPadding, point8); + return intersect_default2.circle(node2, bbox.width / 2 + halfPadding, point8); + }; + return shapeSvg; + }, "circle"); + doublecircle2 = /* @__PURE__ */ __name(async (parent4, node2) => { + const { shapeSvg, bbox, halfPadding } = await labelHelper2( + parent4, + node2, + getClassesFromNode(node2, void 0), + true + ); + const gap = 5; + const circleGroup = shapeSvg.insert("g", ":first-child"); + const outerCircle = circleGroup.insert("circle"); + const innerCircle = circleGroup.insert("circle"); + circleGroup.attr("class", node2.class); + outerCircle.attr("style", node2.style).attr("rx", node2.rx).attr("ry", node2.ry).attr("r", bbox.width / 2 + halfPadding + gap).attr("width", bbox.width + node2.padding + gap * 2).attr("height", bbox.height + node2.padding + gap * 2); + innerCircle.attr("style", node2.style).attr("rx", node2.rx).attr("ry", node2.ry).attr("r", bbox.width / 2 + halfPadding).attr("width", bbox.width + node2.padding).attr("height", bbox.height + node2.padding); + log.info("DoubleCircle main"); + updateNodeBounds2(node2, outerCircle); + node2.intersect = function(point8) { + log.info("DoubleCircle intersect", node2, bbox.width / 2 + halfPadding + gap, point8); + return intersect_default2.circle(node2, bbox.width / 2 + halfPadding + gap, point8); + }; + return shapeSvg; + }, "doublecircle"); + subroutine2 = /* @__PURE__ */ __name(async (parent4, node2) => { + const { shapeSvg, bbox } = await labelHelper2( + parent4, + node2, + getClassesFromNode(node2, void 0), + true + ); + const w4 = bbox.width + node2.padding; + const h3 = bbox.height + node2.padding; + const points = [ + { x: 0, y: 0 }, + { x: w4, y: 0 }, + { x: w4, y: -h3 }, + { x: 0, y: -h3 }, + { x: 0, y: 0 }, + { x: -8, y: 0 }, + { x: w4 + 8, y: 0 }, + { x: w4 + 8, y: -h3 }, + { x: -8, y: -h3 }, + { x: -8, y: 0 } + ]; + const el = insertPolygonShape2(shapeSvg, w4, h3, points); + el.attr("style", node2.style); + updateNodeBounds2(node2, el); + node2.intersect = function(point8) { + return intersect_default2.polygon(node2, points, point8); + }; + return shapeSvg; + }, "subroutine"); + start2 = /* @__PURE__ */ __name((parent4, node2) => { + const shapeSvg = parent4.insert("g").attr("class", "node default").attr("id", node2.domId || node2.id); + const circle6 = shapeSvg.insert("circle", ":first-child"); + circle6.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14); + updateNodeBounds2(node2, circle6); + node2.intersect = function(point8) { + return intersect_default2.circle(node2, 7, point8); + }; + return shapeSvg; + }, "start"); + forkJoin2 = /* @__PURE__ */ __name((parent4, node2, dir2) => { + const shapeSvg = parent4.insert("g").attr("class", "node default").attr("id", node2.domId || node2.id); + let width3 = 70; + let height2 = 10; + if (dir2 === "LR") { + width3 = 10; + height2 = 70; + } + const shape = shapeSvg.append("rect").attr("x", -1 * width3 / 2).attr("y", -1 * height2 / 2).attr("width", width3).attr("height", height2).attr("class", "fork-join"); + updateNodeBounds2(node2, shape); + node2.height = node2.height + node2.padding / 2; + node2.width = node2.width + node2.padding / 2; + node2.intersect = function(point8) { + return intersect_default2.rect(node2, point8); + }; + return shapeSvg; + }, "forkJoin"); + end = /* @__PURE__ */ __name((parent4, node2) => { + const shapeSvg = parent4.insert("g").attr("class", "node default").attr("id", node2.domId || node2.id); + const innerCircle = shapeSvg.insert("circle", ":first-child"); + const circle6 = shapeSvg.insert("circle", ":first-child"); + circle6.attr("class", "state-start").attr("r", 7).attr("width", 14).attr("height", 14); + innerCircle.attr("class", "state-end").attr("r", 5).attr("width", 10).attr("height", 10); + updateNodeBounds2(node2, circle6); + node2.intersect = function(point8) { + return intersect_default2.circle(node2, 7, point8); + }; + return shapeSvg; + }, "end"); + class_box = /* @__PURE__ */ __name(async (parent4, node2) => { + const halfPadding = node2.padding / 2; + const rowPadding = 4; + const lineHeight = 8; + let classes3; + if (!node2.classes) { + classes3 = "node default"; + } else { + classes3 = "node " + node2.classes; + } + const shapeSvg = parent4.insert("g").attr("class", classes3).attr("id", node2.domId || node2.id); + const rect3 = shapeSvg.insert("rect", ":first-child"); + const topLine = shapeSvg.insert("line"); + const bottomLine = shapeSvg.insert("line"); + let maxWidth2 = 0; + let maxHeight = rowPadding; + const labelContainer = shapeSvg.insert("g").attr("class", "label"); + let verticalPos = 0; + const hasInterface = node2.classData.annotations?.[0]; + const interfaceLabelText = node2.classData.annotations[0] ? "\xAB" + node2.classData.annotations[0] + "\xBB" : ""; + const interfaceLabel = labelContainer.node().appendChild(await createLabel_default2(interfaceLabelText, node2.labelStyle, true, true)); + let interfaceBBox = interfaceLabel.getBBox(); + if (evaluate(getConfig2().flowchart.htmlLabels)) { + const div = interfaceLabel.children[0]; + const dv = select_default2(interfaceLabel); + interfaceBBox = div.getBoundingClientRect(); + dv.attr("width", interfaceBBox.width); + dv.attr("height", interfaceBBox.height); + } + if (node2.classData.annotations[0]) { + maxHeight += interfaceBBox.height + rowPadding; + maxWidth2 += interfaceBBox.width; + } + let classTitleString = node2.classData.label; + if (node2.classData.type !== void 0 && node2.classData.type !== "") { + if (getConfig2().flowchart.htmlLabels) { + classTitleString += "<" + node2.classData.type + ">"; + } else { + classTitleString += "<" + node2.classData.type + ">"; + } + } + const classTitleLabel = labelContainer.node().appendChild(await createLabel_default2(classTitleString, node2.labelStyle, true, true)); + select_default2(classTitleLabel).attr("class", "classTitle"); + let classTitleBBox = classTitleLabel.getBBox(); + if (evaluate(getConfig2().flowchart.htmlLabels)) { + const div = classTitleLabel.children[0]; + const dv = select_default2(classTitleLabel); + classTitleBBox = div.getBoundingClientRect(); + dv.attr("width", classTitleBBox.width); + dv.attr("height", classTitleBBox.height); + } + maxHeight += classTitleBBox.height + rowPadding; + if (classTitleBBox.width > maxWidth2) { + maxWidth2 = classTitleBBox.width; + } + const classAttributes = []; + node2.classData.members.forEach(async (member) => { + const parsedInfo = member.getDisplayDetails(); + let parsedText = parsedInfo.displayText; + if (getConfig2().flowchart.htmlLabels) { + parsedText = parsedText.replace(//g, ">"); + } + const lbl = labelContainer.node().appendChild( + await createLabel_default2( + parsedText, + parsedInfo.cssStyle ? parsedInfo.cssStyle : node2.labelStyle, + true, + true + ) + ); + let bbox = lbl.getBBox(); + if (evaluate(getConfig2().flowchart.htmlLabels)) { + const div = lbl.children[0]; + const dv = select_default2(lbl); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + if (bbox.width > maxWidth2) { + maxWidth2 = bbox.width; + } + maxHeight += bbox.height + rowPadding; + classAttributes.push(lbl); + }); + maxHeight += lineHeight; + const classMethods = []; + node2.classData.methods.forEach(async (member) => { + const parsedInfo = member.getDisplayDetails(); + let displayText = parsedInfo.displayText; + if (getConfig2().flowchart.htmlLabels) { + displayText = displayText.replace(//g, ">"); + } + const lbl = labelContainer.node().appendChild( + await createLabel_default2( + displayText, + parsedInfo.cssStyle ? parsedInfo.cssStyle : node2.labelStyle, + true, + true + ) + ); + let bbox = lbl.getBBox(); + if (evaluate(getConfig2().flowchart.htmlLabels)) { + const div = lbl.children[0]; + const dv = select_default2(lbl); + bbox = div.getBoundingClientRect(); + dv.attr("width", bbox.width); + dv.attr("height", bbox.height); + } + if (bbox.width > maxWidth2) { + maxWidth2 = bbox.width; + } + maxHeight += bbox.height + rowPadding; + classMethods.push(lbl); + }); + maxHeight += lineHeight; + if (hasInterface) { + let diffX2 = (maxWidth2 - interfaceBBox.width) / 2; + select_default2(interfaceLabel).attr( + "transform", + "translate( " + (-1 * maxWidth2 / 2 + diffX2) + ", " + -1 * maxHeight / 2 + ")" + ); + verticalPos = interfaceBBox.height + rowPadding; + } + let diffX = (maxWidth2 - classTitleBBox.width) / 2; + select_default2(classTitleLabel).attr( + "transform", + "translate( " + (-1 * maxWidth2 / 2 + diffX) + ", " + (-1 * maxHeight / 2 + verticalPos) + ")" + ); + verticalPos += classTitleBBox.height + rowPadding; + topLine.attr("class", "divider").attr("x1", -maxWidth2 / 2 - halfPadding).attr("x2", maxWidth2 / 2 + halfPadding).attr("y1", -maxHeight / 2 - halfPadding + lineHeight + verticalPos).attr("y2", -maxHeight / 2 - halfPadding + lineHeight + verticalPos); + verticalPos += lineHeight; + classAttributes.forEach((lbl) => { + select_default2(lbl).attr( + "transform", + "translate( " + -maxWidth2 / 2 + ", " + (-1 * maxHeight / 2 + verticalPos + lineHeight / 2) + ")" + ); + const memberBBox = lbl?.getBBox(); + verticalPos += (memberBBox?.height ?? 0) + rowPadding; + }); + verticalPos += lineHeight; + bottomLine.attr("class", "divider").attr("x1", -maxWidth2 / 2 - halfPadding).attr("x2", maxWidth2 / 2 + halfPadding).attr("y1", -maxHeight / 2 - halfPadding + lineHeight + verticalPos).attr("y2", -maxHeight / 2 - halfPadding + lineHeight + verticalPos); + verticalPos += lineHeight; + classMethods.forEach((lbl) => { + select_default2(lbl).attr( + "transform", + "translate( " + -maxWidth2 / 2 + ", " + (-1 * maxHeight / 2 + verticalPos) + ")" + ); + const memberBBox = lbl?.getBBox(); + verticalPos += (memberBBox?.height ?? 0) + rowPadding; + }); + rect3.attr("style", node2.style).attr("class", "outer title-state").attr("x", -maxWidth2 / 2 - halfPadding).attr("y", -(maxHeight / 2) - halfPadding).attr("width", maxWidth2 + node2.padding).attr("height", maxHeight + node2.padding); + updateNodeBounds2(node2, rect3); + node2.intersect = function(point8) { + return intersect_default2.rect(node2, point8); + }; + return shapeSvg; + }, "class_box"); + shapes3 = { + rhombus: question2, + composite, + question: question2, + rect: rect2, + labelRect: labelRect2, + rectWithTitle: rectWithTitle2, + choice: choice2, + circle: circle5, + doublecircle: doublecircle2, + stadium: stadium2, + hexagon: hexagon2, + block_arrow, + rect_left_inv_arrow: rect_left_inv_arrow2, + lean_right: lean_right2, + lean_left: lean_left2, + trapezoid: trapezoid2, + inv_trapezoid: inv_trapezoid2, + rect_right_inv_arrow, + cylinder: cylinder2, + start: start2, + end, + note: note_default, + subroutine: subroutine2, + fork: forkJoin2, + join: forkJoin2, + class_box + }; + nodeElems2 = {}; + insertNode2 = /* @__PURE__ */ __name(async (elem, node2, renderOptions) => { + let newEl; + let el; + if (node2.link) { + let target; + if (getConfig2().securityLevel === "sandbox") { + target = "_top"; + } else if (node2.linkTarget) { + target = node2.linkTarget || "_blank"; + } + newEl = elem.insert("svg:a").attr("xlink:href", node2.link).attr("target", target); + el = await shapes3[node2.shape](newEl, node2, renderOptions); + } else { + el = await shapes3[node2.shape](elem, node2, renderOptions); + newEl = el; + } + if (node2.tooltip) { + el.attr("title", node2.tooltip); + } + if (node2.class) { + el.attr("class", "node default " + node2.class); + } + nodeElems2[node2.id] = newEl; + if (node2.haveCallback) { + nodeElems2[node2.id].attr("class", nodeElems2[node2.id].attr("class") + " clickable"); + } + return newEl; + }, "insertNode"); + positionNode2 = /* @__PURE__ */ __name((node2) => { + const el = nodeElems2[node2.id]; + log.trace( + "Transforming node", + node2.diff, + node2, + "translate(" + (node2.x - node2.width / 2 - 5) + ", " + node2.width / 2 + ")" + ); + const padding2 = 8; + const diff2 = node2.diff || 0; + if (node2.clusterNode) { + el.attr( + "transform", + "translate(" + (node2.x + diff2 - node2.width / 2) + ", " + (node2.y - node2.height / 2 - padding2) + ")" + ); + } else { + el.attr("transform", "translate(" + node2.x + ", " + node2.y + ")"); + } + return diff2; + }, "positionNode"); + } + }); + + // src/diagrams/block/renderHelpers.ts + function getNodeFromBlock(block2, db7, positioned = false) { + const vertex = block2; + let classStr = "default"; + if ((vertex?.classes?.length || 0) > 0) { + classStr = (vertex?.classes ?? []).join(" "); + } + classStr = classStr + " flowchart-label"; + let radius2 = 0; + let shape = ""; + let padding2; + switch (vertex.type) { + case "round": + radius2 = 5; + shape = "rect"; + break; + case "composite": + radius2 = 0; + shape = "composite"; + padding2 = 0; + break; + case "square": + shape = "rect"; + break; + case "diamond": + shape = "question"; + break; + case "hexagon": + shape = "hexagon"; + break; + case "block_arrow": + shape = "block_arrow"; + break; + case "odd": + shape = "rect_left_inv_arrow"; + break; + case "lean_right": + shape = "lean_right"; + break; + case "lean_left": + shape = "lean_left"; + break; + case "trapezoid": + shape = "trapezoid"; + break; + case "inv_trapezoid": + shape = "inv_trapezoid"; + break; + case "rect_left_inv_arrow": + shape = "rect_left_inv_arrow"; + break; + case "circle": + shape = "circle"; + break; + case "ellipse": + shape = "ellipse"; + break; + case "stadium": + shape = "stadium"; + break; + case "subroutine": + shape = "subroutine"; + break; + case "cylinder": + shape = "cylinder"; + break; + case "group": + shape = "rect"; + break; + case "doublecircle": + shape = "doublecircle"; + break; + default: + shape = "rect"; + } + const styles4 = getStylesFromArray(vertex?.styles ?? []); + const vertexText = vertex.label; + const bounds4 = vertex.size ?? { width: 0, height: 0, x: 0, y: 0 }; + const node2 = { + labelStyle: styles4.labelStyle, + shape, + labelText: vertexText, + rx: radius2, + ry: radius2, + class: classStr, + style: styles4.style, + id: vertex.id, + directions: vertex.directions, + width: bounds4.width, + height: bounds4.height, + x: bounds4.x, + y: bounds4.y, + positioned, + intersect: void 0, + type: vertex.type, + padding: padding2 ?? getConfig()?.block?.padding ?? 0 + }; + return node2; + } + async function calculateBlockSize(elem, block2, db7) { + const node2 = getNodeFromBlock(block2, db7, false); + if (node2.type === "group") { + return; + } + const config5 = getConfig(); + const nodeEl = await insertNode2(elem, node2, { config: config5 }); + const boundingBox3 = nodeEl.node().getBBox(); + const obj = db7.getBlock(node2.id); + obj.size = { width: boundingBox3.width, height: boundingBox3.height, x: 0, y: 0, node: nodeEl }; + db7.setBlock(obj); + nodeEl.remove(); + } + async function insertBlockPositioned(elem, block2, db7) { + const node2 = getNodeFromBlock(block2, db7, true); + const obj = db7.getBlock(node2.id); + if (obj.type !== "space") { + const config5 = getConfig(); + await insertNode2(elem, node2, { config: config5 }); + block2.intersect = node2?.intersect; + positionNode2(node2); + } + } + async function performOperations(elem, blocks2, db7, operation) { + for (const block2 of blocks2) { + await operation(elem, block2, db7); + if (block2.children) { + await performOperations(elem, block2.children, db7, operation); + } + } + } + async function calculateBlockSizes(elem, blocks2, db7) { + await performOperations(elem, blocks2, db7, calculateBlockSize); + } + async function insertBlocks(elem, blocks2, db7) { + await performOperations(elem, blocks2, db7, insertBlockPositioned); + } + async function insertEdges(elem, edges3, blocks2, db7, id30) { + const g2 = new Graph({ + multigraph: true, + compound: true + }); + g2.setGraph({ + rankdir: "TB", + nodesep: 10, + ranksep: 10, + marginx: 8, + marginy: 8 + }); + for (const block2 of blocks2) { + if (block2.size) { + g2.setNode(block2.id, { + width: block2.size.width, + height: block2.size.height, + intersect: block2.intersect + }); + } + } + for (const edge of edges3) { + if (edge.start && edge.end) { + const startBlock = db7.getBlock(edge.start); + const endBlock = db7.getBlock(edge.end); + if (startBlock?.size && endBlock?.size) { + const start3 = startBlock.size; + const end2 = endBlock.size; + const points = [ + { x: start3.x, y: start3.y }, + { x: start3.x + (end2.x - start3.x) / 2, y: start3.y + (end2.y - start3.y) / 2 }, + { x: end2.x, y: end2.y } + ]; + insertEdge2( + elem, + { v: edge.start, w: edge.end, name: edge.id }, + { + ...edge, + arrowTypeEnd: edge.arrowTypeEnd, + arrowTypeStart: edge.arrowTypeStart, + points, + classes: "edge-thickness-normal edge-pattern-solid flowchart-link LS-a1 LE-b1" + }, + void 0, + "block", + g2, + id30 + ); + if (edge.label) { + await insertEdgeLabel2(elem, { + ...edge, + label: edge.label, + labelStyle: "stroke: #333; stroke-width: 1.5px;fill:none;", + arrowTypeEnd: edge.arrowTypeEnd, + arrowTypeStart: edge.arrowTypeStart, + points, + classes: "edge-thickness-normal edge-pattern-solid flowchart-link LS-a1 LE-b1" + }); + positionEdgeLabel2( + { ...edge, x: points[1].x, y: points[1].y }, + { + originalPath: points + } + ); + } + } + } + } + } + var init_renderHelpers = __esm({ + "src/diagrams/block/renderHelpers.ts"() { + "use strict"; + init_graphlib(); + init_config(); + init_edges2(); + init_nodes3(); + init_utils2(); + __name(getNodeFromBlock, "getNodeFromBlock"); + __name(calculateBlockSize, "calculateBlockSize"); + __name(insertBlockPositioned, "insertBlockPositioned"); + __name(performOperations, "performOperations"); + __name(calculateBlockSizes, "calculateBlockSizes"); + __name(insertBlocks, "insertBlocks"); + __name(insertEdges, "insertEdges"); + } + }); + + // src/diagrams/block/blockRenderer.ts + var getClasses5, draw23, blockRenderer_default; + var init_blockRenderer = __esm({ + "src/diagrams/block/blockRenderer.ts"() { + "use strict"; + init_src32(); + init_config(); + init_markers2(); + init_logger(); + init_setupGraphViewbox(); + init_layout3(); + init_renderHelpers(); + getClasses5 = /* @__PURE__ */ __name(function(text4, diagObj) { + return diagObj.db.getClasses(); + }, "getClasses"); + draw23 = /* @__PURE__ */ __name(async function(text4, id30, _version, diagObj) { + const { securityLevel, block: conf5 } = getConfig(); + const db7 = diagObj.db; + let sandboxElement; + if (securityLevel === "sandbox") { + sandboxElement = select_default2("#i" + id30); + } + const root3 = securityLevel === "sandbox" ? select_default2(sandboxElement.nodes()[0].contentDocument.body) : select_default2("body"); + const svg2 = securityLevel === "sandbox" ? root3.select(`[id="${id30}"]`) : select_default2(`[id="${id30}"]`); + const markers3 = ["point", "circle", "cross"]; + markers_default2(svg2, markers3, diagObj.type, id30); + const bl = db7.getBlocks(); + const blArr = db7.getBlocksFlat(); + const edges3 = db7.getEdges(); + const nodes5 = svg2.insert("g").attr("class", "block"); + await calculateBlockSizes(nodes5, bl, db7); + const bounds4 = layout5(db7); + await insertBlocks(nodes5, bl, db7); + await insertEdges(nodes5, edges3, blArr, db7, id30); + if (bounds4) { + const bounds22 = bounds4; + const magicFactor = Math.max(1, Math.round(0.125 * (bounds22.width / bounds22.height))); + const height2 = bounds22.height + magicFactor + 10; + const width3 = bounds22.width + 10; + const { useMaxWidth } = conf5; + configureSvgSize(svg2, height2, width3, !!useMaxWidth); + log.debug("Here Bounds", bounds4, bounds22); + svg2.attr( + "viewBox", + `${bounds22.x - 5} ${bounds22.y - 5} ${bounds22.width + 10} ${bounds22.height + 10}` + ); + } + }, "draw"); + blockRenderer_default = { + draw: draw23, + getClasses: getClasses5 + }; + } + }); + + // src/diagrams/block/blockDiagram.ts + var blockDiagram_exports = {}; + __export(blockDiagram_exports, { + diagram: () => diagram24 + }); + var diagram24; + var init_blockDiagram = __esm({ + "src/diagrams/block/blockDiagram.ts"() { + "use strict"; + init_block(); + init_blockDB(); + init_styles18(); + init_blockRenderer(); + diagram24 = { + parser: block_default, + db: blockDB_default, + renderer: blockRenderer_default, + styles: styles_default16 + }; + } + }); + + // src/diagrams/architecture/architectureTypes.ts + var ArchitectureDirectionName, ArchitectureDirectionArrow, ArchitectureDirectionArrowShift, getOppositeArchitectureDirection, isArchitectureDirection, isArchitectureDirectionX, isArchitectureDirectionY, isArchitectureDirectionXY, isArchitecturePairXY, isValidArchitectureDirectionPair, getArchitectureDirectionPair, shiftPositionByArchitectureDirectionPair, getArchitectureDirectionXYFactors, getArchitectureDirectionAlignment, isArchitectureService, isArchitectureJunction, edgeData, nodeData; + var init_architectureTypes = __esm({ + "src/diagrams/architecture/architectureTypes.ts"() { + "use strict"; + ArchitectureDirectionName = { + L: "left", + R: "right", + T: "top", + B: "bottom" + }; + ArchitectureDirectionArrow = { + L: /* @__PURE__ */ __name((scale2) => `${scale2},${scale2 / 2} 0,${scale2} 0,0`, "L"), + R: /* @__PURE__ */ __name((scale2) => `0,${scale2 / 2} ${scale2},0 ${scale2},${scale2}`, "R"), + T: /* @__PURE__ */ __name((scale2) => `0,0 ${scale2},0 ${scale2 / 2},${scale2}`, "T"), + B: /* @__PURE__ */ __name((scale2) => `${scale2 / 2},0 ${scale2},${scale2} 0,${scale2}`, "B") + }; + ArchitectureDirectionArrowShift = { + L: /* @__PURE__ */ __name((orig, arrowSize) => orig - arrowSize + 2, "L"), + R: /* @__PURE__ */ __name((orig, _arrowSize) => orig - 2, "R"), + T: /* @__PURE__ */ __name((orig, arrowSize) => orig - arrowSize + 2, "T"), + B: /* @__PURE__ */ __name((orig, _arrowSize) => orig - 2, "B") + }; + getOppositeArchitectureDirection = /* @__PURE__ */ __name(function(x5) { + if (isArchitectureDirectionX(x5)) { + return x5 === "L" ? "R" : "L"; + } else { + return x5 === "T" ? "B" : "T"; + } + }, "getOppositeArchitectureDirection"); + isArchitectureDirection = /* @__PURE__ */ __name(function(x5) { + const temp = x5; + return temp === "L" || temp === "R" || temp === "T" || temp === "B"; + }, "isArchitectureDirection"); + isArchitectureDirectionX = /* @__PURE__ */ __name(function(x5) { + const temp = x5; + return temp === "L" || temp === "R"; + }, "isArchitectureDirectionX"); + isArchitectureDirectionY = /* @__PURE__ */ __name(function(x5) { + const temp = x5; + return temp === "T" || temp === "B"; + }, "isArchitectureDirectionY"); + isArchitectureDirectionXY = /* @__PURE__ */ __name(function(a2, b3) { + const aX_bY = isArchitectureDirectionX(a2) && isArchitectureDirectionY(b3); + const aY_bX = isArchitectureDirectionY(a2) && isArchitectureDirectionX(b3); + return aX_bY || aY_bX; + }, "isArchitectureDirectionXY"); + isArchitecturePairXY = /* @__PURE__ */ __name(function(pair) { + const lhs = pair[0]; + const rhs = pair[1]; + const aX_bY = isArchitectureDirectionX(lhs) && isArchitectureDirectionY(rhs); + const aY_bX = isArchitectureDirectionY(lhs) && isArchitectureDirectionX(rhs); + return aX_bY || aY_bX; + }, "isArchitecturePairXY"); + isValidArchitectureDirectionPair = /* @__PURE__ */ __name(function(x5) { + return x5 !== "LL" && x5 !== "RR" && x5 !== "TT" && x5 !== "BB"; + }, "isValidArchitectureDirectionPair"); + getArchitectureDirectionPair = /* @__PURE__ */ __name(function(sourceDir, targetDir) { + const pair = `${sourceDir}${targetDir}`; + return isValidArchitectureDirectionPair(pair) ? pair : void 0; + }, "getArchitectureDirectionPair"); + shiftPositionByArchitectureDirectionPair = /* @__PURE__ */ __name(function([x5, y6], pair) { + const lhs = pair[0]; + const rhs = pair[1]; + if (isArchitectureDirectionX(lhs)) { + if (isArchitectureDirectionY(rhs)) { + return [x5 + (lhs === "L" ? -1 : 1), y6 + (rhs === "T" ? 1 : -1)]; + } else { + return [x5 + (lhs === "L" ? -1 : 1), y6]; + } + } else { + if (isArchitectureDirectionX(rhs)) { + return [x5 + (rhs === "L" ? 1 : -1), y6 + (lhs === "T" ? 1 : -1)]; + } else { + return [x5, y6 + (lhs === "T" ? 1 : -1)]; + } + } + }, "shiftPositionByArchitectureDirectionPair"); + getArchitectureDirectionXYFactors = /* @__PURE__ */ __name(function(pair) { + if (pair === "LT" || pair === "TL") { + return [1, 1]; + } else if (pair === "BL" || pair === "LB") { + return [1, -1]; + } else if (pair === "BR" || pair === "RB") { + return [-1, -1]; + } else { + return [-1, 1]; + } + }, "getArchitectureDirectionXYFactors"); + getArchitectureDirectionAlignment = /* @__PURE__ */ __name(function(a2, b3) { + if (isArchitectureDirectionXY(a2, b3)) { + return "bend"; + } else if (isArchitectureDirectionX(a2)) { + return "horizontal"; + } + return "vertical"; + }, "getArchitectureDirectionAlignment"); + isArchitectureService = /* @__PURE__ */ __name(function(x5) { + const temp = x5; + return temp.type === "service"; + }, "isArchitectureService"); + isArchitectureJunction = /* @__PURE__ */ __name(function(x5) { + const temp = x5; + return temp.type === "junction"; + }, "isArchitectureJunction"); + edgeData = /* @__PURE__ */ __name((edge) => { + return edge.data(); + }, "edgeData"); + nodeData = /* @__PURE__ */ __name((node2) => { + return node2.data(); + }, "nodeData"); + } + }); + + // src/diagrams/architecture/architectureDb.ts + var DEFAULT_ARCHITECTURE_CONFIG, ArchitectureDB; + var init_architectureDb = __esm({ + "src/diagrams/architecture/architectureDb.ts"() { + "use strict"; + init_config(); + init_defaultConfig(); + init_utils2(); + init_commonDb(); + init_architectureTypes(); + DEFAULT_ARCHITECTURE_CONFIG = defaultConfig_default.architecture; + ArchitectureDB = class { + constructor() { + this.nodes = {}; + this.groups = {}; + this.edges = []; + this.registeredIds = {}; + this.elements = {}; + this.setAccTitle = setAccTitle; + this.getAccTitle = getAccTitle; + this.setDiagramTitle = setDiagramTitle; + this.getDiagramTitle = getDiagramTitle; + this.getAccDescription = getAccDescription; + this.setAccDescription = setAccDescription; + this.clear(); + } + static { + __name(this, "ArchitectureDB"); + } + clear() { + this.nodes = {}; + this.groups = {}; + this.edges = []; + this.registeredIds = {}; + this.dataStructures = void 0; + this.elements = {}; + clear(); + } + addService({ + id: id30, + icon: icon2, + in: parent4, + title: title2, + iconText + }) { + if (this.registeredIds[id30] !== void 0) { + throw new Error( + `The service id [${id30}] is already in use by another ${this.registeredIds[id30]}` + ); + } + if (parent4 !== void 0) { + if (id30 === parent4) { + throw new Error(`The service [${id30}] cannot be placed within itself`); + } + if (this.registeredIds[parent4] === void 0) { + throw new Error( + `The service [${id30}]'s parent does not exist. Please make sure the parent is created before this service` + ); + } + if (this.registeredIds[parent4] === "node") { + throw new Error(`The service [${id30}]'s parent is not a group`); + } + } + this.registeredIds[id30] = "node"; + this.nodes[id30] = { + id: id30, + type: "service", + icon: icon2, + iconText, + title: title2, + edges: [], + in: parent4 + }; + } + getServices() { + return Object.values(this.nodes).filter(isArchitectureService); + } + addJunction({ id: id30, in: parent4 }) { + this.registeredIds[id30] = "node"; + this.nodes[id30] = { + id: id30, + type: "junction", + edges: [], + in: parent4 + }; + } + getJunctions() { + return Object.values(this.nodes).filter(isArchitectureJunction); + } + getNodes() { + return Object.values(this.nodes); + } + getNode(id30) { + return this.nodes[id30] ?? null; + } + addGroup({ id: id30, icon: icon2, in: parent4, title: title2 }) { + if (this.registeredIds?.[id30] !== void 0) { + throw new Error( + `The group id [${id30}] is already in use by another ${this.registeredIds[id30]}` + ); + } + if (parent4 !== void 0) { + if (id30 === parent4) { + throw new Error(`The group [${id30}] cannot be placed within itself`); + } + if (this.registeredIds?.[parent4] === void 0) { + throw new Error( + `The group [${id30}]'s parent does not exist. Please make sure the parent is created before this group` + ); + } + if (this.registeredIds?.[parent4] === "node") { + throw new Error(`The group [${id30}]'s parent is not a group`); + } + } + this.registeredIds[id30] = "group"; + this.groups[id30] = { + id: id30, + icon: icon2, + title: title2, + in: parent4 + }; + } + getGroups() { + return Object.values(this.groups); + } + addEdge({ + lhsId, + rhsId, + lhsDir, + rhsDir, + lhsInto, + rhsInto, + lhsGroup, + rhsGroup, + title: title2 + }) { + if (!isArchitectureDirection(lhsDir)) { + throw new Error( + `Invalid direction given for left hand side of edge ${lhsId}--${rhsId}. Expected (L,R,T,B) got ${String(lhsDir)}` + ); + } + if (!isArchitectureDirection(rhsDir)) { + throw new Error( + `Invalid direction given for right hand side of edge ${lhsId}--${rhsId}. Expected (L,R,T,B) got ${String(rhsDir)}` + ); + } + if (this.nodes[lhsId] === void 0 && this.groups[lhsId] === void 0) { + throw new Error( + `The left-hand id [${lhsId}] does not yet exist. Please create the service/group before declaring an edge to it.` + ); + } + if (this.nodes[rhsId] === void 0 && this.groups[rhsId] === void 0) { + throw new Error( + `The right-hand id [${rhsId}] does not yet exist. Please create the service/group before declaring an edge to it.` + ); + } + const lhsGroupId = this.nodes[lhsId].in; + const rhsGroupId = this.nodes[rhsId].in; + if (lhsGroup && lhsGroupId && rhsGroupId && lhsGroupId == rhsGroupId) { + throw new Error( + `The left-hand id [${lhsId}] is modified to traverse the group boundary, but the edge does not pass through two groups.` + ); + } + if (rhsGroup && lhsGroupId && rhsGroupId && lhsGroupId == rhsGroupId) { + throw new Error( + `The right-hand id [${rhsId}] is modified to traverse the group boundary, but the edge does not pass through two groups.` + ); + } + const edge = { + lhsId, + lhsDir, + lhsInto, + lhsGroup, + rhsId, + rhsDir, + rhsInto, + rhsGroup, + title: title2 + }; + this.edges.push(edge); + if (this.nodes[lhsId] && this.nodes[rhsId]) { + this.nodes[lhsId].edges.push(this.edges[this.edges.length - 1]); + this.nodes[rhsId].edges.push(this.edges[this.edges.length - 1]); + } + } + getEdges() { + return this.edges; + } + /** + * Returns the current diagram's adjacency list, spatial map, & group alignments. + * If they have not been created, run the algorithms to generate them. + * @returns + */ + getDataStructures() { + if (this.dataStructures === void 0) { + const groupAlignments = {}; + const adjList = Object.entries(this.nodes).reduce((prevOuter, [id30, service]) => { + prevOuter[id30] = service.edges.reduce((prevInner, edge) => { + const lhsGroupId = this.getNode(edge.lhsId)?.in; + const rhsGroupId = this.getNode(edge.rhsId)?.in; + if (lhsGroupId && rhsGroupId && lhsGroupId !== rhsGroupId) { + const alignment = getArchitectureDirectionAlignment(edge.lhsDir, edge.rhsDir); + if (alignment !== "bend") { + groupAlignments[lhsGroupId] ??= {}; + groupAlignments[lhsGroupId][rhsGroupId] = alignment; + groupAlignments[rhsGroupId] ??= {}; + groupAlignments[rhsGroupId][lhsGroupId] = alignment; + } + } + if (edge.lhsId === id30) { + const pair = getArchitectureDirectionPair(edge.lhsDir, edge.rhsDir); + if (pair) { + prevInner[pair] = edge.rhsId; + } + } else { + const pair = getArchitectureDirectionPair(edge.rhsDir, edge.lhsDir); + if (pair) { + prevInner[pair] = edge.lhsId; + } + } + return prevInner; + }, {}); + return prevOuter; + }, {}); + const firstId = Object.keys(adjList)[0]; + const visited = { [firstId]: 1 }; + const notVisited = Object.keys(adjList).reduce( + (prev2, id30) => id30 === firstId ? prev2 : { ...prev2, [id30]: 1 }, + {} + ); + const BFS = /* @__PURE__ */ __name((startingId) => { + const spatialMap = { [startingId]: [0, 0] }; + const queue = [startingId]; + while (queue.length > 0) { + const id30 = queue.shift(); + if (id30) { + visited[id30] = 1; + delete notVisited[id30]; + const adj = adjList[id30]; + const [posX, posY] = spatialMap[id30]; + Object.entries(adj).forEach(([dir2, rhsId]) => { + if (!visited[rhsId]) { + spatialMap[rhsId] = shiftPositionByArchitectureDirectionPair( + [posX, posY], + dir2 + ); + queue.push(rhsId); + } + }); + } + } + return spatialMap; + }, "BFS"); + const spatialMaps = [BFS(firstId)]; + while (Object.keys(notVisited).length > 0) { + spatialMaps.push(BFS(Object.keys(notVisited)[0])); + } + this.dataStructures = { + adjList, + spatialMaps, + groupAlignments + }; + } + return this.dataStructures; + } + setElementForId(id30, element3) { + this.elements[id30] = element3; + } + getElementById(id30) { + return this.elements[id30]; + } + getConfig() { + return cleanAndMerge({ + ...DEFAULT_ARCHITECTURE_CONFIG, + ...getConfig().architecture + }); + } + getConfigField(field) { + return this.getConfig()[field]; + } + }; + } + }); + + // src/diagrams/architecture/architectureParser.ts + var populateDb2, parser22; + var init_architectureParser = __esm({ + "src/diagrams/architecture/architectureParser.ts"() { + "use strict"; + init_mermaid_parser_core(); + init_logger(); + init_populateCommonDb(); + init_architectureDb(); + populateDb2 = /* @__PURE__ */ __name((ast, db7) => { + populateCommonDb(ast, db7); + ast.groups.map((group2) => db7.addGroup(group2)); + ast.services.map((service) => db7.addService({ ...service, type: "service" })); + ast.junctions.map((service) => db7.addJunction({ ...service, type: "junction" })); + ast.edges.map((edge) => db7.addEdge(edge)); + }, "populateDb"); + parser22 = { + parser: { + // @ts-expect-error - ArchitectureDB is not assignable to DiagramDB + yy: void 0 + }, + parse: /* @__PURE__ */ __name(async (input) => { + const ast = await parse3("architecture", input); + log.debug(ast); + const db7 = parser22.parser?.yy; + if (!(db7 instanceof ArchitectureDB)) { + throw new Error( + "parser.parser?.yy was not a ArchitectureDB. This is due to a bug within Mermaid, please report this issue at https://github.com/mermaid-js/mermaid/issues." + ); + } + populateDb2(ast, db7); + }, "parse") + }; + } + }); + + // src/diagrams/architecture/architectureStyles.ts + var getStyles18, architectureStyles_default; + var init_architectureStyles = __esm({ + "src/diagrams/architecture/architectureStyles.ts"() { + "use strict"; + getStyles18 = /* @__PURE__ */ __name((options2) => ` + .edge { + stroke-width: ${options2.archEdgeWidth}; + stroke: ${options2.archEdgeColor}; + fill: none; + } + + .arrow { + fill: ${options2.archEdgeArrowColor}; + } + + .node-bkg { + fill: none; + stroke: ${options2.archGroupBorderColor}; + stroke-width: ${options2.archGroupBorderWidth}; + stroke-dasharray: 8; + } + .node-icon-text { + display: flex; + align-items: center; + } + + .node-icon-text > div { + color: #fff; + margin: 1px; + height: fit-content; + text-align: center; + overflow: hidden; + display: -webkit-box; + -webkit-box-orient: vertical; + } +`, "getStyles"); + architectureStyles_default = getStyles18; + } + }); + + // ../../node_modules/.pnpm/layout-base@2.0.1/node_modules/layout-base/layout-base.js + var require_layout_base2 = __commonJS({ + "../../node_modules/.pnpm/layout-base@2.0.1/node_modules/layout-base/layout-base.js"(exports2, module2) { + "use strict"; + (/* @__PURE__ */ __name((function webpackUniversalModuleDefinition(root3, factory) { + if (typeof exports2 === "object" && typeof module2 === "object") + module2.exports = factory(); + else if (typeof define === "function" && define.amd) + define([], factory); + else if (typeof exports2 === "object") + exports2["layoutBase"] = factory(); + else + root3["layoutBase"] = factory(); + }), "webpackUniversalModuleDefinition"))(exports2, function() { + return ( + /******/ + (function(modules2) { + var installedModules = {}; + function __webpack_require__(moduleId) { + if (installedModules[moduleId]) { + return installedModules[moduleId].exports; + } + var module3 = installedModules[moduleId] = { + /******/ + i: moduleId, + /******/ + l: false, + /******/ + exports: {} + /******/ + }; + modules2[moduleId].call(module3.exports, module3, module3.exports, __webpack_require__); + module3.l = true; + return module3.exports; + } + __name(__webpack_require__, "__webpack_require__"); + __webpack_require__.m = modules2; + __webpack_require__.c = installedModules; + __webpack_require__.i = function(value2) { + return value2; + }; + __webpack_require__.d = function(exports3, name, getter) { + if (!__webpack_require__.o(exports3, name)) { + Object.defineProperty(exports3, name, { + /******/ + configurable: false, + /******/ + enumerable: true, + /******/ + get: getter + /******/ + }); + } + }; + __webpack_require__.n = function(module3) { + var getter = module3 && module3.__esModule ? ( + /******/ + /* @__PURE__ */ __name(function getDefault() { + return module3["default"]; + }, "getDefault") + ) : ( + /******/ + /* @__PURE__ */ __name(function getModuleExports() { + return module3; + }, "getModuleExports") + ); + __webpack_require__.d(getter, "a", getter); + return getter; + }; + __webpack_require__.o = function(object3, property2) { + return Object.prototype.hasOwnProperty.call(object3, property2); + }; + __webpack_require__.p = ""; + return __webpack_require__(__webpack_require__.s = 28); + })([ + /* 0 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function LayoutConstants() { + } + __name(LayoutConstants, "LayoutConstants"); + LayoutConstants.QUALITY = 1; + LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED = false; + LayoutConstants.DEFAULT_INCREMENTAL = false; + LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT = true; + LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT = false; + LayoutConstants.DEFAULT_ANIMATION_PERIOD = 50; + LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = false; + LayoutConstants.DEFAULT_GRAPH_MARGIN = 15; + LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = false; + LayoutConstants.SIMPLE_NODE_SIZE = 40; + LayoutConstants.SIMPLE_NODE_HALF_SIZE = LayoutConstants.SIMPLE_NODE_SIZE / 2; + LayoutConstants.EMPTY_COMPOUND_NODE_SIZE = 40; + LayoutConstants.MIN_EDGE_LENGTH = 1; + LayoutConstants.WORLD_BOUNDARY = 1e6; + LayoutConstants.INITIAL_WORLD_BOUNDARY = LayoutConstants.WORLD_BOUNDARY / 1e3; + LayoutConstants.WORLD_CENTER_X = 1200; + LayoutConstants.WORLD_CENTER_Y = 900; + module3.exports = LayoutConstants; + }), + /* 1 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LGraphObject = __webpack_require__(2); + var IGeometry = __webpack_require__(8); + var IMath = __webpack_require__(9); + function LEdge(source, target, vEdge) { + LGraphObject.call(this, vEdge); + this.isOverlapingSourceAndTarget = false; + this.vGraphObject = vEdge; + this.bendpoints = []; + this.source = source; + this.target = target; + } + __name(LEdge, "LEdge"); + LEdge.prototype = Object.create(LGraphObject.prototype); + for (var prop in LGraphObject) { + LEdge[prop] = LGraphObject[prop]; + } + LEdge.prototype.getSource = function() { + return this.source; + }; + LEdge.prototype.getTarget = function() { + return this.target; + }; + LEdge.prototype.isInterGraph = function() { + return this.isInterGraph; + }; + LEdge.prototype.getLength = function() { + return this.length; + }; + LEdge.prototype.isOverlapingSourceAndTarget = function() { + return this.isOverlapingSourceAndTarget; + }; + LEdge.prototype.getBendpoints = function() { + return this.bendpoints; + }; + LEdge.prototype.getLca = function() { + return this.lca; + }; + LEdge.prototype.getSourceInLca = function() { + return this.sourceInLca; + }; + LEdge.prototype.getTargetInLca = function() { + return this.targetInLca; + }; + LEdge.prototype.getOtherEnd = function(node2) { + if (this.source === node2) { + return this.target; + } else if (this.target === node2) { + return this.source; + } else { + throw "Node is not incident with this edge"; + } + }; + LEdge.prototype.getOtherEndInGraph = function(node2, graph) { + var otherEnd = this.getOtherEnd(node2); + var root3 = graph.getGraphManager().getRoot(); + while (true) { + if (otherEnd.getOwner() == graph) { + return otherEnd; + } + if (otherEnd.getOwner() == root3) { + break; + } + otherEnd = otherEnd.getOwner().getParent(); + } + return null; + }; + LEdge.prototype.updateLength = function() { + var clipPointCoordinates = new Array(4); + this.isOverlapingSourceAndTarget = IGeometry.getIntersection(this.target.getRect(), this.source.getRect(), clipPointCoordinates); + if (!this.isOverlapingSourceAndTarget) { + this.lengthX = clipPointCoordinates[0] - clipPointCoordinates[2]; + this.lengthY = clipPointCoordinates[1] - clipPointCoordinates[3]; + if (Math.abs(this.lengthX) < 1) { + this.lengthX = IMath.sign(this.lengthX); + } + if (Math.abs(this.lengthY) < 1) { + this.lengthY = IMath.sign(this.lengthY); + } + this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY); + } + }; + LEdge.prototype.updateLengthSimple = function() { + this.lengthX = this.target.getCenterX() - this.source.getCenterX(); + this.lengthY = this.target.getCenterY() - this.source.getCenterY(); + if (Math.abs(this.lengthX) < 1) { + this.lengthX = IMath.sign(this.lengthX); + } + if (Math.abs(this.lengthY) < 1) { + this.lengthY = IMath.sign(this.lengthY); + } + this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY); + }; + module3.exports = LEdge; + }), + /* 2 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function LGraphObject(vGraphObject) { + this.vGraphObject = vGraphObject; + } + __name(LGraphObject, "LGraphObject"); + module3.exports = LGraphObject; + }), + /* 3 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LGraphObject = __webpack_require__(2); + var Integer = __webpack_require__(10); + var RectangleD = __webpack_require__(13); + var LayoutConstants = __webpack_require__(0); + var RandomSeed = __webpack_require__(16); + var PointD = __webpack_require__(5); + function LNode(gm, loc, size4, vNode) { + if (size4 == null && vNode == null) { + vNode = loc; + } + LGraphObject.call(this, vNode); + if (gm.graphManager != null) gm = gm.graphManager; + this.estimatedSize = Integer.MIN_VALUE; + this.inclusionTreeDepth = Integer.MAX_VALUE; + this.vGraphObject = vNode; + this.edges = []; + this.graphManager = gm; + if (size4 != null && loc != null) this.rect = new RectangleD(loc.x, loc.y, size4.width, size4.height); + else this.rect = new RectangleD(); + } + __name(LNode, "LNode"); + LNode.prototype = Object.create(LGraphObject.prototype); + for (var prop in LGraphObject) { + LNode[prop] = LGraphObject[prop]; + } + LNode.prototype.getEdges = function() { + return this.edges; + }; + LNode.prototype.getChild = function() { + return this.child; + }; + LNode.prototype.getOwner = function() { + return this.owner; + }; + LNode.prototype.getWidth = function() { + return this.rect.width; + }; + LNode.prototype.setWidth = function(width3) { + this.rect.width = width3; + }; + LNode.prototype.getHeight = function() { + return this.rect.height; + }; + LNode.prototype.setHeight = function(height2) { + this.rect.height = height2; + }; + LNode.prototype.getCenterX = function() { + return this.rect.x + this.rect.width / 2; + }; + LNode.prototype.getCenterY = function() { + return this.rect.y + this.rect.height / 2; + }; + LNode.prototype.getCenter = function() { + return new PointD(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2); + }; + LNode.prototype.getLocation = function() { + return new PointD(this.rect.x, this.rect.y); + }; + LNode.prototype.getRect = function() { + return this.rect; + }; + LNode.prototype.getDiagonal = function() { + return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height); + }; + LNode.prototype.getHalfTheDiagonal = function() { + return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2; + }; + LNode.prototype.setRect = function(upperLeft, dimension) { + this.rect.x = upperLeft.x; + this.rect.y = upperLeft.y; + this.rect.width = dimension.width; + this.rect.height = dimension.height; + }; + LNode.prototype.setCenter = function(cx, cy) { + this.rect.x = cx - this.rect.width / 2; + this.rect.y = cy - this.rect.height / 2; + }; + LNode.prototype.setLocation = function(x5, y6) { + this.rect.x = x5; + this.rect.y = y6; + }; + LNode.prototype.moveBy = function(dx, dy) { + this.rect.x += dx; + this.rect.y += dy; + }; + LNode.prototype.getEdgeListToNode = function(to) { + var edgeList2 = []; + var edge; + var self2 = this; + self2.edges.forEach(function(edge2) { + if (edge2.target == to) { + if (edge2.source != self2) throw "Incorrect edge source!"; + edgeList2.push(edge2); + } + }); + return edgeList2; + }; + LNode.prototype.getEdgesBetween = function(other) { + var edgeList2 = []; + var edge; + var self2 = this; + self2.edges.forEach(function(edge2) { + if (!(edge2.source == self2 || edge2.target == self2)) throw "Incorrect edge source and/or target"; + if (edge2.target == other || edge2.source == other) { + edgeList2.push(edge2); + } + }); + return edgeList2; + }; + LNode.prototype.getNeighborsList = function() { + var neighbors = /* @__PURE__ */ new Set(); + var self2 = this; + self2.edges.forEach(function(edge) { + if (edge.source == self2) { + neighbors.add(edge.target); + } else { + if (edge.target != self2) { + throw "Incorrect incidency!"; + } + neighbors.add(edge.source); + } + }); + return neighbors; + }; + LNode.prototype.withChildren = function() { + var withNeighborsList = /* @__PURE__ */ new Set(); + var childNode; + var children2; + withNeighborsList.add(this); + if (this.child != null) { + var nodes5 = this.child.getNodes(); + for (var i2 = 0; i2 < nodes5.length; i2++) { + childNode = nodes5[i2]; + children2 = childNode.withChildren(); + children2.forEach(function(node2) { + withNeighborsList.add(node2); + }); + } + } + return withNeighborsList; + }; + LNode.prototype.getNoOfChildren = function() { + var noOfChildren = 0; + var childNode; + if (this.child == null) { + noOfChildren = 1; + } else { + var nodes5 = this.child.getNodes(); + for (var i2 = 0; i2 < nodes5.length; i2++) { + childNode = nodes5[i2]; + noOfChildren += childNode.getNoOfChildren(); + } + } + if (noOfChildren == 0) { + noOfChildren = 1; + } + return noOfChildren; + }; + LNode.prototype.getEstimatedSize = function() { + if (this.estimatedSize == Integer.MIN_VALUE) { + throw "assert failed"; + } + return this.estimatedSize; + }; + LNode.prototype.calcEstimatedSize = function() { + if (this.child == null) { + return this.estimatedSize = (this.rect.width + this.rect.height) / 2; + } else { + this.estimatedSize = this.child.calcEstimatedSize(); + this.rect.width = this.estimatedSize; + this.rect.height = this.estimatedSize; + return this.estimatedSize; + } + }; + LNode.prototype.scatter = function() { + var randomCenterX; + var randomCenterY; + var minX = -LayoutConstants.INITIAL_WORLD_BOUNDARY; + var maxX = LayoutConstants.INITIAL_WORLD_BOUNDARY; + randomCenterX = LayoutConstants.WORLD_CENTER_X + RandomSeed.nextDouble() * (maxX - minX) + minX; + var minY = -LayoutConstants.INITIAL_WORLD_BOUNDARY; + var maxY = LayoutConstants.INITIAL_WORLD_BOUNDARY; + randomCenterY = LayoutConstants.WORLD_CENTER_Y + RandomSeed.nextDouble() * (maxY - minY) + minY; + this.rect.x = randomCenterX; + this.rect.y = randomCenterY; + }; + LNode.prototype.updateBounds = function() { + if (this.getChild() == null) { + throw "assert failed"; + } + if (this.getChild().getNodes().length != 0) { + var childGraph = this.getChild(); + childGraph.updateBounds(true); + this.rect.x = childGraph.getLeft(); + this.rect.y = childGraph.getTop(); + this.setWidth(childGraph.getRight() - childGraph.getLeft()); + this.setHeight(childGraph.getBottom() - childGraph.getTop()); + if (LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS) { + var width3 = childGraph.getRight() - childGraph.getLeft(); + var height2 = childGraph.getBottom() - childGraph.getTop(); + if (this.labelWidth) { + if (this.labelPosHorizontal == "left") { + this.rect.x -= this.labelWidth; + this.setWidth(width3 + this.labelWidth); + } else if (this.labelPosHorizontal == "center" && this.labelWidth > width3) { + this.rect.x -= (this.labelWidth - width3) / 2; + this.setWidth(this.labelWidth); + } else if (this.labelPosHorizontal == "right") { + this.setWidth(width3 + this.labelWidth); + } + } + if (this.labelHeight) { + if (this.labelPosVertical == "top") { + this.rect.y -= this.labelHeight; + this.setHeight(height2 + this.labelHeight); + } else if (this.labelPosVertical == "center" && this.labelHeight > height2) { + this.rect.y -= (this.labelHeight - height2) / 2; + this.setHeight(this.labelHeight); + } else if (this.labelPosVertical == "bottom") { + this.setHeight(height2 + this.labelHeight); + } + } + } + } + }; + LNode.prototype.getInclusionTreeDepth = function() { + if (this.inclusionTreeDepth == Integer.MAX_VALUE) { + throw "assert failed"; + } + return this.inclusionTreeDepth; + }; + LNode.prototype.transform = function(trans) { + var left3 = this.rect.x; + if (left3 > LayoutConstants.WORLD_BOUNDARY) { + left3 = LayoutConstants.WORLD_BOUNDARY; + } else if (left3 < -LayoutConstants.WORLD_BOUNDARY) { + left3 = -LayoutConstants.WORLD_BOUNDARY; + } + var top2 = this.rect.y; + if (top2 > LayoutConstants.WORLD_BOUNDARY) { + top2 = LayoutConstants.WORLD_BOUNDARY; + } else if (top2 < -LayoutConstants.WORLD_BOUNDARY) { + top2 = -LayoutConstants.WORLD_BOUNDARY; + } + var leftTop = new PointD(left3, top2); + var vLeftTop = trans.inverseTransformPoint(leftTop); + this.setLocation(vLeftTop.x, vLeftTop.y); + }; + LNode.prototype.getLeft = function() { + return this.rect.x; + }; + LNode.prototype.getRight = function() { + return this.rect.x + this.rect.width; + }; + LNode.prototype.getTop = function() { + return this.rect.y; + }; + LNode.prototype.getBottom = function() { + return this.rect.y + this.rect.height; + }; + LNode.prototype.getParent = function() { + if (this.owner == null) { + return null; + } + return this.owner.getParent(); + }; + module3.exports = LNode; + }), + /* 4 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LayoutConstants = __webpack_require__(0); + function FDLayoutConstants() { + } + __name(FDLayoutConstants, "FDLayoutConstants"); + for (var prop in LayoutConstants) { + FDLayoutConstants[prop] = LayoutConstants[prop]; + } + FDLayoutConstants.MAX_ITERATIONS = 2500; + FDLayoutConstants.DEFAULT_EDGE_LENGTH = 50; + FDLayoutConstants.DEFAULT_SPRING_STRENGTH = 0.45; + FDLayoutConstants.DEFAULT_REPULSION_STRENGTH = 4500; + FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = 0.4; + FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1; + FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8; + FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5; + FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = true; + FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = true; + FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3; + FDLayoutConstants.COOLING_ADAPTATION_FACTOR = 0.33; + FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT = 1e3; + FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT = 5e3; + FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100; + FDLayoutConstants.MAX_NODE_DISPLACEMENT = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3; + FDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10; + FDLayoutConstants.CONVERGENCE_CHECK_PERIOD = 100; + FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1; + FDLayoutConstants.MIN_EDGE_LENGTH = 1; + FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD = 10; + module3.exports = FDLayoutConstants; + }), + /* 5 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function PointD(x5, y6) { + if (x5 == null && y6 == null) { + this.x = 0; + this.y = 0; + } else { + this.x = x5; + this.y = y6; + } + } + __name(PointD, "PointD"); + PointD.prototype.getX = function() { + return this.x; + }; + PointD.prototype.getY = function() { + return this.y; + }; + PointD.prototype.setX = function(x5) { + this.x = x5; + }; + PointD.prototype.setY = function(y6) { + this.y = y6; + }; + PointD.prototype.getDifference = function(pt) { + return new DimensionD(this.x - pt.x, this.y - pt.y); + }; + PointD.prototype.getCopy = function() { + return new PointD(this.x, this.y); + }; + PointD.prototype.translate = function(dim) { + this.x += dim.width; + this.y += dim.height; + return this; + }; + module3.exports = PointD; + }), + /* 6 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LGraphObject = __webpack_require__(2); + var Integer = __webpack_require__(10); + var LayoutConstants = __webpack_require__(0); + var LGraphManager = __webpack_require__(7); + var LNode = __webpack_require__(3); + var LEdge = __webpack_require__(1); + var RectangleD = __webpack_require__(13); + var Point3 = __webpack_require__(12); + var LinkedList = __webpack_require__(11); + function LGraph(parent4, obj2, vGraph) { + LGraphObject.call(this, vGraph); + this.estimatedSize = Integer.MIN_VALUE; + this.margin = LayoutConstants.DEFAULT_GRAPH_MARGIN; + this.edges = []; + this.nodes = []; + this.isConnected = false; + this.parent = parent4; + if (obj2 != null && obj2 instanceof LGraphManager) { + this.graphManager = obj2; + } else if (obj2 != null && obj2 instanceof Layout) { + this.graphManager = obj2.graphManager; + } + } + __name(LGraph, "LGraph"); + LGraph.prototype = Object.create(LGraphObject.prototype); + for (var prop in LGraphObject) { + LGraph[prop] = LGraphObject[prop]; + } + LGraph.prototype.getNodes = function() { + return this.nodes; + }; + LGraph.prototype.getEdges = function() { + return this.edges; + }; + LGraph.prototype.getGraphManager = function() { + return this.graphManager; + }; + LGraph.prototype.getParent = function() { + return this.parent; + }; + LGraph.prototype.getLeft = function() { + return this.left; + }; + LGraph.prototype.getRight = function() { + return this.right; + }; + LGraph.prototype.getTop = function() { + return this.top; + }; + LGraph.prototype.getBottom = function() { + return this.bottom; + }; + LGraph.prototype.isConnected = function() { + return this.isConnected; + }; + LGraph.prototype.add = function(obj1, sourceNode, targetNode) { + if (sourceNode == null && targetNode == null) { + var newNode = obj1; + if (this.graphManager == null) { + throw "Graph has no graph mgr!"; + } + if (this.getNodes().indexOf(newNode) > -1) { + throw "Node already in graph!"; + } + newNode.owner = this; + this.getNodes().push(newNode); + return newNode; + } else { + var newEdge = obj1; + if (!(this.getNodes().indexOf(sourceNode) > -1 && this.getNodes().indexOf(targetNode) > -1)) { + throw "Source or target not in graph!"; + } + if (!(sourceNode.owner == targetNode.owner && sourceNode.owner == this)) { + throw "Both owners must be this graph!"; + } + if (sourceNode.owner != targetNode.owner) { + return null; + } + newEdge.source = sourceNode; + newEdge.target = targetNode; + newEdge.isInterGraph = false; + this.getEdges().push(newEdge); + sourceNode.edges.push(newEdge); + if (targetNode != sourceNode) { + targetNode.edges.push(newEdge); + } + return newEdge; + } + }; + LGraph.prototype.remove = function(obj) { + var node2 = obj; + if (obj instanceof LNode) { + if (node2 == null) { + throw "Node is null!"; + } + if (!(node2.owner != null && node2.owner == this)) { + throw "Owner graph is invalid!"; + } + if (this.graphManager == null) { + throw "Owner graph manager is invalid!"; + } + var edgesToBeRemoved = node2.edges.slice(); + var edge; + var s2 = edgesToBeRemoved.length; + for (var i2 = 0; i2 < s2; i2++) { + edge = edgesToBeRemoved[i2]; + if (edge.isInterGraph) { + this.graphManager.remove(edge); + } else { + edge.source.owner.remove(edge); + } + } + var index = this.nodes.indexOf(node2); + if (index == -1) { + throw "Node not in owner node list!"; + } + this.nodes.splice(index, 1); + } else if (obj instanceof LEdge) { + var edge = obj; + if (edge == null) { + throw "Edge is null!"; + } + if (!(edge.source != null && edge.target != null)) { + throw "Source and/or target is null!"; + } + if (!(edge.source.owner != null && edge.target.owner != null && edge.source.owner == this && edge.target.owner == this)) { + throw "Source and/or target owner is invalid!"; + } + var sourceIndex = edge.source.edges.indexOf(edge); + var targetIndex = edge.target.edges.indexOf(edge); + if (!(sourceIndex > -1 && targetIndex > -1)) { + throw "Source and/or target doesn't know this edge!"; + } + edge.source.edges.splice(sourceIndex, 1); + if (edge.target != edge.source) { + edge.target.edges.splice(targetIndex, 1); + } + var index = edge.source.owner.getEdges().indexOf(edge); + if (index == -1) { + throw "Not in owner's edge list!"; + } + edge.source.owner.getEdges().splice(index, 1); + } + }; + LGraph.prototype.updateLeftTop = function() { + var top2 = Integer.MAX_VALUE; + var left3 = Integer.MAX_VALUE; + var nodeTop; + var nodeLeft; + var margin; + var nodes5 = this.getNodes(); + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + var lNode = nodes5[i2]; + nodeTop = lNode.getTop(); + nodeLeft = lNode.getLeft(); + if (top2 > nodeTop) { + top2 = nodeTop; + } + if (left3 > nodeLeft) { + left3 = nodeLeft; + } + } + if (top2 == Integer.MAX_VALUE) { + return null; + } + if (nodes5[0].getParent().paddingLeft != void 0) { + margin = nodes5[0].getParent().paddingLeft; + } else { + margin = this.margin; + } + this.left = left3 - margin; + this.top = top2 - margin; + return new Point3(this.left, this.top); + }; + LGraph.prototype.updateBounds = function(recursive) { + var left3 = Integer.MAX_VALUE; + var right3 = -Integer.MAX_VALUE; + var top2 = Integer.MAX_VALUE; + var bottom2 = -Integer.MAX_VALUE; + var nodeLeft; + var nodeRight; + var nodeTop; + var nodeBottom; + var margin; + var nodes5 = this.nodes; + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + var lNode = nodes5[i2]; + if (recursive && lNode.child != null) { + lNode.updateBounds(); + } + nodeLeft = lNode.getLeft(); + nodeRight = lNode.getRight(); + nodeTop = lNode.getTop(); + nodeBottom = lNode.getBottom(); + if (left3 > nodeLeft) { + left3 = nodeLeft; + } + if (right3 < nodeRight) { + right3 = nodeRight; + } + if (top2 > nodeTop) { + top2 = nodeTop; + } + if (bottom2 < nodeBottom) { + bottom2 = nodeBottom; + } + } + var boundingRect = new RectangleD(left3, top2, right3 - left3, bottom2 - top2); + if (left3 == Integer.MAX_VALUE) { + this.left = this.parent.getLeft(); + this.right = this.parent.getRight(); + this.top = this.parent.getTop(); + this.bottom = this.parent.getBottom(); + } + if (nodes5[0].getParent().paddingLeft != void 0) { + margin = nodes5[0].getParent().paddingLeft; + } else { + margin = this.margin; + } + this.left = boundingRect.x - margin; + this.right = boundingRect.x + boundingRect.width + margin; + this.top = boundingRect.y - margin; + this.bottom = boundingRect.y + boundingRect.height + margin; + }; + LGraph.calculateBounds = function(nodes5) { + var left3 = Integer.MAX_VALUE; + var right3 = -Integer.MAX_VALUE; + var top2 = Integer.MAX_VALUE; + var bottom2 = -Integer.MAX_VALUE; + var nodeLeft; + var nodeRight; + var nodeTop; + var nodeBottom; + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + var lNode = nodes5[i2]; + nodeLeft = lNode.getLeft(); + nodeRight = lNode.getRight(); + nodeTop = lNode.getTop(); + nodeBottom = lNode.getBottom(); + if (left3 > nodeLeft) { + left3 = nodeLeft; + } + if (right3 < nodeRight) { + right3 = nodeRight; + } + if (top2 > nodeTop) { + top2 = nodeTop; + } + if (bottom2 < nodeBottom) { + bottom2 = nodeBottom; + } + } + var boundingRect = new RectangleD(left3, top2, right3 - left3, bottom2 - top2); + return boundingRect; + }; + LGraph.prototype.getInclusionTreeDepth = function() { + if (this == this.graphManager.getRoot()) { + return 1; + } else { + return this.parent.getInclusionTreeDepth(); + } + }; + LGraph.prototype.getEstimatedSize = function() { + if (this.estimatedSize == Integer.MIN_VALUE) { + throw "assert failed"; + } + return this.estimatedSize; + }; + LGraph.prototype.calcEstimatedSize = function() { + var size4 = 0; + var nodes5 = this.nodes; + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + var lNode = nodes5[i2]; + size4 += lNode.calcEstimatedSize(); + } + if (size4 == 0) { + this.estimatedSize = LayoutConstants.EMPTY_COMPOUND_NODE_SIZE; + } else { + this.estimatedSize = size4 / Math.sqrt(this.nodes.length); + } + return this.estimatedSize; + }; + LGraph.prototype.updateConnected = function() { + var self2 = this; + if (this.nodes.length == 0) { + this.isConnected = true; + return; + } + var queue = new LinkedList(); + var visited = /* @__PURE__ */ new Set(); + var currentNode = this.nodes[0]; + var neighborEdges; + var currentNeighbor; + var childrenOfNode = currentNode.withChildren(); + childrenOfNode.forEach(function(node2) { + queue.push(node2); + visited.add(node2); + }); + while (queue.length !== 0) { + currentNode = queue.shift(); + neighborEdges = currentNode.getEdges(); + var size4 = neighborEdges.length; + for (var i2 = 0; i2 < size4; i2++) { + var neighborEdge = neighborEdges[i2]; + currentNeighbor = neighborEdge.getOtherEndInGraph(currentNode, this); + if (currentNeighbor != null && !visited.has(currentNeighbor)) { + var childrenOfNeighbor = currentNeighbor.withChildren(); + childrenOfNeighbor.forEach(function(node2) { + queue.push(node2); + visited.add(node2); + }); + } + } + } + this.isConnected = false; + if (visited.size >= this.nodes.length) { + var noOfVisitedInThisGraph = 0; + visited.forEach(function(visitedNode) { + if (visitedNode.owner == self2) { + noOfVisitedInThisGraph++; + } + }); + if (noOfVisitedInThisGraph == this.nodes.length) { + this.isConnected = true; + } + } + }; + module3.exports = LGraph; + }), + /* 7 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LGraph; + var LEdge = __webpack_require__(1); + function LGraphManager(layout6) { + LGraph = __webpack_require__(6); + this.layout = layout6; + this.graphs = []; + this.edges = []; + } + __name(LGraphManager, "LGraphManager"); + LGraphManager.prototype.addRoot = function() { + var ngraph = this.layout.newGraph(); + var nnode = this.layout.newNode(null); + var root3 = this.add(ngraph, nnode); + this.setRootGraph(root3); + return this.rootGraph; + }; + LGraphManager.prototype.add = function(newGraph, parentNode, newEdge, sourceNode, targetNode) { + if (newEdge == null && sourceNode == null && targetNode == null) { + if (newGraph == null) { + throw "Graph is null!"; + } + if (parentNode == null) { + throw "Parent node is null!"; + } + if (this.graphs.indexOf(newGraph) > -1) { + throw "Graph already in this graph mgr!"; + } + this.graphs.push(newGraph); + if (newGraph.parent != null) { + throw "Already has a parent!"; + } + if (parentNode.child != null) { + throw "Already has a child!"; + } + newGraph.parent = parentNode; + parentNode.child = newGraph; + return newGraph; + } else { + targetNode = newEdge; + sourceNode = parentNode; + newEdge = newGraph; + var sourceGraph = sourceNode.getOwner(); + var targetGraph = targetNode.getOwner(); + if (!(sourceGraph != null && sourceGraph.getGraphManager() == this)) { + throw "Source not in this graph mgr!"; + } + if (!(targetGraph != null && targetGraph.getGraphManager() == this)) { + throw "Target not in this graph mgr!"; + } + if (sourceGraph == targetGraph) { + newEdge.isInterGraph = false; + return sourceGraph.add(newEdge, sourceNode, targetNode); + } else { + newEdge.isInterGraph = true; + newEdge.source = sourceNode; + newEdge.target = targetNode; + if (this.edges.indexOf(newEdge) > -1) { + throw "Edge already in inter-graph edge list!"; + } + this.edges.push(newEdge); + if (!(newEdge.source != null && newEdge.target != null)) { + throw "Edge source and/or target is null!"; + } + if (!(newEdge.source.edges.indexOf(newEdge) == -1 && newEdge.target.edges.indexOf(newEdge) == -1)) { + throw "Edge already in source and/or target incidency list!"; + } + newEdge.source.edges.push(newEdge); + newEdge.target.edges.push(newEdge); + return newEdge; + } + } + }; + LGraphManager.prototype.remove = function(lObj) { + if (lObj instanceof LGraph) { + var graph = lObj; + if (graph.getGraphManager() != this) { + throw "Graph not in this graph mgr"; + } + if (!(graph == this.rootGraph || graph.parent != null && graph.parent.graphManager == this)) { + throw "Invalid parent node!"; + } + var edgesToBeRemoved = []; + edgesToBeRemoved = edgesToBeRemoved.concat(graph.getEdges()); + var edge; + var s2 = edgesToBeRemoved.length; + for (var i2 = 0; i2 < s2; i2++) { + edge = edgesToBeRemoved[i2]; + graph.remove(edge); + } + var nodesToBeRemoved = []; + nodesToBeRemoved = nodesToBeRemoved.concat(graph.getNodes()); + var node2; + s2 = nodesToBeRemoved.length; + for (var i2 = 0; i2 < s2; i2++) { + node2 = nodesToBeRemoved[i2]; + graph.remove(node2); + } + if (graph == this.rootGraph) { + this.setRootGraph(null); + } + var index = this.graphs.indexOf(graph); + this.graphs.splice(index, 1); + graph.parent = null; + } else if (lObj instanceof LEdge) { + edge = lObj; + if (edge == null) { + throw "Edge is null!"; + } + if (!edge.isInterGraph) { + throw "Not an inter-graph edge!"; + } + if (!(edge.source != null && edge.target != null)) { + throw "Source and/or target is null!"; + } + if (!(edge.source.edges.indexOf(edge) != -1 && edge.target.edges.indexOf(edge) != -1)) { + throw "Source and/or target doesn't know this edge!"; + } + var index = edge.source.edges.indexOf(edge); + edge.source.edges.splice(index, 1); + index = edge.target.edges.indexOf(edge); + edge.target.edges.splice(index, 1); + if (!(edge.source.owner != null && edge.source.owner.getGraphManager() != null)) { + throw "Edge owner graph or owner graph manager is null!"; + } + if (edge.source.owner.getGraphManager().edges.indexOf(edge) == -1) { + throw "Not in owner graph manager's edge list!"; + } + var index = edge.source.owner.getGraphManager().edges.indexOf(edge); + edge.source.owner.getGraphManager().edges.splice(index, 1); + } + }; + LGraphManager.prototype.updateBounds = function() { + this.rootGraph.updateBounds(true); + }; + LGraphManager.prototype.getGraphs = function() { + return this.graphs; + }; + LGraphManager.prototype.getAllNodes = function() { + if (this.allNodes == null) { + var nodeList = []; + var graphs = this.getGraphs(); + var s2 = graphs.length; + for (var i2 = 0; i2 < s2; i2++) { + nodeList = nodeList.concat(graphs[i2].getNodes()); + } + this.allNodes = nodeList; + } + return this.allNodes; + }; + LGraphManager.prototype.resetAllNodes = function() { + this.allNodes = null; + }; + LGraphManager.prototype.resetAllEdges = function() { + this.allEdges = null; + }; + LGraphManager.prototype.resetAllNodesToApplyGravitation = function() { + this.allNodesToApplyGravitation = null; + }; + LGraphManager.prototype.getAllEdges = function() { + if (this.allEdges == null) { + var edgeList2 = []; + var graphs = this.getGraphs(); + var s2 = graphs.length; + for (var i2 = 0; i2 < graphs.length; i2++) { + edgeList2 = edgeList2.concat(graphs[i2].getEdges()); + } + edgeList2 = edgeList2.concat(this.edges); + this.allEdges = edgeList2; + } + return this.allEdges; + }; + LGraphManager.prototype.getAllNodesToApplyGravitation = function() { + return this.allNodesToApplyGravitation; + }; + LGraphManager.prototype.setAllNodesToApplyGravitation = function(nodeList) { + if (this.allNodesToApplyGravitation != null) { + throw "assert failed"; + } + this.allNodesToApplyGravitation = nodeList; + }; + LGraphManager.prototype.getRoot = function() { + return this.rootGraph; + }; + LGraphManager.prototype.setRootGraph = function(graph) { + if (graph.getGraphManager() != this) { + throw "Root not in this graph mgr!"; + } + this.rootGraph = graph; + if (graph.parent == null) { + graph.parent = this.layout.newNode("Root node"); + } + }; + LGraphManager.prototype.getLayout = function() { + return this.layout; + }; + LGraphManager.prototype.isOneAncestorOfOther = function(firstNode, secondNode) { + if (!(firstNode != null && secondNode != null)) { + throw "assert failed"; + } + if (firstNode == secondNode) { + return true; + } + var ownerGraph = firstNode.getOwner(); + var parentNode; + do { + parentNode = ownerGraph.getParent(); + if (parentNode == null) { + break; + } + if (parentNode == secondNode) { + return true; + } + ownerGraph = parentNode.getOwner(); + if (ownerGraph == null) { + break; + } + } while (true); + ownerGraph = secondNode.getOwner(); + do { + parentNode = ownerGraph.getParent(); + if (parentNode == null) { + break; + } + if (parentNode == firstNode) { + return true; + } + ownerGraph = parentNode.getOwner(); + if (ownerGraph == null) { + break; + } + } while (true); + return false; + }; + LGraphManager.prototype.calcLowestCommonAncestors = function() { + var edge; + var sourceNode; + var targetNode; + var sourceAncestorGraph; + var targetAncestorGraph; + var edges3 = this.getAllEdges(); + var s2 = edges3.length; + for (var i2 = 0; i2 < s2; i2++) { + edge = edges3[i2]; + sourceNode = edge.source; + targetNode = edge.target; + edge.lca = null; + edge.sourceInLca = sourceNode; + edge.targetInLca = targetNode; + if (sourceNode == targetNode) { + edge.lca = sourceNode.getOwner(); + continue; + } + sourceAncestorGraph = sourceNode.getOwner(); + while (edge.lca == null) { + edge.targetInLca = targetNode; + targetAncestorGraph = targetNode.getOwner(); + while (edge.lca == null) { + if (targetAncestorGraph == sourceAncestorGraph) { + edge.lca = targetAncestorGraph; + break; + } + if (targetAncestorGraph == this.rootGraph) { + break; + } + if (edge.lca != null) { + throw "assert failed"; + } + edge.targetInLca = targetAncestorGraph.getParent(); + targetAncestorGraph = edge.targetInLca.getOwner(); + } + if (sourceAncestorGraph == this.rootGraph) { + break; + } + if (edge.lca == null) { + edge.sourceInLca = sourceAncestorGraph.getParent(); + sourceAncestorGraph = edge.sourceInLca.getOwner(); + } + } + if (edge.lca == null) { + throw "assert failed"; + } + } + }; + LGraphManager.prototype.calcLowestCommonAncestor = function(firstNode, secondNode) { + if (firstNode == secondNode) { + return firstNode.getOwner(); + } + var firstOwnerGraph = firstNode.getOwner(); + do { + if (firstOwnerGraph == null) { + break; + } + var secondOwnerGraph = secondNode.getOwner(); + do { + if (secondOwnerGraph == null) { + break; + } + if (secondOwnerGraph == firstOwnerGraph) { + return secondOwnerGraph; + } + secondOwnerGraph = secondOwnerGraph.getParent().getOwner(); + } while (true); + firstOwnerGraph = firstOwnerGraph.getParent().getOwner(); + } while (true); + return firstOwnerGraph; + }; + LGraphManager.prototype.calcInclusionTreeDepths = function(graph, depth) { + if (graph == null && depth == null) { + graph = this.rootGraph; + depth = 1; + } + var node2; + var nodes5 = graph.getNodes(); + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + node2 = nodes5[i2]; + node2.inclusionTreeDepth = depth; + if (node2.child != null) { + this.calcInclusionTreeDepths(node2.child, depth + 1); + } + } + }; + LGraphManager.prototype.includesInvalidEdge = function() { + var edge; + var edgesToRemove = []; + var s2 = this.edges.length; + for (var i2 = 0; i2 < s2; i2++) { + edge = this.edges[i2]; + if (this.isOneAncestorOfOther(edge.source, edge.target)) { + edgesToRemove.push(edge); + } + } + for (var i2 = 0; i2 < edgesToRemove.length; i2++) { + this.remove(edgesToRemove[i2]); + } + return false; + }; + module3.exports = LGraphManager; + }), + /* 8 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var Point3 = __webpack_require__(12); + function IGeometry() { + } + __name(IGeometry, "IGeometry"); + IGeometry.calcSeparationAmount = function(rectA, rectB, overlapAmount, separationBuffer) { + if (!rectA.intersects(rectB)) { + throw "assert failed"; + } + var directions = new Array(2); + this.decideDirectionsForOverlappingNodes(rectA, rectB, directions); + overlapAmount[0] = Math.min(rectA.getRight(), rectB.getRight()) - Math.max(rectA.x, rectB.x); + overlapAmount[1] = Math.min(rectA.getBottom(), rectB.getBottom()) - Math.max(rectA.y, rectB.y); + if (rectA.getX() <= rectB.getX() && rectA.getRight() >= rectB.getRight()) { + overlapAmount[0] += Math.min(rectB.getX() - rectA.getX(), rectA.getRight() - rectB.getRight()); + } else if (rectB.getX() <= rectA.getX() && rectB.getRight() >= rectA.getRight()) { + overlapAmount[0] += Math.min(rectA.getX() - rectB.getX(), rectB.getRight() - rectA.getRight()); + } + if (rectA.getY() <= rectB.getY() && rectA.getBottom() >= rectB.getBottom()) { + overlapAmount[1] += Math.min(rectB.getY() - rectA.getY(), rectA.getBottom() - rectB.getBottom()); + } else if (rectB.getY() <= rectA.getY() && rectB.getBottom() >= rectA.getBottom()) { + overlapAmount[1] += Math.min(rectA.getY() - rectB.getY(), rectB.getBottom() - rectA.getBottom()); + } + var slope = Math.abs((rectB.getCenterY() - rectA.getCenterY()) / (rectB.getCenterX() - rectA.getCenterX())); + if (rectB.getCenterY() === rectA.getCenterY() && rectB.getCenterX() === rectA.getCenterX()) { + slope = 1; + } + var moveByY = slope * overlapAmount[0]; + var moveByX = overlapAmount[1] / slope; + if (overlapAmount[0] < moveByX) { + moveByX = overlapAmount[0]; + } else { + moveByY = overlapAmount[1]; + } + overlapAmount[0] = -1 * directions[0] * (moveByX / 2 + separationBuffer); + overlapAmount[1] = -1 * directions[1] * (moveByY / 2 + separationBuffer); + }; + IGeometry.decideDirectionsForOverlappingNodes = function(rectA, rectB, directions) { + if (rectA.getCenterX() < rectB.getCenterX()) { + directions[0] = -1; + } else { + directions[0] = 1; + } + if (rectA.getCenterY() < rectB.getCenterY()) { + directions[1] = -1; + } else { + directions[1] = 1; + } + }; + IGeometry.getIntersection2 = function(rectA, rectB, result) { + var p1x = rectA.getCenterX(); + var p1y = rectA.getCenterY(); + var p2x = rectB.getCenterX(); + var p2y = rectB.getCenterY(); + if (rectA.intersects(rectB)) { + result[0] = p1x; + result[1] = p1y; + result[2] = p2x; + result[3] = p2y; + return true; + } + var topLeftAx = rectA.getX(); + var topLeftAy = rectA.getY(); + var topRightAx = rectA.getRight(); + var bottomLeftAx = rectA.getX(); + var bottomLeftAy = rectA.getBottom(); + var bottomRightAx = rectA.getRight(); + var halfWidthA = rectA.getWidthHalf(); + var halfHeightA = rectA.getHeightHalf(); + var topLeftBx = rectB.getX(); + var topLeftBy = rectB.getY(); + var topRightBx = rectB.getRight(); + var bottomLeftBx = rectB.getX(); + var bottomLeftBy = rectB.getBottom(); + var bottomRightBx = rectB.getRight(); + var halfWidthB = rectB.getWidthHalf(); + var halfHeightB = rectB.getHeightHalf(); + var clipPointAFound = false; + var clipPointBFound = false; + if (p1x === p2x) { + if (p1y > p2y) { + result[0] = p1x; + result[1] = topLeftAy; + result[2] = p2x; + result[3] = bottomLeftBy; + return false; + } else if (p1y < p2y) { + result[0] = p1x; + result[1] = bottomLeftAy; + result[2] = p2x; + result[3] = topLeftBy; + return false; + } else { + } + } else if (p1y === p2y) { + if (p1x > p2x) { + result[0] = topLeftAx; + result[1] = p1y; + result[2] = topRightBx; + result[3] = p2y; + return false; + } else if (p1x < p2x) { + result[0] = topRightAx; + result[1] = p1y; + result[2] = topLeftBx; + result[3] = p2y; + return false; + } else { + } + } else { + var slopeA = rectA.height / rectA.width; + var slopeB = rectB.height / rectB.width; + var slopePrime = (p2y - p1y) / (p2x - p1x); + var cardinalDirectionA = void 0; + var cardinalDirectionB = void 0; + var tempPointAx = void 0; + var tempPointAy = void 0; + var tempPointBx = void 0; + var tempPointBy = void 0; + if (-slopeA === slopePrime) { + if (p1x > p2x) { + result[0] = bottomLeftAx; + result[1] = bottomLeftAy; + clipPointAFound = true; + } else { + result[0] = topRightAx; + result[1] = topLeftAy; + clipPointAFound = true; + } + } else if (slopeA === slopePrime) { + if (p1x > p2x) { + result[0] = topLeftAx; + result[1] = topLeftAy; + clipPointAFound = true; + } else { + result[0] = bottomRightAx; + result[1] = bottomLeftAy; + clipPointAFound = true; + } + } + if (-slopeB === slopePrime) { + if (p2x > p1x) { + result[2] = bottomLeftBx; + result[3] = bottomLeftBy; + clipPointBFound = true; + } else { + result[2] = topRightBx; + result[3] = topLeftBy; + clipPointBFound = true; + } + } else if (slopeB === slopePrime) { + if (p2x > p1x) { + result[2] = topLeftBx; + result[3] = topLeftBy; + clipPointBFound = true; + } else { + result[2] = bottomRightBx; + result[3] = bottomLeftBy; + clipPointBFound = true; + } + } + if (clipPointAFound && clipPointBFound) { + return false; + } + if (p1x > p2x) { + if (p1y > p2y) { + cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 4); + cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 2); + } else { + cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 3); + cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 1); + } + } else { + if (p1y > p2y) { + cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 1); + cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 3); + } else { + cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 2); + cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 4); + } + } + if (!clipPointAFound) { + switch (cardinalDirectionA) { + case 1: + tempPointAy = topLeftAy; + tempPointAx = p1x + -halfHeightA / slopePrime; + result[0] = tempPointAx; + result[1] = tempPointAy; + break; + case 2: + tempPointAx = bottomRightAx; + tempPointAy = p1y + halfWidthA * slopePrime; + result[0] = tempPointAx; + result[1] = tempPointAy; + break; + case 3: + tempPointAy = bottomLeftAy; + tempPointAx = p1x + halfHeightA / slopePrime; + result[0] = tempPointAx; + result[1] = tempPointAy; + break; + case 4: + tempPointAx = bottomLeftAx; + tempPointAy = p1y + -halfWidthA * slopePrime; + result[0] = tempPointAx; + result[1] = tempPointAy; + break; + } + } + if (!clipPointBFound) { + switch (cardinalDirectionB) { + case 1: + tempPointBy = topLeftBy; + tempPointBx = p2x + -halfHeightB / slopePrime; + result[2] = tempPointBx; + result[3] = tempPointBy; + break; + case 2: + tempPointBx = bottomRightBx; + tempPointBy = p2y + halfWidthB * slopePrime; + result[2] = tempPointBx; + result[3] = tempPointBy; + break; + case 3: + tempPointBy = bottomLeftBy; + tempPointBx = p2x + halfHeightB / slopePrime; + result[2] = tempPointBx; + result[3] = tempPointBy; + break; + case 4: + tempPointBx = bottomLeftBx; + tempPointBy = p2y + -halfWidthB * slopePrime; + result[2] = tempPointBx; + result[3] = tempPointBy; + break; + } + } + } + return false; + }; + IGeometry.getCardinalDirection = function(slope, slopePrime, line2) { + if (slope > slopePrime) { + return line2; + } else { + return 1 + line2 % 4; + } + }; + IGeometry.getIntersection = function(s1, s2, f1, f2) { + if (f2 == null) { + return this.getIntersection2(s1, s2, f1); + } + var x1 = s1.x; + var y1 = s1.y; + var x22 = s2.x; + var y22 = s2.y; + var x32 = f1.x; + var y32 = f1.y; + var x42 = f2.x; + var y42 = f2.y; + var x5 = void 0, y6 = void 0; + var a1 = void 0, a2 = void 0, b1 = void 0, b22 = void 0, c1 = void 0, c22 = void 0; + var denom = void 0; + a1 = y22 - y1; + b1 = x1 - x22; + c1 = x22 * y1 - x1 * y22; + a2 = y42 - y32; + b22 = x32 - x42; + c22 = x42 * y32 - x32 * y42; + denom = a1 * b22 - a2 * b1; + if (denom === 0) { + return null; + } + x5 = (b1 * c22 - b22 * c1) / denom; + y6 = (a2 * c1 - a1 * c22) / denom; + return new Point3(x5, y6); + }; + IGeometry.angleOfVector = function(Cx, Cy, Nx, Ny) { + var C_angle = void 0; + if (Cx !== Nx) { + C_angle = Math.atan((Ny - Cy) / (Nx - Cx)); + if (Nx < Cx) { + C_angle += Math.PI; + } else if (Ny < Cy) { + C_angle += this.TWO_PI; + } + } else if (Ny < Cy) { + C_angle = this.ONE_AND_HALF_PI; + } else { + C_angle = this.HALF_PI; + } + return C_angle; + }; + IGeometry.doIntersect = function(p1, p22, p3, p4) { + var a2 = p1.x; + var b3 = p1.y; + var c3 = p22.x; + var d3 = p22.y; + var p5 = p3.x; + var q3 = p3.y; + var r2 = p4.x; + var s2 = p4.y; + var det = (c3 - a2) * (s2 - q3) - (r2 - p5) * (d3 - b3); + if (det === 0) { + return false; + } else { + var lambda = ((s2 - q3) * (r2 - a2) + (p5 - r2) * (s2 - b3)) / det; + var gamma2 = ((b3 - d3) * (r2 - a2) + (c3 - a2) * (s2 - b3)) / det; + return 0 < lambda && lambda < 1 && 0 < gamma2 && gamma2 < 1; + } + }; + IGeometry.findCircleLineIntersections = function(Ex, Ey, Lx, Ly, Cx, Cy, r2) { + var a2 = (Lx - Ex) * (Lx - Ex) + (Ly - Ey) * (Ly - Ey); + var b3 = 2 * ((Ex - Cx) * (Lx - Ex) + (Ey - Cy) * (Ly - Ey)); + var c3 = (Ex - Cx) * (Ex - Cx) + (Ey - Cy) * (Ey - Cy) - r2 * r2; + var disc = b3 * b3 - 4 * a2 * c3; + if (disc >= 0) { + var t13 = (-b3 + Math.sqrt(b3 * b3 - 4 * a2 * c3)) / (2 * a2); + var t22 = (-b3 - Math.sqrt(b3 * b3 - 4 * a2 * c3)) / (2 * a2); + var intersections = null; + if (t13 >= 0 && t13 <= 1) { + return [t13]; + } + if (t22 >= 0 && t22 <= 1) { + return [t22]; + } + return intersections; + } else return null; + }; + IGeometry.HALF_PI = 0.5 * Math.PI; + IGeometry.ONE_AND_HALF_PI = 1.5 * Math.PI; + IGeometry.TWO_PI = 2 * Math.PI; + IGeometry.THREE_PI = 3 * Math.PI; + module3.exports = IGeometry; + }), + /* 9 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function IMath() { + } + __name(IMath, "IMath"); + IMath.sign = function(value2) { + if (value2 > 0) { + return 1; + } else if (value2 < 0) { + return -1; + } else { + return 0; + } + }; + IMath.floor = function(value2) { + return value2 < 0 ? Math.ceil(value2) : Math.floor(value2); + }; + IMath.ceil = function(value2) { + return value2 < 0 ? Math.floor(value2) : Math.ceil(value2); + }; + module3.exports = IMath; + }), + /* 10 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function Integer() { + } + __name(Integer, "Integer"); + Integer.MAX_VALUE = 2147483647; + Integer.MIN_VALUE = -2147483648; + module3.exports = Integer; + }), + /* 11 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var _createClass2 = /* @__PURE__ */ (function() { + function defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + __name(defineProperties, "defineProperties"); + return function(Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + })(); + function _classCallCheck2(instance2, Constructor) { + if (!(instance2 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + __name(_classCallCheck2, "_classCallCheck"); + var nodeFrom = /* @__PURE__ */ __name(function nodeFrom2(value2) { + return { value: value2, next: null, prev: null }; + }, "nodeFrom"); + var add3 = /* @__PURE__ */ __name(function add4(prev2, node2, next3, list) { + if (prev2 !== null) { + prev2.next = node2; + } else { + list.head = node2; + } + if (next3 !== null) { + next3.prev = node2; + } else { + list.tail = node2; + } + node2.prev = prev2; + node2.next = next3; + list.length++; + return node2; + }, "add"); + var _remove = /* @__PURE__ */ __name(function _remove2(node2, list) { + var prev2 = node2.prev, next3 = node2.next; + if (prev2 !== null) { + prev2.next = next3; + } else { + list.head = next3; + } + if (next3 !== null) { + next3.prev = prev2; + } else { + list.tail = prev2; + } + node2.prev = node2.next = null; + list.length--; + return node2; + }, "_remove"); + var LinkedList = (function() { + function LinkedList2(vals) { + var _this = this; + _classCallCheck2(this, LinkedList2); + this.length = 0; + this.head = null; + this.tail = null; + if (vals != null) { + vals.forEach(function(v3) { + return _this.push(v3); + }); + } + } + __name(LinkedList2, "LinkedList"); + _createClass2(LinkedList2, [{ + key: "size", + value: /* @__PURE__ */ __name(function size4() { + return this.length; + }, "size") + }, { + key: "insertBefore", + value: /* @__PURE__ */ __name(function insertBefore(val, otherNode) { + return add3(otherNode.prev, nodeFrom(val), otherNode, this); + }, "insertBefore") + }, { + key: "insertAfter", + value: /* @__PURE__ */ __name(function insertAfter(val, otherNode) { + return add3(otherNode, nodeFrom(val), otherNode.next, this); + }, "insertAfter") + }, { + key: "insertNodeBefore", + value: /* @__PURE__ */ __name(function insertNodeBefore(newNode, otherNode) { + return add3(otherNode.prev, newNode, otherNode, this); + }, "insertNodeBefore") + }, { + key: "insertNodeAfter", + value: /* @__PURE__ */ __name(function insertNodeAfter(newNode, otherNode) { + return add3(otherNode, newNode, otherNode.next, this); + }, "insertNodeAfter") + }, { + key: "push", + value: /* @__PURE__ */ __name(function push3(val) { + return add3(this.tail, nodeFrom(val), null, this); + }, "push") + }, { + key: "unshift", + value: /* @__PURE__ */ __name(function unshift(val) { + return add3(null, nodeFrom(val), this.head, this); + }, "unshift") + }, { + key: "remove", + value: /* @__PURE__ */ __name(function remove3(node2) { + return _remove(node2, this); + }, "remove") + }, { + key: "pop", + value: /* @__PURE__ */ __name(function pop() { + return _remove(this.tail, this).value; + }, "pop") + }, { + key: "popNode", + value: /* @__PURE__ */ __name(function popNode() { + return _remove(this.tail, this); + }, "popNode") + }, { + key: "shift", + value: /* @__PURE__ */ __name(function shift2() { + return _remove(this.head, this).value; + }, "shift") + }, { + key: "shiftNode", + value: /* @__PURE__ */ __name(function shiftNode() { + return _remove(this.head, this); + }, "shiftNode") + }, { + key: "get_object_at", + value: /* @__PURE__ */ __name(function get_object_at(index) { + if (index <= this.length()) { + var i2 = 1; + var current = this.head; + while (i2 < index) { + current = current.next; + i2++; + } + return current.value; + } + }, "get_object_at") + }, { + key: "set_object_at", + value: /* @__PURE__ */ __name(function set_object_at(index, value2) { + if (index <= this.length()) { + var i2 = 1; + var current = this.head; + while (i2 < index) { + current = current.next; + i2++; + } + current.value = value2; + } + }, "set_object_at") + }]); + return LinkedList2; + })(); + module3.exports = LinkedList; + }), + /* 12 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function Point3(x5, y6, p3) { + this.x = null; + this.y = null; + if (x5 == null && y6 == null && p3 == null) { + this.x = 0; + this.y = 0; + } else if (typeof x5 == "number" && typeof y6 == "number" && p3 == null) { + this.x = x5; + this.y = y6; + } else if (x5.constructor.name == "Point" && y6 == null && p3 == null) { + p3 = x5; + this.x = p3.x; + this.y = p3.y; + } + } + __name(Point3, "Point"); + Point3.prototype.getX = function() { + return this.x; + }; + Point3.prototype.getY = function() { + return this.y; + }; + Point3.prototype.getLocation = function() { + return new Point3(this.x, this.y); + }; + Point3.prototype.setLocation = function(x5, y6, p3) { + if (x5.constructor.name == "Point" && y6 == null && p3 == null) { + p3 = x5; + this.setLocation(p3.x, p3.y); + } else if (typeof x5 == "number" && typeof y6 == "number" && p3 == null) { + if (parseInt(x5) == x5 && parseInt(y6) == y6) { + this.move(x5, y6); + } else { + this.x = Math.floor(x5 + 0.5); + this.y = Math.floor(y6 + 0.5); + } + } + }; + Point3.prototype.move = function(x5, y6) { + this.x = x5; + this.y = y6; + }; + Point3.prototype.translate = function(dx, dy) { + this.x += dx; + this.y += dy; + }; + Point3.prototype.equals = function(obj) { + if (obj.constructor.name == "Point") { + var pt = obj; + return this.x == pt.x && this.y == pt.y; + } + return this == obj; + }; + Point3.prototype.toString = function() { + return new Point3().constructor.name + "[x=" + this.x + ",y=" + this.y + "]"; + }; + module3.exports = Point3; + }), + /* 13 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function RectangleD(x5, y6, width3, height2) { + this.x = 0; + this.y = 0; + this.width = 0; + this.height = 0; + if (x5 != null && y6 != null && width3 != null && height2 != null) { + this.x = x5; + this.y = y6; + this.width = width3; + this.height = height2; + } + } + __name(RectangleD, "RectangleD"); + RectangleD.prototype.getX = function() { + return this.x; + }; + RectangleD.prototype.setX = function(x5) { + this.x = x5; + }; + RectangleD.prototype.getY = function() { + return this.y; + }; + RectangleD.prototype.setY = function(y6) { + this.y = y6; + }; + RectangleD.prototype.getWidth = function() { + return this.width; + }; + RectangleD.prototype.setWidth = function(width3) { + this.width = width3; + }; + RectangleD.prototype.getHeight = function() { + return this.height; + }; + RectangleD.prototype.setHeight = function(height2) { + this.height = height2; + }; + RectangleD.prototype.getRight = function() { + return this.x + this.width; + }; + RectangleD.prototype.getBottom = function() { + return this.y + this.height; + }; + RectangleD.prototype.intersects = function(a2) { + if (this.getRight() < a2.x) { + return false; + } + if (this.getBottom() < a2.y) { + return false; + } + if (a2.getRight() < this.x) { + return false; + } + if (a2.getBottom() < this.y) { + return false; + } + return true; + }; + RectangleD.prototype.getCenterX = function() { + return this.x + this.width / 2; + }; + RectangleD.prototype.getMinX = function() { + return this.getX(); + }; + RectangleD.prototype.getMaxX = function() { + return this.getX() + this.width; + }; + RectangleD.prototype.getCenterY = function() { + return this.y + this.height / 2; + }; + RectangleD.prototype.getMinY = function() { + return this.getY(); + }; + RectangleD.prototype.getMaxY = function() { + return this.getY() + this.height; + }; + RectangleD.prototype.getWidthHalf = function() { + return this.width / 2; + }; + RectangleD.prototype.getHeightHalf = function() { + return this.height / 2; + }; + module3.exports = RectangleD; + }), + /* 14 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var _typeof2 = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) { + return typeof obj; + } : function(obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + function UniqueIDGeneretor() { + } + __name(UniqueIDGeneretor, "UniqueIDGeneretor"); + UniqueIDGeneretor.lastID = 0; + UniqueIDGeneretor.createID = function(obj) { + if (UniqueIDGeneretor.isPrimitive(obj)) { + return obj; + } + if (obj.uniqueID != null) { + return obj.uniqueID; + } + obj.uniqueID = UniqueIDGeneretor.getString(); + UniqueIDGeneretor.lastID++; + return obj.uniqueID; + }; + UniqueIDGeneretor.getString = function(id30) { + if (id30 == null) id30 = UniqueIDGeneretor.lastID; + return "Object#" + id30; + }; + UniqueIDGeneretor.isPrimitive = function(arg) { + var type3 = typeof arg === "undefined" ? "undefined" : _typeof2(arg); + return arg == null || type3 != "object" && type3 != "function"; + }; + module3.exports = UniqueIDGeneretor; + }), + /* 15 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function _toConsumableArray2(arr) { + if (Array.isArray(arr)) { + for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++) { + arr2[i2] = arr[i2]; + } + return arr2; + } else { + return Array.from(arr); + } + } + __name(_toConsumableArray2, "_toConsumableArray"); + var LayoutConstants = __webpack_require__(0); + var LGraphManager = __webpack_require__(7); + var LNode = __webpack_require__(3); + var LEdge = __webpack_require__(1); + var LGraph = __webpack_require__(6); + var PointD = __webpack_require__(5); + var Transform2 = __webpack_require__(17); + var Emitter4 = __webpack_require__(29); + function Layout2(isRemoteUse) { + Emitter4.call(this); + this.layoutQuality = LayoutConstants.QUALITY; + this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED; + this.incremental = LayoutConstants.DEFAULT_INCREMENTAL; + this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT; + this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT; + this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD; + this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES; + this.edgeToDummyNodes = /* @__PURE__ */ new Map(); + this.graphManager = new LGraphManager(this); + this.isLayoutFinished = false; + this.isSubLayout = false; + this.isRemoteUse = false; + if (isRemoteUse != null) { + this.isRemoteUse = isRemoteUse; + } + } + __name(Layout2, "Layout"); + Layout2.RANDOM_SEED = 1; + Layout2.prototype = Object.create(Emitter4.prototype); + Layout2.prototype.getGraphManager = function() { + return this.graphManager; + }; + Layout2.prototype.getAllNodes = function() { + return this.graphManager.getAllNodes(); + }; + Layout2.prototype.getAllEdges = function() { + return this.graphManager.getAllEdges(); + }; + Layout2.prototype.getAllNodesToApplyGravitation = function() { + return this.graphManager.getAllNodesToApplyGravitation(); + }; + Layout2.prototype.newGraphManager = function() { + var gm = new LGraphManager(this); + this.graphManager = gm; + return gm; + }; + Layout2.prototype.newGraph = function(vGraph) { + return new LGraph(null, this.graphManager, vGraph); + }; + Layout2.prototype.newNode = function(vNode) { + return new LNode(this.graphManager, vNode); + }; + Layout2.prototype.newEdge = function(vEdge) { + return new LEdge(null, null, vEdge); + }; + Layout2.prototype.checkLayoutSuccess = function() { + return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge(); + }; + Layout2.prototype.runLayout = function() { + this.isLayoutFinished = false; + if (this.tilingPreLayout) { + this.tilingPreLayout(); + } + this.initParameters(); + var isLayoutSuccessfull; + if (this.checkLayoutSuccess()) { + isLayoutSuccessfull = false; + } else { + isLayoutSuccessfull = this.layout(); + } + if (LayoutConstants.ANIMATE === "during") { + return false; + } + if (isLayoutSuccessfull) { + if (!this.isSubLayout) { + this.doPostLayout(); + } + } + if (this.tilingPostLayout) { + this.tilingPostLayout(); + } + this.isLayoutFinished = true; + return isLayoutSuccessfull; + }; + Layout2.prototype.doPostLayout = function() { + if (!this.incremental) { + this.transform(); + } + this.update(); + }; + Layout2.prototype.update2 = function() { + if (this.createBendsAsNeeded) { + this.createBendpointsFromDummyNodes(); + this.graphManager.resetAllEdges(); + } + if (!this.isRemoteUse) { + var edge; + var allEdges = this.graphManager.getAllEdges(); + for (var i2 = 0; i2 < allEdges.length; i2++) { + edge = allEdges[i2]; + } + var node2; + var nodes5 = this.graphManager.getRoot().getNodes(); + for (var i2 = 0; i2 < nodes5.length; i2++) { + node2 = nodes5[i2]; + } + this.update(this.graphManager.getRoot()); + } + }; + Layout2.prototype.update = function(obj) { + if (obj == null) { + this.update2(); + } else if (obj instanceof LNode) { + var node2 = obj; + if (node2.getChild() != null) { + var nodes5 = node2.getChild().getNodes(); + for (var i2 = 0; i2 < nodes5.length; i2++) { + update(nodes5[i2]); + } + } + if (node2.vGraphObject != null) { + var vNode = node2.vGraphObject; + vNode.update(node2); + } + } else if (obj instanceof LEdge) { + var edge = obj; + if (edge.vGraphObject != null) { + var vEdge = edge.vGraphObject; + vEdge.update(edge); + } + } else if (obj instanceof LGraph) { + var graph = obj; + if (graph.vGraphObject != null) { + var vGraph = graph.vGraphObject; + vGraph.update(graph); + } + } + }; + Layout2.prototype.initParameters = function() { + if (!this.isSubLayout) { + this.layoutQuality = LayoutConstants.QUALITY; + this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT; + this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD; + this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT; + this.incremental = LayoutConstants.DEFAULT_INCREMENTAL; + this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED; + this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES; + } + if (this.animationDuringLayout) { + this.animationOnLayout = false; + } + }; + Layout2.prototype.transform = function(newLeftTop) { + if (newLeftTop == void 0) { + this.transform(new PointD(0, 0)); + } else { + var trans = new Transform2(); + var leftTop = this.graphManager.getRoot().updateLeftTop(); + if (leftTop != null) { + trans.setWorldOrgX(newLeftTop.x); + trans.setWorldOrgY(newLeftTop.y); + trans.setDeviceOrgX(leftTop.x); + trans.setDeviceOrgY(leftTop.y); + var nodes5 = this.getAllNodes(); + var node2; + for (var i2 = 0; i2 < nodes5.length; i2++) { + node2 = nodes5[i2]; + node2.transform(trans); + } + } + } + }; + Layout2.prototype.positionNodesRandomly = function(graph) { + if (graph == void 0) { + this.positionNodesRandomly(this.getGraphManager().getRoot()); + this.getGraphManager().getRoot().updateBounds(true); + } else { + var lNode; + var childGraph; + var nodes5 = graph.getNodes(); + for (var i2 = 0; i2 < nodes5.length; i2++) { + lNode = nodes5[i2]; + childGraph = lNode.getChild(); + if (childGraph == null) { + lNode.scatter(); + } else if (childGraph.getNodes().length == 0) { + lNode.scatter(); + } else { + this.positionNodesRandomly(childGraph); + lNode.updateBounds(); + } + } + } + }; + Layout2.prototype.getFlatForest = function() { + var flatForest = []; + var isForest = true; + var allNodes = this.graphManager.getRoot().getNodes(); + var isFlat = true; + for (var i2 = 0; i2 < allNodes.length; i2++) { + if (allNodes[i2].getChild() != null) { + isFlat = false; + } + } + if (!isFlat) { + return flatForest; + } + var visited = /* @__PURE__ */ new Set(); + var toBeVisited = []; + var parents3 = /* @__PURE__ */ new Map(); + var unProcessedNodes = []; + unProcessedNodes = unProcessedNodes.concat(allNodes); + while (unProcessedNodes.length > 0 && isForest) { + toBeVisited.push(unProcessedNodes[0]); + while (toBeVisited.length > 0 && isForest) { + var currentNode = toBeVisited[0]; + toBeVisited.splice(0, 1); + visited.add(currentNode); + var neighborEdges = currentNode.getEdges(); + for (var i2 = 0; i2 < neighborEdges.length; i2++) { + var currentNeighbor = neighborEdges[i2].getOtherEnd(currentNode); + if (parents3.get(currentNode) != currentNeighbor) { + if (!visited.has(currentNeighbor)) { + toBeVisited.push(currentNeighbor); + parents3.set(currentNeighbor, currentNode); + } else { + isForest = false; + break; + } + } + } + } + if (!isForest) { + flatForest = []; + } else { + var temp = [].concat(_toConsumableArray2(visited)); + flatForest.push(temp); + for (var i2 = 0; i2 < temp.length; i2++) { + var value2 = temp[i2]; + var index = unProcessedNodes.indexOf(value2); + if (index > -1) { + unProcessedNodes.splice(index, 1); + } + } + visited = /* @__PURE__ */ new Set(); + parents3 = /* @__PURE__ */ new Map(); + } + } + return flatForest; + }; + Layout2.prototype.createDummyNodesForBendpoints = function(edge) { + var dummyNodes = []; + var prev2 = edge.source; + var graph = this.graphManager.calcLowestCommonAncestor(edge.source, edge.target); + for (var i2 = 0; i2 < edge.bendpoints.length; i2++) { + var dummyNode = this.newNode(null); + dummyNode.setRect(new Point(0, 0), new Dimension(1, 1)); + graph.add(dummyNode); + var dummyEdge = this.newEdge(null); + this.graphManager.add(dummyEdge, prev2, dummyNode); + dummyNodes.add(dummyNode); + prev2 = dummyNode; + } + var dummyEdge = this.newEdge(null); + this.graphManager.add(dummyEdge, prev2, edge.target); + this.edgeToDummyNodes.set(edge, dummyNodes); + if (edge.isInterGraph()) { + this.graphManager.remove(edge); + } else { + graph.remove(edge); + } + return dummyNodes; + }; + Layout2.prototype.createBendpointsFromDummyNodes = function() { + var edges3 = []; + edges3 = edges3.concat(this.graphManager.getAllEdges()); + edges3 = [].concat(_toConsumableArray2(this.edgeToDummyNodes.keys())).concat(edges3); + for (var k2 = 0; k2 < edges3.length; k2++) { + var lEdge = edges3[k2]; + if (lEdge.bendpoints.length > 0) { + var path4 = this.edgeToDummyNodes.get(lEdge); + for (var i2 = 0; i2 < path4.length; i2++) { + var dummyNode = path4[i2]; + var p3 = new PointD(dummyNode.getCenterX(), dummyNode.getCenterY()); + var ebp = lEdge.bendpoints.get(i2); + ebp.x = p3.x; + ebp.y = p3.y; + dummyNode.getOwner().remove(dummyNode); + } + this.graphManager.add(lEdge, lEdge.source, lEdge.target); + } + } + }; + Layout2.transform = function(sliderValue, defaultValue, minDiv, maxMul) { + if (minDiv != void 0 && maxMul != void 0) { + var value2 = defaultValue; + if (sliderValue <= 50) { + var minValue = defaultValue / minDiv; + value2 -= (defaultValue - minValue) / 50 * (50 - sliderValue); + } else { + var maxValue = defaultValue * maxMul; + value2 += (maxValue - defaultValue) / 50 * (sliderValue - 50); + } + return value2; + } else { + var a2, b3; + if (sliderValue <= 50) { + a2 = 9 * defaultValue / 500; + b3 = defaultValue / 10; + } else { + a2 = 9 * defaultValue / 50; + b3 = -8 * defaultValue; + } + return a2 * sliderValue + b3; + } + }; + Layout2.findCenterOfTree = function(nodes5) { + var list = []; + list = list.concat(nodes5); + var removedNodes = []; + var remainingDegrees = /* @__PURE__ */ new Map(); + var foundCenter = false; + var centerNode = null; + if (list.length == 1 || list.length == 2) { + foundCenter = true; + centerNode = list[0]; + } + for (var i2 = 0; i2 < list.length; i2++) { + var node2 = list[i2]; + var degree = node2.getNeighborsList().size; + remainingDegrees.set(node2, node2.getNeighborsList().size); + if (degree == 1) { + removedNodes.push(node2); + } + } + var tempList = []; + tempList = tempList.concat(removedNodes); + while (!foundCenter) { + var tempList2 = []; + tempList2 = tempList2.concat(tempList); + tempList = []; + for (var i2 = 0; i2 < list.length; i2++) { + var node2 = list[i2]; + var index = list.indexOf(node2); + if (index >= 0) { + list.splice(index, 1); + } + var neighbours = node2.getNeighborsList(); + neighbours.forEach(function(neighbour) { + if (removedNodes.indexOf(neighbour) < 0) { + var otherDegree = remainingDegrees.get(neighbour); + var newDegree = otherDegree - 1; + if (newDegree == 1) { + tempList.push(neighbour); + } + remainingDegrees.set(neighbour, newDegree); + } + }); + } + removedNodes = removedNodes.concat(tempList); + if (list.length == 1 || list.length == 2) { + foundCenter = true; + centerNode = list[0]; + } + } + return centerNode; + }; + Layout2.prototype.setGraphManager = function(gm) { + this.graphManager = gm; + }; + module3.exports = Layout2; + }), + /* 16 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function RandomSeed() { + } + __name(RandomSeed, "RandomSeed"); + RandomSeed.seed = 1; + RandomSeed.x = 0; + RandomSeed.nextDouble = function() { + RandomSeed.x = Math.sin(RandomSeed.seed++) * 1e4; + return RandomSeed.x - Math.floor(RandomSeed.x); + }; + module3.exports = RandomSeed; + }), + /* 17 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var PointD = __webpack_require__(5); + function Transform2(x5, y6) { + this.lworldOrgX = 0; + this.lworldOrgY = 0; + this.ldeviceOrgX = 0; + this.ldeviceOrgY = 0; + this.lworldExtX = 1; + this.lworldExtY = 1; + this.ldeviceExtX = 1; + this.ldeviceExtY = 1; + } + __name(Transform2, "Transform"); + Transform2.prototype.getWorldOrgX = function() { + return this.lworldOrgX; + }; + Transform2.prototype.setWorldOrgX = function(wox) { + this.lworldOrgX = wox; + }; + Transform2.prototype.getWorldOrgY = function() { + return this.lworldOrgY; + }; + Transform2.prototype.setWorldOrgY = function(woy) { + this.lworldOrgY = woy; + }; + Transform2.prototype.getWorldExtX = function() { + return this.lworldExtX; + }; + Transform2.prototype.setWorldExtX = function(wex) { + this.lworldExtX = wex; + }; + Transform2.prototype.getWorldExtY = function() { + return this.lworldExtY; + }; + Transform2.prototype.setWorldExtY = function(wey) { + this.lworldExtY = wey; + }; + Transform2.prototype.getDeviceOrgX = function() { + return this.ldeviceOrgX; + }; + Transform2.prototype.setDeviceOrgX = function(dox) { + this.ldeviceOrgX = dox; + }; + Transform2.prototype.getDeviceOrgY = function() { + return this.ldeviceOrgY; + }; + Transform2.prototype.setDeviceOrgY = function(doy) { + this.ldeviceOrgY = doy; + }; + Transform2.prototype.getDeviceExtX = function() { + return this.ldeviceExtX; + }; + Transform2.prototype.setDeviceExtX = function(dex) { + this.ldeviceExtX = dex; + }; + Transform2.prototype.getDeviceExtY = function() { + return this.ldeviceExtY; + }; + Transform2.prototype.setDeviceExtY = function(dey) { + this.ldeviceExtY = dey; + }; + Transform2.prototype.transformX = function(x5) { + var xDevice = 0; + var worldExtX = this.lworldExtX; + if (worldExtX != 0) { + xDevice = this.ldeviceOrgX + (x5 - this.lworldOrgX) * this.ldeviceExtX / worldExtX; + } + return xDevice; + }; + Transform2.prototype.transformY = function(y6) { + var yDevice = 0; + var worldExtY = this.lworldExtY; + if (worldExtY != 0) { + yDevice = this.ldeviceOrgY + (y6 - this.lworldOrgY) * this.ldeviceExtY / worldExtY; + } + return yDevice; + }; + Transform2.prototype.inverseTransformX = function(x5) { + var xWorld = 0; + var deviceExtX = this.ldeviceExtX; + if (deviceExtX != 0) { + xWorld = this.lworldOrgX + (x5 - this.ldeviceOrgX) * this.lworldExtX / deviceExtX; + } + return xWorld; + }; + Transform2.prototype.inverseTransformY = function(y6) { + var yWorld = 0; + var deviceExtY = this.ldeviceExtY; + if (deviceExtY != 0) { + yWorld = this.lworldOrgY + (y6 - this.ldeviceOrgY) * this.lworldExtY / deviceExtY; + } + return yWorld; + }; + Transform2.prototype.inverseTransformPoint = function(inPoint) { + var outPoint = new PointD(this.inverseTransformX(inPoint.x), this.inverseTransformY(inPoint.y)); + return outPoint; + }; + module3.exports = Transform2; + }), + /* 18 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function _toConsumableArray2(arr) { + if (Array.isArray(arr)) { + for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++) { + arr2[i2] = arr[i2]; + } + return arr2; + } else { + return Array.from(arr); + } + } + __name(_toConsumableArray2, "_toConsumableArray"); + var Layout2 = __webpack_require__(15); + var FDLayoutConstants = __webpack_require__(4); + var LayoutConstants = __webpack_require__(0); + var IGeometry = __webpack_require__(8); + var IMath = __webpack_require__(9); + function FDLayout() { + Layout2.call(this); + this.useSmartIdealEdgeLengthCalculation = FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION; + this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH; + this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH; + this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR; + this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR; + this.displacementThresholdPerNode = 3 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100; + this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL; + this.initialCoolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL; + this.totalDisplacement = 0; + this.oldTotalDisplacement = 0; + this.maxIterations = FDLayoutConstants.MAX_ITERATIONS; + } + __name(FDLayout, "FDLayout"); + FDLayout.prototype = Object.create(Layout2.prototype); + for (var prop in Layout2) { + FDLayout[prop] = Layout2[prop]; + } + FDLayout.prototype.initParameters = function() { + Layout2.prototype.initParameters.call(this, arguments); + this.totalIterations = 0; + this.notAnimatedIterations = 0; + this.useFRGridVariant = FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION; + this.grid = []; + }; + FDLayout.prototype.calcIdealEdgeLengths = function() { + var edge; + var originalIdealLength; + var lcaDepth; + var source; + var target; + var sizeOfSourceInLca; + var sizeOfTargetInLca; + var allEdges = this.getGraphManager().getAllEdges(); + for (var i2 = 0; i2 < allEdges.length; i2++) { + edge = allEdges[i2]; + originalIdealLength = edge.idealLength; + if (edge.isInterGraph) { + source = edge.getSource(); + target = edge.getTarget(); + sizeOfSourceInLca = edge.getSourceInLca().getEstimatedSize(); + sizeOfTargetInLca = edge.getTargetInLca().getEstimatedSize(); + if (this.useSmartIdealEdgeLengthCalculation) { + edge.idealLength += sizeOfSourceInLca + sizeOfTargetInLca - 2 * LayoutConstants.SIMPLE_NODE_SIZE; + } + lcaDepth = edge.getLca().getInclusionTreeDepth(); + edge.idealLength += originalIdealLength * FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (source.getInclusionTreeDepth() + target.getInclusionTreeDepth() - 2 * lcaDepth); + } + } + }; + FDLayout.prototype.initSpringEmbedder = function() { + var s2 = this.getAllNodes().length; + if (this.incremental) { + if (s2 > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) { + this.coolingFactor = Math.max(this.coolingFactor * FDLayoutConstants.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (s2 - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR)); + } + this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL; + } else { + if (s2 > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) { + this.coolingFactor = Math.max(FDLayoutConstants.COOLING_ADAPTATION_FACTOR, 1 - (s2 - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR)); + } else { + this.coolingFactor = 1; + } + this.initialCoolingFactor = this.coolingFactor; + this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT; + } + this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations); + this.displacementThresholdPerNode = 3 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100; + this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length; + this.repulsionRange = this.calcRepulsionRange(); + }; + FDLayout.prototype.calcSpringForces = function() { + var lEdges = this.getAllEdges(); + var edge; + for (var i2 = 0; i2 < lEdges.length; i2++) { + edge = lEdges[i2]; + this.calcSpringForce(edge, edge.idealLength); + } + }; + FDLayout.prototype.calcRepulsionForces = function() { + var gridUpdateAllowed = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true; + var forceToNodeSurroundingUpdate = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false; + var i2, j3; + var nodeA, nodeB; + var lNodes = this.getAllNodes(); + var processedNodeSet; + if (this.useFRGridVariant) { + if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed) { + this.updateGrid(); + } + processedNodeSet = /* @__PURE__ */ new Set(); + for (i2 = 0; i2 < lNodes.length; i2++) { + nodeA = lNodes[i2]; + this.calculateRepulsionForceOfANode(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate); + processedNodeSet.add(nodeA); + } + } else { + for (i2 = 0; i2 < lNodes.length; i2++) { + nodeA = lNodes[i2]; + for (j3 = i2 + 1; j3 < lNodes.length; j3++) { + nodeB = lNodes[j3]; + if (nodeA.getOwner() != nodeB.getOwner()) { + continue; + } + this.calcRepulsionForce(nodeA, nodeB); + } + } + } + }; + FDLayout.prototype.calcGravitationalForces = function() { + var node2; + var lNodes = this.getAllNodesToApplyGravitation(); + for (var i2 = 0; i2 < lNodes.length; i2++) { + node2 = lNodes[i2]; + this.calcGravitationalForce(node2); + } + }; + FDLayout.prototype.moveNodes = function() { + var lNodes = this.getAllNodes(); + var node2; + for (var i2 = 0; i2 < lNodes.length; i2++) { + node2 = lNodes[i2]; + node2.move(); + } + }; + FDLayout.prototype.calcSpringForce = function(edge, idealLength) { + var sourceNode = edge.getSource(); + var targetNode = edge.getTarget(); + var length2; + var springForce; + var springForceX; + var springForceY; + if (this.uniformLeafNodeSizes && sourceNode.getChild() == null && targetNode.getChild() == null) { + edge.updateLengthSimple(); + } else { + edge.updateLength(); + if (edge.isOverlapingSourceAndTarget) { + return; + } + } + length2 = edge.getLength(); + if (length2 == 0) return; + springForce = edge.edgeElasticity * (length2 - idealLength); + springForceX = springForce * (edge.lengthX / length2); + springForceY = springForce * (edge.lengthY / length2); + sourceNode.springForceX += springForceX; + sourceNode.springForceY += springForceY; + targetNode.springForceX -= springForceX; + targetNode.springForceY -= springForceY; + }; + FDLayout.prototype.calcRepulsionForce = function(nodeA, nodeB) { + var rectA = nodeA.getRect(); + var rectB = nodeB.getRect(); + var overlapAmount = new Array(2); + var clipPoints = new Array(4); + var distanceX; + var distanceY; + var distanceSquared; + var distance2; + var repulsionForce; + var repulsionForceX; + var repulsionForceY; + if (rectA.intersects(rectB)) { + IGeometry.calcSeparationAmount(rectA, rectB, overlapAmount, FDLayoutConstants.DEFAULT_EDGE_LENGTH / 2); + repulsionForceX = 2 * overlapAmount[0]; + repulsionForceY = 2 * overlapAmount[1]; + var childrenConstant = nodeA.noOfChildren * nodeB.noOfChildren / (nodeA.noOfChildren + nodeB.noOfChildren); + nodeA.repulsionForceX -= childrenConstant * repulsionForceX; + nodeA.repulsionForceY -= childrenConstant * repulsionForceY; + nodeB.repulsionForceX += childrenConstant * repulsionForceX; + nodeB.repulsionForceY += childrenConstant * repulsionForceY; + } else { + if (this.uniformLeafNodeSizes && nodeA.getChild() == null && nodeB.getChild() == null) { + distanceX = rectB.getCenterX() - rectA.getCenterX(); + distanceY = rectB.getCenterY() - rectA.getCenterY(); + } else { + IGeometry.getIntersection(rectA, rectB, clipPoints); + distanceX = clipPoints[2] - clipPoints[0]; + distanceY = clipPoints[3] - clipPoints[1]; + } + if (Math.abs(distanceX) < FDLayoutConstants.MIN_REPULSION_DIST) { + distanceX = IMath.sign(distanceX) * FDLayoutConstants.MIN_REPULSION_DIST; + } + if (Math.abs(distanceY) < FDLayoutConstants.MIN_REPULSION_DIST) { + distanceY = IMath.sign(distanceY) * FDLayoutConstants.MIN_REPULSION_DIST; + } + distanceSquared = distanceX * distanceX + distanceY * distanceY; + distance2 = Math.sqrt(distanceSquared); + repulsionForce = (nodeA.nodeRepulsion / 2 + nodeB.nodeRepulsion / 2) * nodeA.noOfChildren * nodeB.noOfChildren / distanceSquared; + repulsionForceX = repulsionForce * distanceX / distance2; + repulsionForceY = repulsionForce * distanceY / distance2; + nodeA.repulsionForceX -= repulsionForceX; + nodeA.repulsionForceY -= repulsionForceY; + nodeB.repulsionForceX += repulsionForceX; + nodeB.repulsionForceY += repulsionForceY; + } + }; + FDLayout.prototype.calcGravitationalForce = function(node2) { + var ownerGraph; + var ownerCenterX; + var ownerCenterY; + var distanceX; + var distanceY; + var absDistanceX; + var absDistanceY; + var estimatedSize; + ownerGraph = node2.getOwner(); + ownerCenterX = (ownerGraph.getRight() + ownerGraph.getLeft()) / 2; + ownerCenterY = (ownerGraph.getTop() + ownerGraph.getBottom()) / 2; + distanceX = node2.getCenterX() - ownerCenterX; + distanceY = node2.getCenterY() - ownerCenterY; + absDistanceX = Math.abs(distanceX) + node2.getWidth() / 2; + absDistanceY = Math.abs(distanceY) + node2.getHeight() / 2; + if (node2.getOwner() == this.graphManager.getRoot()) { + estimatedSize = ownerGraph.getEstimatedSize() * this.gravityRangeFactor; + if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) { + node2.gravitationForceX = -this.gravityConstant * distanceX; + node2.gravitationForceY = -this.gravityConstant * distanceY; + } + } else { + estimatedSize = ownerGraph.getEstimatedSize() * this.compoundGravityRangeFactor; + if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) { + node2.gravitationForceX = -this.gravityConstant * distanceX * this.compoundGravityConstant; + node2.gravitationForceY = -this.gravityConstant * distanceY * this.compoundGravityConstant; + } + } + }; + FDLayout.prototype.isConverged = function() { + var converged; + var oscilating = false; + if (this.totalIterations > this.maxIterations / 3) { + oscilating = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2; + } + converged = this.totalDisplacement < this.totalDisplacementThreshold; + this.oldTotalDisplacement = this.totalDisplacement; + return converged || oscilating; + }; + FDLayout.prototype.animate = function() { + if (this.animationDuringLayout && !this.isSubLayout) { + if (this.notAnimatedIterations == this.animationPeriod) { + this.update(); + this.notAnimatedIterations = 0; + } else { + this.notAnimatedIterations++; + } + } + }; + FDLayout.prototype.calcNoOfChildrenForAllNodes = function() { + var node2; + var allNodes = this.graphManager.getAllNodes(); + for (var i2 = 0; i2 < allNodes.length; i2++) { + node2 = allNodes[i2]; + node2.noOfChildren = node2.getNoOfChildren(); + } + }; + FDLayout.prototype.calcGrid = function(graph) { + var sizeX = 0; + var sizeY = 0; + sizeX = parseInt(Math.ceil((graph.getRight() - graph.getLeft()) / this.repulsionRange)); + sizeY = parseInt(Math.ceil((graph.getBottom() - graph.getTop()) / this.repulsionRange)); + var grid = new Array(sizeX); + for (var i2 = 0; i2 < sizeX; i2++) { + grid[i2] = new Array(sizeY); + } + for (var i2 = 0; i2 < sizeX; i2++) { + for (var j3 = 0; j3 < sizeY; j3++) { + grid[i2][j3] = new Array(); + } + } + return grid; + }; + FDLayout.prototype.addNodeToGrid = function(v3, left3, top2) { + var startX2 = 0; + var finishX = 0; + var startY2 = 0; + var finishY = 0; + startX2 = parseInt(Math.floor((v3.getRect().x - left3) / this.repulsionRange)); + finishX = parseInt(Math.floor((v3.getRect().width + v3.getRect().x - left3) / this.repulsionRange)); + startY2 = parseInt(Math.floor((v3.getRect().y - top2) / this.repulsionRange)); + finishY = parseInt(Math.floor((v3.getRect().height + v3.getRect().y - top2) / this.repulsionRange)); + for (var i2 = startX2; i2 <= finishX; i2++) { + for (var j3 = startY2; j3 <= finishY; j3++) { + this.grid[i2][j3].push(v3); + v3.setGridCoordinates(startX2, finishX, startY2, finishY); + } + } + }; + FDLayout.prototype.updateGrid = function() { + var i2; + var nodeA; + var lNodes = this.getAllNodes(); + this.grid = this.calcGrid(this.graphManager.getRoot()); + for (i2 = 0; i2 < lNodes.length; i2++) { + nodeA = lNodes[i2]; + this.addNodeToGrid(nodeA, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop()); + } + }; + FDLayout.prototype.calculateRepulsionForceOfANode = function(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate) { + if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed || forceToNodeSurroundingUpdate) { + var surrounding = /* @__PURE__ */ new Set(); + nodeA.surrounding = new Array(); + var nodeB; + var grid = this.grid; + for (var i2 = nodeA.startX - 1; i2 < nodeA.finishX + 2; i2++) { + for (var j3 = nodeA.startY - 1; j3 < nodeA.finishY + 2; j3++) { + if (!(i2 < 0 || j3 < 0 || i2 >= grid.length || j3 >= grid[0].length)) { + for (var k2 = 0; k2 < grid[i2][j3].length; k2++) { + nodeB = grid[i2][j3][k2]; + if (nodeA.getOwner() != nodeB.getOwner() || nodeA == nodeB) { + continue; + } + if (!processedNodeSet.has(nodeB) && !surrounding.has(nodeB)) { + var distanceX = Math.abs(nodeA.getCenterX() - nodeB.getCenterX()) - (nodeA.getWidth() / 2 + nodeB.getWidth() / 2); + var distanceY = Math.abs(nodeA.getCenterY() - nodeB.getCenterY()) - (nodeA.getHeight() / 2 + nodeB.getHeight() / 2); + if (distanceX <= this.repulsionRange && distanceY <= this.repulsionRange) { + surrounding.add(nodeB); + } + } + } + } + } + } + nodeA.surrounding = [].concat(_toConsumableArray2(surrounding)); + } + for (i2 = 0; i2 < nodeA.surrounding.length; i2++) { + this.calcRepulsionForce(nodeA, nodeA.surrounding[i2]); + } + }; + FDLayout.prototype.calcRepulsionRange = function() { + return 0; + }; + module3.exports = FDLayout; + }), + /* 19 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LEdge = __webpack_require__(1); + var FDLayoutConstants = __webpack_require__(4); + function FDLayoutEdge(source, target, vEdge) { + LEdge.call(this, source, target, vEdge); + this.idealLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH; + this.edgeElasticity = FDLayoutConstants.DEFAULT_SPRING_STRENGTH; + } + __name(FDLayoutEdge, "FDLayoutEdge"); + FDLayoutEdge.prototype = Object.create(LEdge.prototype); + for (var prop in LEdge) { + FDLayoutEdge[prop] = LEdge[prop]; + } + module3.exports = FDLayoutEdge; + }), + /* 20 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var LNode = __webpack_require__(3); + var FDLayoutConstants = __webpack_require__(4); + function FDLayoutNode(gm, loc, size4, vNode) { + LNode.call(this, gm, loc, size4, vNode); + this.nodeRepulsion = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH; + this.springForceX = 0; + this.springForceY = 0; + this.repulsionForceX = 0; + this.repulsionForceY = 0; + this.gravitationForceX = 0; + this.gravitationForceY = 0; + this.displacementX = 0; + this.displacementY = 0; + this.startX = 0; + this.finishX = 0; + this.startY = 0; + this.finishY = 0; + this.surrounding = []; + } + __name(FDLayoutNode, "FDLayoutNode"); + FDLayoutNode.prototype = Object.create(LNode.prototype); + for (var prop in LNode) { + FDLayoutNode[prop] = LNode[prop]; + } + FDLayoutNode.prototype.setGridCoordinates = function(_startX, _finishX, _startY, _finishY) { + this.startX = _startX; + this.finishX = _finishX; + this.startY = _startY; + this.finishY = _finishY; + }; + module3.exports = FDLayoutNode; + }), + /* 21 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function DimensionD2(width3, height2) { + this.width = 0; + this.height = 0; + if (width3 !== null && height2 !== null) { + this.height = height2; + this.width = width3; + } + } + __name(DimensionD2, "DimensionD"); + DimensionD2.prototype.getWidth = function() { + return this.width; + }; + DimensionD2.prototype.setWidth = function(width3) { + this.width = width3; + }; + DimensionD2.prototype.getHeight = function() { + return this.height; + }; + DimensionD2.prototype.setHeight = function(height2) { + this.height = height2; + }; + module3.exports = DimensionD2; + }), + /* 22 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var UniqueIDGeneretor = __webpack_require__(14); + function HashMap() { + this.map = {}; + this.keys = []; + } + __name(HashMap, "HashMap"); + HashMap.prototype.put = function(key, value2) { + var theId = UniqueIDGeneretor.createID(key); + if (!this.contains(theId)) { + this.map[theId] = value2; + this.keys.push(key); + } + }; + HashMap.prototype.contains = function(key) { + var theId = UniqueIDGeneretor.createID(key); + return this.map[key] != null; + }; + HashMap.prototype.get = function(key) { + var theId = UniqueIDGeneretor.createID(key); + return this.map[theId]; + }; + HashMap.prototype.keySet = function() { + return this.keys; + }; + module3.exports = HashMap; + }), + /* 23 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var UniqueIDGeneretor = __webpack_require__(14); + function HashSet() { + this.set = {}; + } + __name(HashSet, "HashSet"); + ; + HashSet.prototype.add = function(obj) { + var theId = UniqueIDGeneretor.createID(obj); + if (!this.contains(theId)) this.set[theId] = obj; + }; + HashSet.prototype.remove = function(obj) { + delete this.set[UniqueIDGeneretor.createID(obj)]; + }; + HashSet.prototype.clear = function() { + this.set = {}; + }; + HashSet.prototype.contains = function(obj) { + return this.set[UniqueIDGeneretor.createID(obj)] == obj; + }; + HashSet.prototype.isEmpty = function() { + return this.size() === 0; + }; + HashSet.prototype.size = function() { + return Object.keys(this.set).length; + }; + HashSet.prototype.addAllTo = function(list) { + var keys2 = Object.keys(this.set); + var length2 = keys2.length; + for (var i2 = 0; i2 < length2; i2++) { + list.push(this.set[keys2[i2]]); + } + }; + HashSet.prototype.size = function() { + return Object.keys(this.set).length; + }; + HashSet.prototype.addAll = function(list) { + var s2 = list.length; + for (var i2 = 0; i2 < s2; i2++) { + var v3 = list[i2]; + this.add(v3); + } + }; + module3.exports = HashSet; + }), + /* 24 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function Matrix() { + } + __name(Matrix, "Matrix"); + Matrix.multMat = function(array1, array22) { + var result = []; + for (var i2 = 0; i2 < array1.length; i2++) { + result[i2] = []; + for (var j3 = 0; j3 < array22[0].length; j3++) { + result[i2][j3] = 0; + for (var k2 = 0; k2 < array1[0].length; k2++) { + result[i2][j3] += array1[i2][k2] * array22[k2][j3]; + } + } + } + return result; + }; + Matrix.transpose = function(array4) { + var result = []; + for (var i2 = 0; i2 < array4[0].length; i2++) { + result[i2] = []; + for (var j3 = 0; j3 < array4.length; j3++) { + result[i2][j3] = array4[j3][i2]; + } + } + return result; + }; + Matrix.multCons = function(array4, constant3) { + var result = []; + for (var i2 = 0; i2 < array4.length; i2++) { + result[i2] = array4[i2] * constant3; + } + return result; + }; + Matrix.minusOp = function(array1, array22) { + var result = []; + for (var i2 = 0; i2 < array1.length; i2++) { + result[i2] = array1[i2] - array22[i2]; + } + return result; + }; + Matrix.dotProduct = function(array1, array22) { + var product = 0; + for (var i2 = 0; i2 < array1.length; i2++) { + product += array1[i2] * array22[i2]; + } + return product; + }; + Matrix.mag = function(array4) { + return Math.sqrt(this.dotProduct(array4, array4)); + }; + Matrix.normalize = function(array4) { + var result = []; + var magnitude = this.mag(array4); + for (var i2 = 0; i2 < array4.length; i2++) { + result[i2] = array4[i2] / magnitude; + } + return result; + }; + Matrix.multGamma = function(array4) { + var result = []; + var sum2 = 0; + for (var i2 = 0; i2 < array4.length; i2++) { + sum2 += array4[i2]; + } + sum2 *= -1 / array4.length; + for (var _i = 0; _i < array4.length; _i++) { + result[_i] = sum2 + array4[_i]; + } + return result; + }; + Matrix.multL = function(array4, C3, INV) { + var result = []; + var temp1 = []; + var temp2 = []; + for (var i2 = 0; i2 < C3[0].length; i2++) { + var sum2 = 0; + for (var j3 = 0; j3 < C3.length; j3++) { + sum2 += -0.5 * C3[j3][i2] * array4[j3]; + } + temp1[i2] = sum2; + } + for (var _i2 = 0; _i2 < INV.length; _i2++) { + var _sum = 0; + for (var _j = 0; _j < INV.length; _j++) { + _sum += INV[_i2][_j] * temp1[_j]; + } + temp2[_i2] = _sum; + } + for (var _i3 = 0; _i3 < C3.length; _i3++) { + var _sum2 = 0; + for (var _j2 = 0; _j2 < C3[0].length; _j2++) { + _sum2 += C3[_i3][_j2] * temp2[_j2]; + } + result[_i3] = _sum2; + } + return result; + }; + module3.exports = Matrix; + }), + /* 25 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var _createClass2 = /* @__PURE__ */ (function() { + function defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + __name(defineProperties, "defineProperties"); + return function(Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + })(); + function _classCallCheck2(instance2, Constructor) { + if (!(instance2 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + __name(_classCallCheck2, "_classCallCheck"); + var LinkedList = __webpack_require__(11); + var Quicksort = (function() { + function Quicksort2(A2, compareFunction) { + _classCallCheck2(this, Quicksort2); + if (compareFunction !== null || compareFunction !== void 0) this.compareFunction = this._defaultCompareFunction; + var length2 = void 0; + if (A2 instanceof LinkedList) length2 = A2.size(); + else length2 = A2.length; + this._quicksort(A2, 0, length2 - 1); + } + __name(Quicksort2, "Quicksort"); + _createClass2(Quicksort2, [{ + key: "_quicksort", + value: /* @__PURE__ */ __name(function _quicksort(A2, p3, r2) { + if (p3 < r2) { + var q3 = this._partition(A2, p3, r2); + this._quicksort(A2, p3, q3); + this._quicksort(A2, q3 + 1, r2); + } + }, "_quicksort") + }, { + key: "_partition", + value: /* @__PURE__ */ __name(function _partition(A2, p3, r2) { + var x5 = this._get(A2, p3); + var i2 = p3; + var j3 = r2; + while (true) { + while (this.compareFunction(x5, this._get(A2, j3))) { + j3--; + } + while (this.compareFunction(this._get(A2, i2), x5)) { + i2++; + } + if (i2 < j3) { + this._swap(A2, i2, j3); + i2++; + j3--; + } else return j3; + } + }, "_partition") + }, { + key: "_get", + value: /* @__PURE__ */ __name(function _get(object3, index) { + if (object3 instanceof LinkedList) return object3.get_object_at(index); + else return object3[index]; + }, "_get") + }, { + key: "_set", + value: /* @__PURE__ */ __name(function _set(object3, index, value2) { + if (object3 instanceof LinkedList) object3.set_object_at(index, value2); + else object3[index] = value2; + }, "_set") + }, { + key: "_swap", + value: /* @__PURE__ */ __name(function _swap(A2, i2, j3) { + var temp = this._get(A2, i2); + this._set(A2, i2, this._get(A2, j3)); + this._set(A2, j3, temp); + }, "_swap") + }, { + key: "_defaultCompareFunction", + value: /* @__PURE__ */ __name(function _defaultCompareFunction(a2, b3) { + return b3 > a2; + }, "_defaultCompareFunction") + }]); + return Quicksort2; + })(); + module3.exports = Quicksort; + }), + /* 26 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function SVD() { + } + __name(SVD, "SVD"); + ; + SVD.svd = function(A2) { + this.U = null; + this.V = null; + this.s = null; + this.m = 0; + this.n = 0; + this.m = A2.length; + this.n = A2[0].length; + var nu = Math.min(this.m, this.n); + this.s = (function(s2) { + var a2 = []; + while (s2-- > 0) { + a2.push(0); + } + return a2; + })(Math.min(this.m + 1, this.n)); + this.U = (function(dims) { + var allocate = /* @__PURE__ */ __name(function allocate2(dims2) { + if (dims2.length == 0) { + return 0; + } else { + var array4 = []; + for (var i3 = 0; i3 < dims2[0]; i3++) { + array4.push(allocate2(dims2.slice(1))); + } + return array4; + } + }, "allocate"); + return allocate(dims); + })([this.m, nu]); + this.V = (function(dims) { + var allocate = /* @__PURE__ */ __name(function allocate2(dims2) { + if (dims2.length == 0) { + return 0; + } else { + var array4 = []; + for (var i3 = 0; i3 < dims2[0]; i3++) { + array4.push(allocate2(dims2.slice(1))); + } + return array4; + } + }, "allocate"); + return allocate(dims); + })([this.n, this.n]); + var e3 = (function(s2) { + var a2 = []; + while (s2-- > 0) { + a2.push(0); + } + return a2; + })(this.n); + var work = (function(s2) { + var a2 = []; + while (s2-- > 0) { + a2.push(0); + } + return a2; + })(this.m); + var wantu = true; + var wantv = true; + var nct = Math.min(this.m - 1, this.n); + var nrt = Math.max(0, Math.min(this.n - 2, this.m)); + for (var k2 = 0; k2 < Math.max(nct, nrt); k2++) { + if (k2 < nct) { + this.s[k2] = 0; + for (var i2 = k2; i2 < this.m; i2++) { + this.s[k2] = SVD.hypot(this.s[k2], A2[i2][k2]); + } + ; + if (this.s[k2] !== 0) { + if (A2[k2][k2] < 0) { + this.s[k2] = -this.s[k2]; + } + for (var _i = k2; _i < this.m; _i++) { + A2[_i][k2] /= this.s[k2]; + } + ; + A2[k2][k2] += 1; + } + this.s[k2] = -this.s[k2]; + } + for (var j3 = k2 + 1; j3 < this.n; j3++) { + if (/* @__PURE__ */ (function(lhs, rhs) { + return lhs && rhs; + })(k2 < nct, this.s[k2] !== 0)) { + var t4 = 0; + for (var _i2 = k2; _i2 < this.m; _i2++) { + t4 += A2[_i2][k2] * A2[_i2][j3]; + } + ; + t4 = -t4 / A2[k2][k2]; + for (var _i3 = k2; _i3 < this.m; _i3++) { + A2[_i3][j3] += t4 * A2[_i3][k2]; + } + ; + } + e3[j3] = A2[k2][j3]; + } + ; + if (/* @__PURE__ */ (function(lhs, rhs) { + return lhs && rhs; + })(wantu, k2 < nct)) { + for (var _i4 = k2; _i4 < this.m; _i4++) { + this.U[_i4][k2] = A2[_i4][k2]; + } + ; + } + if (k2 < nrt) { + e3[k2] = 0; + for (var _i5 = k2 + 1; _i5 < this.n; _i5++) { + e3[k2] = SVD.hypot(e3[k2], e3[_i5]); + } + ; + if (e3[k2] !== 0) { + if (e3[k2 + 1] < 0) { + e3[k2] = -e3[k2]; + } + for (var _i6 = k2 + 1; _i6 < this.n; _i6++) { + e3[_i6] /= e3[k2]; + } + ; + e3[k2 + 1] += 1; + } + e3[k2] = -e3[k2]; + if (/* @__PURE__ */ (function(lhs, rhs) { + return lhs && rhs; + })(k2 + 1 < this.m, e3[k2] !== 0)) { + for (var _i7 = k2 + 1; _i7 < this.m; _i7++) { + work[_i7] = 0; + } + ; + for (var _j = k2 + 1; _j < this.n; _j++) { + for (var _i8 = k2 + 1; _i8 < this.m; _i8++) { + work[_i8] += e3[_j] * A2[_i8][_j]; + } + ; + } + ; + for (var _j2 = k2 + 1; _j2 < this.n; _j2++) { + var _t = -e3[_j2] / e3[k2 + 1]; + for (var _i9 = k2 + 1; _i9 < this.m; _i9++) { + A2[_i9][_j2] += _t * work[_i9]; + } + ; + } + ; + } + if (wantv) { + for (var _i10 = k2 + 1; _i10 < this.n; _i10++) { + this.V[_i10][k2] = e3[_i10]; + } + ; + } + } + } + ; + var p3 = Math.min(this.n, this.m + 1); + if (nct < this.n) { + this.s[nct] = A2[nct][nct]; + } + if (this.m < p3) { + this.s[p3 - 1] = 0; + } + if (nrt + 1 < p3) { + e3[nrt] = A2[nrt][p3 - 1]; + } + e3[p3 - 1] = 0; + if (wantu) { + for (var _j3 = nct; _j3 < nu; _j3++) { + for (var _i11 = 0; _i11 < this.m; _i11++) { + this.U[_i11][_j3] = 0; + } + ; + this.U[_j3][_j3] = 1; + } + ; + for (var _k = nct - 1; _k >= 0; _k--) { + if (this.s[_k] !== 0) { + for (var _j4 = _k + 1; _j4 < nu; _j4++) { + var _t2 = 0; + for (var _i12 = _k; _i12 < this.m; _i12++) { + _t2 += this.U[_i12][_k] * this.U[_i12][_j4]; + } + ; + _t2 = -_t2 / this.U[_k][_k]; + for (var _i13 = _k; _i13 < this.m; _i13++) { + this.U[_i13][_j4] += _t2 * this.U[_i13][_k]; + } + ; + } + ; + for (var _i14 = _k; _i14 < this.m; _i14++) { + this.U[_i14][_k] = -this.U[_i14][_k]; + } + ; + this.U[_k][_k] = 1 + this.U[_k][_k]; + for (var _i15 = 0; _i15 < _k - 1; _i15++) { + this.U[_i15][_k] = 0; + } + ; + } else { + for (var _i16 = 0; _i16 < this.m; _i16++) { + this.U[_i16][_k] = 0; + } + ; + this.U[_k][_k] = 1; + } + } + ; + } + if (wantv) { + for (var _k2 = this.n - 1; _k2 >= 0; _k2--) { + if (/* @__PURE__ */ (function(lhs, rhs) { + return lhs && rhs; + })(_k2 < nrt, e3[_k2] !== 0)) { + for (var _j5 = _k2 + 1; _j5 < nu; _j5++) { + var _t3 = 0; + for (var _i17 = _k2 + 1; _i17 < this.n; _i17++) { + _t3 += this.V[_i17][_k2] * this.V[_i17][_j5]; + } + ; + _t3 = -_t3 / this.V[_k2 + 1][_k2]; + for (var _i18 = _k2 + 1; _i18 < this.n; _i18++) { + this.V[_i18][_j5] += _t3 * this.V[_i18][_k2]; + } + ; + } + ; + } + for (var _i19 = 0; _i19 < this.n; _i19++) { + this.V[_i19][_k2] = 0; + } + ; + this.V[_k2][_k2] = 1; + } + ; + } + var pp = p3 - 1; + var iter = 0; + var eps = Math.pow(2, -52); + var tiny = Math.pow(2, -966); + while (p3 > 0) { + var _k3 = void 0; + var kase = void 0; + for (_k3 = p3 - 2; _k3 >= -1; _k3--) { + if (_k3 === -1) { + break; + } + if (Math.abs(e3[_k3]) <= tiny + eps * (Math.abs(this.s[_k3]) + Math.abs(this.s[_k3 + 1]))) { + e3[_k3] = 0; + break; + } + } + ; + if (_k3 === p3 - 2) { + kase = 4; + } else { + var ks = void 0; + for (ks = p3 - 1; ks >= _k3; ks--) { + if (ks === _k3) { + break; + } + var _t4 = (ks !== p3 ? Math.abs(e3[ks]) : 0) + (ks !== _k3 + 1 ? Math.abs(e3[ks - 1]) : 0); + if (Math.abs(this.s[ks]) <= tiny + eps * _t4) { + this.s[ks] = 0; + break; + } + } + ; + if (ks === _k3) { + kase = 3; + } else if (ks === p3 - 1) { + kase = 1; + } else { + kase = 2; + _k3 = ks; + } + } + _k3++; + switch (kase) { + case 1: + { + var f2 = e3[p3 - 2]; + e3[p3 - 2] = 0; + for (var _j6 = p3 - 2; _j6 >= _k3; _j6--) { + var _t5 = SVD.hypot(this.s[_j6], f2); + var cs = this.s[_j6] / _t5; + var sn = f2 / _t5; + this.s[_j6] = _t5; + if (_j6 !== _k3) { + f2 = -sn * e3[_j6 - 1]; + e3[_j6 - 1] = cs * e3[_j6 - 1]; + } + if (wantv) { + for (var _i20 = 0; _i20 < this.n; _i20++) { + _t5 = cs * this.V[_i20][_j6] + sn * this.V[_i20][p3 - 1]; + this.V[_i20][p3 - 1] = -sn * this.V[_i20][_j6] + cs * this.V[_i20][p3 - 1]; + this.V[_i20][_j6] = _t5; + } + ; + } + } + ; + } + ; + break; + case 2: + { + var _f = e3[_k3 - 1]; + e3[_k3 - 1] = 0; + for (var _j7 = _k3; _j7 < p3; _j7++) { + var _t6 = SVD.hypot(this.s[_j7], _f); + var _cs = this.s[_j7] / _t6; + var _sn = _f / _t6; + this.s[_j7] = _t6; + _f = -_sn * e3[_j7]; + e3[_j7] = _cs * e3[_j7]; + if (wantu) { + for (var _i21 = 0; _i21 < this.m; _i21++) { + _t6 = _cs * this.U[_i21][_j7] + _sn * this.U[_i21][_k3 - 1]; + this.U[_i21][_k3 - 1] = -_sn * this.U[_i21][_j7] + _cs * this.U[_i21][_k3 - 1]; + this.U[_i21][_j7] = _t6; + } + ; + } + } + ; + } + ; + break; + case 3: + { + var scale2 = Math.max(Math.max(Math.max(Math.max(Math.abs(this.s[p3 - 1]), Math.abs(this.s[p3 - 2])), Math.abs(e3[p3 - 2])), Math.abs(this.s[_k3])), Math.abs(e3[_k3])); + var sp = this.s[p3 - 1] / scale2; + var spm1 = this.s[p3 - 2] / scale2; + var epm1 = e3[p3 - 2] / scale2; + var sk = this.s[_k3] / scale2; + var ek = e3[_k3] / scale2; + var b3 = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2; + var c3 = sp * epm1 * (sp * epm1); + var shift2 = 0; + if (/* @__PURE__ */ (function(lhs, rhs) { + return lhs || rhs; + })(b3 !== 0, c3 !== 0)) { + shift2 = Math.sqrt(b3 * b3 + c3); + if (b3 < 0) { + shift2 = -shift2; + } + shift2 = c3 / (b3 + shift2); + } + var _f2 = (sk + sp) * (sk - sp) + shift2; + var g2 = sk * ek; + for (var _j8 = _k3; _j8 < p3 - 1; _j8++) { + var _t7 = SVD.hypot(_f2, g2); + var _cs2 = _f2 / _t7; + var _sn2 = g2 / _t7; + if (_j8 !== _k3) { + e3[_j8 - 1] = _t7; + } + _f2 = _cs2 * this.s[_j8] + _sn2 * e3[_j8]; + e3[_j8] = _cs2 * e3[_j8] - _sn2 * this.s[_j8]; + g2 = _sn2 * this.s[_j8 + 1]; + this.s[_j8 + 1] = _cs2 * this.s[_j8 + 1]; + if (wantv) { + for (var _i22 = 0; _i22 < this.n; _i22++) { + _t7 = _cs2 * this.V[_i22][_j8] + _sn2 * this.V[_i22][_j8 + 1]; + this.V[_i22][_j8 + 1] = -_sn2 * this.V[_i22][_j8] + _cs2 * this.V[_i22][_j8 + 1]; + this.V[_i22][_j8] = _t7; + } + ; + } + _t7 = SVD.hypot(_f2, g2); + _cs2 = _f2 / _t7; + _sn2 = g2 / _t7; + this.s[_j8] = _t7; + _f2 = _cs2 * e3[_j8] + _sn2 * this.s[_j8 + 1]; + this.s[_j8 + 1] = -_sn2 * e3[_j8] + _cs2 * this.s[_j8 + 1]; + g2 = _sn2 * e3[_j8 + 1]; + e3[_j8 + 1] = _cs2 * e3[_j8 + 1]; + if (wantu && _j8 < this.m - 1) { + for (var _i23 = 0; _i23 < this.m; _i23++) { + _t7 = _cs2 * this.U[_i23][_j8] + _sn2 * this.U[_i23][_j8 + 1]; + this.U[_i23][_j8 + 1] = -_sn2 * this.U[_i23][_j8] + _cs2 * this.U[_i23][_j8 + 1]; + this.U[_i23][_j8] = _t7; + } + ; + } + } + ; + e3[p3 - 2] = _f2; + iter = iter + 1; + } + ; + break; + case 4: + { + if (this.s[_k3] <= 0) { + this.s[_k3] = this.s[_k3] < 0 ? -this.s[_k3] : 0; + if (wantv) { + for (var _i24 = 0; _i24 <= pp; _i24++) { + this.V[_i24][_k3] = -this.V[_i24][_k3]; + } + ; + } + } + while (_k3 < pp) { + if (this.s[_k3] >= this.s[_k3 + 1]) { + break; + } + var _t8 = this.s[_k3]; + this.s[_k3] = this.s[_k3 + 1]; + this.s[_k3 + 1] = _t8; + if (wantv && _k3 < this.n - 1) { + for (var _i25 = 0; _i25 < this.n; _i25++) { + _t8 = this.V[_i25][_k3 + 1]; + this.V[_i25][_k3 + 1] = this.V[_i25][_k3]; + this.V[_i25][_k3] = _t8; + } + ; + } + if (wantu && _k3 < this.m - 1) { + for (var _i26 = 0; _i26 < this.m; _i26++) { + _t8 = this.U[_i26][_k3 + 1]; + this.U[_i26][_k3 + 1] = this.U[_i26][_k3]; + this.U[_i26][_k3] = _t8; + } + ; + } + _k3++; + } + ; + iter = 0; + p3--; + } + ; + break; + } + } + ; + var result = { U: this.U, V: this.V, S: this.s }; + return result; + }; + SVD.hypot = function(a2, b3) { + var r2 = void 0; + if (Math.abs(a2) > Math.abs(b3)) { + r2 = b3 / a2; + r2 = Math.abs(a2) * Math.sqrt(1 + r2 * r2); + } else if (b3 != 0) { + r2 = a2 / b3; + r2 = Math.abs(b3) * Math.sqrt(1 + r2 * r2); + } else { + r2 = 0; + } + return r2; + }; + module3.exports = SVD; + }), + /* 27 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var _createClass2 = /* @__PURE__ */ (function() { + function defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + __name(defineProperties, "defineProperties"); + return function(Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + })(); + function _classCallCheck2(instance2, Constructor) { + if (!(instance2 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + __name(_classCallCheck2, "_classCallCheck"); + var NeedlemanWunsch = (function() { + function NeedlemanWunsch2(sequence1, sequence2) { + var match_score = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1; + var mismatch_penalty = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : -1; + var gap_penalty = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : -1; + _classCallCheck2(this, NeedlemanWunsch2); + this.sequence1 = sequence1; + this.sequence2 = sequence2; + this.match_score = match_score; + this.mismatch_penalty = mismatch_penalty; + this.gap_penalty = gap_penalty; + this.iMax = sequence1.length + 1; + this.jMax = sequence2.length + 1; + this.grid = new Array(this.iMax); + for (var i2 = 0; i2 < this.iMax; i2++) { + this.grid[i2] = new Array(this.jMax); + for (var j3 = 0; j3 < this.jMax; j3++) { + this.grid[i2][j3] = 0; + } + } + this.tracebackGrid = new Array(this.iMax); + for (var _i = 0; _i < this.iMax; _i++) { + this.tracebackGrid[_i] = new Array(this.jMax); + for (var _j = 0; _j < this.jMax; _j++) { + this.tracebackGrid[_i][_j] = [null, null, null]; + } + } + this.alignments = []; + this.score = -1; + this.computeGrids(); + } + __name(NeedlemanWunsch2, "NeedlemanWunsch"); + _createClass2(NeedlemanWunsch2, [{ + key: "getScore", + value: /* @__PURE__ */ __name(function getScore() { + return this.score; + }, "getScore") + }, { + key: "getAlignments", + value: /* @__PURE__ */ __name(function getAlignments2() { + return this.alignments; + }, "getAlignments") + // Main dynamic programming procedure + }, { + key: "computeGrids", + value: /* @__PURE__ */ __name(function computeGrids() { + for (var j3 = 1; j3 < this.jMax; j3++) { + this.grid[0][j3] = this.grid[0][j3 - 1] + this.gap_penalty; + this.tracebackGrid[0][j3] = [false, false, true]; + } + for (var i2 = 1; i2 < this.iMax; i2++) { + this.grid[i2][0] = this.grid[i2 - 1][0] + this.gap_penalty; + this.tracebackGrid[i2][0] = [false, true, false]; + } + for (var _i2 = 1; _i2 < this.iMax; _i2++) { + for (var _j2 = 1; _j2 < this.jMax; _j2++) { + var diag = void 0; + if (this.sequence1[_i2 - 1] === this.sequence2[_j2 - 1]) diag = this.grid[_i2 - 1][_j2 - 1] + this.match_score; + else diag = this.grid[_i2 - 1][_j2 - 1] + this.mismatch_penalty; + var up = this.grid[_i2 - 1][_j2] + this.gap_penalty; + var left3 = this.grid[_i2][_j2 - 1] + this.gap_penalty; + var maxOf = [diag, up, left3]; + var indices = this.arrayAllMaxIndexes(maxOf); + this.grid[_i2][_j2] = maxOf[indices[0]]; + this.tracebackGrid[_i2][_j2] = [indices.includes(0), indices.includes(1), indices.includes(2)]; + } + } + this.score = this.grid[this.iMax - 1][this.jMax - 1]; + }, "computeGrids") + // Gets all possible valid sequence combinations + }, { + key: "alignmentTraceback", + value: /* @__PURE__ */ __name(function alignmentTraceback() { + var inProcessAlignments = []; + inProcessAlignments.push({ + pos: [this.sequence1.length, this.sequence2.length], + seq1: "", + seq2: "" + }); + while (inProcessAlignments[0]) { + var current = inProcessAlignments[0]; + var directions = this.tracebackGrid[current.pos[0]][current.pos[1]]; + if (directions[0]) { + inProcessAlignments.push({ + pos: [current.pos[0] - 1, current.pos[1] - 1], + seq1: this.sequence1[current.pos[0] - 1] + current.seq1, + seq2: this.sequence2[current.pos[1] - 1] + current.seq2 + }); + } + if (directions[1]) { + inProcessAlignments.push({ + pos: [current.pos[0] - 1, current.pos[1]], + seq1: this.sequence1[current.pos[0] - 1] + current.seq1, + seq2: "-" + current.seq2 + }); + } + if (directions[2]) { + inProcessAlignments.push({ + pos: [current.pos[0], current.pos[1] - 1], + seq1: "-" + current.seq1, + seq2: this.sequence2[current.pos[1] - 1] + current.seq2 + }); + } + if (current.pos[0] === 0 && current.pos[1] === 0) this.alignments.push({ + sequence1: current.seq1, + sequence2: current.seq2 + }); + inProcessAlignments.shift(); + } + return this.alignments; + }, "alignmentTraceback") + // Helper Functions + }, { + key: "getAllIndexes", + value: /* @__PURE__ */ __name(function getAllIndexes(arr, val) { + var indexes = [], i2 = -1; + while ((i2 = arr.indexOf(val, i2 + 1)) !== -1) { + indexes.push(i2); + } + return indexes; + }, "getAllIndexes") + }, { + key: "arrayAllMaxIndexes", + value: /* @__PURE__ */ __name(function arrayAllMaxIndexes(array4) { + return this.getAllIndexes(array4, Math.max.apply(null, array4)); + }, "arrayAllMaxIndexes") + }]); + return NeedlemanWunsch2; + })(); + module3.exports = NeedlemanWunsch; + }), + /* 28 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + var layoutBase = /* @__PURE__ */ __name(function layoutBase2() { + return; + }, "layoutBase"); + layoutBase.FDLayout = __webpack_require__(18); + layoutBase.FDLayoutConstants = __webpack_require__(4); + layoutBase.FDLayoutEdge = __webpack_require__(19); + layoutBase.FDLayoutNode = __webpack_require__(20); + layoutBase.DimensionD = __webpack_require__(21); + layoutBase.HashMap = __webpack_require__(22); + layoutBase.HashSet = __webpack_require__(23); + layoutBase.IGeometry = __webpack_require__(8); + layoutBase.IMath = __webpack_require__(9); + layoutBase.Integer = __webpack_require__(10); + layoutBase.Point = __webpack_require__(12); + layoutBase.PointD = __webpack_require__(5); + layoutBase.RandomSeed = __webpack_require__(16); + layoutBase.RectangleD = __webpack_require__(13); + layoutBase.Transform = __webpack_require__(17); + layoutBase.UniqueIDGeneretor = __webpack_require__(14); + layoutBase.Quicksort = __webpack_require__(25); + layoutBase.LinkedList = __webpack_require__(11); + layoutBase.LGraphObject = __webpack_require__(2); + layoutBase.LGraph = __webpack_require__(6); + layoutBase.LEdge = __webpack_require__(1); + layoutBase.LGraphManager = __webpack_require__(7); + layoutBase.LNode = __webpack_require__(3); + layoutBase.Layout = __webpack_require__(15); + layoutBase.LayoutConstants = __webpack_require__(0); + layoutBase.NeedlemanWunsch = __webpack_require__(27); + layoutBase.Matrix = __webpack_require__(24); + layoutBase.SVD = __webpack_require__(26); + module3.exports = layoutBase; + }), + /* 29 */ + /***/ + (function(module3, exports3, __webpack_require__) { + "use strict"; + function Emitter4() { + this.listeners = []; + } + __name(Emitter4, "Emitter"); + var p3 = Emitter4.prototype; + p3.addListener = function(event3, callback) { + this.listeners.push({ + event: event3, + callback + }); + }; + p3.removeListener = function(event3, callback) { + for (var i2 = this.listeners.length; i2 >= 0; i2--) { + var l4 = this.listeners[i2]; + if (l4.event === event3 && l4.callback === callback) { + this.listeners.splice(i2, 1); + } + } + }; + p3.emit = function(event3, data5) { + for (var i2 = 0; i2 < this.listeners.length; i2++) { + var l4 = this.listeners[i2]; + if (event3 === l4.event) { + l4.callback(data5); + } + } + }; + module3.exports = Emitter4; + }) + /******/ + ]) + ); + }); + } + }); + + // ../../node_modules/.pnpm/cose-base@2.2.0/node_modules/cose-base/cose-base.js + var require_cose_base2 = __commonJS({ + "../../node_modules/.pnpm/cose-base@2.2.0/node_modules/cose-base/cose-base.js"(exports2, module2) { + "use strict"; + (/* @__PURE__ */ __name((function webpackUniversalModuleDefinition(root3, factory) { + if (typeof exports2 === "object" && typeof module2 === "object") + module2.exports = factory(require_layout_base2()); + else if (typeof define === "function" && define.amd) + define(["layout-base"], factory); + else if (typeof exports2 === "object") + exports2["coseBase"] = factory(require_layout_base2()); + else + root3["coseBase"] = factory(root3["layoutBase"]); + }), "webpackUniversalModuleDefinition"))(exports2, function(__WEBPACK_EXTERNAL_MODULE__551__) { + return ( + /******/ + (() => { + "use strict"; + var __webpack_modules__ = { + /***/ + 45: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var coseBase = {}; + coseBase.layoutBase = __webpack_require__2(551); + coseBase.CoSEConstants = __webpack_require__2(806); + coseBase.CoSEEdge = __webpack_require__2(767); + coseBase.CoSEGraph = __webpack_require__2(880); + coseBase.CoSEGraphManager = __webpack_require__2(578); + coseBase.CoSELayout = __webpack_require__2(765); + coseBase.CoSENode = __webpack_require__2(991); + coseBase.ConstraintHandler = __webpack_require__2(902); + module3.exports = coseBase; + }) + ), + /***/ + 806: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var FDLayoutConstants = __webpack_require__2(551).FDLayoutConstants; + function CoSEConstants() { + } + __name(CoSEConstants, "CoSEConstants"); + for (var prop in FDLayoutConstants) { + CoSEConstants[prop] = FDLayoutConstants[prop]; + } + CoSEConstants.DEFAULT_USE_MULTI_LEVEL_SCALING = false; + CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH; + CoSEConstants.DEFAULT_COMPONENT_SEPERATION = 60; + CoSEConstants.TILE = true; + CoSEConstants.TILING_PADDING_VERTICAL = 10; + CoSEConstants.TILING_PADDING_HORIZONTAL = 10; + CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true; + CoSEConstants.ENFORCE_CONSTRAINTS = true; + CoSEConstants.APPLY_LAYOUT = true; + CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS = true; + CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = true; + CoSEConstants.PURE_INCREMENTAL = CoSEConstants.DEFAULT_INCREMENTAL; + module3.exports = CoSEConstants; + }) + ), + /***/ + 767: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var FDLayoutEdge = __webpack_require__2(551).FDLayoutEdge; + function CoSEEdge(source, target, vEdge) { + FDLayoutEdge.call(this, source, target, vEdge); + } + __name(CoSEEdge, "CoSEEdge"); + CoSEEdge.prototype = Object.create(FDLayoutEdge.prototype); + for (var prop in FDLayoutEdge) { + CoSEEdge[prop] = FDLayoutEdge[prop]; + } + module3.exports = CoSEEdge; + }) + ), + /***/ + 880: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var LGraph = __webpack_require__2(551).LGraph; + function CoSEGraph(parent4, graphMgr, vGraph) { + LGraph.call(this, parent4, graphMgr, vGraph); + } + __name(CoSEGraph, "CoSEGraph"); + CoSEGraph.prototype = Object.create(LGraph.prototype); + for (var prop in LGraph) { + CoSEGraph[prop] = LGraph[prop]; + } + module3.exports = CoSEGraph; + }) + ), + /***/ + 578: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var LGraphManager = __webpack_require__2(551).LGraphManager; + function CoSEGraphManager(layout6) { + LGraphManager.call(this, layout6); + } + __name(CoSEGraphManager, "CoSEGraphManager"); + CoSEGraphManager.prototype = Object.create(LGraphManager.prototype); + for (var prop in LGraphManager) { + CoSEGraphManager[prop] = LGraphManager[prop]; + } + module3.exports = CoSEGraphManager; + }) + ), + /***/ + 765: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var FDLayout = __webpack_require__2(551).FDLayout; + var CoSEGraphManager = __webpack_require__2(578); + var CoSEGraph = __webpack_require__2(880); + var CoSENode = __webpack_require__2(991); + var CoSEEdge = __webpack_require__2(767); + var CoSEConstants = __webpack_require__2(806); + var ConstraintHandler = __webpack_require__2(902); + var FDLayoutConstants = __webpack_require__2(551).FDLayoutConstants; + var LayoutConstants = __webpack_require__2(551).LayoutConstants; + var Point3 = __webpack_require__2(551).Point; + var PointD = __webpack_require__2(551).PointD; + var DimensionD2 = __webpack_require__2(551).DimensionD; + var Layout2 = __webpack_require__2(551).Layout; + var Integer = __webpack_require__2(551).Integer; + var IGeometry = __webpack_require__2(551).IGeometry; + var LGraph = __webpack_require__2(551).LGraph; + var Transform2 = __webpack_require__2(551).Transform; + var LinkedList = __webpack_require__2(551).LinkedList; + function CoSELayout() { + FDLayout.call(this); + this.toBeTiled = {}; + this.constraints = {}; + } + __name(CoSELayout, "CoSELayout"); + CoSELayout.prototype = Object.create(FDLayout.prototype); + for (var prop in FDLayout) { + CoSELayout[prop] = FDLayout[prop]; + } + CoSELayout.prototype.newGraphManager = function() { + var gm = new CoSEGraphManager(this); + this.graphManager = gm; + return gm; + }; + CoSELayout.prototype.newGraph = function(vGraph) { + return new CoSEGraph(null, this.graphManager, vGraph); + }; + CoSELayout.prototype.newNode = function(vNode) { + return new CoSENode(this.graphManager, vNode); + }; + CoSELayout.prototype.newEdge = function(vEdge) { + return new CoSEEdge(null, null, vEdge); + }; + CoSELayout.prototype.initParameters = function() { + FDLayout.prototype.initParameters.call(this, arguments); + if (!this.isSubLayout) { + if (CoSEConstants.DEFAULT_EDGE_LENGTH < 10) { + this.idealEdgeLength = 10; + } else { + this.idealEdgeLength = CoSEConstants.DEFAULT_EDGE_LENGTH; + } + this.useSmartIdealEdgeLengthCalculation = CoSEConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION; + this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH; + this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH; + this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR; + this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR; + this.prunedNodesAll = []; + this.growTreeIterations = 0; + this.afterGrowthIterations = 0; + this.isTreeGrowing = false; + this.isGrowthFinished = false; + } + }; + CoSELayout.prototype.initSpringEmbedder = function() { + FDLayout.prototype.initSpringEmbedder.call(this); + this.coolingCycle = 0; + this.maxCoolingCycle = this.maxIterations / FDLayoutConstants.CONVERGENCE_CHECK_PERIOD; + this.finalTemperature = 0.04; + this.coolingAdjuster = 1; + }; + CoSELayout.prototype.layout = function() { + var createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED; + if (createBendsAsNeeded) { + this.createBendpoints(); + this.graphManager.resetAllEdges(); + } + this.level = 0; + return this.classicLayout(); + }; + CoSELayout.prototype.classicLayout = function() { + this.nodesWithGravity = this.calculateNodesToApplyGravitationTo(); + this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity); + this.calcNoOfChildrenForAllNodes(); + this.graphManager.calcLowestCommonAncestors(); + this.graphManager.calcInclusionTreeDepths(); + this.graphManager.getRoot().calcEstimatedSize(); + this.calcIdealEdgeLengths(); + if (!this.incremental) { + var forest = this.getFlatForest(); + if (forest.length > 0) { + this.positionNodesRadially(forest); + } else { + this.reduceTrees(); + this.graphManager.resetAllNodesToApplyGravitation(); + var allNodes = new Set(this.getAllNodes()); + var intersection4 = this.nodesWithGravity.filter(function(x5) { + return allNodes.has(x5); + }); + this.graphManager.setAllNodesToApplyGravitation(intersection4); + this.positionNodesRandomly(); + } + } else { + if (CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL) { + this.reduceTrees(); + this.graphManager.resetAllNodesToApplyGravitation(); + var allNodes = new Set(this.getAllNodes()); + var intersection4 = this.nodesWithGravity.filter(function(x5) { + return allNodes.has(x5); + }); + this.graphManager.setAllNodesToApplyGravitation(intersection4); + } + } + if (Object.keys(this.constraints).length > 0) { + ConstraintHandler.handleConstraints(this); + this.initConstraintVariables(); + } + this.initSpringEmbedder(); + if (CoSEConstants.APPLY_LAYOUT) { + this.runSpringEmbedder(); + } + return true; + }; + CoSELayout.prototype.tick = function() { + this.totalIterations++; + if (this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) { + if (this.prunedNodesAll.length > 0) { + this.isTreeGrowing = true; + } else { + return true; + } + } + if (this.totalIterations % FDLayoutConstants.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) { + if (this.isConverged()) { + if (this.prunedNodesAll.length > 0) { + this.isTreeGrowing = true; + } else { + return true; + } + } + this.coolingCycle++; + if (this.layoutQuality == 0) { + this.coolingAdjuster = this.coolingCycle; + } else if (this.layoutQuality == 1) { + this.coolingAdjuster = this.coolingCycle / 3; + } + this.coolingFactor = Math.max(this.initialCoolingFactor - Math.pow(this.coolingCycle, Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature); + this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor)); + } + if (this.isTreeGrowing) { + if (this.growTreeIterations % 10 == 0) { + if (this.prunedNodesAll.length > 0) { + this.graphManager.updateBounds(); + this.updateGrid(); + this.growTree(this.prunedNodesAll); + this.graphManager.resetAllNodesToApplyGravitation(); + var allNodes = new Set(this.getAllNodes()); + var intersection4 = this.nodesWithGravity.filter(function(x5) { + return allNodes.has(x5); + }); + this.graphManager.setAllNodesToApplyGravitation(intersection4); + this.graphManager.updateBounds(); + this.updateGrid(); + if (CoSEConstants.PURE_INCREMENTAL) this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2; + else this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL; + } else { + this.isTreeGrowing = false; + this.isGrowthFinished = true; + } + } + this.growTreeIterations++; + } + if (this.isGrowthFinished) { + if (this.isConverged()) { + return true; + } + if (this.afterGrowthIterations % 10 == 0) { + this.graphManager.updateBounds(); + this.updateGrid(); + } + if (CoSEConstants.PURE_INCREMENTAL) this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL / 2 * ((100 - this.afterGrowthIterations) / 100); + else this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100); + this.afterGrowthIterations++; + } + var gridUpdateAllowed = !this.isTreeGrowing && !this.isGrowthFinished; + var forceToNodeSurroundingUpdate = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished; + this.totalDisplacement = 0; + this.graphManager.updateBounds(); + this.calcSpringForces(); + this.calcRepulsionForces(gridUpdateAllowed, forceToNodeSurroundingUpdate); + this.calcGravitationalForces(); + this.moveNodes(); + this.animate(); + return false; + }; + CoSELayout.prototype.getPositionsData = function() { + var allNodes = this.graphManager.getAllNodes(); + var pData = {}; + for (var i2 = 0; i2 < allNodes.length; i2++) { + var rect3 = allNodes[i2].rect; + var id30 = allNodes[i2].id; + pData[id30] = { + id: id30, + x: rect3.getCenterX(), + y: rect3.getCenterY(), + w: rect3.width, + h: rect3.height + }; + } + return pData; + }; + CoSELayout.prototype.runSpringEmbedder = function() { + this.initialAnimationPeriod = 25; + this.animationPeriod = this.initialAnimationPeriod; + var layoutEnded = false; + if (FDLayoutConstants.ANIMATE === "during") { + this.emit("layoutstarted"); + } else { + while (!layoutEnded) { + layoutEnded = this.tick(); + } + this.graphManager.updateBounds(); + } + }; + CoSELayout.prototype.moveNodes = function() { + var lNodes = this.getAllNodes(); + var node2; + for (var i2 = 0; i2 < lNodes.length; i2++) { + node2 = lNodes[i2]; + node2.calculateDisplacement(); + } + if (Object.keys(this.constraints).length > 0) { + this.updateDisplacements(); + } + for (var i2 = 0; i2 < lNodes.length; i2++) { + node2 = lNodes[i2]; + node2.move(); + } + }; + CoSELayout.prototype.initConstraintVariables = function() { + var self2 = this; + this.idToNodeMap = /* @__PURE__ */ new Map(); + this.fixedNodeSet = /* @__PURE__ */ new Set(); + var allNodes = this.graphManager.getAllNodes(); + for (var i2 = 0; i2 < allNodes.length; i2++) { + var node2 = allNodes[i2]; + this.idToNodeMap.set(node2.id, node2); + } + var calculateCompoundWeight = /* @__PURE__ */ __name(function calculateCompoundWeight2(compoundNode) { + var nodes5 = compoundNode.getChild().getNodes(); + var node3; + var fixedNodeWeight2 = 0; + for (var i3 = 0; i3 < nodes5.length; i3++) { + node3 = nodes5[i3]; + if (node3.getChild() == null) { + if (self2.fixedNodeSet.has(node3.id)) { + fixedNodeWeight2 += 100; + } + } else { + fixedNodeWeight2 += calculateCompoundWeight2(node3); + } + } + return fixedNodeWeight2; + }, "calculateCompoundWeight"); + if (this.constraints.fixedNodeConstraint) { + this.constraints.fixedNodeConstraint.forEach(function(nodeData2) { + self2.fixedNodeSet.add(nodeData2.nodeId); + }); + var allNodes = this.graphManager.getAllNodes(); + var node2; + for (var i2 = 0; i2 < allNodes.length; i2++) { + node2 = allNodes[i2]; + if (node2.getChild() != null) { + var fixedNodeWeight = calculateCompoundWeight(node2); + if (fixedNodeWeight > 0) { + node2.fixedNodeWeight = fixedNodeWeight; + } + } + } + } + if (this.constraints.relativePlacementConstraint) { + var nodeToDummyForVerticalAlignment = /* @__PURE__ */ new Map(); + var nodeToDummyForHorizontalAlignment = /* @__PURE__ */ new Map(); + this.dummyToNodeForVerticalAlignment = /* @__PURE__ */ new Map(); + this.dummyToNodeForHorizontalAlignment = /* @__PURE__ */ new Map(); + this.fixedNodesOnHorizontal = /* @__PURE__ */ new Set(); + this.fixedNodesOnVertical = /* @__PURE__ */ new Set(); + this.fixedNodeSet.forEach(function(nodeId) { + self2.fixedNodesOnHorizontal.add(nodeId); + self2.fixedNodesOnVertical.add(nodeId); + }); + if (this.constraints.alignmentConstraint) { + if (this.constraints.alignmentConstraint.vertical) { + var verticalAlignment2 = this.constraints.alignmentConstraint.vertical; + for (var i2 = 0; i2 < verticalAlignment2.length; i2++) { + this.dummyToNodeForVerticalAlignment.set("dummy" + i2, []); + verticalAlignment2[i2].forEach(function(nodeId) { + nodeToDummyForVerticalAlignment.set(nodeId, "dummy" + i2); + self2.dummyToNodeForVerticalAlignment.get("dummy" + i2).push(nodeId); + if (self2.fixedNodeSet.has(nodeId)) { + self2.fixedNodesOnHorizontal.add("dummy" + i2); + } + }); + } + } + if (this.constraints.alignmentConstraint.horizontal) { + var horizontalAlignment = this.constraints.alignmentConstraint.horizontal; + for (var i2 = 0; i2 < horizontalAlignment.length; i2++) { + this.dummyToNodeForHorizontalAlignment.set("dummy" + i2, []); + horizontalAlignment[i2].forEach(function(nodeId) { + nodeToDummyForHorizontalAlignment.set(nodeId, "dummy" + i2); + self2.dummyToNodeForHorizontalAlignment.get("dummy" + i2).push(nodeId); + if (self2.fixedNodeSet.has(nodeId)) { + self2.fixedNodesOnVertical.add("dummy" + i2); + } + }); + } + } + } + if (CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS) { + this.shuffle = function(array4) { + var j3, x5, i3; + for (i3 = array4.length - 1; i3 >= 2 * array4.length / 3; i3--) { + j3 = Math.floor(Math.random() * (i3 + 1)); + x5 = array4[i3]; + array4[i3] = array4[j3]; + array4[j3] = x5; + } + return array4; + }; + this.nodesInRelativeHorizontal = []; + this.nodesInRelativeVertical = []; + this.nodeToRelativeConstraintMapHorizontal = /* @__PURE__ */ new Map(); + this.nodeToRelativeConstraintMapVertical = /* @__PURE__ */ new Map(); + this.nodeToTempPositionMapHorizontal = /* @__PURE__ */ new Map(); + this.nodeToTempPositionMapVertical = /* @__PURE__ */ new Map(); + this.constraints.relativePlacementConstraint.forEach(function(constraint) { + if (constraint.left) { + var nodeIdLeft = nodeToDummyForVerticalAlignment.has(constraint.left) ? nodeToDummyForVerticalAlignment.get(constraint.left) : constraint.left; + var nodeIdRight = nodeToDummyForVerticalAlignment.has(constraint.right) ? nodeToDummyForVerticalAlignment.get(constraint.right) : constraint.right; + if (!self2.nodesInRelativeHorizontal.includes(nodeIdLeft)) { + self2.nodesInRelativeHorizontal.push(nodeIdLeft); + self2.nodeToRelativeConstraintMapHorizontal.set(nodeIdLeft, []); + if (self2.dummyToNodeForVerticalAlignment.has(nodeIdLeft)) { + self2.nodeToTempPositionMapHorizontal.set(nodeIdLeft, self2.idToNodeMap.get(self2.dummyToNodeForVerticalAlignment.get(nodeIdLeft)[0]).getCenterX()); + } else { + self2.nodeToTempPositionMapHorizontal.set(nodeIdLeft, self2.idToNodeMap.get(nodeIdLeft).getCenterX()); + } + } + if (!self2.nodesInRelativeHorizontal.includes(nodeIdRight)) { + self2.nodesInRelativeHorizontal.push(nodeIdRight); + self2.nodeToRelativeConstraintMapHorizontal.set(nodeIdRight, []); + if (self2.dummyToNodeForVerticalAlignment.has(nodeIdRight)) { + self2.nodeToTempPositionMapHorizontal.set(nodeIdRight, self2.idToNodeMap.get(self2.dummyToNodeForVerticalAlignment.get(nodeIdRight)[0]).getCenterX()); + } else { + self2.nodeToTempPositionMapHorizontal.set(nodeIdRight, self2.idToNodeMap.get(nodeIdRight).getCenterX()); + } + } + self2.nodeToRelativeConstraintMapHorizontal.get(nodeIdLeft).push({ right: nodeIdRight, gap: constraint.gap }); + self2.nodeToRelativeConstraintMapHorizontal.get(nodeIdRight).push({ left: nodeIdLeft, gap: constraint.gap }); + } else { + var nodeIdTop = nodeToDummyForHorizontalAlignment.has(constraint.top) ? nodeToDummyForHorizontalAlignment.get(constraint.top) : constraint.top; + var nodeIdBottom = nodeToDummyForHorizontalAlignment.has(constraint.bottom) ? nodeToDummyForHorizontalAlignment.get(constraint.bottom) : constraint.bottom; + if (!self2.nodesInRelativeVertical.includes(nodeIdTop)) { + self2.nodesInRelativeVertical.push(nodeIdTop); + self2.nodeToRelativeConstraintMapVertical.set(nodeIdTop, []); + if (self2.dummyToNodeForHorizontalAlignment.has(nodeIdTop)) { + self2.nodeToTempPositionMapVertical.set(nodeIdTop, self2.idToNodeMap.get(self2.dummyToNodeForHorizontalAlignment.get(nodeIdTop)[0]).getCenterY()); + } else { + self2.nodeToTempPositionMapVertical.set(nodeIdTop, self2.idToNodeMap.get(nodeIdTop).getCenterY()); + } + } + if (!self2.nodesInRelativeVertical.includes(nodeIdBottom)) { + self2.nodesInRelativeVertical.push(nodeIdBottom); + self2.nodeToRelativeConstraintMapVertical.set(nodeIdBottom, []); + if (self2.dummyToNodeForHorizontalAlignment.has(nodeIdBottom)) { + self2.nodeToTempPositionMapVertical.set(nodeIdBottom, self2.idToNodeMap.get(self2.dummyToNodeForHorizontalAlignment.get(nodeIdBottom)[0]).getCenterY()); + } else { + self2.nodeToTempPositionMapVertical.set(nodeIdBottom, self2.idToNodeMap.get(nodeIdBottom).getCenterY()); + } + } + self2.nodeToRelativeConstraintMapVertical.get(nodeIdTop).push({ bottom: nodeIdBottom, gap: constraint.gap }); + self2.nodeToRelativeConstraintMapVertical.get(nodeIdBottom).push({ top: nodeIdTop, gap: constraint.gap }); + } + }); + } else { + var subGraphOnHorizontal = /* @__PURE__ */ new Map(); + var subGraphOnVertical = /* @__PURE__ */ new Map(); + this.constraints.relativePlacementConstraint.forEach(function(constraint) { + if (constraint.left) { + var left3 = nodeToDummyForVerticalAlignment.has(constraint.left) ? nodeToDummyForVerticalAlignment.get(constraint.left) : constraint.left; + var right3 = nodeToDummyForVerticalAlignment.has(constraint.right) ? nodeToDummyForVerticalAlignment.get(constraint.right) : constraint.right; + if (subGraphOnHorizontal.has(left3)) { + subGraphOnHorizontal.get(left3).push(right3); + } else { + subGraphOnHorizontal.set(left3, [right3]); + } + if (subGraphOnHorizontal.has(right3)) { + subGraphOnHorizontal.get(right3).push(left3); + } else { + subGraphOnHorizontal.set(right3, [left3]); + } + } else { + var top2 = nodeToDummyForHorizontalAlignment.has(constraint.top) ? nodeToDummyForHorizontalAlignment.get(constraint.top) : constraint.top; + var bottom2 = nodeToDummyForHorizontalAlignment.has(constraint.bottom) ? nodeToDummyForHorizontalAlignment.get(constraint.bottom) : constraint.bottom; + if (subGraphOnVertical.has(top2)) { + subGraphOnVertical.get(top2).push(bottom2); + } else { + subGraphOnVertical.set(top2, [bottom2]); + } + if (subGraphOnVertical.has(bottom2)) { + subGraphOnVertical.get(bottom2).push(top2); + } else { + subGraphOnVertical.set(bottom2, [top2]); + } + } + }); + var constructComponents = /* @__PURE__ */ __name(function constructComponents2(graph, fixedNodes) { + var components3 = []; + var isFixed = []; + var queue = new LinkedList(); + var visited = /* @__PURE__ */ new Set(); + var count2 = 0; + graph.forEach(function(value2, key) { + if (!visited.has(key)) { + components3[count2] = []; + isFixed[count2] = false; + var currentNode = key; + queue.push(currentNode); + visited.add(currentNode); + components3[count2].push(currentNode); + while (queue.length != 0) { + currentNode = queue.shift(); + if (fixedNodes.has(currentNode)) { + isFixed[count2] = true; + } + var neighbors = graph.get(currentNode); + neighbors.forEach(function(neighbor) { + if (!visited.has(neighbor)) { + queue.push(neighbor); + visited.add(neighbor); + components3[count2].push(neighbor); + } + }); + } + count2++; + } + }); + return { components: components3, isFixed }; + }, "constructComponents"); + var resultOnHorizontal = constructComponents(subGraphOnHorizontal, self2.fixedNodesOnHorizontal); + this.componentsOnHorizontal = resultOnHorizontal.components; + this.fixedComponentsOnHorizontal = resultOnHorizontal.isFixed; + var resultOnVertical = constructComponents(subGraphOnVertical, self2.fixedNodesOnVertical); + this.componentsOnVertical = resultOnVertical.components; + this.fixedComponentsOnVertical = resultOnVertical.isFixed; + } + } + }; + CoSELayout.prototype.updateDisplacements = function() { + var self2 = this; + if (this.constraints.fixedNodeConstraint) { + this.constraints.fixedNodeConstraint.forEach(function(nodeData2) { + var fixedNode = self2.idToNodeMap.get(nodeData2.nodeId); + fixedNode.displacementX = 0; + fixedNode.displacementY = 0; + }); + } + if (this.constraints.alignmentConstraint) { + if (this.constraints.alignmentConstraint.vertical) { + var allVerticalAlignments = this.constraints.alignmentConstraint.vertical; + for (var i2 = 0; i2 < allVerticalAlignments.length; i2++) { + var totalDisplacementX = 0; + for (var j3 = 0; j3 < allVerticalAlignments[i2].length; j3++) { + if (this.fixedNodeSet.has(allVerticalAlignments[i2][j3])) { + totalDisplacementX = 0; + break; + } + totalDisplacementX += this.idToNodeMap.get(allVerticalAlignments[i2][j3]).displacementX; + } + var averageDisplacementX = totalDisplacementX / allVerticalAlignments[i2].length; + for (var j3 = 0; j3 < allVerticalAlignments[i2].length; j3++) { + this.idToNodeMap.get(allVerticalAlignments[i2][j3]).displacementX = averageDisplacementX; + } + } + } + if (this.constraints.alignmentConstraint.horizontal) { + var allHorizontalAlignments = this.constraints.alignmentConstraint.horizontal; + for (var i2 = 0; i2 < allHorizontalAlignments.length; i2++) { + var totalDisplacementY = 0; + for (var j3 = 0; j3 < allHorizontalAlignments[i2].length; j3++) { + if (this.fixedNodeSet.has(allHorizontalAlignments[i2][j3])) { + totalDisplacementY = 0; + break; + } + totalDisplacementY += this.idToNodeMap.get(allHorizontalAlignments[i2][j3]).displacementY; + } + var averageDisplacementY = totalDisplacementY / allHorizontalAlignments[i2].length; + for (var j3 = 0; j3 < allHorizontalAlignments[i2].length; j3++) { + this.idToNodeMap.get(allHorizontalAlignments[i2][j3]).displacementY = averageDisplacementY; + } + } + } + } + if (this.constraints.relativePlacementConstraint) { + if (CoSEConstants.RELAX_MOVEMENT_ON_CONSTRAINTS) { + if (this.totalIterations % 10 == 0) { + this.shuffle(this.nodesInRelativeHorizontal); + this.shuffle(this.nodesInRelativeVertical); + } + this.nodesInRelativeHorizontal.forEach(function(nodeId) { + if (!self2.fixedNodesOnHorizontal.has(nodeId)) { + var displacement = 0; + if (self2.dummyToNodeForVerticalAlignment.has(nodeId)) { + displacement = self2.idToNodeMap.get(self2.dummyToNodeForVerticalAlignment.get(nodeId)[0]).displacementX; + } else { + displacement = self2.idToNodeMap.get(nodeId).displacementX; + } + self2.nodeToRelativeConstraintMapHorizontal.get(nodeId).forEach(function(constraint) { + if (constraint.right) { + var diff2 = self2.nodeToTempPositionMapHorizontal.get(constraint.right) - self2.nodeToTempPositionMapHorizontal.get(nodeId) - displacement; + if (diff2 < constraint.gap) { + displacement -= constraint.gap - diff2; + } + } else { + var diff2 = self2.nodeToTempPositionMapHorizontal.get(nodeId) - self2.nodeToTempPositionMapHorizontal.get(constraint.left) + displacement; + if (diff2 < constraint.gap) { + displacement += constraint.gap - diff2; + } + } + }); + self2.nodeToTempPositionMapHorizontal.set(nodeId, self2.nodeToTempPositionMapHorizontal.get(nodeId) + displacement); + if (self2.dummyToNodeForVerticalAlignment.has(nodeId)) { + self2.dummyToNodeForVerticalAlignment.get(nodeId).forEach(function(nodeId2) { + self2.idToNodeMap.get(nodeId2).displacementX = displacement; + }); + } else { + self2.idToNodeMap.get(nodeId).displacementX = displacement; + } + } + }); + this.nodesInRelativeVertical.forEach(function(nodeId) { + if (!self2.fixedNodesOnHorizontal.has(nodeId)) { + var displacement = 0; + if (self2.dummyToNodeForHorizontalAlignment.has(nodeId)) { + displacement = self2.idToNodeMap.get(self2.dummyToNodeForHorizontalAlignment.get(nodeId)[0]).displacementY; + } else { + displacement = self2.idToNodeMap.get(nodeId).displacementY; + } + self2.nodeToRelativeConstraintMapVertical.get(nodeId).forEach(function(constraint) { + if (constraint.bottom) { + var diff2 = self2.nodeToTempPositionMapVertical.get(constraint.bottom) - self2.nodeToTempPositionMapVertical.get(nodeId) - displacement; + if (diff2 < constraint.gap) { + displacement -= constraint.gap - diff2; + } + } else { + var diff2 = self2.nodeToTempPositionMapVertical.get(nodeId) - self2.nodeToTempPositionMapVertical.get(constraint.top) + displacement; + if (diff2 < constraint.gap) { + displacement += constraint.gap - diff2; + } + } + }); + self2.nodeToTempPositionMapVertical.set(nodeId, self2.nodeToTempPositionMapVertical.get(nodeId) + displacement); + if (self2.dummyToNodeForHorizontalAlignment.has(nodeId)) { + self2.dummyToNodeForHorizontalAlignment.get(nodeId).forEach(function(nodeId2) { + self2.idToNodeMap.get(nodeId2).displacementY = displacement; + }); + } else { + self2.idToNodeMap.get(nodeId).displacementY = displacement; + } + } + }); + } else { + for (var i2 = 0; i2 < this.componentsOnHorizontal.length; i2++) { + var component2 = this.componentsOnHorizontal[i2]; + if (this.fixedComponentsOnHorizontal[i2]) { + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForVerticalAlignment.has(component2[j3])) { + this.dummyToNodeForVerticalAlignment.get(component2[j3]).forEach(function(nodeId) { + self2.idToNodeMap.get(nodeId).displacementX = 0; + }); + } else { + this.idToNodeMap.get(component2[j3]).displacementX = 0; + } + } + } else { + var sum2 = 0; + var count2 = 0; + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForVerticalAlignment.has(component2[j3])) { + var actualNodes = this.dummyToNodeForVerticalAlignment.get(component2[j3]); + sum2 += actualNodes.length * this.idToNodeMap.get(actualNodes[0]).displacementX; + count2 += actualNodes.length; + } else { + sum2 += this.idToNodeMap.get(component2[j3]).displacementX; + count2++; + } + } + var averageDisplacement = sum2 / count2; + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForVerticalAlignment.has(component2[j3])) { + this.dummyToNodeForVerticalAlignment.get(component2[j3]).forEach(function(nodeId) { + self2.idToNodeMap.get(nodeId).displacementX = averageDisplacement; + }); + } else { + this.idToNodeMap.get(component2[j3]).displacementX = averageDisplacement; + } + } + } + } + for (var i2 = 0; i2 < this.componentsOnVertical.length; i2++) { + var component2 = this.componentsOnVertical[i2]; + if (this.fixedComponentsOnVertical[i2]) { + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForHorizontalAlignment.has(component2[j3])) { + this.dummyToNodeForHorizontalAlignment.get(component2[j3]).forEach(function(nodeId) { + self2.idToNodeMap.get(nodeId).displacementY = 0; + }); + } else { + this.idToNodeMap.get(component2[j3]).displacementY = 0; + } + } + } else { + var sum2 = 0; + var count2 = 0; + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForHorizontalAlignment.has(component2[j3])) { + var actualNodes = this.dummyToNodeForHorizontalAlignment.get(component2[j3]); + sum2 += actualNodes.length * this.idToNodeMap.get(actualNodes[0]).displacementY; + count2 += actualNodes.length; + } else { + sum2 += this.idToNodeMap.get(component2[j3]).displacementY; + count2++; + } + } + var averageDisplacement = sum2 / count2; + for (var j3 = 0; j3 < component2.length; j3++) { + if (this.dummyToNodeForHorizontalAlignment.has(component2[j3])) { + this.dummyToNodeForHorizontalAlignment.get(component2[j3]).forEach(function(nodeId) { + self2.idToNodeMap.get(nodeId).displacementY = averageDisplacement; + }); + } else { + this.idToNodeMap.get(component2[j3]).displacementY = averageDisplacement; + } + } + } + } + } + } + }; + CoSELayout.prototype.calculateNodesToApplyGravitationTo = function() { + var nodeList = []; + var graph; + var graphs = this.graphManager.getGraphs(); + var size4 = graphs.length; + var i2; + for (i2 = 0; i2 < size4; i2++) { + graph = graphs[i2]; + graph.updateConnected(); + if (!graph.isConnected) { + nodeList = nodeList.concat(graph.getNodes()); + } + } + return nodeList; + }; + CoSELayout.prototype.createBendpoints = function() { + var edges3 = []; + edges3 = edges3.concat(this.graphManager.getAllEdges()); + var visited = /* @__PURE__ */ new Set(); + var i2; + for (i2 = 0; i2 < edges3.length; i2++) { + var edge = edges3[i2]; + if (!visited.has(edge)) { + var source = edge.getSource(); + var target = edge.getTarget(); + if (source == target) { + edge.getBendpoints().push(new PointD()); + edge.getBendpoints().push(new PointD()); + this.createDummyNodesForBendpoints(edge); + visited.add(edge); + } else { + var edgeList2 = []; + edgeList2 = edgeList2.concat(source.getEdgeListToNode(target)); + edgeList2 = edgeList2.concat(target.getEdgeListToNode(source)); + if (!visited.has(edgeList2[0])) { + if (edgeList2.length > 1) { + var k2; + for (k2 = 0; k2 < edgeList2.length; k2++) { + var multiEdge = edgeList2[k2]; + multiEdge.getBendpoints().push(new PointD()); + this.createDummyNodesForBendpoints(multiEdge); + } + } + edgeList2.forEach(function(edge2) { + visited.add(edge2); + }); + } + } + } + if (visited.size == edges3.length) { + break; + } + } + }; + CoSELayout.prototype.positionNodesRadially = function(forest) { + var currentStartingPoint = new Point3(0, 0); + var numberOfColumns = Math.ceil(Math.sqrt(forest.length)); + var height2 = 0; + var currentY = 0; + var currentX = 0; + var point8 = new PointD(0, 0); + for (var i2 = 0; i2 < forest.length; i2++) { + if (i2 % numberOfColumns == 0) { + currentX = 0; + currentY = height2; + if (i2 != 0) { + currentY += CoSEConstants.DEFAULT_COMPONENT_SEPERATION; + } + height2 = 0; + } + var tree = forest[i2]; + var centerNode = Layout2.findCenterOfTree(tree); + currentStartingPoint.x = currentX; + currentStartingPoint.y = currentY; + point8 = CoSELayout.radialLayout(tree, centerNode, currentStartingPoint); + if (point8.y > height2) { + height2 = Math.floor(point8.y); + } + currentX = Math.floor(point8.x + CoSEConstants.DEFAULT_COMPONENT_SEPERATION); + } + this.transform(new PointD(LayoutConstants.WORLD_CENTER_X - point8.x / 2, LayoutConstants.WORLD_CENTER_Y - point8.y / 2)); + }; + CoSELayout.radialLayout = function(tree, centerNode, startingPoint) { + var radialSep = Math.max(this.maxDiagonalInTree(tree), CoSEConstants.DEFAULT_RADIAL_SEPARATION); + CoSELayout.branchRadialLayout(centerNode, null, 0, 359, 0, radialSep); + var bounds4 = LGraph.calculateBounds(tree); + var transform8 = new Transform2(); + transform8.setDeviceOrgX(bounds4.getMinX()); + transform8.setDeviceOrgY(bounds4.getMinY()); + transform8.setWorldOrgX(startingPoint.x); + transform8.setWorldOrgY(startingPoint.y); + for (var i2 = 0; i2 < tree.length; i2++) { + var node2 = tree[i2]; + node2.transform(transform8); + } + var bottomRight = new PointD(bounds4.getMaxX(), bounds4.getMaxY()); + return transform8.inverseTransformPoint(bottomRight); + }; + CoSELayout.branchRadialLayout = function(node2, parentOfNode, startAngle, endAngle, distance2, radialSeparation) { + var halfInterval = (endAngle - startAngle + 1) / 2; + if (halfInterval < 0) { + halfInterval += 180; + } + var nodeAngle = (halfInterval + startAngle) % 360; + var teta = nodeAngle * IGeometry.TWO_PI / 360; + var cos_teta = Math.cos(teta); + var x_ = distance2 * Math.cos(teta); + var y_ = distance2 * Math.sin(teta); + node2.setCenter(x_, y_); + var neighborEdges = []; + neighborEdges = neighborEdges.concat(node2.getEdges()); + var childCount = neighborEdges.length; + if (parentOfNode != null) { + childCount--; + } + var branchCount = 0; + var incEdgesCount = neighborEdges.length; + var startIndex; + var edges3 = node2.getEdgesBetween(parentOfNode); + while (edges3.length > 1) { + var temp = edges3[0]; + edges3.splice(0, 1); + var index = neighborEdges.indexOf(temp); + if (index >= 0) { + neighborEdges.splice(index, 1); + } + incEdgesCount--; + childCount--; + } + if (parentOfNode != null) { + startIndex = (neighborEdges.indexOf(edges3[0]) + 1) % incEdgesCount; + } else { + startIndex = 0; + } + var stepAngle = Math.abs(endAngle - startAngle) / childCount; + for (var i2 = startIndex; branchCount != childCount; i2 = ++i2 % incEdgesCount) { + var currentNeighbor = neighborEdges[i2].getOtherEnd(node2); + if (currentNeighbor == parentOfNode) { + continue; + } + var childStartAngle = (startAngle + branchCount * stepAngle) % 360; + var childEndAngle = (childStartAngle + stepAngle) % 360; + CoSELayout.branchRadialLayout(currentNeighbor, node2, childStartAngle, childEndAngle, distance2 + radialSeparation, radialSeparation); + branchCount++; + } + }; + CoSELayout.maxDiagonalInTree = function(tree) { + var maxDiagonal = Integer.MIN_VALUE; + for (var i2 = 0; i2 < tree.length; i2++) { + var node2 = tree[i2]; + var diagonal = node2.getDiagonal(); + if (diagonal > maxDiagonal) { + maxDiagonal = diagonal; + } + } + return maxDiagonal; + }; + CoSELayout.prototype.calcRepulsionRange = function() { + return 2 * (this.level + 1) * this.idealEdgeLength; + }; + CoSELayout.prototype.groupZeroDegreeMembers = function() { + var self2 = this; + var tempMemberGroups = {}; + this.memberGroups = {}; + this.idToDummyNode = {}; + var zeroDegree = []; + var allNodes = this.graphManager.getAllNodes(); + for (var i2 = 0; i2 < allNodes.length; i2++) { + var node2 = allNodes[i2]; + var parent4 = node2.getParent(); + if (this.getNodeDegreeWithChildren(node2) === 0 && (parent4.id == void 0 || !this.getToBeTiled(parent4))) { + zeroDegree.push(node2); + } + } + for (var i2 = 0; i2 < zeroDegree.length; i2++) { + var node2 = zeroDegree[i2]; + var p_id = node2.getParent().id; + if (typeof tempMemberGroups[p_id] === "undefined") tempMemberGroups[p_id] = []; + tempMemberGroups[p_id] = tempMemberGroups[p_id].concat(node2); + } + Object.keys(tempMemberGroups).forEach(function(p_id2) { + if (tempMemberGroups[p_id2].length > 1) { + var dummyCompoundId = "DummyCompound_" + p_id2; + self2.memberGroups[dummyCompoundId] = tempMemberGroups[p_id2]; + var parent5 = tempMemberGroups[p_id2][0].getParent(); + var dummyCompound = new CoSENode(self2.graphManager); + dummyCompound.id = dummyCompoundId; + dummyCompound.paddingLeft = parent5.paddingLeft || 0; + dummyCompound.paddingRight = parent5.paddingRight || 0; + dummyCompound.paddingBottom = parent5.paddingBottom || 0; + dummyCompound.paddingTop = parent5.paddingTop || 0; + self2.idToDummyNode[dummyCompoundId] = dummyCompound; + var dummyParentGraph = self2.getGraphManager().add(self2.newGraph(), dummyCompound); + var parentGraph = parent5.getChild(); + parentGraph.add(dummyCompound); + for (var i3 = 0; i3 < tempMemberGroups[p_id2].length; i3++) { + var node3 = tempMemberGroups[p_id2][i3]; + parentGraph.remove(node3); + dummyParentGraph.add(node3); + } + } + }); + }; + CoSELayout.prototype.clearCompounds = function() { + var childGraphMap = {}; + var idToNode = {}; + this.performDFSOnCompounds(); + for (var i2 = 0; i2 < this.compoundOrder.length; i2++) { + idToNode[this.compoundOrder[i2].id] = this.compoundOrder[i2]; + childGraphMap[this.compoundOrder[i2].id] = [].concat(this.compoundOrder[i2].getChild().getNodes()); + this.graphManager.remove(this.compoundOrder[i2].getChild()); + this.compoundOrder[i2].child = null; + } + this.graphManager.resetAllNodes(); + this.tileCompoundMembers(childGraphMap, idToNode); + }; + CoSELayout.prototype.clearZeroDegreeMembers = function() { + var self2 = this; + var tiledZeroDegreePack = this.tiledZeroDegreePack = []; + Object.keys(this.memberGroups).forEach(function(id30) { + var compoundNode = self2.idToDummyNode[id30]; + tiledZeroDegreePack[id30] = self2.tileNodes(self2.memberGroups[id30], compoundNode.paddingLeft + compoundNode.paddingRight); + compoundNode.rect.width = tiledZeroDegreePack[id30].width; + compoundNode.rect.height = tiledZeroDegreePack[id30].height; + compoundNode.setCenter(tiledZeroDegreePack[id30].centerX, tiledZeroDegreePack[id30].centerY); + compoundNode.labelMarginLeft = 0; + compoundNode.labelMarginTop = 0; + if (CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS) { + var width3 = compoundNode.rect.width; + var height2 = compoundNode.rect.height; + if (compoundNode.labelWidth) { + if (compoundNode.labelPosHorizontal == "left") { + compoundNode.rect.x -= compoundNode.labelWidth; + compoundNode.setWidth(width3 + compoundNode.labelWidth); + compoundNode.labelMarginLeft = compoundNode.labelWidth; + } else if (compoundNode.labelPosHorizontal == "center" && compoundNode.labelWidth > width3) { + compoundNode.rect.x -= (compoundNode.labelWidth - width3) / 2; + compoundNode.setWidth(compoundNode.labelWidth); + compoundNode.labelMarginLeft = (compoundNode.labelWidth - width3) / 2; + } else if (compoundNode.labelPosHorizontal == "right") { + compoundNode.setWidth(width3 + compoundNode.labelWidth); + } + } + if (compoundNode.labelHeight) { + if (compoundNode.labelPosVertical == "top") { + compoundNode.rect.y -= compoundNode.labelHeight; + compoundNode.setHeight(height2 + compoundNode.labelHeight); + compoundNode.labelMarginTop = compoundNode.labelHeight; + } else if (compoundNode.labelPosVertical == "center" && compoundNode.labelHeight > height2) { + compoundNode.rect.y -= (compoundNode.labelHeight - height2) / 2; + compoundNode.setHeight(compoundNode.labelHeight); + compoundNode.labelMarginTop = (compoundNode.labelHeight - height2) / 2; + } else if (compoundNode.labelPosVertical == "bottom") { + compoundNode.setHeight(height2 + compoundNode.labelHeight); + } + } + } + }); + }; + CoSELayout.prototype.repopulateCompounds = function() { + for (var i2 = this.compoundOrder.length - 1; i2 >= 0; i2--) { + var lCompoundNode = this.compoundOrder[i2]; + var id30 = lCompoundNode.id; + var horizontalMargin = lCompoundNode.paddingLeft; + var verticalMargin = lCompoundNode.paddingTop; + var labelMarginLeft = lCompoundNode.labelMarginLeft; + var labelMarginTop = lCompoundNode.labelMarginTop; + this.adjustLocations(this.tiledMemberPack[id30], lCompoundNode.rect.x, lCompoundNode.rect.y, horizontalMargin, verticalMargin, labelMarginLeft, labelMarginTop); + } + }; + CoSELayout.prototype.repopulateZeroDegreeMembers = function() { + var self2 = this; + var tiledPack = this.tiledZeroDegreePack; + Object.keys(tiledPack).forEach(function(id30) { + var compoundNode = self2.idToDummyNode[id30]; + var horizontalMargin = compoundNode.paddingLeft; + var verticalMargin = compoundNode.paddingTop; + var labelMarginLeft = compoundNode.labelMarginLeft; + var labelMarginTop = compoundNode.labelMarginTop; + self2.adjustLocations(tiledPack[id30], compoundNode.rect.x, compoundNode.rect.y, horizontalMargin, verticalMargin, labelMarginLeft, labelMarginTop); + }); + }; + CoSELayout.prototype.getToBeTiled = function(node2) { + var id30 = node2.id; + if (this.toBeTiled[id30] != null) { + return this.toBeTiled[id30]; + } + var childGraph = node2.getChild(); + if (childGraph == null) { + this.toBeTiled[id30] = false; + return false; + } + var children2 = childGraph.getNodes(); + for (var i2 = 0; i2 < children2.length; i2++) { + var theChild = children2[i2]; + if (this.getNodeDegree(theChild) > 0) { + this.toBeTiled[id30] = false; + return false; + } + if (theChild.getChild() == null) { + this.toBeTiled[theChild.id] = false; + continue; + } + if (!this.getToBeTiled(theChild)) { + this.toBeTiled[id30] = false; + return false; + } + } + this.toBeTiled[id30] = true; + return true; + }; + CoSELayout.prototype.getNodeDegree = function(node2) { + var id30 = node2.id; + var edges3 = node2.getEdges(); + var degree = 0; + for (var i2 = 0; i2 < edges3.length; i2++) { + var edge = edges3[i2]; + if (edge.getSource().id !== edge.getTarget().id) { + degree = degree + 1; + } + } + return degree; + }; + CoSELayout.prototype.getNodeDegreeWithChildren = function(node2) { + var degree = this.getNodeDegree(node2); + if (node2.getChild() == null) { + return degree; + } + var children2 = node2.getChild().getNodes(); + for (var i2 = 0; i2 < children2.length; i2++) { + var child = children2[i2]; + degree += this.getNodeDegreeWithChildren(child); + } + return degree; + }; + CoSELayout.prototype.performDFSOnCompounds = function() { + this.compoundOrder = []; + this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes()); + }; + CoSELayout.prototype.fillCompexOrderByDFS = function(children2) { + for (var i2 = 0; i2 < children2.length; i2++) { + var child = children2[i2]; + if (child.getChild() != null) { + this.fillCompexOrderByDFS(child.getChild().getNodes()); + } + if (this.getToBeTiled(child)) { + this.compoundOrder.push(child); + } + } + }; + CoSELayout.prototype.adjustLocations = function(organization, x5, y6, compoundHorizontalMargin, compoundVerticalMargin, compoundLabelMarginLeft, compoundLabelMarginTop) { + x5 += compoundHorizontalMargin + compoundLabelMarginLeft; + y6 += compoundVerticalMargin + compoundLabelMarginTop; + var left3 = x5; + for (var i2 = 0; i2 < organization.rows.length; i2++) { + var row = organization.rows[i2]; + x5 = left3; + var maxHeight = 0; + for (var j3 = 0; j3 < row.length; j3++) { + var lnode = row[j3]; + lnode.rect.x = x5; + lnode.rect.y = y6; + x5 += lnode.rect.width + organization.horizontalPadding; + if (lnode.rect.height > maxHeight) maxHeight = lnode.rect.height; + } + y6 += maxHeight + organization.verticalPadding; + } + }; + CoSELayout.prototype.tileCompoundMembers = function(childGraphMap, idToNode) { + var self2 = this; + this.tiledMemberPack = []; + Object.keys(childGraphMap).forEach(function(id30) { + var compoundNode = idToNode[id30]; + self2.tiledMemberPack[id30] = self2.tileNodes(childGraphMap[id30], compoundNode.paddingLeft + compoundNode.paddingRight); + compoundNode.rect.width = self2.tiledMemberPack[id30].width; + compoundNode.rect.height = self2.tiledMemberPack[id30].height; + compoundNode.setCenter(self2.tiledMemberPack[id30].centerX, self2.tiledMemberPack[id30].centerY); + compoundNode.labelMarginLeft = 0; + compoundNode.labelMarginTop = 0; + if (CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS) { + var width3 = compoundNode.rect.width; + var height2 = compoundNode.rect.height; + if (compoundNode.labelWidth) { + if (compoundNode.labelPosHorizontal == "left") { + compoundNode.rect.x -= compoundNode.labelWidth; + compoundNode.setWidth(width3 + compoundNode.labelWidth); + compoundNode.labelMarginLeft = compoundNode.labelWidth; + } else if (compoundNode.labelPosHorizontal == "center" && compoundNode.labelWidth > width3) { + compoundNode.rect.x -= (compoundNode.labelWidth - width3) / 2; + compoundNode.setWidth(compoundNode.labelWidth); + compoundNode.labelMarginLeft = (compoundNode.labelWidth - width3) / 2; + } else if (compoundNode.labelPosHorizontal == "right") { + compoundNode.setWidth(width3 + compoundNode.labelWidth); + } + } + if (compoundNode.labelHeight) { + if (compoundNode.labelPosVertical == "top") { + compoundNode.rect.y -= compoundNode.labelHeight; + compoundNode.setHeight(height2 + compoundNode.labelHeight); + compoundNode.labelMarginTop = compoundNode.labelHeight; + } else if (compoundNode.labelPosVertical == "center" && compoundNode.labelHeight > height2) { + compoundNode.rect.y -= (compoundNode.labelHeight - height2) / 2; + compoundNode.setHeight(compoundNode.labelHeight); + compoundNode.labelMarginTop = (compoundNode.labelHeight - height2) / 2; + } else if (compoundNode.labelPosVertical == "bottom") { + compoundNode.setHeight(height2 + compoundNode.labelHeight); + } + } + } + }); + }; + CoSELayout.prototype.tileNodes = function(nodes5, minWidth) { + var horizontalOrg = this.tileNodesByFavoringDim(nodes5, minWidth, true); + var verticalOrg = this.tileNodesByFavoringDim(nodes5, minWidth, false); + var horizontalRatio = this.getOrgRatio(horizontalOrg); + var verticalRatio = this.getOrgRatio(verticalOrg); + var bestOrg; + if (verticalRatio < horizontalRatio) { + bestOrg = verticalOrg; + } else { + bestOrg = horizontalOrg; + } + return bestOrg; + }; + CoSELayout.prototype.getOrgRatio = function(organization) { + var width3 = organization.width; + var height2 = organization.height; + var ratio = width3 / height2; + if (ratio < 1) { + ratio = 1 / ratio; + } + return ratio; + }; + CoSELayout.prototype.calcIdealRowWidth = function(members, favorHorizontalDim) { + var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL; + var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL; + var membersSize = members.length; + var totalWidth = 0; + var totalHeight = 0; + var maxWidth2 = 0; + members.forEach(function(node2) { + totalWidth += node2.getWidth(); + totalHeight += node2.getHeight(); + if (node2.getWidth() > maxWidth2) { + maxWidth2 = node2.getWidth(); + } + }); + var averageWidth = totalWidth / membersSize; + var averageHeight = totalHeight / membersSize; + var delta = Math.pow(verticalPadding - horizontalPadding, 2) + 4 * (averageWidth + horizontalPadding) * (averageHeight + verticalPadding) * membersSize; + var horizontalCountDouble = (horizontalPadding - verticalPadding + Math.sqrt(delta)) / (2 * (averageWidth + horizontalPadding)); + var horizontalCount; + if (favorHorizontalDim) { + horizontalCount = Math.ceil(horizontalCountDouble); + if (horizontalCount == horizontalCountDouble) { + horizontalCount++; + } + } else { + horizontalCount = Math.floor(horizontalCountDouble); + } + var idealWidth = horizontalCount * (averageWidth + horizontalPadding) - horizontalPadding; + if (maxWidth2 > idealWidth) { + idealWidth = maxWidth2; + } + idealWidth += horizontalPadding * 2; + return idealWidth; + }; + CoSELayout.prototype.tileNodesByFavoringDim = function(nodes5, minWidth, favorHorizontalDim) { + var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL; + var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL; + var tilingCompareBy = CoSEConstants.TILING_COMPARE_BY; + var organization = { + rows: [], + rowWidth: [], + rowHeight: [], + width: 0, + height: minWidth, + // assume minHeight equals to minWidth + verticalPadding, + horizontalPadding, + centerX: 0, + centerY: 0 + }; + if (tilingCompareBy) { + organization.idealRowWidth = this.calcIdealRowWidth(nodes5, favorHorizontalDim); + } + var getNodeArea = /* @__PURE__ */ __name(function getNodeArea2(n2) { + return n2.rect.width * n2.rect.height; + }, "getNodeArea"); + var areaCompareFcn = /* @__PURE__ */ __name(function areaCompareFcn2(n1, n2) { + return getNodeArea(n2) - getNodeArea(n1); + }, "areaCompareFcn"); + nodes5.sort(function(n1, n2) { + var cmpBy = areaCompareFcn; + if (organization.idealRowWidth) { + cmpBy = tilingCompareBy; + return cmpBy(n1.id, n2.id); + } + return cmpBy(n1, n2); + }); + var sumCenterX = 0; + var sumCenterY = 0; + for (var i2 = 0; i2 < nodes5.length; i2++) { + var lNode = nodes5[i2]; + sumCenterX += lNode.getCenterX(); + sumCenterY += lNode.getCenterY(); + } + organization.centerX = sumCenterX / nodes5.length; + organization.centerY = sumCenterY / nodes5.length; + for (var i2 = 0; i2 < nodes5.length; i2++) { + var lNode = nodes5[i2]; + if (organization.rows.length == 0) { + this.insertNodeToRow(organization, lNode, 0, minWidth); + } else if (this.canAddHorizontal(organization, lNode.rect.width, lNode.rect.height)) { + var rowIndex = organization.rows.length - 1; + if (!organization.idealRowWidth) { + rowIndex = this.getShortestRowIndex(organization); + } + this.insertNodeToRow(organization, lNode, rowIndex, minWidth); + } else { + this.insertNodeToRow(organization, lNode, organization.rows.length, minWidth); + } + this.shiftToLastRow(organization); + } + return organization; + }; + CoSELayout.prototype.insertNodeToRow = function(organization, node2, rowIndex, minWidth) { + var minCompoundSize = minWidth; + if (rowIndex == organization.rows.length) { + var secondDimension = []; + organization.rows.push(secondDimension); + organization.rowWidth.push(minCompoundSize); + organization.rowHeight.push(0); + } + var w4 = organization.rowWidth[rowIndex] + node2.rect.width; + if (organization.rows[rowIndex].length > 0) { + w4 += organization.horizontalPadding; + } + organization.rowWidth[rowIndex] = w4; + if (organization.width < w4) { + organization.width = w4; + } + var h3 = node2.rect.height; + if (rowIndex > 0) h3 += organization.verticalPadding; + var extraHeight = 0; + if (h3 > organization.rowHeight[rowIndex]) { + extraHeight = organization.rowHeight[rowIndex]; + organization.rowHeight[rowIndex] = h3; + extraHeight = organization.rowHeight[rowIndex] - extraHeight; + } + organization.height += extraHeight; + organization.rows[rowIndex].push(node2); + }; + CoSELayout.prototype.getShortestRowIndex = function(organization) { + var r2 = -1; + var min9 = Number.MAX_VALUE; + for (var i2 = 0; i2 < organization.rows.length; i2++) { + if (organization.rowWidth[i2] < min9) { + r2 = i2; + min9 = organization.rowWidth[i2]; + } + } + return r2; + }; + CoSELayout.prototype.getLongestRowIndex = function(organization) { + var r2 = -1; + var max10 = Number.MIN_VALUE; + for (var i2 = 0; i2 < organization.rows.length; i2++) { + if (organization.rowWidth[i2] > max10) { + r2 = i2; + max10 = organization.rowWidth[i2]; + } + } + return r2; + }; + CoSELayout.prototype.canAddHorizontal = function(organization, extraWidth, extraHeight) { + if (organization.idealRowWidth) { + var lastRowIndex = organization.rows.length - 1; + var lastRowWidth = organization.rowWidth[lastRowIndex]; + return lastRowWidth + extraWidth + organization.horizontalPadding <= organization.idealRowWidth; + } + var sri = this.getShortestRowIndex(organization); + if (sri < 0) { + return true; + } + var min9 = organization.rowWidth[sri]; + if (min9 + organization.horizontalPadding + extraWidth <= organization.width) return true; + var hDiff = 0; + if (organization.rowHeight[sri] < extraHeight) { + if (sri > 0) hDiff = extraHeight + organization.verticalPadding - organization.rowHeight[sri]; + } + var add_to_row_ratio; + if (organization.width - min9 >= extraWidth + organization.horizontalPadding) { + add_to_row_ratio = (organization.height + hDiff) / (min9 + extraWidth + organization.horizontalPadding); + } else { + add_to_row_ratio = (organization.height + hDiff) / organization.width; + } + hDiff = extraHeight + organization.verticalPadding; + var add_new_row_ratio; + if (organization.width < extraWidth) { + add_new_row_ratio = (organization.height + hDiff) / extraWidth; + } else { + add_new_row_ratio = (organization.height + hDiff) / organization.width; + } + if (add_new_row_ratio < 1) add_new_row_ratio = 1 / add_new_row_ratio; + if (add_to_row_ratio < 1) add_to_row_ratio = 1 / add_to_row_ratio; + return add_to_row_ratio < add_new_row_ratio; + }; + CoSELayout.prototype.shiftToLastRow = function(organization) { + var longest = this.getLongestRowIndex(organization); + var last3 = organization.rowWidth.length - 1; + var row = organization.rows[longest]; + var node2 = row[row.length - 1]; + var diff2 = node2.width + organization.horizontalPadding; + if (organization.width - organization.rowWidth[last3] > diff2 && longest != last3) { + row.splice(-1, 1); + organization.rows[last3].push(node2); + organization.rowWidth[longest] = organization.rowWidth[longest] - diff2; + organization.rowWidth[last3] = organization.rowWidth[last3] + diff2; + organization.width = organization.rowWidth[instance.getLongestRowIndex(organization)]; + var maxHeight = Number.MIN_VALUE; + for (var i2 = 0; i2 < row.length; i2++) { + if (row[i2].height > maxHeight) maxHeight = row[i2].height; + } + if (longest > 0) maxHeight += organization.verticalPadding; + var prevTotal = organization.rowHeight[longest] + organization.rowHeight[last3]; + organization.rowHeight[longest] = maxHeight; + if (organization.rowHeight[last3] < node2.height + organization.verticalPadding) organization.rowHeight[last3] = node2.height + organization.verticalPadding; + var finalTotal = organization.rowHeight[longest] + organization.rowHeight[last3]; + organization.height += finalTotal - prevTotal; + this.shiftToLastRow(organization); + } + }; + CoSELayout.prototype.tilingPreLayout = function() { + if (CoSEConstants.TILE) { + this.groupZeroDegreeMembers(); + this.clearCompounds(); + this.clearZeroDegreeMembers(); + } + }; + CoSELayout.prototype.tilingPostLayout = function() { + if (CoSEConstants.TILE) { + this.repopulateZeroDegreeMembers(); + this.repopulateCompounds(); + } + }; + CoSELayout.prototype.reduceTrees = function() { + var prunedNodesAll = []; + var containsLeaf = true; + var node2; + while (containsLeaf) { + var allNodes = this.graphManager.getAllNodes(); + var prunedNodesInStepTemp = []; + containsLeaf = false; + for (var i2 = 0; i2 < allNodes.length; i2++) { + node2 = allNodes[i2]; + if (node2.getEdges().length == 1 && !node2.getEdges()[0].isInterGraph && node2.getChild() == null) { + if (CoSEConstants.PURE_INCREMENTAL) { + var otherEnd = node2.getEdges()[0].getOtherEnd(node2); + var relativePosition2 = new DimensionD2(node2.getCenterX() - otherEnd.getCenterX(), node2.getCenterY() - otherEnd.getCenterY()); + prunedNodesInStepTemp.push([node2, node2.getEdges()[0], node2.getOwner(), relativePosition2]); + } else { + prunedNodesInStepTemp.push([node2, node2.getEdges()[0], node2.getOwner()]); + } + containsLeaf = true; + } + } + if (containsLeaf == true) { + var prunedNodesInStep = []; + for (var j3 = 0; j3 < prunedNodesInStepTemp.length; j3++) { + if (prunedNodesInStepTemp[j3][0].getEdges().length == 1) { + prunedNodesInStep.push(prunedNodesInStepTemp[j3]); + prunedNodesInStepTemp[j3][0].getOwner().remove(prunedNodesInStepTemp[j3][0]); + } + } + prunedNodesAll.push(prunedNodesInStep); + this.graphManager.resetAllNodes(); + this.graphManager.resetAllEdges(); + } + } + this.prunedNodesAll = prunedNodesAll; + }; + CoSELayout.prototype.growTree = function(prunedNodesAll) { + var lengthOfPrunedNodesInStep = prunedNodesAll.length; + var prunedNodesInStep = prunedNodesAll[lengthOfPrunedNodesInStep - 1]; + var nodeData2; + for (var i2 = 0; i2 < prunedNodesInStep.length; i2++) { + nodeData2 = prunedNodesInStep[i2]; + this.findPlaceforPrunedNode(nodeData2); + nodeData2[2].add(nodeData2[0]); + nodeData2[2].add(nodeData2[1], nodeData2[1].source, nodeData2[1].target); + } + prunedNodesAll.splice(prunedNodesAll.length - 1, 1); + this.graphManager.resetAllNodes(); + this.graphManager.resetAllEdges(); + }; + CoSELayout.prototype.findPlaceforPrunedNode = function(nodeData2) { + var gridForPrunedNode; + var nodeToConnect; + var prunedNode = nodeData2[0]; + if (prunedNode == nodeData2[1].source) { + nodeToConnect = nodeData2[1].target; + } else { + nodeToConnect = nodeData2[1].source; + } + if (CoSEConstants.PURE_INCREMENTAL) { + prunedNode.setCenter(nodeToConnect.getCenterX() + nodeData2[3].getWidth(), nodeToConnect.getCenterY() + nodeData2[3].getHeight()); + } else { + var startGridX = nodeToConnect.startX; + var finishGridX = nodeToConnect.finishX; + var startGridY = nodeToConnect.startY; + var finishGridY = nodeToConnect.finishY; + var upNodeCount = 0; + var downNodeCount = 0; + var rightNodeCount = 0; + var leftNodeCount = 0; + var controlRegions = [upNodeCount, rightNodeCount, downNodeCount, leftNodeCount]; + if (startGridY > 0) { + for (var i2 = startGridX; i2 <= finishGridX; i2++) { + controlRegions[0] += this.grid[i2][startGridY - 1].length + this.grid[i2][startGridY].length - 1; + } + } + if (finishGridX < this.grid.length - 1) { + for (var i2 = startGridY; i2 <= finishGridY; i2++) { + controlRegions[1] += this.grid[finishGridX + 1][i2].length + this.grid[finishGridX][i2].length - 1; + } + } + if (finishGridY < this.grid[0].length - 1) { + for (var i2 = startGridX; i2 <= finishGridX; i2++) { + controlRegions[2] += this.grid[i2][finishGridY + 1].length + this.grid[i2][finishGridY].length - 1; + } + } + if (startGridX > 0) { + for (var i2 = startGridY; i2 <= finishGridY; i2++) { + controlRegions[3] += this.grid[startGridX - 1][i2].length + this.grid[startGridX][i2].length - 1; + } + } + var min9 = Integer.MAX_VALUE; + var minCount; + var minIndex; + for (var j3 = 0; j3 < controlRegions.length; j3++) { + if (controlRegions[j3] < min9) { + min9 = controlRegions[j3]; + minCount = 1; + minIndex = j3; + } else if (controlRegions[j3] == min9) { + minCount++; + } + } + if (minCount == 3 && min9 == 0) { + if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[2] == 0) { + gridForPrunedNode = 1; + } else if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[3] == 0) { + gridForPrunedNode = 0; + } else if (controlRegions[0] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) { + gridForPrunedNode = 3; + } else if (controlRegions[1] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) { + gridForPrunedNode = 2; + } + } else if (minCount == 2 && min9 == 0) { + var random2 = Math.floor(Math.random() * 2); + if (controlRegions[0] == 0 && controlRegions[1] == 0) { + ; + if (random2 == 0) { + gridForPrunedNode = 0; + } else { + gridForPrunedNode = 1; + } + } else if (controlRegions[0] == 0 && controlRegions[2] == 0) { + if (random2 == 0) { + gridForPrunedNode = 0; + } else { + gridForPrunedNode = 2; + } + } else if (controlRegions[0] == 0 && controlRegions[3] == 0) { + if (random2 == 0) { + gridForPrunedNode = 0; + } else { + gridForPrunedNode = 3; + } + } else if (controlRegions[1] == 0 && controlRegions[2] == 0) { + if (random2 == 0) { + gridForPrunedNode = 1; + } else { + gridForPrunedNode = 2; + } + } else if (controlRegions[1] == 0 && controlRegions[3] == 0) { + if (random2 == 0) { + gridForPrunedNode = 1; + } else { + gridForPrunedNode = 3; + } + } else { + if (random2 == 0) { + gridForPrunedNode = 2; + } else { + gridForPrunedNode = 3; + } + } + } else if (minCount == 4 && min9 == 0) { + var random2 = Math.floor(Math.random() * 4); + gridForPrunedNode = random2; + } else { + gridForPrunedNode = minIndex; + } + if (gridForPrunedNode == 0) { + prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() - nodeToConnect.getHeight() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getHeight() / 2); + } else if (gridForPrunedNode == 1) { + prunedNode.setCenter(nodeToConnect.getCenterX() + nodeToConnect.getWidth() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getWidth() / 2, nodeToConnect.getCenterY()); + } else if (gridForPrunedNode == 2) { + prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() + nodeToConnect.getHeight() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getHeight() / 2); + } else { + prunedNode.setCenter(nodeToConnect.getCenterX() - nodeToConnect.getWidth() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getWidth() / 2, nodeToConnect.getCenterY()); + } + } + }; + module3.exports = CoSELayout; + }) + ), + /***/ + 991: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var FDLayoutNode = __webpack_require__2(551).FDLayoutNode; + var IMath = __webpack_require__2(551).IMath; + function CoSENode(gm, loc, size4, vNode) { + FDLayoutNode.call(this, gm, loc, size4, vNode); + } + __name(CoSENode, "CoSENode"); + CoSENode.prototype = Object.create(FDLayoutNode.prototype); + for (var prop in FDLayoutNode) { + CoSENode[prop] = FDLayoutNode[prop]; + } + CoSENode.prototype.calculateDisplacement = function() { + var layout6 = this.graphManager.getLayout(); + if (this.getChild() != null && this.fixedNodeWeight) { + this.displacementX += layout6.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.fixedNodeWeight; + this.displacementY += layout6.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.fixedNodeWeight; + } else { + this.displacementX += layout6.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren; + this.displacementY += layout6.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren; + } + if (Math.abs(this.displacementX) > layout6.coolingFactor * layout6.maxNodeDisplacement) { + this.displacementX = layout6.coolingFactor * layout6.maxNodeDisplacement * IMath.sign(this.displacementX); + } + if (Math.abs(this.displacementY) > layout6.coolingFactor * layout6.maxNodeDisplacement) { + this.displacementY = layout6.coolingFactor * layout6.maxNodeDisplacement * IMath.sign(this.displacementY); + } + if (this.child && this.child.getNodes().length > 0) { + this.propogateDisplacementToChildren(this.displacementX, this.displacementY); + } + }; + CoSENode.prototype.propogateDisplacementToChildren = function(dX, dY) { + var nodes5 = this.getChild().getNodes(); + var node2; + for (var i2 = 0; i2 < nodes5.length; i2++) { + node2 = nodes5[i2]; + if (node2.getChild() == null) { + node2.displacementX += dX; + node2.displacementY += dY; + } else { + node2.propogateDisplacementToChildren(dX, dY); + } + } + }; + CoSENode.prototype.move = function() { + var layout6 = this.graphManager.getLayout(); + if (this.child == null || this.child.getNodes().length == 0) { + this.moveBy(this.displacementX, this.displacementY); + layout6.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY); + } + this.springForceX = 0; + this.springForceY = 0; + this.repulsionForceX = 0; + this.repulsionForceY = 0; + this.gravitationForceX = 0; + this.gravitationForceY = 0; + this.displacementX = 0; + this.displacementY = 0; + }; + CoSENode.prototype.setPred1 = function(pred12) { + this.pred1 = pred12; + }; + CoSENode.prototype.getPred1 = function() { + return pred1; + }; + CoSENode.prototype.getPred2 = function() { + return pred2; + }; + CoSENode.prototype.setNext = function(next3) { + this.next = next3; + }; + CoSENode.prototype.getNext = function() { + return next; + }; + CoSENode.prototype.setProcessed = function(processed2) { + this.processed = processed2; + }; + CoSENode.prototype.isProcessed = function() { + return processed; + }; + module3.exports = CoSENode; + }) + ), + /***/ + 902: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + function _toConsumableArray2(arr) { + if (Array.isArray(arr)) { + for (var i2 = 0, arr2 = Array(arr.length); i2 < arr.length; i2++) { + arr2[i2] = arr[i2]; + } + return arr2; + } else { + return Array.from(arr); + } + } + __name(_toConsumableArray2, "_toConsumableArray"); + var CoSEConstants = __webpack_require__2(806); + var LinkedList = __webpack_require__2(551).LinkedList; + var Matrix = __webpack_require__2(551).Matrix; + var SVD = __webpack_require__2(551).SVD; + function ConstraintHandler() { + } + __name(ConstraintHandler, "ConstraintHandler"); + ConstraintHandler.handleConstraints = function(layout6) { + var constraints = {}; + constraints.fixedNodeConstraint = layout6.constraints.fixedNodeConstraint; + constraints.alignmentConstraint = layout6.constraints.alignmentConstraint; + constraints.relativePlacementConstraint = layout6.constraints.relativePlacementConstraint; + var idToNodeMap = /* @__PURE__ */ new Map(); + var nodeIndexes = /* @__PURE__ */ new Map(); + var xCoords = []; + var yCoords = []; + var allNodes = layout6.getAllNodes(); + var index = 0; + for (var i2 = 0; i2 < allNodes.length; i2++) { + var node2 = allNodes[i2]; + if (node2.getChild() == null) { + nodeIndexes.set(node2.id, index++); + xCoords.push(node2.getCenterX()); + yCoords.push(node2.getCenterY()); + idToNodeMap.set(node2.id, node2); + } + } + if (constraints.relativePlacementConstraint) { + constraints.relativePlacementConstraint.forEach(function(constraint) { + if (!constraint.gap && constraint.gap != 0) { + if (constraint.left) { + constraint.gap = CoSEConstants.DEFAULT_EDGE_LENGTH + idToNodeMap.get(constraint.left).getWidth() / 2 + idToNodeMap.get(constraint.right).getWidth() / 2; + } else { + constraint.gap = CoSEConstants.DEFAULT_EDGE_LENGTH + idToNodeMap.get(constraint.top).getHeight() / 2 + idToNodeMap.get(constraint.bottom).getHeight() / 2; + } + } + }); + } + var calculatePositionDiff = /* @__PURE__ */ __name(function calculatePositionDiff2(pos1, pos2) { + return { x: pos1.x - pos2.x, y: pos1.y - pos2.y }; + }, "calculatePositionDiff"); + var calculateAvgPosition = /* @__PURE__ */ __name(function calculateAvgPosition2(nodeIdSet) { + var xPosSum = 0; + var yPosSum = 0; + nodeIdSet.forEach(function(nodeId) { + xPosSum += xCoords[nodeIndexes.get(nodeId)]; + yPosSum += yCoords[nodeIndexes.get(nodeId)]; + }); + return { x: xPosSum / nodeIdSet.size, y: yPosSum / nodeIdSet.size }; + }, "calculateAvgPosition"); + var findAppropriatePositionForRelativePlacement = /* @__PURE__ */ __name(function findAppropriatePositionForRelativePlacement2(graph, direction, fixedNodes2, dummyPositions, componentSources) { + function setUnion(setA, setB) { + var union2 = new Set(setA); + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = void 0; + try { + for (var _iterator = setB[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var elem = _step.value; + union2.add(elem); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + return union2; + } + __name(setUnion, "setUnion"); + var inDegrees = /* @__PURE__ */ new Map(); + graph.forEach(function(value2, key) { + inDegrees.set(key, 0); + }); + graph.forEach(function(value2, key) { + value2.forEach(function(adjacent) { + inDegrees.set(adjacent.id, inDegrees.get(adjacent.id) + 1); + }); + }); + var positionMap = /* @__PURE__ */ new Map(); + var pastMap = /* @__PURE__ */ new Map(); + var queue = new LinkedList(); + inDegrees.forEach(function(value2, key) { + if (value2 == 0) { + queue.push(key); + if (!fixedNodes2) { + if (direction == "horizontal") { + positionMap.set(key, nodeIndexes.has(key) ? xCoords[nodeIndexes.get(key)] : dummyPositions.get(key)); + } else { + positionMap.set(key, nodeIndexes.has(key) ? yCoords[nodeIndexes.get(key)] : dummyPositions.get(key)); + } + } + } else { + positionMap.set(key, Number.NEGATIVE_INFINITY); + } + if (fixedNodes2) { + pastMap.set(key, /* @__PURE__ */ new Set([key])); + } + }); + if (fixedNodes2) { + componentSources.forEach(function(component2) { + var fixedIds = []; + component2.forEach(function(nodeId) { + if (fixedNodes2.has(nodeId)) { + fixedIds.push(nodeId); + } + }); + if (fixedIds.length > 0) { + var position5 = 0; + fixedIds.forEach(function(fixedId) { + if (direction == "horizontal") { + positionMap.set(fixedId, nodeIndexes.has(fixedId) ? xCoords[nodeIndexes.get(fixedId)] : dummyPositions.get(fixedId)); + position5 += positionMap.get(fixedId); + } else { + positionMap.set(fixedId, nodeIndexes.has(fixedId) ? yCoords[nodeIndexes.get(fixedId)] : dummyPositions.get(fixedId)); + position5 += positionMap.get(fixedId); + } + }); + position5 = position5 / fixedIds.length; + component2.forEach(function(nodeId) { + if (!fixedNodes2.has(nodeId)) { + positionMap.set(nodeId, position5); + } + }); + } else { + var _position = 0; + component2.forEach(function(nodeId) { + if (direction == "horizontal") { + _position += nodeIndexes.has(nodeId) ? xCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId); + } else { + _position += nodeIndexes.has(nodeId) ? yCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId); + } + }); + _position = _position / component2.length; + component2.forEach(function(nodeId) { + positionMap.set(nodeId, _position); + }); + } + }); + } + var _loop = /* @__PURE__ */ __name(function _loop2() { + var currentNode = queue.shift(); + var neighbors = graph.get(currentNode); + neighbors.forEach(function(neighbor) { + if (positionMap.get(neighbor.id) < positionMap.get(currentNode) + neighbor.gap) { + if (fixedNodes2 && fixedNodes2.has(neighbor.id)) { + var fixedPosition = void 0; + if (direction == "horizontal") { + fixedPosition = nodeIndexes.has(neighbor.id) ? xCoords[nodeIndexes.get(neighbor.id)] : dummyPositions.get(neighbor.id); + } else { + fixedPosition = nodeIndexes.has(neighbor.id) ? yCoords[nodeIndexes.get(neighbor.id)] : dummyPositions.get(neighbor.id); + } + positionMap.set(neighbor.id, fixedPosition); + if (fixedPosition < positionMap.get(currentNode) + neighbor.gap) { + var diff2 = positionMap.get(currentNode) + neighbor.gap - fixedPosition; + pastMap.get(currentNode).forEach(function(nodeId) { + positionMap.set(nodeId, positionMap.get(nodeId) - diff2); + }); + } + } else { + positionMap.set(neighbor.id, positionMap.get(currentNode) + neighbor.gap); + } + } + inDegrees.set(neighbor.id, inDegrees.get(neighbor.id) - 1); + if (inDegrees.get(neighbor.id) == 0) { + queue.push(neighbor.id); + } + if (fixedNodes2) { + pastMap.set(neighbor.id, setUnion(pastMap.get(currentNode), pastMap.get(neighbor.id))); + } + }); + }, "_loop"); + while (queue.length != 0) { + _loop(); + } + if (fixedNodes2) { + var sinkNodes = /* @__PURE__ */ new Set(); + graph.forEach(function(value2, key) { + if (value2.length == 0) { + sinkNodes.add(key); + } + }); + var _components = []; + pastMap.forEach(function(value2, key) { + if (sinkNodes.has(key)) { + var isFixedComponent = false; + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = void 0; + try { + for (var _iterator2 = value2[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var nodeId = _step2.value; + if (fixedNodes2.has(nodeId)) { + isFixedComponent = true; + } + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + if (!isFixedComponent) { + var isExist = false; + var existAt = void 0; + _components.forEach(function(component2, index2) { + if (component2.has([].concat(_toConsumableArray2(value2))[0])) { + isExist = true; + existAt = index2; + } + }); + if (!isExist) { + _components.push(new Set(value2)); + } else { + value2.forEach(function(ele) { + _components[existAt].add(ele); + }); + } + } + } + }); + _components.forEach(function(component2, index2) { + var minBefore = Number.POSITIVE_INFINITY; + var minAfter = Number.POSITIVE_INFINITY; + var maxBefore = Number.NEGATIVE_INFINITY; + var maxAfter = Number.NEGATIVE_INFINITY; + var _iteratorNormalCompletion3 = true; + var _didIteratorError3 = false; + var _iteratorError3 = void 0; + try { + for (var _iterator3 = component2[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { + var nodeId = _step3.value; + var posBefore = void 0; + if (direction == "horizontal") { + posBefore = nodeIndexes.has(nodeId) ? xCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId); + } else { + posBefore = nodeIndexes.has(nodeId) ? yCoords[nodeIndexes.get(nodeId)] : dummyPositions.get(nodeId); + } + var posAfter = positionMap.get(nodeId); + if (posBefore < minBefore) { + minBefore = posBefore; + } + if (posBefore > maxBefore) { + maxBefore = posBefore; + } + if (posAfter < minAfter) { + minAfter = posAfter; + } + if (posAfter > maxAfter) { + maxAfter = posAfter; + } + } + } catch (err) { + _didIteratorError3 = true; + _iteratorError3 = err; + } finally { + try { + if (!_iteratorNormalCompletion3 && _iterator3.return) { + _iterator3.return(); + } + } finally { + if (_didIteratorError3) { + throw _iteratorError3; + } + } + } + var diff2 = (minBefore + maxBefore) / 2 - (minAfter + maxAfter) / 2; + var _iteratorNormalCompletion4 = true; + var _didIteratorError4 = false; + var _iteratorError4 = void 0; + try { + for (var _iterator4 = component2[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { + var _nodeId = _step4.value; + positionMap.set(_nodeId, positionMap.get(_nodeId) + diff2); + } + } catch (err) { + _didIteratorError4 = true; + _iteratorError4 = err; + } finally { + try { + if (!_iteratorNormalCompletion4 && _iterator4.return) { + _iterator4.return(); + } + } finally { + if (_didIteratorError4) { + throw _iteratorError4; + } + } + } + }); + } + return positionMap; + }, "findAppropriatePositionForRelativePlacement"); + var applyReflectionForRelativePlacement = /* @__PURE__ */ __name(function applyReflectionForRelativePlacement2(relativePlacementConstraints) { + var reflectOnY = 0, notReflectOnY = 0; + var reflectOnX = 0, notReflectOnX = 0; + relativePlacementConstraints.forEach(function(constraint) { + if (constraint.left) { + xCoords[nodeIndexes.get(constraint.left)] - xCoords[nodeIndexes.get(constraint.right)] >= 0 ? reflectOnY++ : notReflectOnY++; + } else { + yCoords[nodeIndexes.get(constraint.top)] - yCoords[nodeIndexes.get(constraint.bottom)] >= 0 ? reflectOnX++ : notReflectOnX++; + } + }); + if (reflectOnY > notReflectOnY && reflectOnX > notReflectOnX) { + for (var _i = 0; _i < nodeIndexes.size; _i++) { + xCoords[_i] = -1 * xCoords[_i]; + yCoords[_i] = -1 * yCoords[_i]; + } + } else if (reflectOnY > notReflectOnY) { + for (var _i2 = 0; _i2 < nodeIndexes.size; _i2++) { + xCoords[_i2] = -1 * xCoords[_i2]; + } + } else if (reflectOnX > notReflectOnX) { + for (var _i3 = 0; _i3 < nodeIndexes.size; _i3++) { + yCoords[_i3] = -1 * yCoords[_i3]; + } + } + }, "applyReflectionForRelativePlacement"); + var findComponents = /* @__PURE__ */ __name(function findComponents2(graph) { + var components4 = []; + var queue = new LinkedList(); + var visited = /* @__PURE__ */ new Set(); + var count2 = 0; + graph.forEach(function(value2, key) { + if (!visited.has(key)) { + components4[count2] = []; + var _currentNode = key; + queue.push(_currentNode); + visited.add(_currentNode); + components4[count2].push(_currentNode); + while (queue.length != 0) { + _currentNode = queue.shift(); + var neighbors = graph.get(_currentNode); + neighbors.forEach(function(neighbor) { + if (!visited.has(neighbor.id)) { + queue.push(neighbor.id); + visited.add(neighbor.id); + components4[count2].push(neighbor.id); + } + }); + } + count2++; + } + }); + return components4; + }, "findComponents"); + var dagToUndirected = /* @__PURE__ */ __name(function dagToUndirected2(dag2) { + var undirected = /* @__PURE__ */ new Map(); + dag2.forEach(function(value2, key) { + undirected.set(key, []); + }); + dag2.forEach(function(value2, key) { + value2.forEach(function(adjacent) { + undirected.get(key).push(adjacent); + undirected.get(adjacent.id).push({ id: key, gap: adjacent.gap, direction: adjacent.direction }); + }); + }); + return undirected; + }, "dagToUndirected"); + var dagToReversed = /* @__PURE__ */ __name(function dagToReversed2(dag2) { + var reversed = /* @__PURE__ */ new Map(); + dag2.forEach(function(value2, key) { + reversed.set(key, []); + }); + dag2.forEach(function(value2, key) { + value2.forEach(function(adjacent) { + reversed.get(adjacent.id).push({ id: key, gap: adjacent.gap, direction: adjacent.direction }); + }); + }); + return reversed; + }, "dagToReversed"); + var targetMatrix = []; + var sourceMatrix = []; + var standardTransformation = false; + var reflectionType = false; + var fixedNodes = /* @__PURE__ */ new Set(); + var dag = /* @__PURE__ */ new Map(); + var dagUndirected = /* @__PURE__ */ new Map(); + var components3 = []; + if (constraints.fixedNodeConstraint) { + constraints.fixedNodeConstraint.forEach(function(nodeData2) { + fixedNodes.add(nodeData2.nodeId); + }); + } + if (constraints.relativePlacementConstraint) { + constraints.relativePlacementConstraint.forEach(function(constraint) { + if (constraint.left) { + if (dag.has(constraint.left)) { + dag.get(constraint.left).push({ id: constraint.right, gap: constraint.gap, direction: "horizontal" }); + } else { + dag.set(constraint.left, [{ id: constraint.right, gap: constraint.gap, direction: "horizontal" }]); + } + if (!dag.has(constraint.right)) { + dag.set(constraint.right, []); + } + } else { + if (dag.has(constraint.top)) { + dag.get(constraint.top).push({ id: constraint.bottom, gap: constraint.gap, direction: "vertical" }); + } else { + dag.set(constraint.top, [{ id: constraint.bottom, gap: constraint.gap, direction: "vertical" }]); + } + if (!dag.has(constraint.bottom)) { + dag.set(constraint.bottom, []); + } + } + }); + dagUndirected = dagToUndirected(dag); + components3 = findComponents(dagUndirected); + } + if (CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING) { + if (constraints.fixedNodeConstraint && constraints.fixedNodeConstraint.length > 1) { + constraints.fixedNodeConstraint.forEach(function(nodeData2, i3) { + targetMatrix[i3] = [nodeData2.position.x, nodeData2.position.y]; + sourceMatrix[i3] = [xCoords[nodeIndexes.get(nodeData2.nodeId)], yCoords[nodeIndexes.get(nodeData2.nodeId)]]; + }); + standardTransformation = true; + } else if (constraints.alignmentConstraint) { + (function() { + var count2 = 0; + if (constraints.alignmentConstraint.vertical) { + var verticalAlign = constraints.alignmentConstraint.vertical; + var _loop2 = /* @__PURE__ */ __name(function _loop22(_i42) { + var alignmentSet = /* @__PURE__ */ new Set(); + verticalAlign[_i42].forEach(function(nodeId) { + alignmentSet.add(nodeId); + }); + var intersection4 = new Set([].concat(_toConsumableArray2(alignmentSet)).filter(function(x5) { + return fixedNodes.has(x5); + })); + var xPos = void 0; + if (intersection4.size > 0) xPos = xCoords[nodeIndexes.get(intersection4.values().next().value)]; + else xPos = calculateAvgPosition(alignmentSet).x; + verticalAlign[_i42].forEach(function(nodeId) { + targetMatrix[count2] = [xPos, yCoords[nodeIndexes.get(nodeId)]]; + sourceMatrix[count2] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]]; + count2++; + }); + }, "_loop2"); + for (var _i4 = 0; _i4 < verticalAlign.length; _i4++) { + _loop2(_i4); + } + standardTransformation = true; + } + if (constraints.alignmentConstraint.horizontal) { + var horizontalAlign = constraints.alignmentConstraint.horizontal; + var _loop3 = /* @__PURE__ */ __name(function _loop32(_i52) { + var alignmentSet = /* @__PURE__ */ new Set(); + horizontalAlign[_i52].forEach(function(nodeId) { + alignmentSet.add(nodeId); + }); + var intersection4 = new Set([].concat(_toConsumableArray2(alignmentSet)).filter(function(x5) { + return fixedNodes.has(x5); + })); + var yPos = void 0; + if (intersection4.size > 0) yPos = xCoords[nodeIndexes.get(intersection4.values().next().value)]; + else yPos = calculateAvgPosition(alignmentSet).y; + horizontalAlign[_i52].forEach(function(nodeId) { + targetMatrix[count2] = [xCoords[nodeIndexes.get(nodeId)], yPos]; + sourceMatrix[count2] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]]; + count2++; + }); + }, "_loop3"); + for (var _i5 = 0; _i5 < horizontalAlign.length; _i5++) { + _loop3(_i5); + } + standardTransformation = true; + } + if (constraints.relativePlacementConstraint) { + reflectionType = true; + } + })(); + } else if (constraints.relativePlacementConstraint) { + var largestComponentSize = 0; + var largestComponentIndex = 0; + for (var _i6 = 0; _i6 < components3.length; _i6++) { + if (components3[_i6].length > largestComponentSize) { + largestComponentSize = components3[_i6].length; + largestComponentIndex = _i6; + } + } + if (largestComponentSize < dagUndirected.size / 2) { + applyReflectionForRelativePlacement(constraints.relativePlacementConstraint); + standardTransformation = false; + reflectionType = false; + } else { + var subGraphOnHorizontal = /* @__PURE__ */ new Map(); + var subGraphOnVertical = /* @__PURE__ */ new Map(); + var constraintsInlargestComponent = []; + components3[largestComponentIndex].forEach(function(nodeId) { + dag.get(nodeId).forEach(function(adjacent) { + if (adjacent.direction == "horizontal") { + if (subGraphOnHorizontal.has(nodeId)) { + subGraphOnHorizontal.get(nodeId).push(adjacent); + } else { + subGraphOnHorizontal.set(nodeId, [adjacent]); + } + if (!subGraphOnHorizontal.has(adjacent.id)) { + subGraphOnHorizontal.set(adjacent.id, []); + } + constraintsInlargestComponent.push({ left: nodeId, right: adjacent.id }); + } else { + if (subGraphOnVertical.has(nodeId)) { + subGraphOnVertical.get(nodeId).push(adjacent); + } else { + subGraphOnVertical.set(nodeId, [adjacent]); + } + if (!subGraphOnVertical.has(adjacent.id)) { + subGraphOnVertical.set(adjacent.id, []); + } + constraintsInlargestComponent.push({ top: nodeId, bottom: adjacent.id }); + } + }); + }); + applyReflectionForRelativePlacement(constraintsInlargestComponent); + reflectionType = false; + var positionMapHorizontal = findAppropriatePositionForRelativePlacement(subGraphOnHorizontal, "horizontal"); + var positionMapVertical = findAppropriatePositionForRelativePlacement(subGraphOnVertical, "vertical"); + components3[largestComponentIndex].forEach(function(nodeId, i3) { + sourceMatrix[i3] = [xCoords[nodeIndexes.get(nodeId)], yCoords[nodeIndexes.get(nodeId)]]; + targetMatrix[i3] = []; + if (positionMapHorizontal.has(nodeId)) { + targetMatrix[i3][0] = positionMapHorizontal.get(nodeId); + } else { + targetMatrix[i3][0] = xCoords[nodeIndexes.get(nodeId)]; + } + if (positionMapVertical.has(nodeId)) { + targetMatrix[i3][1] = positionMapVertical.get(nodeId); + } else { + targetMatrix[i3][1] = yCoords[nodeIndexes.get(nodeId)]; + } + }); + standardTransformation = true; + } + } + if (standardTransformation) { + var transformationMatrix = void 0; + var targetMatrixTranspose = Matrix.transpose(targetMatrix); + var sourceMatrixTranspose = Matrix.transpose(sourceMatrix); + for (var _i7 = 0; _i7 < targetMatrixTranspose.length; _i7++) { + targetMatrixTranspose[_i7] = Matrix.multGamma(targetMatrixTranspose[_i7]); + sourceMatrixTranspose[_i7] = Matrix.multGamma(sourceMatrixTranspose[_i7]); + } + var tempMatrix = Matrix.multMat(targetMatrixTranspose, Matrix.transpose(sourceMatrixTranspose)); + var SVDResult = SVD.svd(tempMatrix); + transformationMatrix = Matrix.multMat(SVDResult.V, Matrix.transpose(SVDResult.U)); + for (var _i8 = 0; _i8 < nodeIndexes.size; _i8++) { + var temp1 = [xCoords[_i8], yCoords[_i8]]; + var temp2 = [transformationMatrix[0][0], transformationMatrix[1][0]]; + var temp3 = [transformationMatrix[0][1], transformationMatrix[1][1]]; + xCoords[_i8] = Matrix.dotProduct(temp1, temp2); + yCoords[_i8] = Matrix.dotProduct(temp1, temp3); + } + if (reflectionType) { + applyReflectionForRelativePlacement(constraints.relativePlacementConstraint); + } + } + } + if (CoSEConstants.ENFORCE_CONSTRAINTS) { + if (constraints.fixedNodeConstraint && constraints.fixedNodeConstraint.length > 0) { + var translationAmount = { x: 0, y: 0 }; + constraints.fixedNodeConstraint.forEach(function(nodeData2, i3) { + var posInTheory = { x: xCoords[nodeIndexes.get(nodeData2.nodeId)], y: yCoords[nodeIndexes.get(nodeData2.nodeId)] }; + var posDesired = nodeData2.position; + var posDiff = calculatePositionDiff(posDesired, posInTheory); + translationAmount.x += posDiff.x; + translationAmount.y += posDiff.y; + }); + translationAmount.x /= constraints.fixedNodeConstraint.length; + translationAmount.y /= constraints.fixedNodeConstraint.length; + xCoords.forEach(function(value2, i3) { + xCoords[i3] += translationAmount.x; + }); + yCoords.forEach(function(value2, i3) { + yCoords[i3] += translationAmount.y; + }); + constraints.fixedNodeConstraint.forEach(function(nodeData2) { + xCoords[nodeIndexes.get(nodeData2.nodeId)] = nodeData2.position.x; + yCoords[nodeIndexes.get(nodeData2.nodeId)] = nodeData2.position.y; + }); + } + if (constraints.alignmentConstraint) { + if (constraints.alignmentConstraint.vertical) { + var xAlign = constraints.alignmentConstraint.vertical; + var _loop4 = /* @__PURE__ */ __name(function _loop42(_i92) { + var alignmentSet = /* @__PURE__ */ new Set(); + xAlign[_i92].forEach(function(nodeId) { + alignmentSet.add(nodeId); + }); + var intersection4 = new Set([].concat(_toConsumableArray2(alignmentSet)).filter(function(x5) { + return fixedNodes.has(x5); + })); + var xPos = void 0; + if (intersection4.size > 0) xPos = xCoords[nodeIndexes.get(intersection4.values().next().value)]; + else xPos = calculateAvgPosition(alignmentSet).x; + alignmentSet.forEach(function(nodeId) { + if (!fixedNodes.has(nodeId)) xCoords[nodeIndexes.get(nodeId)] = xPos; + }); + }, "_loop4"); + for (var _i9 = 0; _i9 < xAlign.length; _i9++) { + _loop4(_i9); + } + } + if (constraints.alignmentConstraint.horizontal) { + var yAlign = constraints.alignmentConstraint.horizontal; + var _loop5 = /* @__PURE__ */ __name(function _loop52(_i102) { + var alignmentSet = /* @__PURE__ */ new Set(); + yAlign[_i102].forEach(function(nodeId) { + alignmentSet.add(nodeId); + }); + var intersection4 = new Set([].concat(_toConsumableArray2(alignmentSet)).filter(function(x5) { + return fixedNodes.has(x5); + })); + var yPos = void 0; + if (intersection4.size > 0) yPos = yCoords[nodeIndexes.get(intersection4.values().next().value)]; + else yPos = calculateAvgPosition(alignmentSet).y; + alignmentSet.forEach(function(nodeId) { + if (!fixedNodes.has(nodeId)) yCoords[nodeIndexes.get(nodeId)] = yPos; + }); + }, "_loop5"); + for (var _i10 = 0; _i10 < yAlign.length; _i10++) { + _loop5(_i10); + } + } + } + if (constraints.relativePlacementConstraint) { + (function() { + var nodeToDummyForVerticalAlignment = /* @__PURE__ */ new Map(); + var nodeToDummyForHorizontalAlignment = /* @__PURE__ */ new Map(); + var dummyToNodeForVerticalAlignment = /* @__PURE__ */ new Map(); + var dummyToNodeForHorizontalAlignment = /* @__PURE__ */ new Map(); + var dummyPositionsForVerticalAlignment = /* @__PURE__ */ new Map(); + var dummyPositionsForHorizontalAlignment = /* @__PURE__ */ new Map(); + var fixedNodesOnHorizontal = /* @__PURE__ */ new Set(); + var fixedNodesOnVertical = /* @__PURE__ */ new Set(); + fixedNodes.forEach(function(nodeId2) { + fixedNodesOnHorizontal.add(nodeId2); + fixedNodesOnVertical.add(nodeId2); + }); + if (constraints.alignmentConstraint) { + if (constraints.alignmentConstraint.vertical) { + var verticalAlignment2 = constraints.alignmentConstraint.vertical; + var _loop6 = /* @__PURE__ */ __name(function _loop62(_i112) { + dummyToNodeForVerticalAlignment.set("dummy" + _i112, []); + verticalAlignment2[_i112].forEach(function(nodeId2) { + nodeToDummyForVerticalAlignment.set(nodeId2, "dummy" + _i112); + dummyToNodeForVerticalAlignment.get("dummy" + _i112).push(nodeId2); + if (fixedNodes.has(nodeId2)) { + fixedNodesOnHorizontal.add("dummy" + _i112); + } + }); + dummyPositionsForVerticalAlignment.set("dummy" + _i112, xCoords[nodeIndexes.get(verticalAlignment2[_i112][0])]); + }, "_loop6"); + for (var _i11 = 0; _i11 < verticalAlignment2.length; _i11++) { + _loop6(_i11); + } + } + if (constraints.alignmentConstraint.horizontal) { + var horizontalAlignment = constraints.alignmentConstraint.horizontal; + var _loop7 = /* @__PURE__ */ __name(function _loop72(_i122) { + dummyToNodeForHorizontalAlignment.set("dummy" + _i122, []); + horizontalAlignment[_i122].forEach(function(nodeId2) { + nodeToDummyForHorizontalAlignment.set(nodeId2, "dummy" + _i122); + dummyToNodeForHorizontalAlignment.get("dummy" + _i122).push(nodeId2); + if (fixedNodes.has(nodeId2)) { + fixedNodesOnVertical.add("dummy" + _i122); + } + }); + dummyPositionsForHorizontalAlignment.set("dummy" + _i122, yCoords[nodeIndexes.get(horizontalAlignment[_i122][0])]); + }, "_loop7"); + for (var _i12 = 0; _i12 < horizontalAlignment.length; _i12++) { + _loop7(_i12); + } + } + } + var dagOnHorizontal = /* @__PURE__ */ new Map(); + var dagOnVertical = /* @__PURE__ */ new Map(); + var _loop8 = /* @__PURE__ */ __name(function _loop82(nodeId2) { + dag.get(nodeId2).forEach(function(adjacent) { + var sourceId = void 0; + var targetNode = void 0; + if (adjacent["direction"] == "horizontal") { + sourceId = nodeToDummyForVerticalAlignment.get(nodeId2) ? nodeToDummyForVerticalAlignment.get(nodeId2) : nodeId2; + if (nodeToDummyForVerticalAlignment.get(adjacent.id)) { + targetNode = { id: nodeToDummyForVerticalAlignment.get(adjacent.id), gap: adjacent.gap, direction: adjacent.direction }; + } else { + targetNode = adjacent; + } + if (dagOnHorizontal.has(sourceId)) { + dagOnHorizontal.get(sourceId).push(targetNode); + } else { + dagOnHorizontal.set(sourceId, [targetNode]); + } + if (!dagOnHorizontal.has(targetNode.id)) { + dagOnHorizontal.set(targetNode.id, []); + } + } else { + sourceId = nodeToDummyForHorizontalAlignment.get(nodeId2) ? nodeToDummyForHorizontalAlignment.get(nodeId2) : nodeId2; + if (nodeToDummyForHorizontalAlignment.get(adjacent.id)) { + targetNode = { id: nodeToDummyForHorizontalAlignment.get(adjacent.id), gap: adjacent.gap, direction: adjacent.direction }; + } else { + targetNode = adjacent; + } + if (dagOnVertical.has(sourceId)) { + dagOnVertical.get(sourceId).push(targetNode); + } else { + dagOnVertical.set(sourceId, [targetNode]); + } + if (!dagOnVertical.has(targetNode.id)) { + dagOnVertical.set(targetNode.id, []); + } + } + }); + }, "_loop8"); + var _iteratorNormalCompletion5 = true; + var _didIteratorError5 = false; + var _iteratorError5 = void 0; + try { + for (var _iterator5 = dag.keys()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) { + var nodeId = _step5.value; + _loop8(nodeId); + } + } catch (err) { + _didIteratorError5 = true; + _iteratorError5 = err; + } finally { + try { + if (!_iteratorNormalCompletion5 && _iterator5.return) { + _iterator5.return(); + } + } finally { + if (_didIteratorError5) { + throw _iteratorError5; + } + } + } + var undirectedOnHorizontal = dagToUndirected(dagOnHorizontal); + var undirectedOnVertical = dagToUndirected(dagOnVertical); + var componentsOnHorizontal = findComponents(undirectedOnHorizontal); + var componentsOnVertical = findComponents(undirectedOnVertical); + var reversedDagOnHorizontal = dagToReversed(dagOnHorizontal); + var reversedDagOnVertical = dagToReversed(dagOnVertical); + var componentSourcesOnHorizontal = []; + var componentSourcesOnVertical = []; + componentsOnHorizontal.forEach(function(component2, index2) { + componentSourcesOnHorizontal[index2] = []; + component2.forEach(function(nodeId2) { + if (reversedDagOnHorizontal.get(nodeId2).length == 0) { + componentSourcesOnHorizontal[index2].push(nodeId2); + } + }); + }); + componentsOnVertical.forEach(function(component2, index2) { + componentSourcesOnVertical[index2] = []; + component2.forEach(function(nodeId2) { + if (reversedDagOnVertical.get(nodeId2).length == 0) { + componentSourcesOnVertical[index2].push(nodeId2); + } + }); + }); + var positionMapHorizontal2 = findAppropriatePositionForRelativePlacement(dagOnHorizontal, "horizontal", fixedNodesOnHorizontal, dummyPositionsForVerticalAlignment, componentSourcesOnHorizontal); + var positionMapVertical2 = findAppropriatePositionForRelativePlacement(dagOnVertical, "vertical", fixedNodesOnVertical, dummyPositionsForHorizontalAlignment, componentSourcesOnVertical); + var _loop9 = /* @__PURE__ */ __name(function _loop92(key2) { + if (dummyToNodeForVerticalAlignment.get(key2)) { + dummyToNodeForVerticalAlignment.get(key2).forEach(function(nodeId2) { + xCoords[nodeIndexes.get(nodeId2)] = positionMapHorizontal2.get(key2); + }); + } else { + xCoords[nodeIndexes.get(key2)] = positionMapHorizontal2.get(key2); + } + }, "_loop9"); + var _iteratorNormalCompletion6 = true; + var _didIteratorError6 = false; + var _iteratorError6 = void 0; + try { + for (var _iterator6 = positionMapHorizontal2.keys()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) { + var key = _step6.value; + _loop9(key); + } + } catch (err) { + _didIteratorError6 = true; + _iteratorError6 = err; + } finally { + try { + if (!_iteratorNormalCompletion6 && _iterator6.return) { + _iterator6.return(); + } + } finally { + if (_didIteratorError6) { + throw _iteratorError6; + } + } + } + var _loop10 = /* @__PURE__ */ __name(function _loop102(key2) { + if (dummyToNodeForHorizontalAlignment.get(key2)) { + dummyToNodeForHorizontalAlignment.get(key2).forEach(function(nodeId2) { + yCoords[nodeIndexes.get(nodeId2)] = positionMapVertical2.get(key2); + }); + } else { + yCoords[nodeIndexes.get(key2)] = positionMapVertical2.get(key2); + } + }, "_loop10"); + var _iteratorNormalCompletion7 = true; + var _didIteratorError7 = false; + var _iteratorError7 = void 0; + try { + for (var _iterator7 = positionMapVertical2.keys()[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) { + var key = _step7.value; + _loop10(key); + } + } catch (err) { + _didIteratorError7 = true; + _iteratorError7 = err; + } finally { + try { + if (!_iteratorNormalCompletion7 && _iterator7.return) { + _iterator7.return(); + } + } finally { + if (_didIteratorError7) { + throw _iteratorError7; + } + } + } + })(); + } + } + for (var _i13 = 0; _i13 < allNodes.length; _i13++) { + var _node = allNodes[_i13]; + if (_node.getChild() == null) { + _node.setCenter(xCoords[nodeIndexes.get(_node.id)], yCoords[nodeIndexes.get(_node.id)]); + } + } + }; + module3.exports = ConstraintHandler; + }) + ), + /***/ + 551: ( + /***/ + ((module3) => { + module3.exports = __WEBPACK_EXTERNAL_MODULE__551__; + }) + ) + /******/ + }; + var __webpack_module_cache__ = {}; + function __webpack_require__(moduleId) { + var cachedModule = __webpack_module_cache__[moduleId]; + if (cachedModule !== void 0) { + return cachedModule.exports; + } + var module3 = __webpack_module_cache__[moduleId] = { + /******/ + // no module.id needed + /******/ + // no module.loaded needed + /******/ + exports: {} + /******/ + }; + __webpack_modules__[moduleId](module3, module3.exports, __webpack_require__); + return module3.exports; + } + __name(__webpack_require__, "__webpack_require__"); + var __webpack_exports__ = __webpack_require__(45); + return __webpack_exports__; + })() + ); + }); + } + }); + + // ../../node_modules/.pnpm/cytoscape-fcose@2.2.0_cytoscape@3.33.1/node_modules/cytoscape-fcose/cytoscape-fcose.js + var require_cytoscape_fcose = __commonJS({ + "../../node_modules/.pnpm/cytoscape-fcose@2.2.0_cytoscape@3.33.1/node_modules/cytoscape-fcose/cytoscape-fcose.js"(exports2, module2) { + "use strict"; + (/* @__PURE__ */ __name((function webpackUniversalModuleDefinition(root3, factory) { + if (typeof exports2 === "object" && typeof module2 === "object") + module2.exports = factory(require_cose_base2()); + else if (typeof define === "function" && define.amd) + define(["cose-base"], factory); + else if (typeof exports2 === "object") + exports2["cytoscapeFcose"] = factory(require_cose_base2()); + else + root3["cytoscapeFcose"] = factory(root3["coseBase"]); + }), "webpackUniversalModuleDefinition"))(exports2, function(__WEBPACK_EXTERNAL_MODULE__140__) { + return ( + /******/ + (() => { + "use strict"; + var __webpack_modules__ = { + /***/ + 658: ( + /***/ + ((module3) => { + module3.exports = Object.assign != null ? Object.assign.bind(Object) : function(tgt) { + for (var _len = arguments.length, srcs = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + srcs[_key - 1] = arguments[_key]; + } + srcs.forEach(function(src) { + Object.keys(src).forEach(function(k2) { + return tgt[k2] = src[k2]; + }); + }); + return tgt; + }; + }) + ), + /***/ + 548: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var _slicedToArray2 = /* @__PURE__ */ (function() { + function sliceIterator(arr, i2) { + var _arr = []; + var _n = true; + var _d = false; + var _e2 = void 0; + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + if (i2 && _arr.length === i2) break; + } + } catch (err) { + _d = true; + _e2 = err; + } finally { + try { + if (!_n && _i["return"]) _i["return"](); + } finally { + if (_d) throw _e2; + } + } + return _arr; + } + __name(sliceIterator, "sliceIterator"); + return function(arr, i2) { + if (Array.isArray(arr)) { + return arr; + } else if (Symbol.iterator in Object(arr)) { + return sliceIterator(arr, i2); + } else { + throw new TypeError("Invalid attempt to destructure non-iterable instance"); + } + }; + })(); + var LinkedList = __webpack_require__2(140).layoutBase.LinkedList; + var auxiliary = {}; + auxiliary.getTopMostNodes = function(nodes5) { + var nodesMap2 = {}; + for (var i2 = 0; i2 < nodes5.length; i2++) { + nodesMap2[nodes5[i2].id()] = true; + } + var roots = nodes5.filter(function(ele, i3) { + if (typeof ele === "number") { + ele = i3; + } + var parent4 = ele.parent()[0]; + while (parent4 != null) { + if (nodesMap2[parent4.id()]) { + return false; + } + parent4 = parent4.parent()[0]; + } + return true; + }); + return roots; + }; + auxiliary.connectComponents = function(cy, eles, topMostNodes, dummyNodes) { + var queue = new LinkedList(); + var visited = /* @__PURE__ */ new Set(); + var visitedTopMostNodes = []; + var currentNeighbor = void 0; + var minDegreeNode = void 0; + var minDegree = void 0; + var isConnected = false; + var count2 = 1; + var nodesConnectedToDummy = []; + var components3 = []; + var _loop = /* @__PURE__ */ __name(function _loop2() { + var cmpt = cy.collection(); + components3.push(cmpt); + var currentNode = topMostNodes[0]; + var childrenOfCurrentNode = cy.collection(); + childrenOfCurrentNode.merge(currentNode).merge(currentNode.descendants().intersection(eles)); + visitedTopMostNodes.push(currentNode); + childrenOfCurrentNode.forEach(function(node2) { + queue.push(node2); + visited.add(node2); + cmpt.merge(node2); + }); + var _loop22 = /* @__PURE__ */ __name(function _loop23() { + currentNode = queue.shift(); + var neighborNodes = cy.collection(); + currentNode.neighborhood().nodes().forEach(function(node2) { + if (eles.intersection(currentNode.edgesWith(node2)).length > 0) { + neighborNodes.merge(node2); + } + }); + for (var i2 = 0; i2 < neighborNodes.length; i2++) { + var neighborNode = neighborNodes[i2]; + currentNeighbor = topMostNodes.intersection(neighborNode.union(neighborNode.ancestors())); + if (currentNeighbor != null && !visited.has(currentNeighbor[0])) { + var childrenOfNeighbor = currentNeighbor.union(currentNeighbor.descendants()); + childrenOfNeighbor.forEach(function(node2) { + queue.push(node2); + visited.add(node2); + cmpt.merge(node2); + if (topMostNodes.has(node2)) { + visitedTopMostNodes.push(node2); + } + }); + } + } + }, "_loop2"); + while (queue.length != 0) { + _loop22(); + } + cmpt.forEach(function(node2) { + eles.intersection(node2.connectedEdges()).forEach(function(e3) { + if (cmpt.has(e3.source()) && cmpt.has(e3.target())) { + cmpt.merge(e3); + } + }); + }); + if (visitedTopMostNodes.length == topMostNodes.length) { + isConnected = true; + } + if (!isConnected || isConnected && count2 > 1) { + minDegreeNode = visitedTopMostNodes[0]; + minDegree = minDegreeNode.connectedEdges().length; + visitedTopMostNodes.forEach(function(node2) { + if (node2.connectedEdges().length < minDegree) { + minDegree = node2.connectedEdges().length; + minDegreeNode = node2; + } + }); + nodesConnectedToDummy.push(minDegreeNode.id()); + var temp = cy.collection(); + temp.merge(visitedTopMostNodes[0]); + visitedTopMostNodes.forEach(function(node2) { + temp.merge(node2); + }); + visitedTopMostNodes = []; + topMostNodes = topMostNodes.difference(temp); + count2++; + } + }, "_loop"); + do { + _loop(); + } while (!isConnected); + if (dummyNodes) { + if (nodesConnectedToDummy.length > 0) { + dummyNodes.set("dummy" + (dummyNodes.size + 1), nodesConnectedToDummy); + } + } + return components3; + }; + auxiliary.relocateComponent = function(originalCenter, componentResult, options2) { + if (!options2.fixedNodeConstraint) { + var minXCoord = Number.POSITIVE_INFINITY; + var maxXCoord = Number.NEGATIVE_INFINITY; + var minYCoord = Number.POSITIVE_INFINITY; + var maxYCoord = Number.NEGATIVE_INFINITY; + if (options2.quality == "draft") { + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = void 0; + try { + for (var _iterator = componentResult.nodeIndexes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var _ref = _step.value; + var _ref2 = _slicedToArray2(_ref, 2); + var key = _ref2[0]; + var value2 = _ref2[1]; + var cyNode = options2.cy.getElementById(key); + if (cyNode) { + var nodeBB = cyNode.boundingBox(); + var leftX = componentResult.xCoords[value2] - nodeBB.w / 2; + var rightX = componentResult.xCoords[value2] + nodeBB.w / 2; + var topY = componentResult.yCoords[value2] - nodeBB.h / 2; + var bottomY = componentResult.yCoords[value2] + nodeBB.h / 2; + if (leftX < minXCoord) minXCoord = leftX; + if (rightX > maxXCoord) maxXCoord = rightX; + if (topY < minYCoord) minYCoord = topY; + if (bottomY > maxYCoord) maxYCoord = bottomY; + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + var diffOnX = originalCenter.x - (maxXCoord + minXCoord) / 2; + var diffOnY = originalCenter.y - (maxYCoord + minYCoord) / 2; + componentResult.xCoords = componentResult.xCoords.map(function(x5) { + return x5 + diffOnX; + }); + componentResult.yCoords = componentResult.yCoords.map(function(y6) { + return y6 + diffOnY; + }); + } else { + Object.keys(componentResult).forEach(function(item) { + var node2 = componentResult[item]; + var leftX2 = node2.getRect().x; + var rightX2 = node2.getRect().x + node2.getRect().width; + var topY2 = node2.getRect().y; + var bottomY2 = node2.getRect().y + node2.getRect().height; + if (leftX2 < minXCoord) minXCoord = leftX2; + if (rightX2 > maxXCoord) maxXCoord = rightX2; + if (topY2 < minYCoord) minYCoord = topY2; + if (bottomY2 > maxYCoord) maxYCoord = bottomY2; + }); + var _diffOnX = originalCenter.x - (maxXCoord + minXCoord) / 2; + var _diffOnY = originalCenter.y - (maxYCoord + minYCoord) / 2; + Object.keys(componentResult).forEach(function(item) { + var node2 = componentResult[item]; + node2.setCenter(node2.getCenterX() + _diffOnX, node2.getCenterY() + _diffOnY); + }); + } + } + }; + auxiliary.calcBoundingBox = function(parentNode, xCoords, yCoords, nodeIndexes) { + var left3 = Number.MAX_SAFE_INTEGER; + var right3 = Number.MIN_SAFE_INTEGER; + var top2 = Number.MAX_SAFE_INTEGER; + var bottom2 = Number.MIN_SAFE_INTEGER; + var nodeLeft = void 0; + var nodeRight = void 0; + var nodeTop = void 0; + var nodeBottom = void 0; + var nodes5 = parentNode.descendants().not(":parent"); + var s2 = nodes5.length; + for (var i2 = 0; i2 < s2; i2++) { + var node2 = nodes5[i2]; + nodeLeft = xCoords[nodeIndexes.get(node2.id())] - node2.width() / 2; + nodeRight = xCoords[nodeIndexes.get(node2.id())] + node2.width() / 2; + nodeTop = yCoords[nodeIndexes.get(node2.id())] - node2.height() / 2; + nodeBottom = yCoords[nodeIndexes.get(node2.id())] + node2.height() / 2; + if (left3 > nodeLeft) { + left3 = nodeLeft; + } + if (right3 < nodeRight) { + right3 = nodeRight; + } + if (top2 > nodeTop) { + top2 = nodeTop; + } + if (bottom2 < nodeBottom) { + bottom2 = nodeBottom; + } + } + var boundingBox3 = {}; + boundingBox3.topLeftX = left3; + boundingBox3.topLeftY = top2; + boundingBox3.width = right3 - left3; + boundingBox3.height = bottom2 - top2; + return boundingBox3; + }; + auxiliary.calcParentsWithoutChildren = function(cy, eles) { + var parentsWithoutChildren = cy.collection(); + eles.nodes(":parent").forEach(function(parent4) { + var check = false; + parent4.children().forEach(function(child) { + if (child.css("display") != "none") { + check = true; + } + }); + if (!check) { + parentsWithoutChildren.merge(parent4); + } + }); + return parentsWithoutChildren; + }; + module3.exports = auxiliary; + }) + ), + /***/ + 816: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var aux = __webpack_require__2(548); + var CoSELayout = __webpack_require__2(140).CoSELayout; + var CoSENode = __webpack_require__2(140).CoSENode; + var PointD = __webpack_require__2(140).layoutBase.PointD; + var DimensionD2 = __webpack_require__2(140).layoutBase.DimensionD; + var LayoutConstants = __webpack_require__2(140).layoutBase.LayoutConstants; + var FDLayoutConstants = __webpack_require__2(140).layoutBase.FDLayoutConstants; + var CoSEConstants = __webpack_require__2(140).CoSEConstants; + var coseLayout = /* @__PURE__ */ __name(function coseLayout2(options2, spectralResult) { + var cy = options2.cy; + var eles = options2.eles; + var nodes5 = eles.nodes(); + var edges3 = eles.edges(); + var nodeIndexes = void 0; + var xCoords = void 0; + var yCoords = void 0; + var idToLNode = {}; + if (options2.randomize) { + nodeIndexes = spectralResult["nodeIndexes"]; + xCoords = spectralResult["xCoords"]; + yCoords = spectralResult["yCoords"]; + } + var isFn = /* @__PURE__ */ __name(function isFn2(fn3) { + return typeof fn3 === "function"; + }, "isFn"); + var optFn = /* @__PURE__ */ __name(function optFn2(opt, ele) { + if (isFn(opt)) { + return opt(ele); + } else { + return opt; + } + }, "optFn"); + var parentsWithoutChildren = aux.calcParentsWithoutChildren(cy, eles); + var processChildrenList = /* @__PURE__ */ __name(function processChildrenList2(parent4, children2, layout6, options3) { + var size4 = children2.length; + for (var i2 = 0; i2 < size4; i2++) { + var theChild = children2[i2]; + var children_of_children = null; + if (theChild.intersection(parentsWithoutChildren).length == 0) { + children_of_children = theChild.children(); + } + var theNode = void 0; + var dimensions2 = theChild.layoutDimensions({ + nodeDimensionsIncludeLabels: options3.nodeDimensionsIncludeLabels + }); + if (theChild.outerWidth() != null && theChild.outerHeight() != null) { + if (options3.randomize) { + if (!theChild.isParent()) { + theNode = parent4.add(new CoSENode(layout6.graphManager, new PointD(xCoords[nodeIndexes.get(theChild.id())] - dimensions2.w / 2, yCoords[nodeIndexes.get(theChild.id())] - dimensions2.h / 2), new DimensionD2(parseFloat(dimensions2.w), parseFloat(dimensions2.h)))); + } else { + var parentInfo = aux.calcBoundingBox(theChild, xCoords, yCoords, nodeIndexes); + if (theChild.intersection(parentsWithoutChildren).length == 0) { + theNode = parent4.add(new CoSENode(layout6.graphManager, new PointD(parentInfo.topLeftX, parentInfo.topLeftY), new DimensionD2(parentInfo.width, parentInfo.height))); + } else { + theNode = parent4.add(new CoSENode(layout6.graphManager, new PointD(parentInfo.topLeftX, parentInfo.topLeftY), new DimensionD2(parseFloat(dimensions2.w), parseFloat(dimensions2.h)))); + } + } + } else { + theNode = parent4.add(new CoSENode(layout6.graphManager, new PointD(theChild.position("x") - dimensions2.w / 2, theChild.position("y") - dimensions2.h / 2), new DimensionD2(parseFloat(dimensions2.w), parseFloat(dimensions2.h)))); + } + } else { + theNode = parent4.add(new CoSENode(this.graphManager)); + } + theNode.id = theChild.data("id"); + theNode.nodeRepulsion = optFn(options3.nodeRepulsion, theChild); + theNode.paddingLeft = parseInt(theChild.css("padding")); + theNode.paddingTop = parseInt(theChild.css("padding")); + theNode.paddingRight = parseInt(theChild.css("padding")); + theNode.paddingBottom = parseInt(theChild.css("padding")); + if (options3.nodeDimensionsIncludeLabels) { + theNode.labelWidth = theChild.boundingBox({ includeLabels: true, includeNodes: false, includeOverlays: false }).w; + theNode.labelHeight = theChild.boundingBox({ includeLabels: true, includeNodes: false, includeOverlays: false }).h; + theNode.labelPosVertical = theChild.css("text-valign"); + theNode.labelPosHorizontal = theChild.css("text-halign"); + } + idToLNode[theChild.data("id")] = theNode; + if (isNaN(theNode.rect.x)) { + theNode.rect.x = 0; + } + if (isNaN(theNode.rect.y)) { + theNode.rect.y = 0; + } + if (children_of_children != null && children_of_children.length > 0) { + var theNewGraph = void 0; + theNewGraph = layout6.getGraphManager().add(layout6.newGraph(), theNode); + processChildrenList2(theNewGraph, children_of_children, layout6, options3); + } + } + }, "processChildrenList"); + var processEdges = /* @__PURE__ */ __name(function processEdges2(layout6, gm2, edges4) { + var idealLengthTotal = 0; + var edgeCount3 = 0; + for (var i2 = 0; i2 < edges4.length; i2++) { + var edge = edges4[i2]; + var sourceNode = idToLNode[edge.data("source")]; + var targetNode = idToLNode[edge.data("target")]; + if (sourceNode && targetNode && sourceNode !== targetNode && sourceNode.getEdgesBetween(targetNode).length == 0) { + var e1 = gm2.add(layout6.newEdge(), sourceNode, targetNode); + e1.id = edge.id(); + e1.idealLength = optFn(options2.idealEdgeLength, edge); + e1.edgeElasticity = optFn(options2.edgeElasticity, edge); + idealLengthTotal += e1.idealLength; + edgeCount3++; + } + } + if (options2.idealEdgeLength != null) { + if (edgeCount3 > 0) CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = idealLengthTotal / edgeCount3; + else if (!isFn(options2.idealEdgeLength)) + CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = options2.idealEdgeLength; + else + CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = 50; + CoSEConstants.MIN_REPULSION_DIST = FDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10; + CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH; + } + }, "processEdges"); + var processConstraints = /* @__PURE__ */ __name(function processConstraints2(layout6, options3) { + if (options3.fixedNodeConstraint) { + layout6.constraints["fixedNodeConstraint"] = options3.fixedNodeConstraint; + } + if (options3.alignmentConstraint) { + layout6.constraints["alignmentConstraint"] = options3.alignmentConstraint; + } + if (options3.relativePlacementConstraint) { + layout6.constraints["relativePlacementConstraint"] = options3.relativePlacementConstraint; + } + }, "processConstraints"); + if (options2.nestingFactor != null) CoSEConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = options2.nestingFactor; + if (options2.gravity != null) CoSEConstants.DEFAULT_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = options2.gravity; + if (options2.numIter != null) CoSEConstants.MAX_ITERATIONS = FDLayoutConstants.MAX_ITERATIONS = options2.numIter; + if (options2.gravityRange != null) CoSEConstants.DEFAULT_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = options2.gravityRange; + if (options2.gravityCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = options2.gravityCompound; + if (options2.gravityRangeCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = options2.gravityRangeCompound; + if (options2.initialEnergyOnIncremental != null) CoSEConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = options2.initialEnergyOnIncremental; + if (options2.tilingCompareBy != null) CoSEConstants.TILING_COMPARE_BY = options2.tilingCompareBy; + if (options2.quality == "proof") LayoutConstants.QUALITY = 2; + else LayoutConstants.QUALITY = 0; + CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS = FDLayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = options2.nodeDimensionsIncludeLabels; + CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = !options2.randomize; + CoSEConstants.ANIMATE = FDLayoutConstants.ANIMATE = LayoutConstants.ANIMATE = options2.animate; + CoSEConstants.TILE = options2.tile; + CoSEConstants.TILING_PADDING_VERTICAL = typeof options2.tilingPaddingVertical === "function" ? options2.tilingPaddingVertical.call() : options2.tilingPaddingVertical; + CoSEConstants.TILING_PADDING_HORIZONTAL = typeof options2.tilingPaddingHorizontal === "function" ? options2.tilingPaddingHorizontal.call() : options2.tilingPaddingHorizontal; + CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = true; + CoSEConstants.PURE_INCREMENTAL = !options2.randomize; + LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = options2.uniformNodeDimensions; + if (options2.step == "transformed") { + CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true; + CoSEConstants.ENFORCE_CONSTRAINTS = false; + CoSEConstants.APPLY_LAYOUT = false; + } + if (options2.step == "enforced") { + CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false; + CoSEConstants.ENFORCE_CONSTRAINTS = true; + CoSEConstants.APPLY_LAYOUT = false; + } + if (options2.step == "cose") { + CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false; + CoSEConstants.ENFORCE_CONSTRAINTS = false; + CoSEConstants.APPLY_LAYOUT = true; + } + if (options2.step == "all") { + if (options2.randomize) CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = true; + else CoSEConstants.TRANSFORM_ON_CONSTRAINT_HANDLING = false; + CoSEConstants.ENFORCE_CONSTRAINTS = true; + CoSEConstants.APPLY_LAYOUT = true; + } + if (options2.fixedNodeConstraint || options2.alignmentConstraint || options2.relativePlacementConstraint) { + CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = false; + } else { + CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = true; + } + var coseLayout3 = new CoSELayout(); + var gm = coseLayout3.newGraphManager(); + processChildrenList(gm.addRoot(), aux.getTopMostNodes(nodes5), coseLayout3, options2); + processEdges(coseLayout3, gm, edges3); + processConstraints(coseLayout3, options2); + coseLayout3.runLayout(); + return idToLNode; + }, "coseLayout"); + module3.exports = { coseLayout }; + }) + ), + /***/ + 212: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var _createClass2 = /* @__PURE__ */ (function() { + function defineProperties(target, props) { + for (var i2 = 0; i2 < props.length; i2++) { + var descriptor = props[i2]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + __name(defineProperties, "defineProperties"); + return function(Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + })(); + function _classCallCheck2(instance2, Constructor) { + if (!(instance2 instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + __name(_classCallCheck2, "_classCallCheck"); + var assign7 = __webpack_require__2(658); + var aux = __webpack_require__2(548); + var _require = __webpack_require__2(657), spectralLayout = _require.spectralLayout; + var _require2 = __webpack_require__2(816), coseLayout = _require2.coseLayout; + var defaults4 = Object.freeze({ + // 'draft', 'default' or 'proof' + // - 'draft' only applies spectral layout + // - 'default' improves the quality with subsequent CoSE layout (fast cooling rate) + // - 'proof' improves the quality with subsequent CoSE layout (slow cooling rate) + quality: "default", + // Use random node positions at beginning of layout + // if this is set to false, then quality option must be "proof" + randomize: true, + // Whether or not to animate the layout + animate: true, + // Duration of animation in ms, if enabled + animationDuration: 1e3, + // Easing of animation, if enabled + animationEasing: void 0, + // Fit the viewport to the repositioned nodes + fit: true, + // Padding around layout + padding: 30, + // Whether to include labels in node dimensions. Valid in "proof" quality + nodeDimensionsIncludeLabels: false, + // Whether or not simple nodes (non-compound nodes) are of uniform dimensions + uniformNodeDimensions: false, + // Whether to pack disconnected components - valid only if randomize: true + packComponents: true, + // Layout step - all, transformed, enforced, cose - for debug purpose only + step: "all", + /* spectral layout options */ + // False for random, true for greedy + samplingType: true, + // Sample size to construct distance matrix + sampleSize: 25, + // Separation amount between nodes + nodeSeparation: 75, + // Power iteration tolerance + piTol: 1e-7, + /* CoSE layout options */ + // Node repulsion (non overlapping) multiplier + nodeRepulsion: /* @__PURE__ */ __name(function nodeRepulsion4(node2) { + return 4500; + }, "nodeRepulsion"), + // Ideal edge (non nested) length + idealEdgeLength: /* @__PURE__ */ __name(function idealEdgeLength2(edge) { + return 50; + }, "idealEdgeLength"), + // Divisor to compute edge forces + edgeElasticity: /* @__PURE__ */ __name(function edgeElasticity2(edge) { + return 0.45; + }, "edgeElasticity"), + // Nesting factor (multiplier) to compute ideal edge length for nested edges + nestingFactor: 0.1, + // Gravity force (constant) + gravity: 0.25, + // Maximum number of iterations to perform + numIter: 2500, + // For enabling tiling + tile: true, + // The function that specifies the criteria for comparing nodes while sorting them during tiling operation. + // Takes the node id as a parameter and the default tiling operation is perfomed when this option is not set. + tilingCompareBy: void 0, + // Represents the amount of the vertical space to put between the zero degree members during the tiling operation(can also be a function) + tilingPaddingVertical: 10, + // Represents the amount of the horizontal space to put between the zero degree members during the tiling operation(can also be a function) + tilingPaddingHorizontal: 10, + // Gravity range (constant) for compounds + gravityRangeCompound: 1.5, + // Gravity force (constant) for compounds + gravityCompound: 1, + // Gravity range (constant) + gravityRange: 3.8, + // Initial cooling factor for incremental layout + initialEnergyOnIncremental: 0.3, + /* constraint options */ + // Fix required nodes to predefined positions + // [{nodeId: 'n1', position: {x: 100, y: 200}, {...}] + fixedNodeConstraint: void 0, + // Align required nodes in vertical/horizontal direction + // {vertical: [['n1', 'n2')], ['n3', 'n4']], horizontal: ['n2', 'n4']} + alignmentConstraint: void 0, + // Place two nodes relatively in vertical/horizontal direction + // [{top: 'n1', bottom: 'n2', gap: 100}, {left: 'n3', right: 'n4', gap: 75}] + relativePlacementConstraint: void 0, + /* layout event callbacks */ + ready: /* @__PURE__ */ __name(function ready4() { + }, "ready"), + // on layoutready + stop: /* @__PURE__ */ __name(function stop5() { + }, "stop") + // on layoutstop + }); + var Layout2 = (function() { + function Layout3(options2) { + _classCallCheck2(this, Layout3); + this.options = assign7({}, defaults4, options2); + } + __name(Layout3, "Layout"); + _createClass2(Layout3, [{ + key: "run", + value: /* @__PURE__ */ __name(function run5() { + var layout6 = this; + var options2 = this.options; + var cy = options2.cy; + var eles = options2.eles; + var spectralResult = []; + var xCoords = void 0; + var yCoords = void 0; + var coseResult = []; + var components3 = void 0; + var componentCenters = []; + if (options2.fixedNodeConstraint && (!Array.isArray(options2.fixedNodeConstraint) || options2.fixedNodeConstraint.length == 0)) { + options2.fixedNodeConstraint = void 0; + } + if (options2.alignmentConstraint) { + if (options2.alignmentConstraint.vertical && (!Array.isArray(options2.alignmentConstraint.vertical) || options2.alignmentConstraint.vertical.length == 0)) { + options2.alignmentConstraint.vertical = void 0; + } + if (options2.alignmentConstraint.horizontal && (!Array.isArray(options2.alignmentConstraint.horizontal) || options2.alignmentConstraint.horizontal.length == 0)) { + options2.alignmentConstraint.horizontal = void 0; + } + } + if (options2.relativePlacementConstraint && (!Array.isArray(options2.relativePlacementConstraint) || options2.relativePlacementConstraint.length == 0)) { + options2.relativePlacementConstraint = void 0; + } + var constraintExist = options2.fixedNodeConstraint || options2.alignmentConstraint || options2.relativePlacementConstraint; + if (constraintExist) { + options2.tile = false; + options2.packComponents = false; + } + var layUtil = void 0; + var packingEnabled = false; + if (cy.layoutUtilities && options2.packComponents) { + layUtil = cy.layoutUtilities("get"); + if (!layUtil) layUtil = cy.layoutUtilities(); + packingEnabled = true; + } + if (eles.nodes().length > 0) { + if (!packingEnabled) { + var boundingBox3 = options2.eles.boundingBox(); + componentCenters.push({ x: boundingBox3.x1 + boundingBox3.w / 2, y: boundingBox3.y1 + boundingBox3.h / 2 }); + if (options2.randomize) { + var result = spectralLayout(options2); + spectralResult.push(result); + } + if (options2.quality == "default" || options2.quality == "proof") { + coseResult.push(coseLayout(options2, spectralResult[0])); + aux.relocateComponent(componentCenters[0], coseResult[0], options2); + } else { + aux.relocateComponent(componentCenters[0], spectralResult[0], options2); + } + } else { + var topMostNodes = aux.getTopMostNodes(options2.eles.nodes()); + components3 = aux.connectComponents(cy, options2.eles, topMostNodes); + components3.forEach(function(component2) { + var boundingBox4 = component2.boundingBox(); + componentCenters.push({ x: boundingBox4.x1 + boundingBox4.w / 2, y: boundingBox4.y1 + boundingBox4.h / 2 }); + }); + if (options2.randomize) { + components3.forEach(function(component2) { + options2.eles = component2; + spectralResult.push(spectralLayout(options2)); + }); + } + if (options2.quality == "default" || options2.quality == "proof") { + var toBeTiledNodes = cy.collection(); + if (options2.tile) { + var nodeIndexes = /* @__PURE__ */ new Map(); + var _xCoords = []; + var _yCoords = []; + var count2 = 0; + var tempSpectralResult = { nodeIndexes, xCoords: _xCoords, yCoords: _yCoords }; + var indexesToBeDeleted = []; + components3.forEach(function(component2, index) { + if (component2.edges().length == 0) { + component2.nodes().forEach(function(node2, i3) { + toBeTiledNodes.merge(component2.nodes()[i3]); + if (!node2.isParent()) { + tempSpectralResult.nodeIndexes.set(component2.nodes()[i3].id(), count2++); + tempSpectralResult.xCoords.push(component2.nodes()[0].position().x); + tempSpectralResult.yCoords.push(component2.nodes()[0].position().y); + } + }); + indexesToBeDeleted.push(index); + } + }); + if (toBeTiledNodes.length > 1) { + var _boundingBox = toBeTiledNodes.boundingBox(); + componentCenters.push({ x: _boundingBox.x1 + _boundingBox.w / 2, y: _boundingBox.y1 + _boundingBox.h / 2 }); + components3.push(toBeTiledNodes); + spectralResult.push(tempSpectralResult); + for (var i2 = indexesToBeDeleted.length - 1; i2 >= 0; i2--) { + components3.splice(indexesToBeDeleted[i2], 1); + spectralResult.splice(indexesToBeDeleted[i2], 1); + componentCenters.splice(indexesToBeDeleted[i2], 1); + } + ; + } + } + components3.forEach(function(component2, index) { + options2.eles = component2; + coseResult.push(coseLayout(options2, spectralResult[index])); + aux.relocateComponent(componentCenters[index], coseResult[index], options2); + }); + } else { + components3.forEach(function(component2, index) { + aux.relocateComponent(componentCenters[index], spectralResult[index], options2); + }); + } + var componentsEvaluated = /* @__PURE__ */ new Set(); + if (components3.length > 1) { + var subgraphs = []; + var hiddenEles = eles.filter(function(ele) { + return ele.css("display") == "none"; + }); + components3.forEach(function(component2, index) { + var nodeIndexes2 = void 0; + if (options2.quality == "draft") { + nodeIndexes2 = spectralResult[index].nodeIndexes; + } + if (component2.nodes().not(hiddenEles).length > 0) { + var subgraph = {}; + subgraph.edges = []; + subgraph.nodes = []; + var nodeIndex = void 0; + component2.nodes().not(hiddenEles).forEach(function(node2) { + if (options2.quality == "draft") { + if (!node2.isParent()) { + nodeIndex = nodeIndexes2.get(node2.id()); + subgraph.nodes.push({ x: spectralResult[index].xCoords[nodeIndex] - node2.boundingbox().w / 2, y: spectralResult[index].yCoords[nodeIndex] - node2.boundingbox().h / 2, width: node2.boundingbox().w, height: node2.boundingbox().h }); + } else { + var parentInfo = aux.calcBoundingBox(node2, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2); + subgraph.nodes.push({ x: parentInfo.topLeftX, y: parentInfo.topLeftY, width: parentInfo.width, height: parentInfo.height }); + } + } else { + if (coseResult[index][node2.id()]) { + subgraph.nodes.push({ x: coseResult[index][node2.id()].getLeft(), y: coseResult[index][node2.id()].getTop(), width: coseResult[index][node2.id()].getWidth(), height: coseResult[index][node2.id()].getHeight() }); + } + } + }); + component2.edges().forEach(function(edge) { + var source = edge.source(); + var target = edge.target(); + if (source.css("display") != "none" && target.css("display") != "none") { + if (options2.quality == "draft") { + var sourceNodeIndex = nodeIndexes2.get(source.id()); + var targetNodeIndex = nodeIndexes2.get(target.id()); + var sourceCenter = []; + var targetCenter = []; + if (source.isParent()) { + var parentInfo = aux.calcBoundingBox(source, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2); + sourceCenter.push(parentInfo.topLeftX + parentInfo.width / 2); + sourceCenter.push(parentInfo.topLeftY + parentInfo.height / 2); + } else { + sourceCenter.push(spectralResult[index].xCoords[sourceNodeIndex]); + sourceCenter.push(spectralResult[index].yCoords[sourceNodeIndex]); + } + if (target.isParent()) { + var _parentInfo = aux.calcBoundingBox(target, spectralResult[index].xCoords, spectralResult[index].yCoords, nodeIndexes2); + targetCenter.push(_parentInfo.topLeftX + _parentInfo.width / 2); + targetCenter.push(_parentInfo.topLeftY + _parentInfo.height / 2); + } else { + targetCenter.push(spectralResult[index].xCoords[targetNodeIndex]); + targetCenter.push(spectralResult[index].yCoords[targetNodeIndex]); + } + subgraph.edges.push({ startX: sourceCenter[0], startY: sourceCenter[1], endX: targetCenter[0], endY: targetCenter[1] }); + } else { + if (coseResult[index][source.id()] && coseResult[index][target.id()]) { + subgraph.edges.push({ startX: coseResult[index][source.id()].getCenterX(), startY: coseResult[index][source.id()].getCenterY(), endX: coseResult[index][target.id()].getCenterX(), endY: coseResult[index][target.id()].getCenterY() }); + } + } + } + }); + if (subgraph.nodes.length > 0) { + subgraphs.push(subgraph); + componentsEvaluated.add(index); + } + } + }); + var shiftResult = layUtil.packComponents(subgraphs, options2.randomize).shifts; + if (options2.quality == "draft") { + spectralResult.forEach(function(result2, index) { + var newXCoords = result2.xCoords.map(function(x5) { + return x5 + shiftResult[index].dx; + }); + var newYCoords = result2.yCoords.map(function(y6) { + return y6 + shiftResult[index].dy; + }); + result2.xCoords = newXCoords; + result2.yCoords = newYCoords; + }); + } else { + var _count = 0; + componentsEvaluated.forEach(function(index) { + Object.keys(coseResult[index]).forEach(function(item) { + var nodeRectangle = coseResult[index][item]; + nodeRectangle.setCenter(nodeRectangle.getCenterX() + shiftResult[_count].dx, nodeRectangle.getCenterY() + shiftResult[_count].dy); + }); + _count++; + }); + } + } + } + } + var getPositions = /* @__PURE__ */ __name(function getPositions2(ele, i3) { + if (options2.quality == "default" || options2.quality == "proof") { + if (typeof ele === "number") { + ele = i3; + } + var pos = void 0; + var node2 = void 0; + var theId = ele.data("id"); + coseResult.forEach(function(result2) { + if (theId in result2) { + pos = { x: result2[theId].getRect().getCenterX(), y: result2[theId].getRect().getCenterY() }; + node2 = result2[theId]; + } + }); + if (options2.nodeDimensionsIncludeLabels) { + if (node2.labelWidth) { + if (node2.labelPosHorizontal == "left") { + pos.x += node2.labelWidth / 2; + } else if (node2.labelPosHorizontal == "right") { + pos.x -= node2.labelWidth / 2; + } + } + if (node2.labelHeight) { + if (node2.labelPosVertical == "top") { + pos.y += node2.labelHeight / 2; + } else if (node2.labelPosVertical == "bottom") { + pos.y -= node2.labelHeight / 2; + } + } + } + if (pos == void 0) pos = { x: ele.position("x"), y: ele.position("y") }; + return { + x: pos.x, + y: pos.y + }; + } else { + var _pos = void 0; + spectralResult.forEach(function(result2) { + var index = result2.nodeIndexes.get(ele.id()); + if (index != void 0) { + _pos = { x: result2.xCoords[index], y: result2.yCoords[index] }; + } + }); + if (_pos == void 0) _pos = { x: ele.position("x"), y: ele.position("y") }; + return { + x: _pos.x, + y: _pos.y + }; + } + }, "getPositions"); + if (options2.quality == "default" || options2.quality == "proof" || options2.randomize) { + var parentsWithoutChildren = aux.calcParentsWithoutChildren(cy, eles); + var _hiddenEles = eles.filter(function(ele) { + return ele.css("display") == "none"; + }); + options2.eles = eles.not(_hiddenEles); + eles.nodes().not(":parent").not(_hiddenEles).layoutPositions(layout6, options2, getPositions); + if (parentsWithoutChildren.length > 0) { + parentsWithoutChildren.forEach(function(ele) { + ele.position(getPositions(ele)); + }); + } + } else { + console.log("If randomize option is set to false, then quality option must be 'default' or 'proof'."); + } + }, "run") + }]); + return Layout3; + })(); + module3.exports = Layout2; + }) + ), + /***/ + 657: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var aux = __webpack_require__2(548); + var Matrix = __webpack_require__2(140).layoutBase.Matrix; + var SVD = __webpack_require__2(140).layoutBase.SVD; + var spectralLayout = /* @__PURE__ */ __name(function spectralLayout2(options2) { + var cy = options2.cy; + var eles = options2.eles; + var nodes5 = eles.nodes(); + var parentNodes = eles.nodes(":parent"); + var dummyNodes = /* @__PURE__ */ new Map(); + var nodeIndexes = /* @__PURE__ */ new Map(); + var parentChildMap = /* @__PURE__ */ new Map(); + var allNodesNeighborhood = []; + var xCoords = []; + var yCoords = []; + var samplesColumn = []; + var minDistancesColumn = []; + var C3 = []; + var PHI = []; + var INV = []; + var firstSample = void 0; + var nodeSize = void 0; + var infinity = 1e8; + var small = 1e-9; + var piTol = options2.piTol; + var samplingType = options2.samplingType; + var nodeSeparation = options2.nodeSeparation; + var sampleSize = void 0; + var randomSampleCR = /* @__PURE__ */ __name(function randomSampleCR2() { + var sample2 = 0; + var count2 = 0; + var flag = false; + while (count2 < sampleSize) { + sample2 = Math.floor(Math.random() * nodeSize); + flag = false; + for (var i3 = 0; i3 < count2; i3++) { + if (samplesColumn[i3] == sample2) { + flag = true; + break; + } + } + if (!flag) { + samplesColumn[count2] = sample2; + count2++; + } else { + continue; + } + } + }, "randomSampleCR"); + var BFS = /* @__PURE__ */ __name(function BFS2(pivot, index2, samplingMethod) { + var path4 = []; + var front = 0; + var back = 0; + var current = 0; + var temp = void 0; + var distance2 = []; + var max_dist = 0; + var max_ind = 1; + for (var i3 = 0; i3 < nodeSize; i3++) { + distance2[i3] = infinity; + } + path4[back] = pivot; + distance2[pivot] = 0; + while (back >= front) { + current = path4[front++]; + var neighbors = allNodesNeighborhood[current]; + for (var _i = 0; _i < neighbors.length; _i++) { + temp = nodeIndexes.get(neighbors[_i]); + if (distance2[temp] == infinity) { + distance2[temp] = distance2[current] + 1; + path4[++back] = temp; + } + } + C3[current][index2] = distance2[current] * nodeSeparation; + } + if (samplingMethod) { + for (var _i2 = 0; _i2 < nodeSize; _i2++) { + if (C3[_i2][index2] < minDistancesColumn[_i2]) minDistancesColumn[_i2] = C3[_i2][index2]; + } + for (var _i3 = 0; _i3 < nodeSize; _i3++) { + if (minDistancesColumn[_i3] > max_dist) { + max_dist = minDistancesColumn[_i3]; + max_ind = _i3; + } + } + } + return max_ind; + }, "BFS"); + var allBFS = /* @__PURE__ */ __name(function allBFS2(samplingMethod) { + var sample2 = void 0; + if (!samplingMethod) { + randomSampleCR(); + for (var i3 = 0; i3 < sampleSize; i3++) { + BFS(samplesColumn[i3], i3, samplingMethod, false); + } + } else { + sample2 = Math.floor(Math.random() * nodeSize); + firstSample = sample2; + for (var _i4 = 0; _i4 < nodeSize; _i4++) { + minDistancesColumn[_i4] = infinity; + } + for (var _i5 = 0; _i5 < sampleSize; _i5++) { + samplesColumn[_i5] = sample2; + sample2 = BFS(sample2, _i5, samplingMethod); + } + } + for (var _i6 = 0; _i6 < nodeSize; _i6++) { + for (var j3 = 0; j3 < sampleSize; j3++) { + C3[_i6][j3] *= C3[_i6][j3]; + } + } + for (var _i7 = 0; _i7 < sampleSize; _i7++) { + PHI[_i7] = []; + } + for (var _i8 = 0; _i8 < sampleSize; _i8++) { + for (var _j = 0; _j < sampleSize; _j++) { + PHI[_i8][_j] = C3[samplesColumn[_j]][_i8]; + } + } + }, "allBFS"); + var sample = /* @__PURE__ */ __name(function sample2() { + var SVDResult = SVD.svd(PHI); + var a_q = SVDResult.S; + var a_u = SVDResult.U; + var a_v = SVDResult.V; + var max_s = a_q[0] * a_q[0] * a_q[0]; + var a_Sig = []; + for (var i3 = 0; i3 < sampleSize; i3++) { + a_Sig[i3] = []; + for (var j3 = 0; j3 < sampleSize; j3++) { + a_Sig[i3][j3] = 0; + if (i3 == j3) { + a_Sig[i3][j3] = a_q[i3] / (a_q[i3] * a_q[i3] + max_s / (a_q[i3] * a_q[i3])); + } + } + } + INV = Matrix.multMat(Matrix.multMat(a_v, a_Sig), Matrix.transpose(a_u)); + }, "sample"); + var powerIteration = /* @__PURE__ */ __name(function powerIteration2() { + var theta1 = void 0; + var theta2 = void 0; + var Y1 = []; + var Y22 = []; + var V1 = []; + var V22 = []; + for (var i3 = 0; i3 < nodeSize; i3++) { + Y1[i3] = Math.random(); + Y22[i3] = Math.random(); + } + Y1 = Matrix.normalize(Y1); + Y22 = Matrix.normalize(Y22); + var count2 = 0; + var current = small; + var previous = small; + var temp = void 0; + while (true) { + count2++; + for (var _i9 = 0; _i9 < nodeSize; _i9++) { + V1[_i9] = Y1[_i9]; + } + Y1 = Matrix.multGamma(Matrix.multL(Matrix.multGamma(V1), C3, INV)); + theta1 = Matrix.dotProduct(V1, Y1); + Y1 = Matrix.normalize(Y1); + current = Matrix.dotProduct(V1, Y1); + temp = Math.abs(current / previous); + if (temp <= 1 + piTol && temp >= 1) { + break; + } + previous = current; + } + for (var _i10 = 0; _i10 < nodeSize; _i10++) { + V1[_i10] = Y1[_i10]; + } + count2 = 0; + previous = small; + while (true) { + count2++; + for (var _i11 = 0; _i11 < nodeSize; _i11++) { + V22[_i11] = Y22[_i11]; + } + V22 = Matrix.minusOp(V22, Matrix.multCons(V1, Matrix.dotProduct(V1, V22))); + Y22 = Matrix.multGamma(Matrix.multL(Matrix.multGamma(V22), C3, INV)); + theta2 = Matrix.dotProduct(V22, Y22); + Y22 = Matrix.normalize(Y22); + current = Matrix.dotProduct(V22, Y22); + temp = Math.abs(current / previous); + if (temp <= 1 + piTol && temp >= 1) { + break; + } + previous = current; + } + for (var _i12 = 0; _i12 < nodeSize; _i12++) { + V22[_i12] = Y22[_i12]; + } + xCoords = Matrix.multCons(V1, Math.sqrt(Math.abs(theta1))); + yCoords = Matrix.multCons(V22, Math.sqrt(Math.abs(theta2))); + }, "powerIteration"); + aux.connectComponents(cy, eles, aux.getTopMostNodes(nodes5), dummyNodes); + parentNodes.forEach(function(ele) { + aux.connectComponents(cy, eles, aux.getTopMostNodes(ele.descendants().intersection(eles)), dummyNodes); + }); + var index = 0; + for (var i2 = 0; i2 < nodes5.length; i2++) { + if (!nodes5[i2].isParent()) { + nodeIndexes.set(nodes5[i2].id(), index++); + } + } + var _iteratorNormalCompletion = true; + var _didIteratorError = false; + var _iteratorError = void 0; + try { + for (var _iterator = dummyNodes.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { + var key = _step.value; + nodeIndexes.set(key, index++); + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally { + try { + if (!_iteratorNormalCompletion && _iterator.return) { + _iterator.return(); + } + } finally { + if (_didIteratorError) { + throw _iteratorError; + } + } + } + for (var _i13 = 0; _i13 < nodeIndexes.size; _i13++) { + allNodesNeighborhood[_i13] = []; + } + parentNodes.forEach(function(ele) { + var children2 = ele.children().intersection(eles); + while (children2.nodes(":childless").length == 0) { + children2 = children2.nodes()[0].children().intersection(eles); + } + var index2 = 0; + var min9 = children2.nodes(":childless")[0].connectedEdges().length; + children2.nodes(":childless").forEach(function(ele2, i3) { + if (ele2.connectedEdges().length < min9) { + min9 = ele2.connectedEdges().length; + index2 = i3; + } + }); + parentChildMap.set(ele.id(), children2.nodes(":childless")[index2].id()); + }); + nodes5.forEach(function(ele) { + var eleIndex = void 0; + if (ele.isParent()) eleIndex = nodeIndexes.get(parentChildMap.get(ele.id())); + else eleIndex = nodeIndexes.get(ele.id()); + ele.neighborhood().nodes().forEach(function(node2) { + if (eles.intersection(ele.edgesWith(node2)).length > 0) { + if (node2.isParent()) allNodesNeighborhood[eleIndex].push(parentChildMap.get(node2.id())); + else allNodesNeighborhood[eleIndex].push(node2.id()); + } + }); + }); + var _loop = /* @__PURE__ */ __name(function _loop2(_key2) { + var eleIndex = nodeIndexes.get(_key2); + var disconnectedId = void 0; + dummyNodes.get(_key2).forEach(function(id30) { + if (cy.getElementById(id30).isParent()) disconnectedId = parentChildMap.get(id30); + else disconnectedId = id30; + allNodesNeighborhood[eleIndex].push(disconnectedId); + allNodesNeighborhood[nodeIndexes.get(disconnectedId)].push(_key2); + }); + }, "_loop"); + var _iteratorNormalCompletion2 = true; + var _didIteratorError2 = false; + var _iteratorError2 = void 0; + try { + for (var _iterator2 = dummyNodes.keys()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { + var _key = _step2.value; + _loop(_key); + } + } catch (err) { + _didIteratorError2 = true; + _iteratorError2 = err; + } finally { + try { + if (!_iteratorNormalCompletion2 && _iterator2.return) { + _iterator2.return(); + } + } finally { + if (_didIteratorError2) { + throw _iteratorError2; + } + } + } + nodeSize = nodeIndexes.size; + var spectralResult = void 0; + if (nodeSize > 2) { + sampleSize = nodeSize < options2.sampleSize ? nodeSize : options2.sampleSize; + for (var _i14 = 0; _i14 < nodeSize; _i14++) { + C3[_i14] = []; + } + for (var _i15 = 0; _i15 < sampleSize; _i15++) { + INV[_i15] = []; + } + if (options2.quality == "draft" || options2.step == "all") { + allBFS(samplingType); + sample(); + powerIteration(); + spectralResult = { nodeIndexes, xCoords, yCoords }; + } else { + nodeIndexes.forEach(function(value2, key2) { + xCoords.push(cy.getElementById(key2).position("x")); + yCoords.push(cy.getElementById(key2).position("y")); + }); + spectralResult = { nodeIndexes, xCoords, yCoords }; + } + return spectralResult; + } else { + var iterator = nodeIndexes.keys(); + var firstNode = cy.getElementById(iterator.next().value); + var firstNodePos = firstNode.position(); + var firstNodeWidth = firstNode.outerWidth(); + xCoords.push(firstNodePos.x); + yCoords.push(firstNodePos.y); + if (nodeSize == 2) { + var secondNode = cy.getElementById(iterator.next().value); + var secondNodeWidth = secondNode.outerWidth(); + xCoords.push(firstNodePos.x + firstNodeWidth / 2 + secondNodeWidth / 2 + options2.idealEdgeLength); + yCoords.push(firstNodePos.y); + } + spectralResult = { nodeIndexes, xCoords, yCoords }; + return spectralResult; + } + }, "spectralLayout"); + module3.exports = { spectralLayout }; + }) + ), + /***/ + 579: ( + /***/ + ((module3, __unused_webpack_exports, __webpack_require__2) => { + var impl2 = __webpack_require__2(212); + var register = /* @__PURE__ */ __name(function register2(cytoscape4) { + if (!cytoscape4) { + return; + } + cytoscape4("layout", "fcose", impl2); + }, "register"); + if (typeof cytoscape !== "undefined") { + register(cytoscape); + } + module3.exports = register; + }) + ), + /***/ + 140: ( + /***/ + ((module3) => { + module3.exports = __WEBPACK_EXTERNAL_MODULE__140__; + }) + ) + /******/ + }; + var __webpack_module_cache__ = {}; + function __webpack_require__(moduleId) { + var cachedModule = __webpack_module_cache__[moduleId]; + if (cachedModule !== void 0) { + return cachedModule.exports; + } + var module3 = __webpack_module_cache__[moduleId] = { + /******/ + // no module.id needed + /******/ + // no module.loaded needed + /******/ + exports: {} + /******/ + }; + __webpack_modules__[moduleId](module3, module3.exports, __webpack_require__); + return module3.exports; + } + __name(__webpack_require__, "__webpack_require__"); + var __webpack_exports__ = __webpack_require__(579); + return __webpack_exports__; + })() + ); + }); + } + }); + + // src/diagrams/architecture/architectureIcons.ts + var wrapIcon, architectureIcons; + var init_architectureIcons = __esm({ + "src/diagrams/architecture/architectureIcons.ts"() { + "use strict"; + init_icons(); + wrapIcon = /* @__PURE__ */ __name((icon2) => { + return `
/g, "
"); + return cleanedUpSvg; + }, "cleanUpSvgCode"); + var putIntoIFrame = /* @__PURE__ */ __name((svgCode = "", svgElement) => { + const height2 = svgElement?.viewBox?.baseVal?.height ? svgElement.viewBox.baseVal.height + "px" : IFRAME_HEIGHT; + const base64encodedSrc = toBase64(`${svgCode}`); + return ``; + }, "putIntoIFrame"); + var appendDivSvgG = /* @__PURE__ */ __name((parentRoot, id30, enclosingDivId, divStyle, svgXlink) => { + const enclosingDiv = parentRoot.append("div"); + enclosingDiv.attr("id", enclosingDivId); + if (divStyle) { + enclosingDiv.attr("style", divStyle); + } + const svgNode2 = enclosingDiv.append("svg").attr("id", id30).attr("width", "100%").attr("xmlns", XMLNS_SVG_STD); + if (svgXlink) { + svgNode2.attr("xmlns:xlink", svgXlink); + } + svgNode2.append("g"); + return parentRoot; + }, "appendDivSvgG"); + function sandboxedIframe(parentNode, iFrameId) { + return parentNode.append("iframe").attr("id", iFrameId).attr("style", "width: 100%; height: 100%;").attr("sandbox", ""); + } + __name(sandboxedIframe, "sandboxedIframe"); + var removeExistingElements = /* @__PURE__ */ __name((doc, id30, divId, iFrameId) => { + doc.getElementById(id30)?.remove(); + doc.getElementById(divId)?.remove(); + doc.getElementById(iFrameId)?.remove(); + }, "removeExistingElements"); + var render7 = /* @__PURE__ */ __name(async function(id30, text4, svgContainingElement) { + addDiagrams(); + const processed2 = processAndSetConfigs(text4); + text4 = processed2.code; + const config5 = getConfig(); + log.debug(config5); + if (text4.length > (config5?.maxTextSize ?? MAX_TEXTLENGTH)) { + text4 = MAX_TEXTLENGTH_EXCEEDED_MSG; + } + const idSelector = "#" + id30; + const iFrameID = "i" + id30; + const iFrameID_selector = "#" + iFrameID; + const enclosingDivID = "d" + id30; + const enclosingDivID_selector = "#" + enclosingDivID; + const removeTempElements = /* @__PURE__ */ __name(() => { + const tmpElementSelector = isSandboxed ? iFrameID_selector : enclosingDivID_selector; + const node2 = select_default2(tmpElementSelector).node(); + if (node2 && "remove" in node2) { + node2.remove(); + } + }, "removeTempElements"); + let root3 = select_default2("body"); + const isSandboxed = config5.securityLevel === SECURITY_LVL_SANDBOX; + const isLooseSecurityLevel = config5.securityLevel === SECURITY_LVL_LOOSE; + const fontFamily = config5.fontFamily; + if (svgContainingElement !== void 0) { + if (svgContainingElement) { + svgContainingElement.innerHTML = ""; + } + if (isSandboxed) { + const iframe = sandboxedIframe(select_default2(svgContainingElement), iFrameID); + root3 = select_default2(iframe.nodes()[0].contentDocument.body); + root3.node().style.margin = 0; + } else { + root3 = select_default2(svgContainingElement); + } + appendDivSvgG(root3, id30, enclosingDivID, `font-family: ${fontFamily}`, XMLNS_XLINK_STD); + } else { + removeExistingElements(document, id30, enclosingDivID, iFrameID); + if (isSandboxed) { + const iframe = sandboxedIframe(select_default2("body"), iFrameID); + root3 = select_default2(iframe.nodes()[0].contentDocument.body); + root3.node().style.margin = 0; + } else { + root3 = select_default2("body"); + } + appendDivSvgG(root3, id30, enclosingDivID); + } + let diag; + let parseEncounteredException; + try { + diag = await Diagram.fromText(text4, { title: processed2.title }); + } catch (error3) { + if (config5.suppressErrorRendering) { + removeTempElements(); + throw error3; + } + diag = await Diagram.fromText("error"); + parseEncounteredException = error3; + } + const element3 = root3.select(enclosingDivID_selector).node(); + const diagramType = diag.type; + const svg2 = element3.firstChild; + const firstChild = svg2.firstChild; + const diagramClassDefs = diag.renderer.getClasses?.(text4, diag); + const rules = createUserStyles(config5, diagramType, diagramClassDefs, idSelector); + const style1 = document.createElement("style"); + style1.innerHTML = rules; + svg2.insertBefore(style1, firstChild); + try { + await diag.renderer.draw(text4, id30, package_default.version, diag); + } catch (e3) { + if (config5.suppressErrorRendering) { + removeTempElements(); + } else { + errorRenderer_default.draw(text4, id30, package_default.version); + } + throw e3; + } + const svgNode2 = root3.select(`${enclosingDivID_selector} svg`); + const a11yTitle = diag.db.getAccTitle?.(); + const a11yDescr = diag.db.getAccDescription?.(); + addA11yInfo(diagramType, svgNode2, a11yTitle, a11yDescr); + root3.select(`[id="${id30}"]`).selectAll("foreignobject > *").attr("xmlns", XMLNS_XHTML_STD); + let svgCode = root3.select(enclosingDivID_selector).node().innerHTML; + log.debug("config.arrowMarkerAbsolute", config5.arrowMarkerAbsolute); + svgCode = cleanUpSvgCode(svgCode, isSandboxed, evaluate(config5.arrowMarkerAbsolute)); + if (isSandboxed) { + const svgEl = root3.select(enclosingDivID_selector + " svg").node(); + svgCode = putIntoIFrame(svgCode, svgEl); + } else if (!isLooseSecurityLevel) { + svgCode = purify.sanitize(svgCode, { + ADD_TAGS: DOMPURIFY_TAGS, + ADD_ATTR: DOMPURIFY_ATTR, + HTML_INTEGRATION_POINTS: { foreignobject: true } + }); + } + attachFunctions(); + if (parseEncounteredException) { + throw parseEncounteredException; + } + removeTempElements(); + return { + diagramType, + svg: svgCode, + bindFunctions: diag.db.bindFunctions + }; + }, "render"); + function initialize(userOptions = {}) { + const options2 = assignWithDepth_default({}, userOptions); + if (options2?.fontFamily && !options2.themeVariables?.fontFamily) { + if (!options2.themeVariables) { + options2.themeVariables = {}; + } + options2.themeVariables.fontFamily = options2.fontFamily; + } + saveConfigFromInitialize(options2); + if (options2?.theme && options2.theme in themes_default) { + options2.themeVariables = themes_default[options2.theme].getThemeVariables( + options2.themeVariables + ); + } else if (options2) { + options2.themeVariables = themes_default.default.getThemeVariables(options2.themeVariables); + } + const config5 = typeof options2 === "object" ? setSiteConfig(options2) : getSiteConfig(); + setLogLevel(config5.logLevel); + addDiagrams(); + } + __name(initialize, "initialize"); + var getDiagramFromText = /* @__PURE__ */ __name((text4, metadata = {}) => { + const { code } = preprocessDiagram(text4); + return Diagram.fromText(code, metadata); + }, "getDiagramFromText"); + function addA11yInfo(diagramType, svgNode2, a11yTitle, a11yDescr) { + setA11yDiagramInfo(svgNode2, diagramType); + addSVGa11yTitleDescription(svgNode2, a11yTitle, a11yDescr, svgNode2.attr("id")); + } + __name(addA11yInfo, "addA11yInfo"); + var mermaidAPI = Object.freeze({ + render: render7, + parse: parse5, + getDiagramFromText, + initialize, + getConfig, + setConfig, + getSiteConfig, + updateSiteConfig, + reset: /* @__PURE__ */ __name(() => { + reset(); + }, "reset"), + globalReset: /* @__PURE__ */ __name(() => { + reset(defaultConfig); + }, "globalReset"), + defaultConfig + }); + setLogLevel(getConfig().logLevel); + reset(getConfig()); + + // src/mermaid.ts + init_render2(); + init_utils2(); + var handleError = /* @__PURE__ */ __name((error3, errors, parseError) => { + log.warn(error3); + if (isDetailedError(error3)) { + if (parseError) { + parseError(error3.str, error3.hash); + } + errors.push({ ...error3, message: error3.str, error: error3 }); + } else { + if (parseError) { + parseError(error3); + } + if (error3 instanceof Error) { + errors.push({ + str: error3.message, + message: error3.message, + hash: error3.name, + error: error3 + }); + } + } + }, "handleError"); + var run4 = /* @__PURE__ */ __name(async function(options2 = { + querySelector: ".mermaid" + }) { + try { + await runThrowsErrors(options2); + } catch (e3) { + if (isDetailedError(e3)) { + log.error(e3.str); + } + if (mermaid.parseError) { + mermaid.parseError(e3); + } + if (!options2.suppressErrors) { + log.error("Use the suppressErrors option to suppress these errors"); + throw e3; + } + } + }, "run"); + var runThrowsErrors = /* @__PURE__ */ __name(async function({ postRenderCallback, querySelector, nodes: nodes5 } = { + querySelector: ".mermaid" + }) { + const conf5 = mermaidAPI.getConfig(); + log.debug(`${!postRenderCallback ? "No " : ""}Callback function found`); + let nodesToProcess; + if (nodes5) { + nodesToProcess = nodes5; + } else if (querySelector) { + nodesToProcess = document.querySelectorAll(querySelector); + } else { + throw new Error("Nodes and querySelector are both undefined"); + } + log.debug(`Found ${nodesToProcess.length} diagrams`); + if (conf5?.startOnLoad !== void 0) { + log.debug("Start On Load: " + conf5?.startOnLoad); + mermaidAPI.updateSiteConfig({ startOnLoad: conf5?.startOnLoad }); + } + const idGenerator = new utils_default2.InitIDGenerator(conf5.deterministicIds, conf5.deterministicIDSeed); + let txt; + const errors = []; + for (const element3 of Array.from(nodesToProcess)) { + log.info("Rendering diagram: " + element3.id); + if (element3.getAttribute("data-processed")) { + continue; + } + element3.setAttribute("data-processed", "true"); + const id30 = `mermaid-${idGenerator.next()}`; + txt = element3.innerHTML; + txt = dedent(utils_default2.entityDecode(txt)).trim().replace(/
"); + const init3 = utils_default2.detectInit(txt); + if (init3) { + log.debug("Detected early reinit: ", init3); + } + try { + const { svg: svg2, bindFunctions: bindFunctions2 } = await render8(id30, txt, element3); + element3.innerHTML = svg2; + if (postRenderCallback) { + await postRenderCallback(id30); + } + if (bindFunctions2) { + bindFunctions2(element3); + } + } catch (error3) { + handleError(error3, errors, mermaid.parseError); + } + } + if (errors.length > 0) { + throw errors[0]; + } + }, "runThrowsErrors"); + var initialize2 = /* @__PURE__ */ __name(function(config5) { + mermaidAPI.initialize(config5); + }, "initialize"); + var init2 = /* @__PURE__ */ __name(async function(config5, nodes5, callback) { + log.warn("mermaid.init is deprecated. Please use run instead."); + if (config5) { + initialize2(config5); + } + const runOptions = { postRenderCallback: callback, querySelector: ".mermaid" }; + if (typeof nodes5 === "string") { + runOptions.querySelector = nodes5; + } else if (nodes5) { + if (nodes5 instanceof HTMLElement) { + runOptions.nodes = [nodes5]; + } else { + runOptions.nodes = nodes5; + } + } + await run4(runOptions); + }, "init"); + var registerExternalDiagrams = /* @__PURE__ */ __name(async (diagrams2, { + lazyLoad = true + } = {}) => { + addDiagrams(); + registerLazyLoadedDiagrams(...diagrams2); + if (lazyLoad === false) { + await loadRegisteredDiagrams(); + } + }, "registerExternalDiagrams"); + var contentLoaded = /* @__PURE__ */ __name(function() { + if (mermaid.startOnLoad) { + const { startOnLoad } = mermaidAPI.getConfig(); + if (startOnLoad) { + mermaid.run().catch((err) => log.error("Mermaid failed to initialize", err)); + } + } + }, "contentLoaded"); + if (typeof document !== "undefined") { + window.addEventListener("load", contentLoaded, false); + } + var setParseErrorHandler = /* @__PURE__ */ __name(function(parseErrorHandler) { + mermaid.parseError = parseErrorHandler; + }, "setParseErrorHandler"); + var executionQueue = []; + var executionQueueRunning = false; + var executeQueue = /* @__PURE__ */ __name(async () => { + if (executionQueueRunning) { + return; + } + executionQueueRunning = true; + while (executionQueue.length > 0) { + const f2 = executionQueue.shift(); + if (f2) { + try { + await f2(); + } catch (e3) { + log.error("Error executing queue", e3); + } + } + } + executionQueueRunning = false; + }, "executeQueue"); + var parse6 = /* @__PURE__ */ __name(async (text4, parseOptions) => { + return new Promise((resolve2, reject3) => { + const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => { + mermaidAPI.parse(text4, parseOptions).then( + (r2) => { + res(r2); + resolve2(r2); + }, + (e3) => { + log.error("Error parsing", e3); + mermaid.parseError?.(e3); + rej(e3); + reject3(e3); + } + ); + }), "performCall"); + executionQueue.push(performCall); + executeQueue().catch(reject3); + }); + }, "parse"); + var render8 = /* @__PURE__ */ __name((id30, text4, container2) => { + return new Promise((resolve2, reject3) => { + const performCall = /* @__PURE__ */ __name(() => new Promise((res, rej) => { + mermaidAPI.render(id30, text4, container2).then( + (r2) => { + res(r2); + resolve2(r2); + }, + (e3) => { + log.error("Error parsing", e3); + mermaid.parseError?.(e3); + rej(e3); + reject3(e3); + } + ); + }), "performCall"); + executionQueue.push(performCall); + executeQueue().catch(reject3); + }); + }, "render"); + var getRegisteredDiagramsMetadata = /* @__PURE__ */ __name(() => { + return Object.keys(detectors).map((id30) => ({ + id: id30 + })); + }, "getRegisteredDiagramsMetadata"); + var mermaid = { + startOnLoad: true, + mermaidAPI, + parse: parse6, + render: render8, + init: init2, + run: run4, + registerExternalDiagrams, + registerLayoutLoaders, + initialize: initialize2, + parseError: void 0, + contentLoaded, + setParseErrorHandler, + detectType, + registerIconPacks, + getRegisteredDiagramsMetadata + }; + var mermaid_default = mermaid; + return __toCommonJS(mermaid_exports); +})(); +/*! Check if previously processed */ +/*! + * Wait for document loaded before starting the execution + */ +/*! Bundled license information: + +dompurify/dist/purify.es.mjs: + (*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE *) + +js-yaml/dist/js-yaml.mjs: + (*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT *) + +lodash-es/lodash.js: + (** + * @license + * Lodash (Custom Build)
-
+ *
- If a {@code .bndrun} file is selected: universe = bundles from {@code -runbundles}, seeded as selected. + *
- If projects are selected: universe = bundles found in those projects, no initial selection. + *
+ * Each invocation opens a new view instance (the view has {@code allowMultiple="true"} in plugin.xml).
+ */
+public class ShowBundleGraphHandler extends AbstractHandler {
+
+ /**
+ * Counter used to generate unique secondary IDs for each new Bundle Graph view instance.
+ * {@link AtomicInteger#getAndIncrement()} is atomic, so concurrent handler executions produce distinct IDs without
+ * any additional synchronization.
+ */
+ private static final AtomicInteger instanceCounter = new AtomicInteger(1);
+
+ @Override
+ public Object execute(ExecutionEvent event) throws ExecutionException {
+ ISelection selection = HandlerUtil.getCurrentSelection(event);
+ if (!(selection instanceof IStructuredSelection)) {
+ return null;
+ }
+ IStructuredSelection structured = (IStructuredSelection) selection;
+
+ IWorkbenchPage page = PlatformUI.getWorkbench()
+ .getActiveWorkbenchWindow()
+ .getActivePage();
+
+ BundleGraphView view = openView(page);
+ if (view == null) {
+ return null;
+ }
+
+ // Check for a .bndrun file in the selection
+ IFile bndrunFile = findBndrunFile(structured);
+ if (bndrunFile != null) {
+ Supplier
+ * Accepted transfer types:
+ *
+ * The view has two halves:
+ *
+ * An edge {@code A → B} is emitted when bundle A imports a package that bundle B exports. Every edge records whether
+ * it is optional (all contributing {@code Import-Package} entries carry {@code resolution:=optional}) or
+ * mandatory (at least one import is mandatory). Callers can use that flag to filter or style edges at render
+ * time without rebuilding the model.
+ */
+public final class ManifestDependencyCalculator {
+
+ /** The value of the {@code resolution} directive that marks an import as optional. */
+ private static final String RESOLUTION_OPTIONAL = "optional";
+
+ private ManifestDependencyCalculator() {}
+
+ /**
+ * Computes dependency edges for a set of bundles. Both mandatory and optional imports are always included; each
+ * resulting {@link BundleEdge} records whether it is optional via {@link BundleEdge#optional()}.
+ *
+ * @param nodeToJar map from {@link BundleNode} to its JAR {@link File}. Missing files are skipped silently.
+ * @return map where {@code (A, {B, C})} means A depends on B and C.
+ */
+ public static Map
+ * An edge is optional when every {@code Import-Package} entry contributing to that edge carries
+ * {@code resolution:=optional}; if at least one import is mandatory, the edge is mandatory.
+ *
+ * @param nodeToJar map from {@link BundleNode} to its JAR {@link File}. Missing files are skipped silently.
+ * @return set of {@link BundleEdge}s (one per importer–exporter pair).
+ */
+ public static Set
+ * For each BSN the latest available version is used. The JAR file is fetched from the repository and its manifest
+ * is analysed to derive dependency edges. Each edge records whether it is optional via
+ * {@link bndtools.views.bundlegraph.model.BundleEdge#optional()}.
+ *
+ * @param repos the repositories to query (must not be null)
+ * @return a BundleGraphModel (never null)
+ */
+ public BundleGraphModel createModel(List
+ * An edge {@code (from, to)} means bundle {@code from} depends on bundle {@code to} (i.e., {@code from} imports at
+ * least one package that {@code to} exports). The edge is considered optional when every
+ * {@code Import-Package} entry that gave rise to this edge carries {@code resolution:=optional}; if at least one
+ * contributing import is mandatory, the edge is mandatory.
+ *
+ * @param from the importing bundle
+ * @param to the exporting bundle (the dependency)
+ * @param optional {@code true} when every import that created this edge is {@code resolution:=optional}
+ */
+public record BundleEdge(BundleNode from, BundleNode to, boolean optional) {}
diff --git a/bndtools.core/src/bndtools/views/bundlegraph/model/BundleGraphModel.java b/bndtools.core/src/bndtools/views/bundlegraph/model/BundleGraphModel.java
new file mode 100644
index 0000000000..4754268ca4
--- /dev/null
+++ b/bndtools.core/src/bndtools/views/bundlegraph/model/BundleGraphModel.java
@@ -0,0 +1,58 @@
+package bndtools.views.bundlegraph.model;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Model interface for querying bundle graph nodes and their dependency relationships.
+ */
+public interface BundleGraphModel {
+
+ /**
+ * Returns all known bundle nodes in this model's universe.
+ */
+ Set
+ * The default implementation derives edges from {@link #dependenciesOf(BundleNode)}, treating all edges as
+ * mandatory. Implementations that track {@link BundleEdge#optional() optional} edges should override this method.
+ */
+ default Set
+ * Identity is based solely on {@code bsn} and {@code version}; {@code projectName} is informational metadata and is
+ * intentionally excluded from {@link #equals(Object)} and {@link #hashCode()}. This ensures that a node loaded from a
+ * repository and the same bundle loaded from a workspace project are treated as the same node so that edges can be
+ * shared across providers.
+ */
+public record BundleNode(String bsn, String version, String projectName) {
+
+ public BundleNode(String bsn, String version, String projectName) {
+ this.bsn = Objects.requireNonNull(bsn, "bsn");
+ this.version = version != null ? version : "";
+ this.projectName = projectName != null ? projectName : "";
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (!(obj instanceof BundleNode other))
+ return false;
+ return Objects.equals(bsn, other.bsn) && Objects.equals(version, other.version);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(bsn, version);
+ }
+
+ public String getBsn() {
+ return bsn;
+ }
+
+ public String getVersion() {
+ return version;
+ }
+
+ public String getProjectName() {
+ return projectName;
+ }
+
+ @Override
+ public String toString() {
+ if (version.isEmpty()) {
+ return bsn;
+ }
+ return bsn + " " + version;
+ }
+}
diff --git a/bndtools.core/src/bndtools/views/bundlegraph/model/GraphClosures.java b/bndtools.core/src/bndtools/views/bundlegraph/model/GraphClosures.java
new file mode 100644
index 0000000000..2ea647eac9
--- /dev/null
+++ b/bndtools.core/src/bndtools/views/bundlegraph/model/GraphClosures.java
@@ -0,0 +1,43 @@
+package bndtools.views.bundlegraph.model;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+/**
+ * Helper for computing transitive closures over a {@link BundleGraphModel}.
+ */
+public final class GraphClosures {
+
+ private GraphClosures() {}
+
+ /**
+ * Returns the transitive closure of all dependencies reachable from the given seed nodes (including the seeds
+ * themselves).
+ */
+ public static Set
+ * Primary nodes get a solid, highlighted border; secondary nodes get a dashed, muted border. Mandatory dependency
+ * edges are rendered as solid arrows ({@code -->}); optional-only edges (where every contributing
+ * {@code Import-Package} entry carried {@code resolution:=optional}) are rendered as dotted arrows ({@code -.->}).
+ * Only edges where both endpoints are in the subset are included.
+ *
+ * @param model the full graph model
+ * @param subset all nodes to include in the diagram (primary ∪ secondary)
+ * @param primaryNodes the user-selected seed nodes (subset of {@code subset})
+ * @return Mermaid graph definition string
+ */
+ public static String toMermaid(BundleGraphModel model, Set
+ * Primary nodes get a solid, highlighted border; secondary nodes get a dashed, muted border. Mandatory dependency
+ * edges are rendered as solid arrows ({@code -->}); optional-only edges are rendered as dotted arrows
+ * ({@code -.->}). The {@code edgeFilter} controls which edges are included:
+ *
+ *
+ * Supported drop payloads:
+ *
+ *
+ * When dropped on Available bundles, the resolved nodes are merged into the universe. When dropped on
+ * Selected input bundles, the resolved nodes are merged into the universe and added to the selected
+ * set.
+ */
+class BundleGraphDropAdapter extends ViewerDropAdapter {
+
+ private static final ILogger logger = Logger.getLogger(BundleGraphDropAdapter.class);
+
+ private final BundleGraphView view;
+ private final boolean addToSelected;
+
+ /**
+ * @param viewer the viewer this adapter is registered on
+ * @param view the host view
+ * @param addToSelected {@code true} if drops should populate the "Selected input bundles" list; {@code false} to
+ * populate the "Available bundles" universe only
+ */
+ BundleGraphDropAdapter(Viewer viewer, BundleGraphView view, boolean addToSelected) {
+ super(viewer);
+ this.view = view;
+ this.addToSelected = addToSelected;
+ }
+
+ @Override
+ public boolean validateDrop(Object target, int operation, TransferData transferType) {
+ return LocalSelectionTransfer.getTransfer()
+ .isSupportedType(transferType)
+ || ResourceTransfer.getInstance()
+ .isSupportedType(transferType);
+ }
+
+ @Override
+ public void dragEnter(DropTargetEvent event) {
+ super.dragEnter(event);
+ event.detail = DND.DROP_COPY;
+ }
+
+ @Override
+ public boolean performDrop(Object data) {
+ List
+ *
+ */
+public class BundleGraphView extends ViewPart {
+
+ public static final String VIEW_ID = "bndtools.bundleGraphView";
+
+ private static final ILogger logger = Logger.getLogger(BundleGraphView.class);
+
+ /** Expansion mode for the graph. */
+ public enum ExpansionMode {
+ ONLY_SELECTED("Only selected"),
+ SELECTED_AND_DEPENDENCIES("Selected + dependencies"),
+ SELECTED_AND_DEPENDANTS("Selected + dependants");
+
+ private final String label;
+
+ ExpansionMode(String label) {
+ this.label = label;
+ }
+
+ public String getLabel() {
+ return label;
+ }
+ }
+
+ // Model
+ private BundleGraphModel model = new SimpleBundleGraphModel(Collections.emptySet(),
+ Collections.emptyMap());
+ private Supplier\n" //
+ + "\n" //
+ + "\n" //
+ + "\n";
+ }
+
+ /**
+ * Returns a {@code ";
+ }
+ }
+ } catch (IOException e) {
+ logger.logWarning("Failed to resolve bundled mermaid.min.js", e);
+ }
+ throw new IllegalArgumentException("Cannot load mermaid.min.js for graph rendering");
+ }
+
+ // ---- Public API ----
+
+ /**
+ * Sets the model and optionally seeds the selected set.
+ *
+ * @param newModel the new graph model
+ * @param initialSelected seed nodes to select (may be null)
+ */
+ public void setInput(BundleGraphModel newModel, Set
+ *
+ * Only edges where both endpoints are in the subset are included.
+ *
+ * @param model the full graph model
+ * @param subset all nodes to include in the diagram (primary ∪ secondary)
+ * @param primaryNodes the user-selected seed nodes (subset of {@code subset})
+ * @param edgeFilter controls which dependency edges to include
+ * @return Mermaid graph definition string
+ */
+ public static String toMermaid(BundleGraphModel model, Set