/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ 38573:
/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {


// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape@3.25.0/node_modules/cytoscape/dist/cytoscape.cjs.js
var cytoscape_cjs = __webpack_require__(82985);
var cytoscape_cjs_default = /*#__PURE__*/__webpack_require__.n(cytoscape_cjs);
// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape-dagre@2.5.0_cytoscape@3.25.0/node_modules/cytoscape-dagre/cytoscape-dagre.js
var cytoscape_dagre = __webpack_require__(93581);
var cytoscape_dagre_default = /*#__PURE__*/__webpack_require__.n(cytoscape_dagre);
// EXTERNAL MODULE: ../../node_modules/.pnpm/slugify@1.6.6/node_modules/slugify/slugify.js
var slugify_slugify = __webpack_require__(24264);
;// CONCATENATED MODULE: ../utils-core/dist/commonalityco-utils-core.esm.js

var Theme = /*#__PURE__*/ function(Theme) {
    Theme["Dark"] = "dark";
    Theme["Light"] = "light";
    Theme["System"] = "system";
    return Theme;
}({});
var Lockfile = /*#__PURE__*/ function(Lockfile) {
    Lockfile["NPM_LOCKFILE"] = "package-lock.json";
    Lockfile["YARN_LOCKFILE"] = "yarn.lock";
    Lockfile["PNPM_LOCKFILE"] = "pnpm-lock.yaml";
    return Lockfile;
}({});
var DependencyType = /*#__PURE__*/ function(DependencyType) {
    DependencyType["PEER"] = "peer";
    DependencyType["DEVELOPMENT"] = "development";
    DependencyType["PRODUCTION"] = "production";
    return DependencyType;
}({});
var PackageType = /*#__PURE__*/ function(PackageType) {
    PackageType["NODE"] = "node";
    PackageType["REACT"] = "react";
    PackageType["NEXT"] = "next";
    return PackageType;
}({});
var PackageManager = /*#__PURE__*/ function(PackageManager) {
    PackageManager["PNPM"] = "pnpm";
    PackageManager["YARN"] = "yarn";
    PackageManager["NPM"] = "npm";
    return PackageManager;
}({});
var AllPackagesWildcard = "*";
/**
 * Takes a package name and converts it into a URL-friendly slug.
 * Replaces slashes (/) with hyphens (-) and removes any non-URL-safe characters.
 *
 * @param packageName - The package name to be slugified.
 * @returns The slugified package name.
 */ var slugifyPackageName = function slugifyPackageName(packageName) {
    var replacementRegex = /\//g;
    if (!packageName) {
        return "";
    }
    var packageNameWithoutScopeSlash = packageName.replace(replacementRegex, "-");
    return slugify(packageNameWithoutScopeSlash, {
        strict: true,
        lower: true
    });
};
/**
 * Takes a tag name and converts it into a URL-friendly slug.
 * Replaces slashes (/) with hyphens (-) and removes any non-URL-safe characters.
 *
 * @param packageName - The package name to be slugified.
 * @returns The slugified package name.
 */ var slugifyTagName = function slugifyTagName(tagName) {
    if (!tagName) {
        return "";
    }
    return slugify(tagName, {
        strict: true,
        lower: true
    });
};
var formatTagName = function formatTagName(tagName) {
    return "#".concat(slugifyTagName(tagName));
};
var formatPackageName = function formatPackageName(name, options) {
    var _options$stripScope = options.stripScope, stripScope = _options$stripScope === void 0 ? false : _options$stripScope;
    if (!name) {
        return name;
    }
    if (name.includes("/") && stripScope) {
        return name.split("/")[1];
    }
    return name;
};


// EXTERNAL MODULE: ../../node_modules/.pnpm/cytoscape-popper@2.0.0_cytoscape@3.25.0/node_modules/cytoscape-popper/cytoscape-popper.js
var cytoscape_popper = __webpack_require__(2929);
var cytoscape_popper_default = /*#__PURE__*/__webpack_require__.n(cytoscape_popper);
// EXTERNAL MODULE: ../utils-graph/dist/asyncToGenerator-031c744a.esm.js
var asyncToGenerator_031c744a_esm = __webpack_require__(99694);
;// CONCATENATED MODULE: ../utils-graph/dist/render-elements-to-graph-1ef750c8.esm.js
/* __next_internal_client_entry_do_not_use__ updateGraphElements auto */ 

/**********************************
 *            NODES               *
 **********************************/ var handleNodeMouseover = function handleNodeMouseover(_ref) {
    var target = _ref.target, renderGraph = _ref.renderGraph;
    var neighborhood = target.closedNeighborhood();
    renderGraph === null || renderGraph === void 0 ? void 0 : renderGraph.elements().difference(neighborhood).filter(function(ele) {
        return !ele.selected();
    }).addClass("dim");
    var forceEdgeColor = renderGraph.scratch("forceEdgeColor");
    if (!forceEdgeColor) {
        target.connectedEdges().map(function(element) {
            var type = element.data("type");
            element.addClass(type);
        });
    }
    target.addClass("hover");
};
var handleNodeMouseout = function handleNodeMouseout(_ref2) {
    var target = _ref2.target, renderGraph = _ref2.renderGraph;
    var neighborhood = target.neighborhood();
    var focusedElements = renderGraph.collection([
        neighborhood,
        target
    ]);
    renderGraph === null || renderGraph === void 0 ? void 0 : renderGraph.elements().difference(focusedElements).removeClass("dim");
    var forceEdgeColor = renderGraph.scratch("forceEdgeColor");
    if (!forceEdgeColor) {
        target.connectedEdges().map(function(element) {
            element.removeClass([
                DependencyType.PRODUCTION,
                DependencyType.DEVELOPMENT,
                DependencyType.PEER
            ]);
        });
    }
    target.removeClass("hover");
};
/**********************************
 *            EDGES               *
 **********************************/ var handleEdgeMouseover = function handleEdgeMouseover(_ref3) {
    var target = _ref3.target, renderGraph = _ref3.renderGraph, _ref3$violations = _ref3.violations, violations = _ref3$violations === void 0 ? [] : _ref3$violations;
    var forceEdgeColor = renderGraph.scratch("forceEdgeColor");
    target.addClass("hover");
    if (forceEdgeColor) return;
    var type = target.data("type");
    var sourcePackageName = target.source().id();
    var targetPackageName = target.target().id();
    var hasViolation = violations.some(function(violation) {
        return violation.sourcePackageName === sourcePackageName && violation.targetPackageName === targetPackageName;
    });
    if (!hasViolation) {
        target.addClass(type);
    }
};
var handleEdgeMouseout = function handleEdgeMouseout(_ref4) {
    var target = _ref4.target, renderGraph = _ref4.renderGraph;
    var forceEdgeColor = renderGraph.scratch("forceEdgeColor");
    target.removeClass("hover");
    if (forceEdgeColor) return;
    target.removeClass([
        DependencyType.PRODUCTION,
        DependencyType.DEVELOPMENT,
        DependencyType.PEER
    ]);
};
/**********************************
 *         GENERAL               *
 **********************************/ var bindRenderGraphEvents = function bindRenderGraphEvents(args) {
    var renderGraph = args.renderGraph;
    renderGraph.nodes().on("mouseover", function(event) {
        return handleNodeMouseover((0,asyncToGenerator_031c744a_esm.a)((0,asyncToGenerator_031c744a_esm.a)({}, args), {}, {
            target: event.target
        }));
    });
    renderGraph.nodes().on("mouseout", function(event) {
        return handleNodeMouseout((0,asyncToGenerator_031c744a_esm.a)((0,asyncToGenerator_031c744a_esm.a)({}, args), {}, {
            target: event.target
        }));
    });
    renderGraph.edges().on("mouseover", function(event) {
        return handleEdgeMouseover((0,asyncToGenerator_031c744a_esm.a)((0,asyncToGenerator_031c744a_esm.a)({}, args), {}, {
            target: event.target
        }));
    });
    renderGraph.edges().on("mouseout", function(event) {
        return handleEdgeMouseout((0,asyncToGenerator_031c744a_esm.a)((0,asyncToGenerator_031c744a_esm.a)({}, args), {}, {
            target: event.target
        }));
    });
};
function withTiming(name, function_) {
    return function() {
        var startTime = Date.now();
        var result = function_.apply(void 0, arguments);
        var endTime = Date.now();
        var duration = (endTime - startTime) / 1000;
        console.log({
            seconds: duration.toFixed(2)
        }, "".concat(name, " executed"));
        return result;
    };
}
var updateStyles = function updateStyles(_ref) {
    var graph = _ref.graph, theme = _ref.theme, forceEdgeColor = _ref.forceEdgeColor, _ref$violations = _ref.violations, violations = _ref$violations === void 0 ? [] : _ref$violations;
    graph.elements().removeClass([
        "dark",
        "light"
    ]).addClass(theme);
    graph.edges().forEach(function(edge) {
        var edgeData = edge.data();
        var violationForEdge = edgeData ? violations.find(function(violation) {
            var source = edge.source().data();
            var target = edge.target().data();
            return violation.sourcePackageName === source.name && violation.targetPackageName === target.name;
        }) : null;
        if (forceEdgeColor) {
            edge.addClass(edgeData.type);
            edge.addClass("focus");
        } else {
            edge.removeClass([
                DependencyType.DEVELOPMENT,
                DependencyType.PEER,
                DependencyType.PRODUCTION
            ]);
            edge.removeClass("focus");
        }
        if (violationForEdge) {
            edge.removeClass([
                DependencyType.DEVELOPMENT,
                DependencyType.PEER,
                DependencyType.PRODUCTION
            ]);
            edge.removeClass("focus");
            edge.addClass("violation");
        }
    });
};
var updateGraphElements = withTiming("updateGraphElements", /*#__PURE__*/ function() {
    var _ref3 = (0,asyncToGenerator_031c744a_esm.b)(/*#__PURE__*/ (0,asyncToGenerator_031c744a_esm.c)().mark(function _callee(_ref2) {
        var renderGraph, traversalGraph, theme, forceEdgeColor, violations, elements;
        return (0,asyncToGenerator_031c744a_esm.c)().wrap(function _callee$(_context) {
            while(1)switch(_context.prev = _context.next){
                case 0:
                    renderGraph = _ref2.renderGraph, traversalGraph = _ref2.traversalGraph, theme = _ref2.theme, forceEdgeColor = _ref2.forceEdgeColor, violations = _ref2.violations, elements = _ref2.elements;
                    // Clear the graph
                    renderGraph.json({
                        elements: elements
                    });
                    updateStyles({
                        graph: renderGraph,
                        theme: theme,
                        forceEdgeColor: forceEdgeColor,
                        violations: violations
                    });
                    renderGraph.fit(undefined, 24);
                    // Bind graph events, these events are all fired by the Cytoscape library
                    bindRenderGraphEvents({
                        renderGraph: renderGraph,
                        theme: theme,
                        traversalGraph: traversalGraph,
                        violations: violations
                    });
                case 5:
                case "end":
                    return _context.stop();
            }
        }, _callee);
    }));
    return function(_x) {
        return _ref3.apply(this, arguments);
    };
}());


;// CONCATENATED MODULE: ../utils-graph/dist/commonalityco-utils-graph.esm.js






function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(o);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
var fontSize = 24;
var fontFamily = "Fira Code";
var fontWeight = 600;
var nodeStyles = [
    {
        selector: "node",
        style: {
            label: "data(id)",
            width: "data(width)",
            height: "data(height)",
            shape: "roundrectangle",
            "text-margin-x": 20,
            "background-height": 42,
            "background-width": 42,
            "background-position-x": "24px",
            "background-position-y": "16px",
            "background-image": "data(image)",
            "font-size": fontSize,
            "font-family": fontFamily,
            "font-weight": fontWeight,
            "background-color": "#f4f4f5",
            color: "#27272a",
            "border-width": 1,
            "border-style": "solid",
            "border-color": "#e4e4e7",
            "text-halign": "center",
            "text-valign": "center",
            "overlay-opacity": 0
        }
    },
    {
        selector: "node.dim",
        style: {
            opacity: 0.2
        }
    },
    {
        selector: "node.hover",
        style: {
            "background-color": "#09090b",
            color: "#FFF",
            "border-color": "#09090b"
        }
    },
    {
        selector: "node.dark",
        style: {
            "background-color": "#27272a",
            "border-color": "#3f3f46",
            color: "#fff"
        }
    }
];
var colors = {
    light: {
        "default": "#e4e4e7",
        development: "#0284c7",
        peer: "#0284c7",
        production: "#059669",
        violation: "#FF0000"
    },
    dark: {
        "default": "#27272a",
        development: "#0284c7",
        peer: "#0284c7",
        production: "#059669",
        violation: "#FF0000"
    }
};
var edgeStyles = [
    {
        selector: "edge",
        style: {
            width: 3,
            "target-arrow-color": colors.light["default"],
            "target-arrow-shape": "triangle",
            "curve-style": "unbundled-bezier",
            "source-endpoint": "0% 50%",
            "target-endpoint": "0% -50%",
            "arrow-scale": 1.3,
            "line-color": colors.light["default"]
        }
    },
    {
        selector: "edge.dark",
        style: {
            "line-color": colors.dark["default"],
            "target-arrow-color": colors.dark["default"]
        }
    },
    {
        selector: "edge.".concat(DependencyType.PRODUCTION),
        style: {
            "line-color": colors.light.production,
            "target-arrow-color": colors.light.production,
            "overlay-color": colors.light.production,
            width: 3
        }
    },
    {
        selector: "edge.".concat(DependencyType.DEVELOPMENT),
        style: {
            "line-color": colors.light.development,
            "target-arrow-color": colors.light.development,
            "overlay-color": colors.light.development,
            width: 3
        }
    },
    {
        selector: "edge.".concat(DependencyType.PEER),
        style: {
            "line-color": colors.light.peer,
            "target-arrow-color": colors.light.peer,
            "overlay-color": colors.light.peer,
            width: 3
        }
    },
    {
        selector: "edge.dark.".concat(DependencyType.PRODUCTION),
        style: {
            "line-color": colors.dark.production,
            "target-arrow-color": colors.dark.production,
            "overlay-color": colors.dark.production,
            width: 3
        }
    },
    {
        selector: "edge.dark.".concat(DependencyType.DEVELOPMENT),
        style: {
            "line-color": colors.dark.development,
            "target-arrow-color": colors.dark.development,
            "overlay-color": colors.dark.development,
            width: 3
        }
    },
    {
        selector: "edge.dark.".concat(DependencyType.PEER),
        style: {
            "line-color": colors.dark.peer,
            "target-arrow-color": colors.dark.peer,
            "overlay-color": colors.dark.peer,
            width: 3
        }
    },
    {
        selector: "edge.violation",
        style: {
            "line-color": colors.dark.violation,
            "target-arrow-color": colors.dark.violation,
            "overlay-color": colors.dark.violation,
            "z-index": 10
        }
    },
    {
        selector: "edge.dim",
        style: {
            "z-index": 0,
            opacity: 0.1
        }
    },
    {
        selector: "edge.dark.dim",
        style: {
            "z-index": 0,
            opacity: 0.2
        }
    },
    {
        selector: "edge.hover",
        style: {
            "z-index": 100,
            "overlay-padding": 8,
            "overlay-opacity": 0.35
        }
    }
];
cytoscape_cjs_default().use((cytoscape_dagre_default()));
cytoscape_cjs_default().use((cytoscape_popper_default()));
/**
 * Calculates the minZoom value based on the length of the elements array.
 */ var calculateMinZoom = function calculateMinZoom(elementsLength) {
    var minZoomBase = 0.1; // Change this value to set the minimum zoom level when the array is empty
    var minZoomFactor = 0.000115; // Change this value to control the rate at which minZoom decreases as the array length increases
    return minZoomBase - elementsLength * minZoomFactor;
};
/**
 * Creates and renders a graph.
 */ var createRenderGraph = function createRenderGraph(_ref) {
    var container = _ref.container, elements = _ref.elements;
    var renderGraph = cytoscape({
        container: container,
        style: [].concat(_toConsumableArray(nodeStyles), _toConsumableArray(edgeStyles)),
        autoungrabify: true,
        maxZoom: 2,
        minZoom: calculateMinZoom(elements.length),
        elements: elements
    });
    return renderGraph;
};
var _ImageByPrimaryDepend;
var nodeImage = " ";
var reactLogo = "PHN2ZyB3aWR0aD0iMzYiIGhlaWdodD0iMzYiIHZpZXdCb3g9IjAgMCAzNiAzNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzBfMykiPgo8cGF0aCBkPSJNMTggMjEuMTA1NUMxOS43NzIxIDIxLjEwNTUgMjEuMjA4NyAxOS43MTUxIDIxLjIwODcgMThDMjEuMjA4NyAxNi4yODQ5IDE5Ljc3MjEgMTQuODk0NSAxOCAxNC44OTQ1QzE2LjIyNzkgMTQuODk0NSAxNC43OTEzIDE2LjI4NDkgMTQuNzkxMyAxOEMxNC43OTEzIDE5LjcxNTEgMTYuMjI3OSAyMS4xMDU1IDE4IDIxLjEwNTVaIiBmaWxsPSIjNjFEQUZCIi8+CjxwYXRoIGQ9Ik0xOCAyNC4zNjI2QzI3LjUwODkgMjQuMzYyNiAzNS4yMTc0IDIxLjUxMzkgMzUuMjE3NCAxOEMzNS4yMTc0IDE0LjQ4NjEgMjcuNTA4OSAxMS42Mzc1IDE4IDExLjYzNzVDOC40OTExMSAxMS42Mzc1IDAuNzgyNjIzIDE0LjQ4NjEgMC43ODI2MjMgMThDMC43ODI2MjMgMjEuNTEzOSA4LjQ5MTExIDI0LjM2MjYgMTggMjQuMzYyNloiIHN0cm9rZT0iIzYxREFGQiIvPgo8cGF0aCBkPSJNMTIuMzA2OCAyMS4xODEzQzE3LjA2MTMgMjkuMTUxNSAyMy40NjQ1IDM0LjE4ODMgMjYuNjA4NyAzMi40MzEzQzI5Ljc1MyAzMC42NzQzIDI4LjQ0NzcgMjIuNzg4OSAyMy42OTMyIDE0LjgxODdDMTguOTM4NyA2Ljg0ODUzIDEyLjUzNTYgMS44MTE3MyA5LjM5MTMzIDMuNTY4N0M2LjI0NzA3IDUuMzI1NjcgNy41NTI0IDEzLjIxMTEgMTIuMzA2OCAyMS4xODEzWiIgc3Ryb2tlPSIjNjFEQUZCIi8+CjxwYXRoIGQ9Ik0xMi4zMDY4IDE0LjgxODdDNy41NTIzOCAyMi43ODg5IDYuMjQ3MDYgMzAuNjc0MyA5LjM5MTMxIDMyLjQzMTNDMTIuNTM1NiAzNC4xODgzIDE4LjkzODcgMjkuMTUxNSAyMy42OTMyIDIxLjE4MTNDMjguNDQ3NiAxMy4yMTExIDI5Ljc1MyA1LjMyNTY2IDI2LjYwODcgMy41Njg2OUMyMy40NjQ0IDEuODExNzIgMTcuMDYxMyA2Ljg0ODUzIDEyLjMwNjggMTQuODE4N1oiIHN0cm9rZT0iIzYxREFGQiIvPgo8L2c+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzBfMyI+CjxyZWN0IHdpZHRoPSIzNiIgaGVpZ2h0PSIzMSIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDAgMi41KSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=";
var nextLogo = "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";
var ImageByPrimaryDependency = (_ImageByPrimaryDepend = {}, (0,asyncToGenerator_031c744a_esm._)(_ImageByPrimaryDepend, PackageType.REACT, reactLogo), (0,asyncToGenerator_031c744a_esm._)(_ImageByPrimaryDepend, PackageType.NODE, nodeImage), (0,asyncToGenerator_031c744a_esm._)(_ImageByPrimaryDepend, PackageType.NEXT, nextLogo), _ImageByPrimaryDepend);
var getNodeSize = function getNodeSize(_ref) {
    var context = _ref.context, name = _ref.name;
    if (!context) return;
    context.font = "normal ".concat(fontWeight, " ").concat(fontSize, "px ").concat(fontFamily);
    var paddingY = 24;
    var paddingX = 24;
    var iconWidth = 50;
    var labelWidth = context.measureText(name).width;
    var paddedLabelWidth = labelWidth + paddingX * 2 + iconWidth;
    var paddedLabelHeight = fontSize + paddingY * 2;
    return {
        width: Math.ceil(paddedLabelWidth),
        height: Math.ceil(paddedLabelHeight)
    };
};
var getElementDefinitions = function getElementDefinitions(_ref2) {
    var dependencies = _ref2.dependencies, packages = _ref2.packages;
    if (typeof document === "undefined") return [];
    try {
        var canvas = document.createElement("canvas");
        var context = canvas.getContext("2d");
        var nodes = packages.map(function(package_) {
            var _ImageByPrimaryDepend2;
            var dimensions = getNodeSize({
                context: context,
                name: package_.name
            });
            var image = (_ImageByPrimaryDepend2 = ImageByPrimaryDependency[package_.type]) !== null && _ImageByPrimaryDepend2 !== void 0 ? _ImageByPrimaryDepend2 : nodeImage;
            var imageData = "data:image/svg+xml;base64," + image;
            return {
                data: _objectSpread2(_objectSpread2({}, package_), {}, {
                    id: package_.name,
                    image: imageData
                }, dimensions)
            };
        });
        var edges = dependencies.map(function(dep) {
            return {
                data: _objectSpread2(_objectSpread2({}, dep), {}, {
                    id: "".concat(dep.source, "->").concat(dep.target)
                })
            };
        });
        return [].concat(_toConsumableArray(nodes), _toConsumableArray(edges));
    } catch (error) {
        console.error(error);
        return [];
    }
};
var layoutOptions = {
    name: "dagre",
    animate: false,
    rankSep: 240,
    nodeSep: 140,
    nodeDimensionsIncludeLabels: true
};
cytoscape_cjs_default().use((cytoscape_dagre_default()));
var getElementDefinitionsWithUpdatedLayout = /*#__PURE__*/ function() {
    var _ref2 = (0,asyncToGenerator_031c744a_esm.b)(/*#__PURE__*/ (0,asyncToGenerator_031c744a_esm.c)().mark(function _callee(_ref) {
        var elements, graph;
        return (0,asyncToGenerator_031c744a_esm.c)().wrap(function _callee$(_context) {
            while(1)switch(_context.prev = _context.next){
                case 0:
                    elements = _ref.elements;
                    graph = cytoscape_cjs_default()({
                        styleEnabled: true,
                        style: [].concat(_toConsumableArray(nodeStyles), _toConsumableArray(edgeStyles)),
                        elements: elements
                    });
                    graph.layout(layoutOptions).run();
                    return _context.abrupt("return", graph.elements().jsons());
                case 4:
                case "end":
                    return _context.stop();
            }
        }, _callee);
    }));
    return function getElementDefinitionsWithUpdatedLayout(_x) {
        return _ref2.apply(this, arguments);
    };
}();
var createTraversalGraph = function createTraversalGraph(_ref) {
    var elements = _ref.elements;
    return cytoscape({
        headless: true,
        elements: elements
    });
};
function withSerialization(fn) {
    return function(args) {
        var result = fn(args);
        return result.jsons();
    };
}
var show = withSerialization(function(_ref) {
    var traversalGraph = _ref.traversalGraph, renderGraph = _ref.renderGraph, selector = _ref.selector;
    var matchingNodes = traversalGraph.nodes().filter(selector);
    var existingNodes = renderGraph.nodes();
    var nodesToRender = existingNodes.union(matchingNodes);
    var edgesToRender = nodesToRender.nodes().edgesTo(nodesToRender.nodes());
    var elementsToRender = nodesToRender.union(edgesToRender);
    return elementsToRender;
});
var showDependencies = withSerialization(function(_ref2) {
    var traversalGraph = _ref2.traversalGraph, renderGraph = _ref2.renderGraph, id = _ref2.id;
    var node = traversalGraph.$id(id);
    var nodeAndDependants = node.union(node.outgoers());
    var elementsToRender = renderGraph.elements().union(nodeAndDependants);
    return elementsToRender;
});
var showDependants = withSerialization(function(_ref3) {
    var traversalGraph = _ref3.traversalGraph, renderGraph = _ref3.renderGraph, id = _ref3.id;
    var node = traversalGraph.$id(id);
    var nodeAndDependants = node.union(node.incomers());
    var nodesToRender = nodeAndDependants.nodes();
    var edgesToRender = nodesToRender.edgesTo(nodesToRender);
    var elementsToRender = renderGraph.elements().union(nodesToRender).union(edgesToRender);
    return elementsToRender;
});
var setInitialElements = withSerialization(function(_ref4) {
    var renderGraph = _ref4.renderGraph;
    return renderGraph.elements();
});
var commonalityco_utils_graph_esm_focus = withSerialization(function(_ref5) {
    var traversalGraph = _ref5.traversalGraph, selector = _ref5.selector;
    var nodesToRender = traversalGraph.nodes().filter(selector);
    var edgesToRender = nodesToRender.edgesTo(nodesToRender);
    return traversalGraph.collection().union(nodesToRender).union(edgesToRender);
});
var showAll = withSerialization(function(_ref6) {
    var traversalGraph = _ref6.traversalGraph;
    return traversalGraph.elements();
});
var hideAll = withSerialization(function(_ref7) {
    var traversalGraph = _ref7.traversalGraph;
    return traversalGraph.collection();
});
var hideDependents = withSerialization(function(_ref8) {
    var traversalGraph = _ref8.traversalGraph, renderGraph = _ref8.renderGraph, id = _ref8.id;
    var successorsOfNode = renderGraph.$id(id).successors();
    var successorsOfDirectDependents = traversalGraph.$id(id).incomers().successors();
    if (successorsOfDirectDependents.length) {
        return traversalGraph.collection().union(traversalGraph.$id(id)).union(successorsOfNode).intersection(successorsOfDirectDependents);
    } else {
        return renderGraph.elements();
    }
});
var hideDependencies = withSerialization(function(_ref9) {
    var traversalGraph = _ref9.traversalGraph, renderGraph = _ref9.renderGraph, id = _ref9.id;
    var elementsToHide = traversalGraph.$id(id).successors();
    return renderGraph.elements().difference(elementsToHide);
});
var hide = withSerialization(function(_ref10) {
    var traversalGraph = _ref10.traversalGraph, renderGraph = _ref10.renderGraph, selector = _ref10.selector;
    var elementsToHide = traversalGraph.collection();
    var nodesToHide = traversalGraph.nodes().filter(selector);
    var edgesForElements = nodesToHide.connectedEdges();
    elementsToHide.merge(nodesToHide).merge(edgesForElements);
    return renderGraph.elements().difference(elementsToHide);
});
var metadataKey = "metadata";
var documentsKeys = [
    metadataKey,
    "documents"
];
var violationsKeys = [
    metadataKey,
    "violations"
];
var tagsKeys = [
    metadataKey,
    "tags"
];
var projectConfigKeys = [
    metadataKey,
    "projectConfig"
];
var constraintsKeys = [
    metadataKey,
    "constraints"
];
var codeownersKeys = [
    metadataKey,
    "codeowners"
];
var packagesKeys = [
    metadataKey,
    "packages"
];
var dependenciesKeys = [
    metadataKey,
    "dependencies"
];


;// CONCATENATED MODULE: ../data-graph-worker/dist/commonalityco-data-graph-worker.esm.js

function _regeneratorRuntime() {
    _regeneratorRuntime = function() {
        return exports;
    };
    var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function(obj, key, desc) {
        obj[key] = desc.value;
    }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
    function define(obj, key, value) {
        return Object.defineProperty(obj, key, {
            value: value,
            enumerable: !0,
            configurable: !0,
            writable: !0
        }), obj[key];
    }
    try {
        define({}, "");
    } catch (err) {
        define = function(obj, key, value) {
            return obj[key] = value;
        };
    }
    function wrap(innerFn, outerFn, self, tryLocsList) {
        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []);
        return defineProperty(generator, "_invoke", {
            value: makeInvokeMethod(innerFn, self, context)
        }), generator;
    }
    function tryCatch(fn, obj, arg) {
        try {
            return {
                type: "normal",
                arg: fn.call(obj, arg)
            };
        } catch (err) {
            return {
                type: "throw",
                arg: err
            };
        }
    }
    exports.wrap = wrap;
    var ContinueSentinel = {};
    function Generator() {}
    function GeneratorFunction() {}
    function GeneratorFunctionPrototype() {}
    var IteratorPrototype = {};
    define(IteratorPrototype, iteratorSymbol, function() {
        return this;
    });
    var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([])));
    NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
    function defineIteratorMethods(prototype) {
        [
            "next",
            "throw",
            "return"
        ].forEach(function(method) {
            define(prototype, method, function(arg) {
                return this._invoke(method, arg);
            });
        });
    }
    function AsyncIterator(generator, PromiseImpl) {
        function invoke(method, arg, resolve, reject) {
            var record = tryCatch(generator[method], generator, arg);
            if ("throw" !== record.type) {
                var result = record.arg, value = result.value;
                return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function(value) {
                    invoke("next", value, resolve, reject);
                }, function(err) {
                    invoke("throw", err, resolve, reject);
                }) : PromiseImpl.resolve(value).then(function(unwrapped) {
                    result.value = unwrapped, resolve(result);
                }, function(error) {
                    return invoke("throw", error, resolve, reject);
                });
            }
            reject(record.arg);
        }
        var previousPromise;
        defineProperty(this, "_invoke", {
            value: function(method, arg) {
                function callInvokeWithMethodAndArg() {
                    return new PromiseImpl(function(resolve, reject) {
                        invoke(method, arg, resolve, reject);
                    });
                }
                return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
            }
        });
    }
    function makeInvokeMethod(innerFn, self, context) {
        var state = "suspendedStart";
        return function(method, arg) {
            if ("executing" === state) throw new Error("Generator is already running");
            if ("completed" === state) {
                if ("throw" === method) throw arg;
                return {
                    value: void 0,
                    done: !0
                };
            }
            for(context.method = method, context.arg = arg;;){
                var delegate = context.delegate;
                if (delegate) {
                    var delegateResult = maybeInvokeDelegate(delegate, context);
                    if (delegateResult) {
                        if (delegateResult === ContinueSentinel) continue;
                        return delegateResult;
                    }
                }
                if ("next" === context.method) context.sent = context._sent = context.arg;
                else if ("throw" === context.method) {
                    if ("suspendedStart" === state) throw state = "completed", context.arg;
                    context.dispatchException(context.arg);
                } else "return" === context.method && context.abrupt("return", context.arg);
                state = "executing";
                var record = tryCatch(innerFn, self, context);
                if ("normal" === record.type) {
                    if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
                    return {
                        value: record.arg,
                        done: context.done
                    };
                }
                "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
            }
        };
    }
    function maybeInvokeDelegate(delegate, context) {
        var methodName = context.method, method = delegate.iterator[methodName];
        if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel;
        var record = tryCatch(method, delegate.iterator, context.arg);
        if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
        var info = record.arg;
        return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
    }
    function pushTryEntry(locs) {
        var entry = {
            tryLoc: locs[0]
        };
        1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
    }
    function resetTryEntry(entry) {
        var record = entry.completion || {};
        record.type = "normal", delete record.arg, entry.completion = record;
    }
    function Context(tryLocsList) {
        this.tryEntries = [
            {
                tryLoc: "root"
            }
        ], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
    }
    function values(iterable) {
        if (iterable || "" === iterable) {
            var iteratorMethod = iterable[iteratorSymbol];
            if (iteratorMethod) return iteratorMethod.call(iterable);
            if ("function" == typeof iterable.next) return iterable;
            if (!isNaN(iterable.length)) {
                var i = -1, next = function next() {
                    for(; ++i < iterable.length;)if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
                    return next.value = undefined, next.done = !0, next;
                };
                return next.next = next;
            }
        }
        throw new TypeError(typeof iterable + " is not iterable");
    }
    return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", {
        value: GeneratorFunctionPrototype,
        configurable: !0
    }), defineProperty(GeneratorFunctionPrototype, "constructor", {
        value: GeneratorFunction,
        configurable: !0
    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function(genFun) {
        var ctor = "function" == typeof genFun && genFun.constructor;
        return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
    }, exports.mark = function(genFun) {
        return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
    }, exports.awrap = function(arg) {
        return {
            __await: arg
        };
    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
        return this;
    }), exports.AsyncIterator = AsyncIterator, exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
        void 0 === PromiseImpl && (PromiseImpl = Promise);
        var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
        return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
            return result.done ? result.value : iter.next();
        });
    }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function() {
        return this;
    }), define(Gp, "toString", function() {
        return "[object Generator]";
    }), exports.keys = function(val) {
        var object = Object(val), keys = [];
        for(var key in object)keys.push(key);
        return keys.reverse(), function next() {
            for(; keys.length;){
                var key = keys.pop();
                if (key in object) return next.value = key, next.done = !1, next;
            }
            return next.done = !0, next;
        };
    }, exports.values = values, Context.prototype = {
        constructor: Context,
        reset: function(skipTempReset) {
            if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for(var name in this)"t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
        },
        stop: function() {
            this.done = !0;
            var rootRecord = this.tryEntries[0].completion;
            if ("throw" === rootRecord.type) throw rootRecord.arg;
            return this.rval;
        },
        dispatchException: function(exception) {
            if (this.done) throw exception;
            var context = this;
            function handle(loc, caught) {
                return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
            }
            for(var i = this.tryEntries.length - 1; i >= 0; --i){
                var entry = this.tryEntries[i], record = entry.completion;
                if ("root" === entry.tryLoc) return handle("end");
                if (entry.tryLoc <= this.prev) {
                    var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc");
                    if (hasCatch && hasFinally) {
                        if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
                        if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
                    } else if (hasCatch) {
                        if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
                    } else {
                        if (!hasFinally) throw new Error("try statement without catch or finally");
                        if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
                    }
                }
            }
        },
        abrupt: function(type, arg) {
            for(var i = this.tryEntries.length - 1; i >= 0; --i){
                var entry = this.tryEntries[i];
                if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
                    var finallyEntry = entry;
                    break;
                }
            }
            finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
            var record = finallyEntry ? finallyEntry.completion : {};
            return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
        },
        complete: function(record, afterLoc) {
            if ("throw" === record.type) throw record.arg;
            return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
        },
        finish: function(finallyLoc) {
            for(var i = this.tryEntries.length - 1; i >= 0; --i){
                var entry = this.tryEntries[i];
                if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
            }
        },
        catch: function(tryLoc) {
            for(var i = this.tryEntries.length - 1; i >= 0; --i){
                var entry = this.tryEntries[i];
                if (entry.tryLoc === tryLoc) {
                    var record = entry.completion;
                    if ("throw" === record.type) {
                        var thrown = record.arg;
                        resetTryEntry(entry);
                    }
                    return thrown;
                }
            }
            throw new Error("illegal catch attempt");
        },
        delegateYield: function(iterable, resultName, nextLoc) {
            return this.delegate = {
                iterator: values(iterable),
                resultName: resultName,
                nextLoc: nextLoc
            }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
        }
    }, exports;
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
    try {
        var info = gen[key](arg);
        var value = info.value;
    } catch (error) {
        reject(error);
        return;
    }
    if (info.done) {
        resolve(value);
    } else {
        Promise.resolve(value).then(_next, _throw);
    }
}
function _asyncToGenerator(fn) {
    return function() {
        var self = this, args = arguments;
        return new Promise(function(resolve, reject) {
            var gen = fn.apply(self, args);
            function _next(value) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
            }
            function _throw(err) {
                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
            }
            _next(undefined);
        });
    };
}
addEventListener("message", /*#__PURE__*/ function() {
    var _ref = _asyncToGenerator(/*#__PURE__*/ _regeneratorRuntime().mark(function _callee(event) {
        var updatedElelementDefinitions;
        return _regeneratorRuntime().wrap(function _callee$(_context) {
            while(1)switch(_context.prev = _context.next){
                case 0:
                    _context.next = 2;
                    return getElementDefinitionsWithUpdatedLayout({
                        elements: event.data
                    });
                case 2:
                    updatedElelementDefinitions = _context.sent;
                    try {
                        postMessage(updatedElelementDefinitions);
                    } catch (error) {
                        console.error(error);
                    }
                case 4:
                case "end":
                    return _context.stop();
            }
        }, _callee);
    }));
    return function(_x) {
        return _ref.apply(this, arguments);
    };
}());

;// CONCATENATED MODULE: ./src/app/worker.ts



/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			id: moduleId,
/******/ 			loaded: false,
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		var threw = true;
/******/ 		try {
/******/ 			__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ 			threw = false;
/******/ 		} finally {
/******/ 			if(threw) delete __webpack_module_cache__[moduleId];
/******/ 		}
/******/ 	
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = __webpack_modules__;
/******/ 	
/******/ 	// the startup function
/******/ 	__webpack_require__.x = () => {
/******/ 		// Load entry module and return exports
/******/ 		// This entry module depends on other loaded chunks and execution need to be delayed
/******/ 		var __webpack_exports__ = __webpack_require__.O(undefined, [654,264,694], () => (__webpack_require__(38573)))
/******/ 		__webpack_exports__ = __webpack_require__.O(__webpack_exports__);
/******/ 		return __webpack_exports__;
/******/ 	};
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/chunk loaded */
/******/ 	(() => {
/******/ 		var deferred = [];
/******/ 		__webpack_require__.O = (result, chunkIds, fn, priority) => {
/******/ 			if(chunkIds) {
/******/ 				priority = priority || 0;
/******/ 				for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
/******/ 				deferred[i] = [chunkIds, fn, priority];
/******/ 				return;
/******/ 			}
/******/ 			var notFulfilled = Infinity;
/******/ 			for (var i = 0; i < deferred.length; i++) {
/******/ 				var [chunkIds, fn, priority] = deferred[i];
/******/ 				var fulfilled = true;
/******/ 				for (var j = 0; j < chunkIds.length; j++) {
/******/ 					if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
/******/ 						chunkIds.splice(j--, 1);
/******/ 					} else {
/******/ 						fulfilled = false;
/******/ 						if(priority < notFulfilled) notFulfilled = priority;
/******/ 					}
/******/ 				}
/******/ 				if(fulfilled) {
/******/ 					deferred.splice(i--, 1)
/******/ 					var r = fn();
/******/ 					if (r !== undefined) result = r;
/******/ 				}
/******/ 			}
/******/ 			return result;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/compat get default export */
/******/ 	(() => {
/******/ 		// getDefaultExport function for compatibility with non-harmony modules
/******/ 		__webpack_require__.n = (module) => {
/******/ 			var getter = module && module.__esModule ?
/******/ 				() => (module['default']) :
/******/ 				() => (module);
/******/ 			__webpack_require__.d(getter, { a: getter });
/******/ 			return getter;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/ensure chunk */
/******/ 	(() => {
/******/ 		__webpack_require__.f = {};
/******/ 		// This file contains only the entry chunk.
/******/ 		// The chunk loading function for additional chunks
/******/ 		__webpack_require__.e = (chunkId) => {
/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
/******/ 				__webpack_require__.f[key](chunkId, promises);
/******/ 				return promises;
/******/ 			}, []));
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/get javascript chunk filename */
/******/ 	(() => {
/******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
/******/ 		__webpack_require__.u = (chunkId) => {
/******/ 			// return url for filenames based on template
/******/ 			return "" + chunkId + ".js";
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/node module decorator */
/******/ 	(() => {
/******/ 		__webpack_require__.nmd = (module) => {
/******/ 			module.paths = [];
/******/ 			if (!module.children) module.children = [];
/******/ 			return module;
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/require chunk loading */
/******/ 	(() => {
/******/ 		// no baseURI
/******/ 		
/******/ 		// object to store loaded chunks
/******/ 		// "1" means "loaded", otherwise not loaded yet
/******/ 		var installedChunks = {
/******/ 			573: 1
/******/ 		};
/******/ 		
/******/ 		__webpack_require__.O.require = (chunkId) => (installedChunks[chunkId]);
/******/ 		
/******/ 		var installChunk = (chunk) => {
/******/ 			var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
/******/ 			for(var moduleId in moreModules) {
/******/ 				if(__webpack_require__.o(moreModules, moduleId)) {
/******/ 					__webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ 				}
/******/ 			}
/******/ 			if(runtime) runtime(__webpack_require__);
/******/ 			for(var i = 0; i < chunkIds.length; i++)
/******/ 				installedChunks[chunkIds[i]] = 1;
/******/ 			__webpack_require__.O();
/******/ 		};
/******/ 		
/******/ 		// require() chunk loading for javascript
/******/ 		__webpack_require__.f.require = (chunkId, promises) => {
/******/ 			// "1" is the signal for "already loaded"
/******/ 			if(!installedChunks[chunkId]) {
/******/ 				if(true) { // all chunks have JS
/******/ 					installChunk(require("./" + __webpack_require__.u(chunkId)));
/******/ 				} else installedChunks[chunkId] = 1;
/******/ 			}
/******/ 		};
/******/ 		
/******/ 		// no external install chunk
/******/ 		
/******/ 		// no HMR
/******/ 		
/******/ 		// no HMR manifest
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/startup chunk dependencies */
/******/ 	(() => {
/******/ 		var next = __webpack_require__.x;
/******/ 		__webpack_require__.x = () => {
/******/ 			__webpack_require__.e(654);
/******/ 			__webpack_require__.e(264);
/******/ 			__webpack_require__.e(694);
/******/ 			return next();
/******/ 		};
/******/ 	})();
/******/ 	
/************************************************************************/
/******/ 	
/******/ 	// run startup
/******/ 	var __webpack_exports__ = __webpack_require__.x();
/******/ 	module.exports = __webpack_exports__;
/******/ 	
/******/ })()
;