aboutsummaryrefslogtreecommitdiff
path: root/build/assets/js/1.6d8e9162.js
diff options
context:
space:
mode:
Diffstat (limited to 'build/assets/js/1.6d8e9162.js')
-rw-r--r--build/assets/js/1.6d8e9162.js10323
1 files changed, 10323 insertions, 0 deletions
diff --git a/build/assets/js/1.6d8e9162.js b/build/assets/js/1.6d8e9162.js
new file mode 100644
index 00000000..9c8a07f6
--- /dev/null
+++ b/build/assets/js/1.6d8e9162.js
@@ -0,0 +1,10323 @@
+"use strict";
+exports.id = 1;
+exports.ids = [1];
+exports.modules = {
+
+/***/ 21176:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ Zp: () => (/* reexport */ layout)
+});
+
+// UNUSED EXPORTS: acyclic, normalize, rank
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/forEach.js
+var forEach = __webpack_require__(8058);
+// EXTERNAL MODULE: ./node_modules/lodash-es/uniqueId.js
+var uniqueId = __webpack_require__(5664);
+// EXTERNAL MODULE: ./node_modules/lodash-es/has.js + 1 modules
+var has = __webpack_require__(48585);
+// EXTERNAL MODULE: ./node_modules/lodash-es/constant.js
+var constant = __webpack_require__(39142);
+// EXTERNAL MODULE: ./node_modules/lodash-es/flatten.js
+var flatten = __webpack_require__(34098);
+// EXTERNAL MODULE: ./node_modules/lodash-es/map.js
+var map = __webpack_require__(74722);
+// EXTERNAL MODULE: ./node_modules/lodash-es/range.js + 2 modules
+var range = __webpack_require__(91395);
+// EXTERNAL MODULE: ./node_modules/dagre-d3-es/src/graphlib/index.js
+var graphlib = __webpack_require__(697);
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/data/list.js
+/*
+ * Simple doubly linked list implementation derived from Cormen, et al.,
+ * "Introduction to Algorithms".
+ */
+
+
+
+class 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(', ') + ']';
+ }
+}
+
+function unlink(entry) {
+ entry._prev._next = entry._next;
+ entry._next._prev = entry._prev;
+ delete entry._next;
+ delete entry._prev;
+}
+
+function filterOutLinks(k, v) {
+ if (k !== '_next' && k !== '_prev') {
+ return v;
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/greedy-fas.js
+
+
+
+
+/*
+ * A greedy heuristic for finding a feedback arc set for a graph. A feedback
+ * arc set is a set of edges that can be removed to make a graph acyclic.
+ * The algorithm comes from: P. Eades, X. Lin, and W. F. Smyth, "A fast and
+ * effective heuristic for the feedback arc set problem." This implementation
+ * adjusts that from the paper to allow for weighted edges.
+ */
+
+
+var DEFAULT_WEIGHT_FN = constant/* default */.A(1);
+
+function greedyFAS(g, weightFn) {
+ if (g.nodeCount() <= 1) {
+ return [];
+ }
+ var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+ var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+
+ // Expand multi-edges
+ return flatten/* default */.A(
+ map/* default */.A(results, function (e) {
+ return g.outEdges(e.v, e.w);
+ })
+ );
+}
+
+function doGreedyFAS(g, buckets, zeroIdx) {
+ var results = [];
+ var sources = buckets[buckets.length - 1];
+ var sinks = buckets[0];
+
+ var entry;
+ while (g.nodeCount()) {
+ while ((entry = sinks.dequeue())) {
+ removeNode(g, buckets, zeroIdx, entry);
+ }
+ while ((entry = sources.dequeue())) {
+ removeNode(g, buckets, zeroIdx, entry);
+ }
+ if (g.nodeCount()) {
+ for (var i = buckets.length - 2; i > 0; --i) {
+ entry = buckets[i].dequeue();
+ if (entry) {
+ results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
+ break;
+ }
+ }
+ }
+ }
+
+ return results;
+}
+
+function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
+ var results = collectPredecessors ? [] : undefined;
+
+ forEach/* default */.A(g.inEdges(entry.v), function (edge) {
+ var weight = g.edge(edge);
+ var uEntry = g.node(edge.v);
+
+ if (collectPredecessors) {
+ results.push({ v: edge.v, w: edge.w });
+ }
+
+ uEntry.out -= weight;
+ assignBucket(buckets, zeroIdx, uEntry);
+ });
+
+ forEach/* default */.A(g.outEdges(entry.v), function (edge) {
+ var weight = g.edge(edge);
+ var w = edge.w;
+ var wEntry = g.node(w);
+ wEntry['in'] -= weight;
+ assignBucket(buckets, zeroIdx, wEntry);
+ });
+
+ g.removeNode(entry.v);
+
+ return results;
+}
+
+function buildState(g, weightFn) {
+ var fasGraph = new graphlib/* Graph */.T();
+ var maxIn = 0;
+ var maxOut = 0;
+
+ forEach/* default */.A(g.nodes(), function (v) {
+ fasGraph.setNode(v, { v: v, in: 0, out: 0 });
+ });
+
+ // Aggregate weights on nodes, but also sum the weights across multi-edges
+ // into a single edge for the fasGraph.
+ forEach/* default */.A(g.edges(), function (e) {
+ var prevWeight = fasGraph.edge(e.v, e.w) || 0;
+ var weight = weightFn(e);
+ var edgeWeight = prevWeight + weight;
+ fasGraph.setEdge(e.v, e.w, edgeWeight);
+ maxOut = Math.max(maxOut, (fasGraph.node(e.v).out += weight));
+ maxIn = Math.max(maxIn, (fasGraph.node(e.w)['in'] += weight));
+ });
+
+ var buckets = range/* default */.A(maxOut + maxIn + 3).map(function () {
+ return new List();
+ });
+ var zeroIdx = maxIn + 1;
+
+ forEach/* default */.A(fasGraph.nodes(), function (v) {
+ assignBucket(buckets, zeroIdx, fasGraph.node(v));
+ });
+
+ return { graph: fasGraph, buckets: buckets, zeroIdx: 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);
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/acyclic.js
+
+
+
+
+
+function run(g) {
+ var fas = g.graph().acyclicer === 'greedy' ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+ forEach/* default */.A(fas, function (e) {
+ var label = g.edge(e);
+ g.removeEdge(e);
+ label.forwardName = e.name;
+ label.reversed = true;
+ g.setEdge(e.w, e.v, label, uniqueId/* default */.A('rev'));
+ });
+
+ function weightFn(g) {
+ return function (e) {
+ return g.edge(e).weight;
+ };
+ }
+}
+
+function dfsFAS(g) {
+ var fas = [];
+ var stack = {};
+ var visited = {};
+
+ function dfs(v) {
+ if (has/* default */.A(visited, v)) {
+ return;
+ }
+ visited[v] = true;
+ stack[v] = true;
+ forEach/* default */.A(g.outEdges(v), function (e) {
+ if (has/* default */.A(stack, e.w)) {
+ fas.push(e);
+ } else {
+ dfs(e.w);
+ }
+ });
+ delete stack[v];
+ }
+
+ forEach/* default */.A(g.nodes(), dfs);
+ return fas;
+}
+
+function undo(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ var label = g.edge(e);
+ if (label.reversed) {
+ g.removeEdge(e);
+
+ var forwardName = label.forwardName;
+ delete label.reversed;
+ delete label.forwardName;
+ g.setEdge(e.w, e.v, label, forwardName);
+ }
+ });
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/merge.js + 6 modules
+var merge = __webpack_require__(98879);
+// EXTERNAL MODULE: ./node_modules/lodash-es/pick.js + 4 modules
+var pick = __webpack_require__(81942);
+// EXTERNAL MODULE: ./node_modules/lodash-es/defaults.js
+var defaults = __webpack_require__(23068);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isSymbol.js
+var isSymbol = __webpack_require__(61882);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseExtremum.js
+
+
+/**
+ * The base implementation of methods like `_.max` and `_.min` which accepts a
+ * `comparator` to determine the extremum value.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The iteratee invoked per iteration.
+ * @param {Function} comparator The comparator used to compare values.
+ * @returns {*} Returns the extremum value.
+ */
+function baseExtremum(array, iteratee, comparator) {
+ var index = -1,
+ length = array.length;
+
+ while (++index < length) {
+ var value = array[index],
+ current = iteratee(value);
+
+ if (current != null && (computed === undefined
+ ? (current === current && !(0,isSymbol/* default */.A)(current))
+ : comparator(current, computed)
+ )) {
+ var computed = current,
+ result = value;
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ const _baseExtremum = (baseExtremum);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseGt.js
+/**
+ * The base implementation of `_.gt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than `other`,
+ * else `false`.
+ */
+function baseGt(value, other) {
+ return value > other;
+}
+
+/* harmony default export */ const _baseGt = (baseGt);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/identity.js
+var identity = __webpack_require__(29008);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/max.js
+
+
+
+
+/**
+ * Computes the maximum value of `array`. If `array` is empty or falsey,
+ * `undefined` is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * _.max([4, 2, 8, 6]);
+ * // => 8
+ *
+ * _.max([]);
+ * // => undefined
+ */
+function max(array) {
+ return (array && array.length)
+ ? _baseExtremum(array, identity/* default */.A, _baseGt)
+ : undefined;
+}
+
+/* harmony default export */ const lodash_es_max = (max);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/last.js
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+function last(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? array[length - 1] : undefined;
+}
+
+/* harmony default export */ const lodash_es_last = (last);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseAssignValue.js
+var _baseAssignValue = __webpack_require__(52528);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseForOwn.js
+var _baseForOwn = __webpack_require__(79841);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseIteratee.js + 16 modules
+var _baseIteratee = __webpack_require__(49574);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/mapValues.js
+
+
+
+
+/**
+ * Creates an object with the same keys as `object` and values generated
+ * by running each own enumerable string keyed property of `object` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns the new mapped object.
+ * @see _.mapKeys
+ * @example
+ *
+ * var users = {
+ * 'fred': { 'user': 'fred', 'age': 40 },
+ * 'pebbles': { 'user': 'pebbles', 'age': 1 }
+ * };
+ *
+ * _.mapValues(users, function(o) { return o.age; });
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.mapValues(users, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ */
+function mapValues(object, iteratee) {
+ var result = {};
+ iteratee = (0,_baseIteratee/* default */.A)(iteratee, 3);
+
+ (0,_baseForOwn/* default */.A)(object, function(value, key, object) {
+ (0,_baseAssignValue/* default */.A)(result, key, iteratee(value, key, object));
+ });
+ return result;
+}
+
+/* harmony default export */ const lodash_es_mapValues = (mapValues);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isUndefined.js
+var isUndefined = __webpack_require__(69592);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseLt.js
+/**
+ * The base implementation of `_.lt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is less than `other`,
+ * else `false`.
+ */
+function baseLt(value, other) {
+ return value < other;
+}
+
+/* harmony default export */ const _baseLt = (baseLt);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/min.js
+
+
+
+
+/**
+ * Computes the minimum value of `array`. If `array` is empty or falsey,
+ * `undefined` is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * _.min([]);
+ * // => undefined
+ */
+function min(array) {
+ return (array && array.length)
+ ? _baseExtremum(array, identity/* default */.A, _baseLt)
+ : undefined;
+}
+
+/* harmony default export */ const lodash_es_min = (min);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_root.js
+var _root = __webpack_require__(41917);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/now.js
+
+
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ * console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */
+var now = function() {
+ return _root/* default */.A.Date.now();
+};
+
+/* harmony default export */ const lodash_es_now = (now);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/util.js
+
+
+
+
+
+/*
+ * Adds a dummy node to the graph and return v.
+ */
+function addDummyNode(g, type, attrs, name) {
+ var v;
+ do {
+ v = uniqueId/* default */.A(name);
+ } while (g.hasNode(v));
+
+ attrs.dummy = type;
+ g.setNode(v, attrs);
+ return v;
+}
+
+/*
+ * Returns a new graph with only simple edges. Handles aggregation of data
+ * associated with multi-edges.
+ */
+function simplify(g) {
+ var simplified = new graphlib/* Graph */.T().setGraph(g.graph());
+ forEach/* default */.A(g.nodes(), function (v) {
+ simplified.setNode(v, g.node(v));
+ });
+ forEach/* default */.A(g.edges(), function (e) {
+ var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
+ var label = g.edge(e);
+ simplified.setEdge(e.v, e.w, {
+ weight: simpleLabel.weight + label.weight,
+ minlen: Math.max(simpleLabel.minlen, label.minlen),
+ });
+ });
+ return simplified;
+}
+
+function asNonCompoundGraph(g) {
+ var simplified = new graphlib/* Graph */.T({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+ forEach/* default */.A(g.nodes(), function (v) {
+ if (!g.children(v).length) {
+ simplified.setNode(v, g.node(v));
+ }
+ });
+ forEach/* default */.A(g.edges(), function (e) {
+ simplified.setEdge(e, g.edge(e));
+ });
+ return simplified;
+}
+
+function successorWeights(g) {
+ var weightMap = _.map(g.nodes(), function (v) {
+ var sucs = {};
+ _.forEach(g.outEdges(v), function (e) {
+ sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
+ });
+ return sucs;
+ });
+ return _.zipObject(g.nodes(), weightMap);
+}
+
+function predecessorWeights(g) {
+ var weightMap = _.map(g.nodes(), function (v) {
+ var preds = {};
+ _.forEach(g.inEdges(v), function (e) {
+ preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
+ });
+ return preds;
+ });
+ return _.zipObject(g.nodes(), weightMap);
+}
+
+/*
+ * Finds where a line starting at point ({x, y}) would intersect a rectangle
+ * ({x, y, width, height}) if it were pointing at the rectangle's center.
+ */
+function intersectRect(rect, point) {
+ var x = rect.x;
+ var y = rect.y;
+
+ // Rectangle intersection algorithm from:
+ // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+ var dx = point.x - x;
+ var dy = point.y - y;
+ var w = rect.width / 2;
+ var h = rect.height / 2;
+
+ if (!dx && !dy) {
+ throw new Error('Not possible to find intersection inside of the rectangle');
+ }
+
+ var sx, sy;
+ if (Math.abs(dy) * w > Math.abs(dx) * h) {
+ // Intersection is top or bottom of rect.
+ if (dy < 0) {
+ h = -h;
+ }
+ sx = (h * dx) / dy;
+ sy = h;
+ } else {
+ // Intersection is left or right of rect.
+ if (dx < 0) {
+ w = -w;
+ }
+ sx = w;
+ sy = (w * dy) / dx;
+ }
+
+ return { x: x + sx, y: y + sy };
+}
+
+/*
+ * Given a DAG with each node assigned "rank" and "order" properties, this
+ * function will produce a matrix with the ids of each node.
+ */
+function buildLayerMatrix(g) {
+ var layering = map/* default */.A(range/* default */.A(util_maxRank(g) + 1), function () {
+ return [];
+ });
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ var rank = node.rank;
+ if (!isUndefined/* default */.A(rank)) {
+ layering[rank][node.order] = v;
+ }
+ });
+ return layering;
+}
+
+/*
+ * Adjusts the ranks for all nodes in the graph such that all nodes v have
+ * rank(v) >= 0 and at least one node w has rank(w) = 0.
+ */
+function normalizeRanks(g) {
+ var min = lodash_es_min(
+ map/* default */.A(g.nodes(), function (v) {
+ return g.node(v).rank;
+ })
+ );
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ if (has/* default */.A(node, 'rank')) {
+ node.rank -= min;
+ }
+ });
+}
+
+function removeEmptyRanks(g) {
+ // Ranks may not start at 0, so we need to offset them
+ var offset = lodash_es_min(
+ map/* default */.A(g.nodes(), function (v) {
+ return g.node(v).rank;
+ })
+ );
+
+ var layers = [];
+ forEach/* default */.A(g.nodes(), function (v) {
+ var rank = g.node(v).rank - offset;
+ if (!layers[rank]) {
+ layers[rank] = [];
+ }
+ layers[rank].push(v);
+ });
+
+ var delta = 0;
+ var nodeRankFactor = g.graph().nodeRankFactor;
+ forEach/* default */.A(layers, function (vs, i) {
+ if (isUndefined/* default */.A(vs) && i % nodeRankFactor !== 0) {
+ --delta;
+ } else if (delta) {
+ forEach/* default */.A(vs, function (v) {
+ g.node(v).rank += delta;
+ });
+ }
+ });
+}
+
+function addBorderNode(g, prefix, rank, order) {
+ var node = {
+ width: 0,
+ height: 0,
+ };
+ if (arguments.length >= 4) {
+ node.rank = rank;
+ node.order = order;
+ }
+ return addDummyNode(g, 'border', node, prefix);
+}
+
+function util_maxRank(g) {
+ return lodash_es_max(
+ map/* default */.A(g.nodes(), function (v) {
+ var rank = g.node(v).rank;
+ if (!isUndefined/* default */.A(rank)) {
+ return rank;
+ }
+ })
+ );
+}
+
+/*
+ * Partition a collection into two groups: `lhs` and `rhs`. If the supplied
+ * function returns true for an entry it goes into `lhs`. Otherwise it goes
+ * into `rhs.
+ */
+function partition(collection, fn) {
+ var result = { lhs: [], rhs: [] };
+ forEach/* default */.A(collection, function (value) {
+ if (fn(value)) {
+ result.lhs.push(value);
+ } else {
+ result.rhs.push(value);
+ }
+ });
+ return result;
+}
+
+/*
+ * Returns a new function that wraps `fn` with a timer. The wrapper logs the
+ * time it takes to execute the function.
+ */
+function util_time(name, fn) {
+ var start = lodash_es_now();
+ try {
+ return fn();
+ } finally {
+ console.log(name + ' time: ' + (lodash_es_now() - start) + 'ms');
+ }
+}
+
+function notime(name, fn) {
+ return fn();
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/add-border-segments.js
+
+
+
+
+
+function addBorderSegments(g) {
+ function dfs(v) {
+ var children = g.children(v);
+ var node = g.node(v);
+ if (children.length) {
+ forEach/* default */.A(children, dfs);
+ }
+
+ if (has/* default */.A(node, 'minRank')) {
+ node.borderLeft = [];
+ node.borderRight = [];
+ for (var rank = node.minRank, maxRank = node.maxRank + 1; rank < maxRank; ++rank) {
+ add_border_segments_addBorderNode(g, 'borderLeft', '_bl', v, node, rank);
+ add_border_segments_addBorderNode(g, 'borderRight', '_br', v, node, rank);
+ }
+ }
+ }
+
+ forEach/* default */.A(g.children(), dfs);
+}
+
+function add_border_segments_addBorderNode(g, prop, prefix, sg, sgNode, rank) {
+ var label = { width: 0, height: 0, rank: rank, borderType: prop };
+ var prev = sgNode[prop][rank - 1];
+ var curr = addDummyNode(g, 'border', label, prefix);
+ sgNode[prop][rank] = curr;
+ g.setParent(curr, sg);
+ if (prev) {
+ g.setEdge(prev, curr, { weight: 1 });
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/coordinate-system.js
+
+
+
+
+function adjust(g) {
+ var rankDir = g.graph().rankdir.toLowerCase();
+ if (rankDir === 'lr' || rankDir === 'rl') {
+ swapWidthHeight(g);
+ }
+}
+
+function coordinate_system_undo(g) {
+ var rankDir = g.graph().rankdir.toLowerCase();
+ if (rankDir === 'bt' || rankDir === 'rl') {
+ reverseY(g);
+ }
+
+ if (rankDir === 'lr' || rankDir === 'rl') {
+ swapXY(g);
+ swapWidthHeight(g);
+ }
+}
+
+function swapWidthHeight(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ swapWidthHeightOne(g.node(v));
+ });
+ forEach/* default */.A(g.edges(), function (e) {
+ swapWidthHeightOne(g.edge(e));
+ });
+}
+
+function swapWidthHeightOne(attrs) {
+ var w = attrs.width;
+ attrs.width = attrs.height;
+ attrs.height = w;
+}
+
+function reverseY(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ reverseYOne(g.node(v));
+ });
+
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ forEach/* default */.A(edge.points, reverseYOne);
+ if (has/* default */.A(edge, 'y')) {
+ reverseYOne(edge);
+ }
+ });
+}
+
+function reverseYOne(attrs) {
+ attrs.y = -attrs.y;
+}
+
+function swapXY(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ swapXYOne(g.node(v));
+ });
+
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ forEach/* default */.A(edge.points, swapXYOne);
+ if (has/* default */.A(edge, 'x')) {
+ swapXYOne(edge);
+ }
+ });
+}
+
+function swapXYOne(attrs) {
+ var x = attrs.x;
+ attrs.x = attrs.y;
+ attrs.y = x;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/normalize.js
+
+
+
+
+
+/*
+ * Breaks any long edges in the graph into short segments that span 1 layer
+ * each. This operation is undoable with the denormalize function.
+ *
+ * Pre-conditions:
+ *
+ * 1. The input graph is a DAG.
+ * 2. Each node in the graph has a "rank" property.
+ *
+ * Post-condition:
+ *
+ * 1. All edges in the graph have a length of 1.
+ * 2. Dummy nodes are added where edges have been split into segments.
+ * 3. The graph is augmented with a "dummyChains" attribute which contains
+ * the first dummy in each chain of dummy nodes produced.
+ */
+function normalize_run(g) {
+ g.graph().dummyChains = [];
+ forEach/* default */.A(g.edges(), function (edge) {
+ normalizeEdge(g, edge);
+ });
+}
+
+function normalizeEdge(g, e) {
+ var v = e.v;
+ var vRank = g.node(v).rank;
+ var w = e.w;
+ var wRank = g.node(w).rank;
+ var name = e.name;
+ var edgeLabel = g.edge(e);
+ var labelRank = edgeLabel.labelRank;
+
+ if (wRank === vRank + 1) return;
+
+ g.removeEdge(e);
+
+ var dummy, attrs, i;
+ for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
+ edgeLabel.points = [];
+ attrs = {
+ width: 0,
+ height: 0,
+ edgeLabel: edgeLabel,
+ edgeObj: e,
+ rank: vRank,
+ };
+ dummy = addDummyNode(g, 'edge', attrs, '_d');
+ if (vRank === labelRank) {
+ attrs.width = edgeLabel.width;
+ attrs.height = edgeLabel.height;
+ // @ts-expect-error
+ attrs.dummy = 'edge-label';
+ // @ts-expect-error
+ attrs.labelpos = edgeLabel.labelpos;
+ }
+ g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
+ if (i === 0) {
+ g.graph().dummyChains.push(dummy);
+ }
+ v = dummy;
+ }
+
+ g.setEdge(v, w, { weight: edgeLabel.weight }, name);
+}
+
+function normalize_undo(g) {
+ forEach/* default */.A(g.graph().dummyChains, function (v) {
+ var node = g.node(v);
+ var origLabel = node.edgeLabel;
+ var w;
+ g.setEdge(node.edgeObj, origLabel);
+ while (node.dummy) {
+ w = g.successors(v)[0];
+ g.removeNode(v);
+ origLabel.points.push({ x: node.x, y: node.y });
+ if (node.dummy === 'edge-label') {
+ origLabel.x = node.x;
+ origLabel.y = node.y;
+ origLabel.width = node.width;
+ origLabel.height = node.height;
+ }
+ v = w;
+ node = g.node(v);
+ }
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/minBy.js
+
+
+
+
+/**
+ * This method is like `_.min` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.minBy(objects, function(o) { return o.n; });
+ * // => { 'n': 1 }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.minBy(objects, 'n');
+ * // => { 'n': 1 }
+ */
+function minBy(array, iteratee) {
+ return (array && array.length)
+ ? _baseExtremum(array, (0,_baseIteratee/* default */.A)(iteratee, 2), _baseLt)
+ : undefined;
+}
+
+/* harmony default export */ const lodash_es_minBy = (minBy);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/rank/util.js
+
+
+
+
+/*
+ * Initializes ranks for the input graph using the longest path algorithm. This
+ * algorithm scales well and is fast in practice, it yields rather poor
+ * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
+ * ranks wide and leaving edges longer than necessary. However, due to its
+ * speed, this algorithm is good for getting an initial ranking that can be fed
+ * into other algorithms.
+ *
+ * This algorithm does not normalize layers because it will be used by other
+ * algorithms in most cases. If using this algorithm directly, be sure to
+ * run normalize at the end.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph is a DAG.
+ * 2. Input graph node labels can be assigned properties.
+ *
+ * Post-conditions:
+ *
+ * 1. Each node will be assign an (unnormalized) "rank" property.
+ */
+function longestPath(g) {
+ var visited = {};
+
+ function dfs(v) {
+ var label = g.node(v);
+ if (has/* default */.A(visited, v)) {
+ return label.rank;
+ }
+ visited[v] = true;
+
+ var rank = lodash_es_min(
+ map/* default */.A(g.outEdges(v), function (e) {
+ return dfs(e.w) - g.edge(e).minlen;
+ })
+ );
+
+ if (
+ rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+ rank === undefined || // return value of _.map([]) for Lodash 4
+ rank === null
+ ) {
+ // return value of _.map([null])
+ rank = 0;
+ }
+
+ return (label.rank = rank);
+ }
+
+ forEach/* default */.A(g.sources(), dfs);
+}
+
+/*
+ * Returns the amount of slack for the given edge. The slack is defined as the
+ * difference between the length of the edge and its minimum length.
+ */
+function slack(g, e) {
+ return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/rank/feasible-tree.js
+
+
+
+
+
+
+/*
+ * Constructs a spanning tree with tight edges and adjusted the input node's
+ * ranks to achieve this. A tight edge is one that is has a length that matches
+ * its "minlen" attribute.
+ *
+ * The basic structure for this function is derived from Gansner, et al., "A
+ * Technique for Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be a DAG.
+ * 2. Graph must be connected.
+ * 3. Graph must have at least one node.
+ * 5. Graph nodes must have been previously assigned a "rank" property that
+ * respects the "minlen" property of incident edges.
+ * 6. Graph edges must have a "minlen" property.
+ *
+ * Post-conditions:
+ *
+ * - Graph nodes will have their rank adjusted to ensure that all edges are
+ * tight.
+ *
+ * Returns a tree (undirected graph) that is constructed using only "tight"
+ * edges.
+ */
+function feasibleTree(g) {
+ var t = new graphlib/* Graph */.T({ directed: false });
+
+ // Choose arbitrary node from which to start our tree
+ var start = g.nodes()[0];
+ var size = g.nodeCount();
+ t.setNode(start, {});
+
+ var edge, delta;
+ while (tightTree(t, g) < size) {
+ edge = findMinSlackEdge(t, g);
+ delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+ shiftRanks(t, g, delta);
+ }
+
+ return t;
+}
+
+/*
+ * Finds a maximal tree of tight edges and returns the number of nodes in the
+ * tree.
+ */
+function tightTree(t, g) {
+ function dfs(v) {
+ forEach/* default */.A(g.nodeEdges(v), function (e) {
+ var edgeV = e.v,
+ w = v === edgeV ? e.w : edgeV;
+ if (!t.hasNode(w) && !slack(g, e)) {
+ t.setNode(w, {});
+ t.setEdge(v, w, {});
+ dfs(w);
+ }
+ });
+ }
+
+ forEach/* default */.A(t.nodes(), dfs);
+ return t.nodeCount();
+}
+
+/*
+ * Finds the edge with the smallest slack that is incident on tree and returns
+ * it.
+ */
+function findMinSlackEdge(t, g) {
+ return lodash_es_minBy(g.edges(), function (e) {
+ if (t.hasNode(e.v) !== t.hasNode(e.w)) {
+ return slack(g, e);
+ }
+ });
+}
+
+function shiftRanks(t, g, delta) {
+ forEach/* default */.A(t.nodes(), function (v) {
+ g.node(v).rank += delta;
+ });
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArrayLike.js
+var isArrayLike = __webpack_require__(38446);
+// EXTERNAL MODULE: ./node_modules/lodash-es/keys.js
+var keys = __webpack_require__(27422);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_createFind.js
+
+
+
+
+/**
+ * Creates a `_.find` or `_.findLast` function.
+ *
+ * @private
+ * @param {Function} findIndexFunc The function to find the collection index.
+ * @returns {Function} Returns the new find function.
+ */
+function createFind(findIndexFunc) {
+ return function(collection, predicate, fromIndex) {
+ var iterable = Object(collection);
+ if (!(0,isArrayLike/* default */.A)(collection)) {
+ var iteratee = (0,_baseIteratee/* default */.A)(predicate, 3);
+ collection = (0,keys/* default */.A)(collection);
+ predicate = function(key) { return iteratee(iterable[key], key, iterable); };
+ }
+ var index = findIndexFunc(collection, predicate, fromIndex);
+ return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
+ };
+}
+
+/* harmony default export */ const _createFind = (createFind);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseFindIndex.js
+var _baseFindIndex = __webpack_require__(25707);
+// EXTERNAL MODULE: ./node_modules/lodash-es/toFinite.js + 3 modules
+var toFinite = __webpack_require__(74342);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/toInteger.js
+
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+ var result = (0,toFinite/* default */.A)(value),
+ remainder = result % 1;
+
+ return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+/* harmony default export */ const lodash_es_toInteger = (toInteger);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/findIndex.js
+
+
+
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max;
+
+/**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.findIndex(users, function(o) { return o.user == 'barney'; });
+ * // => 0
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findIndex(users, { 'user': 'fred', 'active': false });
+ * // => 1
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findIndex(users, ['active', false]);
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findIndex(users, 'active');
+ * // => 2
+ */
+function findIndex(array, predicate, fromIndex) {
+ var length = array == null ? 0 : array.length;
+ if (!length) {
+ return -1;
+ }
+ var index = fromIndex == null ? 0 : lodash_es_toInteger(fromIndex);
+ if (index < 0) {
+ index = nativeMax(length + index, 0);
+ }
+ return (0,_baseFindIndex/* default */.A)(array, (0,_baseIteratee/* default */.A)(predicate, 3), index);
+}
+
+/* harmony default export */ const lodash_es_findIndex = (findIndex);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/find.js
+
+
+
+/**
+ * Iterates over elements of `collection`, returning the first element
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false },
+ * { 'user': 'pebbles', 'age': 1, 'active': true }
+ * ];
+ *
+ * _.find(users, function(o) { return o.age < 40; });
+ * // => object for 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.find(users, { 'age': 1, 'active': true });
+ * // => object for 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.find(users, ['active', false]);
+ * // => object for 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.find(users, 'active');
+ * // => object for 'barney'
+ */
+var find = _createFind(lodash_es_findIndex);
+
+/* harmony default export */ const lodash_es_find = (find);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/filter.js + 1 modules
+var filter = __webpack_require__(11662);
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/dijkstra.js
+
+
+
+
+
+var DEFAULT_WEIGHT_FUNC = constant/* default */.A(1);
+
+function dijkstra_dijkstra(g, source, weightFn, edgeFn) {
+ return runDijkstra(
+ g,
+ String(source),
+ weightFn || DEFAULT_WEIGHT_FUNC,
+ edgeFn ||
+ function (v) {
+ return g.outEdges(v);
+ }
+ );
+}
+
+function runDijkstra(g, source, weightFn, edgeFn) {
+ var results = {};
+ var pq = new PriorityQueue();
+ var v, vEntry;
+
+ var updateNeighbors = function (edge) {
+ var w = edge.v !== v ? edge.v : edge.w;
+ var wEntry = results[w];
+ var weight = weightFn(edge);
+ var distance = vEntry.distance + weight;
+
+ if (weight < 0) {
+ throw new Error(
+ 'dijkstra does not allow negative edge weights. ' +
+ 'Bad edge: ' +
+ edge +
+ ' Weight: ' +
+ weight
+ );
+ }
+
+ if (distance < wEntry.distance) {
+ wEntry.distance = distance;
+ wEntry.predecessor = v;
+ pq.decrease(w, distance);
+ }
+ };
+
+ g.nodes().forEach(function (v) {
+ var distance = v === source ? 0 : Number.POSITIVE_INFINITY;
+ results[v] = { distance: distance };
+ pq.add(v, distance);
+ });
+
+ while (pq.size() > 0) {
+ v = pq.removeMin();
+ vEntry = results[v];
+ if (vEntry.distance === Number.POSITIVE_INFINITY) {
+ break;
+ }
+
+ edgeFn(v).forEach(updateNeighbors);
+ }
+
+ return results;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/dijkstra-all.js
+
+
+
+
+
+function dijkstraAll(g, weightFunc, edgeFunc) {
+ return _.transform(
+ g.nodes(),
+ function (acc, v) {
+ acc[v] = dijkstra(g, v, weightFunc, edgeFunc);
+ },
+ {}
+ );
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/floyd-warshall.js
+
+
+
+
+var floyd_warshall_DEFAULT_WEIGHT_FUNC = constant/* default */.A(1);
+
+function floydWarshall(g, weightFn, edgeFn) {
+ return runFloydWarshall(
+ g,
+ weightFn || floyd_warshall_DEFAULT_WEIGHT_FUNC,
+ edgeFn ||
+ function (v) {
+ return g.outEdges(v);
+ }
+ );
+}
+
+function runFloydWarshall(g, weightFn, edgeFn) {
+ var results = {};
+ var nodes = g.nodes();
+
+ nodes.forEach(function (v) {
+ results[v] = {};
+ results[v][v] = { distance: 0 };
+ nodes.forEach(function (w) {
+ if (v !== w) {
+ results[v][w] = { distance: Number.POSITIVE_INFINITY };
+ }
+ });
+ edgeFn(v).forEach(function (edge) {
+ var w = edge.v === v ? edge.w : edge.v;
+ var d = weightFn(edge);
+ results[v][w] = { distance: d, predecessor: v };
+ });
+ });
+
+ nodes.forEach(function (k) {
+ var rowK = results[k];
+ nodes.forEach(function (i) {
+ var rowI = results[i];
+ nodes.forEach(function (j) {
+ var ik = rowI[k];
+ var kj = rowK[j];
+ var ij = rowI[j];
+ var altDistance = ik.distance + kj.distance;
+ if (altDistance < ij.distance) {
+ ij.distance = altDistance;
+ ij.predecessor = kj.predecessor;
+ }
+ });
+ });
+ });
+
+ return results;
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseKeys.js + 1 modules
+var _baseKeys = __webpack_require__(69471);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getTag.js + 3 modules
+var _getTag = __webpack_require__(9779);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseGetTag.js + 2 modules
+var _baseGetTag = __webpack_require__(88496);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObjectLike.js
+var isObjectLike = __webpack_require__(53098);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/isString.js
+
+
+
+
+/** `Object#toString` result references. */
+var stringTag = '[object String]';
+
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */
+function isString(value) {
+ return typeof value == 'string' ||
+ (!(0,isArray/* default */.A)(value) && (0,isObjectLike/* default */.A)(value) && (0,_baseGetTag/* default */.A)(value) == stringTag);
+}
+
+/* harmony default export */ const lodash_es_isString = (isString);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseProperty.js
+var _baseProperty = __webpack_require__(70805);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_asciiSize.js
+
+
+/**
+ * Gets the size of an ASCII `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+var asciiSize = (0,_baseProperty/* default */.A)('length');
+
+/* harmony default export */ const _asciiSize = (asciiSize);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_hasUnicode.js
+/** Used to compose unicode character classes. */
+var rsAstralRange = '\\ud800-\\udfff',
+ rsComboMarksRange = '\\u0300-\\u036f',
+ reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+ rsComboSymbolsRange = '\\u20d0-\\u20ff',
+ rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
+ rsVarRange = '\\ufe0e\\ufe0f';
+
+/** Used to compose unicode capture groups. */
+var rsZWJ = '\\u200d';
+
+/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
+var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');
+
+/**
+ * Checks if `string` contains Unicode symbols.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {boolean} Returns `true` if a symbol is found, else `false`.
+ */
+function hasUnicode(string) {
+ return reHasUnicode.test(string);
+}
+
+/* harmony default export */ const _hasUnicode = (hasUnicode);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_unicodeSize.js
+/** Used to compose unicode character classes. */
+var _unicodeSize_rsAstralRange = '\\ud800-\\udfff',
+ _unicodeSize_rsComboMarksRange = '\\u0300-\\u036f',
+ _unicodeSize_reComboHalfMarksRange = '\\ufe20-\\ufe2f',
+ _unicodeSize_rsComboSymbolsRange = '\\u20d0-\\u20ff',
+ _unicodeSize_rsComboRange = _unicodeSize_rsComboMarksRange + _unicodeSize_reComboHalfMarksRange + _unicodeSize_rsComboSymbolsRange,
+ _unicodeSize_rsVarRange = '\\ufe0e\\ufe0f';
+
+/** Used to compose unicode capture groups. */
+var rsAstral = '[' + _unicodeSize_rsAstralRange + ']',
+ rsCombo = '[' + _unicodeSize_rsComboRange + ']',
+ rsFitz = '\\ud83c[\\udffb-\\udfff]',
+ rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
+ rsNonAstral = '[^' + _unicodeSize_rsAstralRange + ']',
+ rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
+ rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+ _unicodeSize_rsZWJ = '\\u200d';
+
+/** Used to compose unicode regexes. */
+var reOptMod = rsModifier + '?',
+ rsOptVar = '[' + _unicodeSize_rsVarRange + ']?',
+ rsOptJoin = '(?:' + _unicodeSize_rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
+ rsSeq = rsOptVar + reOptMod + rsOptJoin,
+ rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+
+/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
+var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
+
+/**
+ * Gets the size of a Unicode `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+function unicodeSize(string) {
+ var result = reUnicode.lastIndex = 0;
+ while (reUnicode.test(string)) {
+ ++result;
+ }
+ return result;
+}
+
+/* harmony default export */ const _unicodeSize = (unicodeSize);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_stringSize.js
+
+
+
+
+/**
+ * Gets the number of symbols in `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the string size.
+ */
+function stringSize(string) {
+ return _hasUnicode(string)
+ ? _unicodeSize(string)
+ : _asciiSize(string);
+}
+
+/* harmony default export */ const _stringSize = (stringSize);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/size.js
+
+
+
+
+
+
+/** `Object#toString` result references. */
+var mapTag = '[object Map]',
+ setTag = '[object Set]';
+
+/**
+ * Gets the size of `collection` by returning its length for array-like
+ * values or the number of own enumerable string keyed properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns the collection size.
+ * @example
+ *
+ * _.size([1, 2, 3]);
+ * // => 3
+ *
+ * _.size({ 'a': 1, 'b': 2 });
+ * // => 2
+ *
+ * _.size('pebbles');
+ * // => 7
+ */
+function size(collection) {
+ if (collection == null) {
+ return 0;
+ }
+ if ((0,isArrayLike/* default */.A)(collection)) {
+ return lodash_es_isString(collection) ? _stringSize(collection) : collection.length;
+ }
+ var tag = (0,_getTag/* default */.A)(collection);
+ if (tag == mapTag || tag == setTag) {
+ return collection.size;
+ }
+ return (0,_baseKeys/* default */.A)(collection).length;
+}
+
+/* harmony default export */ const lodash_es_size = (size);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/topsort.js
+
+
+
+
+topsort_topsort.CycleException = topsort_CycleException;
+
+function topsort_topsort(g) {
+ var visited = {};
+ var stack = {};
+ var results = [];
+
+ function visit(node) {
+ if (has/* default */.A(stack, node)) {
+ throw new topsort_CycleException();
+ }
+
+ if (!has/* default */.A(visited, node)) {
+ stack[node] = true;
+ visited[node] = true;
+ forEach/* default */.A(g.predecessors(node), visit);
+ delete stack[node];
+ results.push(node);
+ }
+ }
+
+ forEach/* default */.A(g.sinks(), visit);
+
+ if (lodash_es_size(visited) !== g.nodeCount()) {
+ throw new topsort_CycleException();
+ }
+
+ return results;
+}
+
+function topsort_CycleException() {}
+topsort_CycleException.prototype = new Error(); // must be an instance of Error to pass testing
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/is-acyclic.js
+
+
+
+
+function isAcyclic(g) {
+ try {
+ topsort(g);
+ } catch (e) {
+ if (e instanceof CycleException) {
+ return false;
+ }
+ throw e;
+ }
+ return true;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/dfs.js
+
+
+
+
+/*
+ * A helper that preforms a pre- or post-order traversal on the input graph
+ * and returns the nodes in the order they were visited. If the graph is
+ * undirected then this algorithm will navigate using neighbors. If the graph
+ * is directed then this algorithm will navigate using successors.
+ *
+ * Order must be one of "pre" or "post".
+ */
+function dfs(g, vs, order) {
+ if (!isArray/* default */.A(vs)) {
+ vs = [vs];
+ }
+
+ var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+
+ var acc = [];
+ var visited = {};
+ forEach/* default */.A(vs, function (v) {
+ if (!g.hasNode(v)) {
+ throw new Error('Graph does not have node: ' + v);
+ }
+
+ doDfs(g, v, order === 'post', visited, navigation, acc);
+ });
+ return acc;
+}
+
+function doDfs(g, v, postorder, visited, navigation, acc) {
+ if (!has/* default */.A(visited, v)) {
+ visited[v] = true;
+
+ if (!postorder) {
+ acc.push(v);
+ }
+ forEach/* default */.A(navigation(v), function (w) {
+ doDfs(g, w, postorder, visited, navigation, acc);
+ });
+ if (postorder) {
+ acc.push(v);
+ }
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/postorder.js
+
+
+
+
+function postorder(g, vs) {
+ return dfs(g, vs, 'post');
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/preorder.js
+
+
+
+
+function preorder(g, vs) {
+ return dfs(g, vs, 'pre');
+}
+
+// EXTERNAL MODULE: ./node_modules/dagre-d3-es/src/graphlib/graph.js + 9 modules
+var graph = __webpack_require__(73046);
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/prim.js
+
+
+
+
+
+
+function prim(g, weightFunc) {
+ var result = new Graph();
+ var parents = {};
+ var pq = new PriorityQueue();
+ var v;
+
+ function updateNeighbors(edge) {
+ var w = edge.v === v ? edge.w : edge.v;
+ var pri = pq.priority(w);
+ if (pri !== undefined) {
+ var edgeWeight = weightFunc(edge);
+ if (edgeWeight < pri) {
+ parents[w] = v;
+ pq.decrease(w, edgeWeight);
+ }
+ }
+ }
+
+ if (g.nodeCount() === 0) {
+ return result;
+ }
+
+ _.each(g.nodes(), function (v) {
+ pq.add(v, Number.POSITIVE_INFINITY);
+ result.setNode(v);
+ });
+
+ // Start from an arbitrary node
+ pq.decrease(g.nodes()[0], 0);
+
+ var init = false;
+ while (pq.size() > 0) {
+ v = pq.removeMin();
+ if (_.has(parents, v)) {
+ result.setEdge(v, parents[v]);
+ } else if (init) {
+ throw new Error('Input graph is not connected: ' + g);
+ } else {
+ init = true;
+ }
+
+ g.nodeEdges(v).forEach(updateNeighbors);
+ }
+
+ return result;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/alg/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/rank/network-simplex.js
+
+
+
+
+
+
+
+
+// Expose some internals for testing purposes
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+
+/*
+ * The network simplex algorithm assigns ranks to each node in the input graph
+ * and iteratively improves the ranking to reduce the length of edges.
+ *
+ * Preconditions:
+ *
+ * 1. The input graph must be a DAG.
+ * 2. All nodes in the graph must have an object value.
+ * 3. All edges in the graph must have "minlen" and "weight" attributes.
+ *
+ * Postconditions:
+ *
+ * 1. All nodes in the graph will have an assigned "rank" attribute that has
+ * been optimized by the network simplex algorithm. Ranks start at 0.
+ *
+ *
+ * A rough sketch of the algorithm is as follows:
+ *
+ * 1. Assign initial ranks to each node. We use the longest path algorithm,
+ * which assigns ranks to the lowest position possible. In general this
+ * leads to very wide bottom ranks and unnecessarily long edges.
+ * 2. Construct a feasible tight tree. A tight tree is one such that all
+ * edges in the tree have no slack (difference between length of edge
+ * and minlen for the edge). This by itself greatly improves the assigned
+ * rankings by shorting edges.
+ * 3. Iteratively find edges that have negative cut values. Generally a
+ * negative cut value indicates that the edge could be removed and a new
+ * tree edge could be added to produce a more compact graph.
+ *
+ * Much of the algorithms here are derived from Gansner, et al., "A Technique
+ * for Drawing Directed Graphs." The structure of the file roughly follows the
+ * structure of the overall algorithm.
+ */
+function networkSimplex(g) {
+ g = simplify(g);
+ longestPath(g);
+ var t = feasibleTree(g);
+ initLowLimValues(t);
+ initCutValues(t, g);
+
+ var e, f;
+ while ((e = leaveEdge(t))) {
+ f = enterEdge(t, g, e);
+ exchangeEdges(t, g, e, f);
+ }
+}
+
+/*
+ * Initializes cut values for all edges in the tree.
+ */
+function initCutValues(t, g) {
+ var vs = postorder(t, t.nodes());
+ vs = vs.slice(0, vs.length - 1);
+ forEach/* default */.A(vs, function (v) {
+ assignCutValue(t, g, v);
+ });
+}
+
+function assignCutValue(t, g, child) {
+ var childLab = t.node(child);
+ var parent = childLab.parent;
+ t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+
+/*
+ * Given the tight tree, its graph, and a child in the graph calculate and
+ * return the cut value for the edge between the child and its parent.
+ */
+function calcCutValue(t, g, child) {
+ var childLab = t.node(child);
+ var parent = childLab.parent;
+ // True if the child is on the tail end of the edge in the directed graph
+ var childIsTail = true;
+ // The graph's view of the tree edge we're inspecting
+ var graphEdge = g.edge(child, parent);
+ // The accumulated cut value for the edge between this node and its parent
+ var cutValue = 0;
+
+ if (!graphEdge) {
+ childIsTail = false;
+ graphEdge = g.edge(parent, child);
+ }
+
+ cutValue = graphEdge.weight;
+
+ forEach/* default */.A(g.nodeEdges(child), function (e) {
+ var isOutEdge = e.v === child,
+ other = isOutEdge ? e.w : e.v;
+
+ if (other !== parent) {
+ var pointsToHead = isOutEdge === childIsTail,
+ otherWeight = g.edge(e).weight;
+
+ cutValue += pointsToHead ? otherWeight : -otherWeight;
+ if (isTreeEdge(t, child, other)) {
+ var otherCutValue = t.edge(child, other).cutvalue;
+ cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+ }
+ }
+ });
+
+ return cutValue;
+}
+
+function initLowLimValues(tree, root) {
+ if (arguments.length < 2) {
+ root = tree.nodes()[0];
+ }
+ dfsAssignLowLim(tree, {}, 1, root);
+}
+
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+ var low = nextLim;
+ var label = tree.node(v);
+
+ visited[v] = true;
+ forEach/* default */.A(tree.neighbors(v), function (w) {
+ if (!has/* default */.A(visited, w)) {
+ nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+ }
+ });
+
+ label.low = low;
+ label.lim = nextLim++;
+ if (parent) {
+ label.parent = parent;
+ } else {
+ // TODO should be able to remove this when we incrementally update low lim
+ delete label.parent;
+ }
+
+ return nextLim;
+}
+
+function leaveEdge(tree) {
+ return lodash_es_find(tree.edges(), function (e) {
+ return tree.edge(e).cutvalue < 0;
+ });
+}
+
+function enterEdge(t, g, edge) {
+ var v = edge.v;
+ var w = edge.w;
+
+ // For the rest of this function we assume that v is the tail and w is the
+ // head, so if we don't have this edge in the graph we should flip it to
+ // match the correct orientation.
+ if (!g.hasEdge(v, w)) {
+ v = edge.w;
+ w = edge.v;
+ }
+
+ var vLabel = t.node(v);
+ var wLabel = t.node(w);
+ var tailLabel = vLabel;
+ var flip = false;
+
+ // If the root is in the tail of the edge then we need to flip the logic that
+ // checks for the head and tail nodes in the candidates function below.
+ if (vLabel.lim > wLabel.lim) {
+ tailLabel = wLabel;
+ flip = true;
+ }
+
+ var candidates = filter/* default */.A(g.edges(), function (edge) {
+ return (
+ flip === isDescendant(t, t.node(edge.v), tailLabel) &&
+ flip !== isDescendant(t, t.node(edge.w), tailLabel)
+ );
+ });
+
+ return lodash_es_minBy(candidates, function (edge) {
+ return slack(g, edge);
+ });
+}
+
+function exchangeEdges(t, g, e, f) {
+ var v = e.v;
+ var w = e.w;
+ t.removeEdge(v, w);
+ t.setEdge(f.v, f.w, {});
+ initLowLimValues(t);
+ initCutValues(t, g);
+ updateRanks(t, g);
+}
+
+function updateRanks(t, g) {
+ var root = lodash_es_find(t.nodes(), function (v) {
+ return !g.node(v).parent;
+ });
+ var vs = preorder(t, root);
+ vs = vs.slice(1);
+ forEach/* default */.A(vs, function (v) {
+ var parent = t.node(v).parent,
+ edge = g.edge(v, parent),
+ flipped = false;
+
+ if (!edge) {
+ edge = g.edge(parent, v);
+ flipped = true;
+ }
+
+ g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+ });
+}
+
+/*
+ * Returns true if the edge is in the tree.
+ */
+function isTreeEdge(tree, u, v) {
+ return tree.hasEdge(u, v);
+}
+
+/*
+ * Returns true if the specified node is descendant of the root node per the
+ * assigned low and lim attributes in the tree.
+ */
+function isDescendant(tree, vLabel, rootLabel) {
+ return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/rank/index.js
+
+
+
+
+
+
+/*
+ * Assigns a rank to each node in the input graph that respects the "minlen"
+ * constraint specified on edges between nodes.
+ *
+ * This basic structure is derived from Gansner, et al., "A Technique for
+ * Drawing Directed Graphs."
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be a connected DAG
+ * 2. Graph nodes must be objects
+ * 3. Graph edges must have "weight" and "minlen" attributes
+ *
+ * Post-conditions:
+ *
+ * 1. Graph nodes will have a "rank" attribute based on the results of the
+ * algorithm. Ranks can start at any index (including negative), we'll
+ * fix them up later.
+ */
+function rank(g) {
+ switch (g.graph().ranker) {
+ case 'network-simplex':
+ networkSimplexRanker(g);
+ break;
+ case 'tight-tree':
+ tightTreeRanker(g);
+ break;
+ case 'longest-path':
+ longestPathRanker(g);
+ break;
+ default:
+ networkSimplexRanker(g);
+ }
+}
+
+// A fast and simple ranker, but results are far from optimal.
+var longestPathRanker = longestPath;
+
+function tightTreeRanker(g) {
+ longestPath(g);
+ feasibleTree(g);
+}
+
+function networkSimplexRanker(g) {
+ networkSimplex(g);
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/values.js + 1 modules
+var values = __webpack_require__(38207);
+// EXTERNAL MODULE: ./node_modules/lodash-es/reduce.js + 2 modules
+var reduce = __webpack_require__(89463);
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/nesting-graph.js
+
+
+
+
+
+/*
+ * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
+ * adds appropriate edges to ensure that all cluster nodes are placed between
+ * these boundries, and ensures that the graph is connected.
+ *
+ * In addition we ensure, through the use of the minlen property, that nodes
+ * and subgraph border nodes to not end up on the same rank.
+ *
+ * Preconditions:
+ *
+ * 1. Input graph is a DAG
+ * 2. Nodes in the input graph has a minlen attribute
+ *
+ * Postconditions:
+ *
+ * 1. Input graph is connected.
+ * 2. Dummy nodes are added for the tops and bottoms of subgraphs.
+ * 3. The minlen attribute for nodes is adjusted to ensure nodes do not
+ * get placed on the same rank as subgraph border nodes.
+ *
+ * The nesting graph idea comes from Sander, "Layout of Compound Directed
+ * Graphs."
+ */
+function nesting_graph_run(g) {
+ var root = addDummyNode(g, 'root', {}, '_root');
+ var depths = treeDepths(g);
+ var height = lodash_es_max(values/* default */.A(depths)) - 1; // Note: depths is an Object not an array
+ var nodeSep = 2 * height + 1;
+
+ g.graph().nestingRoot = root;
+
+ // Multiply minlen by nodeSep to align nodes on non-border ranks.
+ forEach/* default */.A(g.edges(), function (e) {
+ g.edge(e).minlen *= nodeSep;
+ });
+
+ // Calculate a weight that is sufficient to keep subgraphs vertically compact
+ var weight = sumWeights(g) + 1;
+
+ // Create border nodes and link them up
+ forEach/* default */.A(g.children(), function (child) {
+ nesting_graph_dfs(g, root, nodeSep, weight, height, depths, child);
+ });
+
+ // Save the multiplier for node layers for later removal of empty border
+ // layers.
+ g.graph().nodeRankFactor = nodeSep;
+}
+
+function nesting_graph_dfs(g, root, nodeSep, weight, height, depths, v) {
+ var children = g.children(v);
+ if (!children.length) {
+ if (v !== root) {
+ g.setEdge(root, v, { weight: 0, minlen: nodeSep });
+ }
+ return;
+ }
+
+ var top = addBorderNode(g, '_bt');
+ var bottom = addBorderNode(g, '_bb');
+ var label = g.node(v);
+
+ g.setParent(top, v);
+ label.borderTop = top;
+ g.setParent(bottom, v);
+ label.borderBottom = bottom;
+
+ forEach/* default */.A(children, function (child) {
+ nesting_graph_dfs(g, root, nodeSep, weight, height, depths, child);
+
+ var childNode = g.node(child);
+ var childTop = childNode.borderTop ? childNode.borderTop : child;
+ var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+ var thisWeight = childNode.borderTop ? weight : 2 * weight;
+ var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+
+ g.setEdge(top, childTop, {
+ weight: thisWeight,
+ minlen: minlen,
+ nestingEdge: true,
+ });
+
+ g.setEdge(childBottom, bottom, {
+ weight: thisWeight,
+ minlen: minlen,
+ nestingEdge: true,
+ });
+ });
+
+ if (!g.parent(v)) {
+ g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+ }
+}
+
+function treeDepths(g) {
+ var depths = {};
+ function dfs(v, depth) {
+ var children = g.children(v);
+ if (children && children.length) {
+ forEach/* default */.A(children, function (child) {
+ dfs(child, depth + 1);
+ });
+ }
+ depths[v] = depth;
+ }
+ forEach/* default */.A(g.children(), function (v) {
+ dfs(v, 1);
+ });
+ return depths;
+}
+
+function sumWeights(g) {
+ return reduce/* default */.A(
+ g.edges(),
+ function (acc, e) {
+ return acc + g.edge(e).weight;
+ },
+ 0
+ );
+}
+
+function cleanup(g) {
+ var graphLabel = g.graph();
+ g.removeNode(graphLabel.nestingRoot);
+ delete graphLabel.nestingRoot;
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ if (edge.nestingEdge) {
+ g.removeEdge(e);
+ }
+ });
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseClone.js + 15 modules
+var _baseClone = __webpack_require__(91641);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/cloneDeep.js
+
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+ CLONE_SYMBOLS_FLAG = 4;
+
+/**
+ * This method is like `_.clone` except that it recursively clones `value`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.0.0
+ * @category Lang
+ * @param {*} value The value to recursively clone.
+ * @returns {*} Returns the deep cloned value.
+ * @see _.clone
+ * @example
+ *
+ * var objects = [{ 'a': 1 }, { 'b': 2 }];
+ *
+ * var deep = _.cloneDeep(objects);
+ * console.log(deep[0] === objects[0]);
+ * // => false
+ */
+function cloneDeep(value) {
+ return (0,_baseClone/* default */.A)(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+
+/* harmony default export */ const lodash_es_cloneDeep = (cloneDeep);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/add-subgraph-constraints.js
+
+
+
+
+function addSubgraphConstraints(g, cg, vs) {
+ var prev = {},
+ rootPrev;
+
+ forEach/* default */.A(vs, function (v) {
+ var child = g.parent(v),
+ parent,
+ prevChild;
+ while (child) {
+ parent = g.parent(child);
+ if (parent) {
+ prevChild = prev[parent];
+ prev[parent] = child;
+ } else {
+ prevChild = rootPrev;
+ rootPrev = child;
+ }
+ if (prevChild && prevChild !== child) {
+ cg.setEdge(prevChild, child);
+ return;
+ }
+ child = parent;
+ }
+ });
+
+ /*
+ function dfs(v) {
+ var children = v ? g.children(v) : g.children();
+ if (children.length) {
+ var min = Number.POSITIVE_INFINITY,
+ subgraphs = [];
+ _.each(children, function(child) {
+ var childMin = dfs(child);
+ if (g.children(child).length) {
+ subgraphs.push({ v: child, order: childMin });
+ }
+ min = Math.min(min, childMin);
+ });
+ _.reduce(_.sortBy(subgraphs, "order"), function(prev, curr) {
+ cg.setEdge(prev.v, curr.v);
+ return curr;
+ });
+ return min;
+ }
+ return g.node(v).order;
+ }
+ dfs(undefined);
+ */
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/build-layer-graph.js
+
+
+
+
+
+/*
+ * Constructs a graph that can be used to sort a layer of nodes. The graph will
+ * contain all base and subgraph nodes from the request layer in their original
+ * hierarchy and any edges that are incident on these nodes and are of the type
+ * requested by the "relationship" parameter.
+ *
+ * Nodes from the requested rank that do not have parents are assigned a root
+ * node in the output graph, which is set in the root graph attribute. This
+ * makes it easy to walk the hierarchy of movable nodes during ordering.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph is a DAG
+ * 2. Base nodes in the input graph have a rank attribute
+ * 3. Subgraph nodes in the input graph has minRank and maxRank attributes
+ * 4. Edges have an assigned weight
+ *
+ * Post-conditions:
+ *
+ * 1. Output graph has all nodes in the movable rank with preserved
+ * hierarchy.
+ * 2. Root nodes in the movable layer are made children of the node
+ * indicated by the root attribute of the graph.
+ * 3. Non-movable nodes incident on movable nodes, selected by the
+ * relationship parameter, are included in the graph (without hierarchy).
+ * 4. Edges incident on movable nodes, selected by the relationship
+ * parameter, are added to the output graph.
+ * 5. The weights for copied edges are aggregated as need, since the output
+ * graph is not a multi-graph.
+ */
+function buildLayerGraph(g, rank, relationship) {
+ var root = createRootNode(g),
+ result = new graphlib/* Graph */.T({ compound: true })
+ .setGraph({ root: root })
+ .setDefaultNodeLabel(function (v) {
+ return g.node(v);
+ });
+
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v),
+ parent = g.parent(v);
+
+ if (node.rank === rank || (node.minRank <= rank && rank <= node.maxRank)) {
+ result.setNode(v);
+ result.setParent(v, parent || root);
+
+ // This assumes we have only short edges!
+ forEach/* default */.A(g[relationship](v), function (e) {
+ var u = e.v === v ? e.w : e.v,
+ edge = result.edge(u, v),
+ weight = !isUndefined/* default */.A(edge) ? edge.weight : 0;
+ result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+ });
+
+ if (has/* default */.A(node, 'minRank')) {
+ result.setNode(v, {
+ borderLeft: node.borderLeft[rank],
+ borderRight: node.borderRight[rank],
+ });
+ }
+ }
+ });
+
+ return result;
+}
+
+function createRootNode(g) {
+ var v;
+ while (g.hasNode((v = uniqueId/* default */.A('_root'))));
+ return v;
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_assignValue.js
+var _assignValue = __webpack_require__(52851);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseZipObject.js
+/**
+ * This base implementation of `_.zipObject` which assigns values using `assignFunc`.
+ *
+ * @private
+ * @param {Array} props The property identifiers.
+ * @param {Array} values The property values.
+ * @param {Function} assignFunc The function to assign values.
+ * @returns {Object} Returns the new object.
+ */
+function baseZipObject(props, values, assignFunc) {
+ var index = -1,
+ length = props.length,
+ valsLength = values.length,
+ result = {};
+
+ while (++index < length) {
+ var value = index < valsLength ? values[index] : undefined;
+ assignFunc(result, props[index], value);
+ }
+ return result;
+}
+
+/* harmony default export */ const _baseZipObject = (baseZipObject);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/zipObject.js
+
+
+
+/**
+ * This method is like `_.fromPairs` except that it accepts two arrays,
+ * one of property identifiers and one of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.4.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObject(['a', 'b'], [1, 2]);
+ * // => { 'a': 1, 'b': 2 }
+ */
+function zipObject(props, values) {
+ return _baseZipObject(props || [], values || [], _assignValue/* default */.A);
+}
+
+/* harmony default export */ const lodash_es_zipObject = (zipObject);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseFlatten.js + 1 modules
+var _baseFlatten = __webpack_require__(13588);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayMap.js
+var _arrayMap = __webpack_require__(45572);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseGet.js
+var _baseGet = __webpack_require__(66318);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseMap.js
+var _baseMap = __webpack_require__(52568);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseSortBy.js
+/**
+ * The base implementation of `_.sortBy` which uses `comparer` to define the
+ * sort order of `array` and replaces criteria objects with their corresponding
+ * values.
+ *
+ * @private
+ * @param {Array} array The array to sort.
+ * @param {Function} comparer The function to define sort order.
+ * @returns {Array} Returns `array`.
+ */
+function baseSortBy(array, comparer) {
+ var length = array.length;
+
+ array.sort(comparer);
+ while (length--) {
+ array[length] = array[length].value;
+ }
+ return array;
+}
+
+/* harmony default export */ const _baseSortBy = (baseSortBy);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseUnary.js
+var _baseUnary = __webpack_require__(52789);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_compareAscending.js
+
+
+/**
+ * Compares values to sort them in ascending order.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {number} Returns the sort order indicator for `value`.
+ */
+function compareAscending(value, other) {
+ if (value !== other) {
+ var valIsDefined = value !== undefined,
+ valIsNull = value === null,
+ valIsReflexive = value === value,
+ valIsSymbol = (0,isSymbol/* default */.A)(value);
+
+ var othIsDefined = other !== undefined,
+ othIsNull = other === null,
+ othIsReflexive = other === other,
+ othIsSymbol = (0,isSymbol/* default */.A)(other);
+
+ if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||
+ (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||
+ (valIsNull && othIsDefined && othIsReflexive) ||
+ (!valIsDefined && othIsReflexive) ||
+ !valIsReflexive) {
+ return 1;
+ }
+ if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||
+ (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||
+ (othIsNull && valIsDefined && valIsReflexive) ||
+ (!othIsDefined && valIsReflexive) ||
+ !othIsReflexive) {
+ return -1;
+ }
+ }
+ return 0;
+}
+
+/* harmony default export */ const _compareAscending = (compareAscending);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_compareMultiple.js
+
+
+/**
+ * Used by `_.orderBy` to compare multiple properties of a value to another
+ * and stable sort them.
+ *
+ * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,
+ * specify an order of "desc" for descending or "asc" for ascending sort order
+ * of corresponding values.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {boolean[]|string[]} orders The order to sort by for each property.
+ * @returns {number} Returns the sort order indicator for `object`.
+ */
+function compareMultiple(object, other, orders) {
+ var index = -1,
+ objCriteria = object.criteria,
+ othCriteria = other.criteria,
+ length = objCriteria.length,
+ ordersLength = orders.length;
+
+ while (++index < length) {
+ var result = _compareAscending(objCriteria[index], othCriteria[index]);
+ if (result) {
+ if (index >= ordersLength) {
+ return result;
+ }
+ var order = orders[index];
+ return result * (order == 'desc' ? -1 : 1);
+ }
+ }
+ // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications
+ // that causes it, under certain circumstances, to provide the same value for
+ // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247
+ // for more details.
+ //
+ // This also ensures a stable sort in V8 and other engines.
+ // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
+ return object.index - other.index;
+}
+
+/* harmony default export */ const _compareMultiple = (compareMultiple);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseOrderBy.js
+
+
+
+
+
+
+
+
+
+
+/**
+ * The base implementation of `_.orderBy` without param guards.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.
+ * @param {string[]} orders The sort orders of `iteratees`.
+ * @returns {Array} Returns the new sorted array.
+ */
+function baseOrderBy(collection, iteratees, orders) {
+ if (iteratees.length) {
+ iteratees = (0,_arrayMap/* default */.A)(iteratees, function(iteratee) {
+ if ((0,isArray/* default */.A)(iteratee)) {
+ return function(value) {
+ return (0,_baseGet/* default */.A)(value, iteratee.length === 1 ? iteratee[0] : iteratee);
+ }
+ }
+ return iteratee;
+ });
+ } else {
+ iteratees = [identity/* default */.A];
+ }
+
+ var index = -1;
+ iteratees = (0,_arrayMap/* default */.A)(iteratees, (0,_baseUnary/* default */.A)(_baseIteratee/* default */.A));
+
+ var result = (0,_baseMap/* default */.A)(collection, function(value, key, collection) {
+ var criteria = (0,_arrayMap/* default */.A)(iteratees, function(iteratee) {
+ return iteratee(value);
+ });
+ return { 'criteria': criteria, 'index': ++index, 'value': value };
+ });
+
+ return _baseSortBy(result, function(object, other) {
+ return _compareMultiple(object, other, orders);
+ });
+}
+
+/* harmony default export */ const _baseOrderBy = (baseOrderBy);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseRest.js
+var _baseRest = __webpack_require__(24326);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_isIterateeCall.js
+var _isIterateeCall = __webpack_require__(6832);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/sortBy.js
+
+
+
+
+
+/**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection thru each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ * The iteratees to sort by.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 30 },
+ * { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]
+ */
+var sortBy = (0,_baseRest/* default */.A)(function(collection, iteratees) {
+ if (collection == null) {
+ return [];
+ }
+ var length = iteratees.length;
+ if (length > 1 && (0,_isIterateeCall/* default */.A)(collection, iteratees[0], iteratees[1])) {
+ iteratees = [];
+ } else if (length > 2 && (0,_isIterateeCall/* default */.A)(iteratees[0], iteratees[1], iteratees[2])) {
+ iteratees = [iteratees[0]];
+ }
+ return _baseOrderBy(collection, (0,_baseFlatten/* default */.A)(iteratees, 1), []);
+});
+
+/* harmony default export */ const lodash_es_sortBy = (sortBy);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/cross-count.js
+
+
+
+
+/*
+ * A function that takes a layering (an array of layers, each with an array of
+ * ordererd nodes) and a graph and returns a weighted crossing count.
+ *
+ * Pre-conditions:
+ *
+ * 1. Input graph must be simple (not a multigraph), directed, and include
+ * only simple edges.
+ * 2. Edges in the input graph must have assigned weights.
+ *
+ * Post-conditions:
+ *
+ * 1. The graph and layering matrix are left unchanged.
+ *
+ * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
+ */
+function crossCount(g, layering) {
+ var cc = 0;
+ for (var i = 1; i < layering.length; ++i) {
+ cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+ }
+ return cc;
+}
+
+function twoLayerCrossCount(g, northLayer, southLayer) {
+ // Sort all of the edges between the north and south layers by their position
+ // in the north layer and then the south. Map these edges to the position of
+ // their head in the south layer.
+ var southPos = lodash_es_zipObject(
+ southLayer,
+ map/* default */.A(southLayer, function (v, i) {
+ return i;
+ })
+ );
+ var southEntries = flatten/* default */.A(
+ map/* default */.A(northLayer, function (v) {
+ return lodash_es_sortBy(
+ map/* default */.A(g.outEdges(v), function (e) {
+ return { pos: southPos[e.w], weight: g.edge(e).weight };
+ }),
+ 'pos'
+ );
+ })
+ );
+
+ // Build the accumulator tree
+ var firstIndex = 1;
+ while (firstIndex < southLayer.length) firstIndex <<= 1;
+ var treeSize = 2 * firstIndex - 1;
+ firstIndex -= 1;
+ var tree = map/* default */.A(new Array(treeSize), function () {
+ return 0;
+ });
+
+ // Calculate the weighted crossings
+ var cc = 0;
+ forEach/* default */.A(
+ // @ts-expect-error
+ southEntries.forEach(function (entry) {
+ var index = entry.pos + firstIndex;
+ tree[index] += entry.weight;
+ var weightSum = 0;
+ // @ts-expect-error
+ while (index > 0) {
+ // @ts-expect-error
+ if (index % 2) {
+ weightSum += tree[index + 1];
+ }
+ // @ts-expect-error
+ index = (index - 1) >> 1;
+ tree[index] += entry.weight;
+ }
+ cc += entry.weight * weightSum;
+ })
+ );
+
+ return cc;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/init-order.js
+
+
+
+
+/*
+ * Assigns an initial order value for each node by performing a DFS search
+ * starting from nodes in the first rank. Nodes are assigned an order in their
+ * rank as they are first visited.
+ *
+ * This approach comes from Gansner, et al., "A Technique for Drawing Directed
+ * Graphs."
+ *
+ * Returns a layering matrix with an array per layer and each layer sorted by
+ * the order of its nodes.
+ */
+function initOrder(g) {
+ var visited = {};
+ var simpleNodes = filter/* default */.A(g.nodes(), function (v) {
+ return !g.children(v).length;
+ });
+ var maxRank = lodash_es_max(
+ map/* default */.A(simpleNodes, function (v) {
+ return g.node(v).rank;
+ })
+ );
+ var layers = map/* default */.A(range/* default */.A(maxRank + 1), function () {
+ return [];
+ });
+
+ function dfs(v) {
+ if (has/* default */.A(visited, v)) return;
+ visited[v] = true;
+ var node = g.node(v);
+ layers[node.rank].push(v);
+ forEach/* default */.A(g.successors(v), dfs);
+ }
+
+ var orderedVs = lodash_es_sortBy(simpleNodes, function (v) {
+ return g.node(v).rank;
+ });
+ forEach/* default */.A(orderedVs, dfs);
+
+ return layers;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/barycenter.js
+
+
+
+
+function barycenter(g, movable) {
+ return map/* default */.A(movable, function (v) {
+ var inV = g.inEdges(v);
+ if (!inV.length) {
+ return { v: v };
+ } else {
+ var result = reduce/* default */.A(
+ inV,
+ function (acc, e) {
+ var edge = g.edge(e),
+ nodeU = g.node(e.v);
+ return {
+ sum: acc.sum + edge.weight * nodeU.order,
+ weight: acc.weight + edge.weight,
+ };
+ },
+ { sum: 0, weight: 0 }
+ );
+
+ return {
+ v: v,
+ barycenter: result.sum / result.weight,
+ weight: result.weight,
+ };
+ }
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/resolve-conflicts.js
+
+
+
+
+/*
+ * Given a list of entries of the form {v, barycenter, weight} and a
+ * constraint graph this function will resolve any conflicts between the
+ * constraint graph and the barycenters for the entries. If the barycenters for
+ * an entry would violate a constraint in the constraint graph then we coalesce
+ * the nodes in the conflict into a new node that respects the contraint and
+ * aggregates barycenter and weight information.
+ *
+ * This implementation is based on the description in Forster, "A Fast and
+ * Simple Hueristic for Constrained Two-Level Crossing Reduction," thought it
+ * differs in some specific details.
+ *
+ * Pre-conditions:
+ *
+ * 1. Each entry has the form {v, barycenter, weight}, or if the node has
+ * no barycenter, then {v}.
+ *
+ * Returns:
+ *
+ * A new list of entries of the form {vs, i, barycenter, weight}. The list
+ * `vs` may either be a singleton or it may be an aggregation of nodes
+ * ordered such that they do not violate constraints from the constraint
+ * graph. The property `i` is the lowest original index of any of the
+ * elements in `vs`.
+ */
+function resolveConflicts(entries, cg) {
+ var mappedEntries = {};
+ forEach/* default */.A(entries, function (entry, i) {
+ var tmp = (mappedEntries[entry.v] = {
+ indegree: 0,
+ in: [],
+ out: [],
+ vs: [entry.v],
+ i: i,
+ });
+ if (!isUndefined/* default */.A(entry.barycenter)) {
+ // @ts-expect-error
+ tmp.barycenter = entry.barycenter;
+ // @ts-expect-error
+ tmp.weight = entry.weight;
+ }
+ });
+
+ forEach/* default */.A(cg.edges(), function (e) {
+ var entryV = mappedEntries[e.v];
+ var entryW = mappedEntries[e.w];
+ if (!isUndefined/* default */.A(entryV) && !isUndefined/* default */.A(entryW)) {
+ entryW.indegree++;
+ entryV.out.push(mappedEntries[e.w]);
+ }
+ });
+
+ var sourceSet = filter/* default */.A(mappedEntries, function (entry) {
+ // @ts-expect-error
+ return !entry.indegree;
+ });
+
+ return doResolveConflicts(sourceSet);
+}
+
+function doResolveConflicts(sourceSet) {
+ var entries = [];
+
+ function handleIn(vEntry) {
+ return function (uEntry) {
+ if (uEntry.merged) {
+ return;
+ }
+ if (
+ isUndefined/* default */.A(uEntry.barycenter) ||
+ isUndefined/* default */.A(vEntry.barycenter) ||
+ uEntry.barycenter >= vEntry.barycenter
+ ) {
+ mergeEntries(vEntry, uEntry);
+ }
+ };
+ }
+
+ function handleOut(vEntry) {
+ return function (wEntry) {
+ wEntry['in'].push(vEntry);
+ if (--wEntry.indegree === 0) {
+ sourceSet.push(wEntry);
+ }
+ };
+ }
+
+ while (sourceSet.length) {
+ var entry = sourceSet.pop();
+ entries.push(entry);
+ forEach/* default */.A(entry['in'].reverse(), handleIn(entry));
+ forEach/* default */.A(entry.out, handleOut(entry));
+ }
+
+ return map/* default */.A(
+ filter/* default */.A(entries, function (entry) {
+ return !entry.merged;
+ }),
+ function (entry) {
+ return pick/* default */.A(entry, ['vs', 'i', 'barycenter', 'weight']);
+ }
+ );
+}
+
+function mergeEntries(target, source) {
+ var sum = 0;
+ var weight = 0;
+
+ if (target.weight) {
+ sum += target.barycenter * target.weight;
+ weight += target.weight;
+ }
+
+ if (source.weight) {
+ sum += source.barycenter * source.weight;
+ weight += source.weight;
+ }
+
+ target.vs = source.vs.concat(target.vs);
+ target.barycenter = sum / weight;
+ target.weight = weight;
+ target.i = Math.min(source.i, target.i);
+ source.merged = true;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/sort.js
+
+
+
+
+
+function sort(entries, biasRight) {
+ var parts = partition(entries, function (entry) {
+ return has/* default */.A(entry, 'barycenter');
+ });
+ var sortable = parts.lhs,
+ unsortable = lodash_es_sortBy(parts.rhs, function (entry) {
+ return -entry.i;
+ }),
+ vs = [],
+ sum = 0,
+ weight = 0,
+ vsIndex = 0;
+
+ sortable.sort(compareWithBias(!!biasRight));
+
+ vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+
+ forEach/* default */.A(sortable, function (entry) {
+ vsIndex += entry.vs.length;
+ vs.push(entry.vs);
+ sum += entry.barycenter * entry.weight;
+ weight += entry.weight;
+ vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
+ });
+
+ var result = { vs: flatten/* default */.A(vs) };
+ if (weight) {
+ result.barycenter = sum / weight;
+ result.weight = weight;
+ }
+ return result;
+}
+
+function consumeUnsortable(vs, unsortable, index) {
+ var last;
+ while (unsortable.length && (last = lodash_es_last(unsortable)).i <= index) {
+ unsortable.pop();
+ vs.push(last.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;
+ };
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/sort-subgraph.js
+
+
+
+
+
+
+
+function sortSubgraph(g, v, cg, biasRight) {
+ var movable = g.children(v);
+ var node = g.node(v);
+ var bl = node ? node.borderLeft : undefined;
+ var br = node ? node.borderRight : undefined;
+ var subgraphs = {};
+
+ if (bl) {
+ movable = filter/* default */.A(movable, function (w) {
+ return w !== bl && w !== br;
+ });
+ }
+
+ var barycenters = barycenter(g, movable);
+ forEach/* default */.A(barycenters, function (entry) {
+ if (g.children(entry.v).length) {
+ var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+ subgraphs[entry.v] = subgraphResult;
+ if (has/* default */.A(subgraphResult, 'barycenter')) {
+ mergeBarycenters(entry, subgraphResult);
+ }
+ }
+ });
+
+ var entries = resolveConflicts(barycenters, cg);
+ expandSubgraphs(entries, subgraphs);
+
+ var result = sort(entries, biasRight);
+
+ if (bl) {
+ result.vs = flatten/* default */.A([bl, result.vs, br]);
+ if (g.predecessors(bl).length) {
+ var blPred = g.node(g.predecessors(bl)[0]),
+ brPred = g.node(g.predecessors(br)[0]);
+ if (!has/* default */.A(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(entries, subgraphs) {
+ forEach/* default */.A(entries, function (entry) {
+ entry.vs = flatten/* default */.A(
+ entry.vs.map(function (v) {
+ if (subgraphs[v]) {
+ return subgraphs[v].vs;
+ }
+ return v;
+ })
+ );
+ });
+}
+
+function mergeBarycenters(target, other) {
+ if (!isUndefined/* default */.A(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;
+ }
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/order/index.js
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * Applies heuristics to minimize edge crossings in the graph and sets the best
+ * order solution as an order attribute on each node.
+ *
+ * Pre-conditions:
+ *
+ * 1. Graph must be DAG
+ * 2. Graph nodes must be objects with a "rank" attribute
+ * 3. Graph edges must have the "weight" attribute
+ *
+ * Post-conditions:
+ *
+ * 1. Graph nodes will have an "order" attribute based on the results of the
+ * algorithm.
+ */
+function order(g) {
+ var maxRank = util_maxRank(g),
+ downLayerGraphs = buildLayerGraphs(g, range/* default */.A(1, maxRank + 1), 'inEdges'),
+ upLayerGraphs = buildLayerGraphs(g, range/* default */.A(maxRank - 1, -1, -1), 'outEdges');
+
+ var layering = initOrder(g);
+ assignOrder(g, layering);
+
+ var bestCC = Number.POSITIVE_INFINITY,
+ best;
+
+ for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+ sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+
+ layering = buildLayerMatrix(g);
+ var cc = crossCount(g, layering);
+ if (cc < bestCC) {
+ lastBest = 0;
+ best = lodash_es_cloneDeep(layering);
+ bestCC = cc;
+ }
+ }
+
+ assignOrder(g, best);
+}
+
+function buildLayerGraphs(g, ranks, relationship) {
+ return map/* default */.A(ranks, function (rank) {
+ return buildLayerGraph(g, rank, relationship);
+ });
+}
+
+function sweepLayerGraphs(layerGraphs, biasRight) {
+ var cg = new graphlib/* Graph */.T();
+ forEach/* default */.A(layerGraphs, function (lg) {
+ var root = lg.graph().root;
+ var sorted = sortSubgraph(lg, root, cg, biasRight);
+ forEach/* default */.A(sorted.vs, function (v, i) {
+ lg.node(v).order = i;
+ });
+ addSubgraphConstraints(lg, cg, sorted.vs);
+ });
+}
+
+function assignOrder(g, layering) {
+ forEach/* default */.A(layering, function (layer) {
+ forEach/* default */.A(layer, function (v, i) {
+ g.node(v).order = i;
+ });
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/parent-dummy-chains.js
+
+
+
+
+function parentDummyChains(g) {
+ var postorderNums = parent_dummy_chains_postorder(g);
+
+ forEach/* default */.A(g.graph().dummyChains, function (v) {
+ var node = g.node(v);
+ var edgeObj = node.edgeObj;
+ var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+ var path = pathData.path;
+ var lca = pathData.lca;
+ var pathIdx = 0;
+ var pathV = path[pathIdx];
+ var ascending = true;
+
+ while (v !== edgeObj.w) {
+ node = g.node(v);
+
+ if (ascending) {
+ while ((pathV = path[pathIdx]) !== lca && g.node(pathV).maxRank < node.rank) {
+ pathIdx++;
+ }
+
+ if (pathV === lca) {
+ ascending = false;
+ }
+ }
+
+ if (!ascending) {
+ while (
+ pathIdx < path.length - 1 &&
+ g.node((pathV = path[pathIdx + 1])).minRank <= node.rank
+ ) {
+ pathIdx++;
+ }
+ pathV = path[pathIdx];
+ }
+
+ g.setParent(v, pathV);
+ v = g.successors(v)[0];
+ }
+ });
+}
+
+// Find a path from v to w through the lowest common ancestor (LCA). Return the
+// full path and the LCA.
+function findPath(g, postorderNums, v, w) {
+ var vPath = [];
+ var wPath = [];
+ var low = Math.min(postorderNums[v].low, postorderNums[w].low);
+ var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+ var parent;
+ var lca;
+
+ // Traverse up from v to find the LCA
+ parent = v;
+ do {
+ parent = g.parent(parent);
+ vPath.push(parent);
+ } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+ lca = parent;
+
+ // Traverse from w to LCA
+ parent = w;
+ while ((parent = g.parent(parent)) !== lca) {
+ wPath.push(parent);
+ }
+
+ return { path: vPath.concat(wPath.reverse()), lca: lca };
+}
+
+function parent_dummy_chains_postorder(g) {
+ var result = {};
+ var lim = 0;
+
+ function dfs(v) {
+ var low = lim;
+ forEach/* default */.A(g.children(v), dfs);
+ result[v] = { low: low, lim: lim++ };
+ }
+ forEach/* default */.A(g.children(), dfs);
+
+ return result;
+}
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_castFunction.js
+var _castFunction = __webpack_require__(99922);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/forOwn.js
+
+
+
+/**
+ * Iterates over own enumerable string keyed properties of an object and
+ * invokes `iteratee` for each property. The iteratee is invoked with three
+ * arguments: (value, key, object). Iteratee functions may exit iteration
+ * early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forOwnRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forOwn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+function forOwn(object, iteratee) {
+ return object && (0,_baseForOwn/* default */.A)(object, (0,_castFunction/* default */.A)(iteratee));
+}
+
+/* harmony default export */ const lodash_es_forOwn = (forOwn);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseFor.js + 1 modules
+var _baseFor = __webpack_require__(4574);
+// EXTERNAL MODULE: ./node_modules/lodash-es/keysIn.js + 2 modules
+var keysIn = __webpack_require__(55615);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/forIn.js
+
+
+
+
+/**
+ * Iterates over own and inherited enumerable string keyed properties of an
+ * object and invokes `iteratee` for each property. The iteratee is invoked
+ * with three arguments: (value, key, object). Iteratee functions may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forInRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forIn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
+ */
+function forIn(object, iteratee) {
+ return object == null
+ ? object
+ : (0,_baseFor/* default */.A)(object, (0,_castFunction/* default */.A)(iteratee), keysIn/* default */.A);
+}
+
+/* harmony default export */ const lodash_es_forIn = (forIn);
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/position/bk.js
+
+
+
+
+/*
+ * This module provides coordinate assignment based on Brandes and Köpf, "Fast
+ * and Simple Horizontal Coordinate Assignment."
+ */
+
+
+
+/*
+ * Marks all edges in the graph with a type-1 conflict with the "type1Conflict"
+ * property. A type-1 conflict is one where a non-inner segment crosses an
+ * inner segment. An inner segment is an edge with both incident nodes marked
+ * with the "dummy" property.
+ *
+ * This algorithm scans layer by layer, starting with the second, for type-1
+ * conflicts between the current layer and the previous layer. For each layer
+ * it scans the nodes from left to right until it reaches one that is incident
+ * on an inner segment. It then scans predecessors to determine if they have
+ * edges that cross that inner segment. At the end a final scan is done for all
+ * nodes on the current rank to see if they cross the last visited inner
+ * segment.
+ *
+ * This algorithm (safely) assumes that a dummy node will only be incident on a
+ * single node in the layers being scanned.
+ */
+function findType1Conflicts(g, layering) {
+ var conflicts = {};
+
+ function visitLayer(prevLayer, layer) {
+ var // last visited node in the previous layer that is incident on an inner
+ // segment.
+ k0 = 0,
+ // Tracks the last node in this layer scanned for crossings with a type-1
+ // segment.
+ scanPos = 0,
+ prevLayerLength = prevLayer.length,
+ lastNode = lodash_es_last(layer);
+
+ forEach/* default */.A(layer, function (v, i) {
+ var w = findOtherInnerSegmentNode(g, v),
+ k1 = w ? g.node(w).order : prevLayerLength;
+
+ if (w || v === lastNode) {
+ forEach/* default */.A(layer.slice(scanPos, i + 1), function (scanNode) {
+ forEach/* default */.A(g.predecessors(scanNode), function (u) {
+ var uLabel = g.node(u),
+ uPos = uLabel.order;
+ if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
+ addConflict(conflicts, u, scanNode);
+ }
+ });
+ });
+ // @ts-expect-error
+ scanPos = i + 1;
+ k0 = k1;
+ }
+ });
+
+ return layer;
+ }
+
+ reduce/* default */.A(layering, visitLayer);
+ return conflicts;
+}
+
+function findType2Conflicts(g, layering) {
+ var conflicts = {};
+
+ function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+ var v;
+ forEach/* default */.A(range/* default */.A(southPos, southEnd), function (i) {
+ v = south[i];
+ if (g.node(v).dummy) {
+ forEach/* default */.A(g.predecessors(v), function (u) {
+ var uNode = g.node(u);
+ if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+ addConflict(conflicts, u, v);
+ }
+ });
+ }
+ });
+ }
+
+ function visitLayer(north, south) {
+ var prevNorthPos = -1,
+ nextNorthPos,
+ southPos = 0;
+
+ forEach/* default */.A(south, function (v, southLookahead) {
+ if (g.node(v).dummy === 'border') {
+ var predecessors = g.predecessors(v);
+ if (predecessors.length) {
+ nextNorthPos = g.node(predecessors[0]).order;
+ scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+ // @ts-expect-error
+ southPos = southLookahead;
+ prevNorthPos = nextNorthPos;
+ }
+ }
+ scan(south, southPos, south.length, nextNorthPos, north.length);
+ });
+
+ return south;
+ }
+
+ reduce/* default */.A(layering, visitLayer);
+ return conflicts;
+}
+
+function findOtherInnerSegmentNode(g, v) {
+ if (g.node(v).dummy) {
+ return lodash_es_find(g.predecessors(v), function (u) {
+ return g.node(u).dummy;
+ });
+ }
+}
+
+function addConflict(conflicts, v, w) {
+ if (v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+
+ var conflictsV = conflicts[v];
+ if (!conflictsV) {
+ conflicts[v] = conflictsV = {};
+ }
+ conflictsV[w] = true;
+}
+
+function hasConflict(conflicts, v, w) {
+ if (v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ return has/* default */.A(conflicts[v], w);
+}
+
+/*
+ * Try to align nodes into vertical "blocks" where possible. This algorithm
+ * attempts to align a node with one of its median neighbors. If the edge
+ * connecting a neighbor is a type-1 conflict then we ignore that possibility.
+ * If a previous node has already formed a block with a node after the node
+ * we're trying to form a block with, we also ignore that possibility - our
+ * blocks would be split in that scenario.
+ */
+function verticalAlignment(g, layering, conflicts, neighborFn) {
+ var root = {},
+ align = {},
+ pos = {};
+
+ // We cache the position here based on the layering because the graph and
+ // layering may be out of sync. The layering matrix is manipulated to
+ // generate different extreme alignments.
+ forEach/* default */.A(layering, function (layer) {
+ forEach/* default */.A(layer, function (v, order) {
+ root[v] = v;
+ align[v] = v;
+ pos[v] = order;
+ });
+ });
+
+ forEach/* default */.A(layering, function (layer) {
+ var prevIdx = -1;
+ forEach/* default */.A(layer, function (v) {
+ var ws = neighborFn(v);
+ if (ws.length) {
+ ws = lodash_es_sortBy(ws, function (w) {
+ return pos[w];
+ });
+ var mp = (ws.length - 1) / 2;
+ for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+ var w = ws[i];
+ if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+ align[w] = v;
+ align[v] = root[v] = root[w];
+ prevIdx = pos[w];
+ }
+ }
+ }
+ });
+ });
+
+ return { root: root, align: align };
+}
+
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+ // This portion of the algorithm differs from BK due to a number of problems.
+ // Instead of their algorithm we construct a new block graph and do two
+ // sweeps. The first sweep places blocks with the smallest possible
+ // coordinates. The second sweep removes unused space by moving blocks to the
+ // greatest coordinates without violating separation.
+ var xs = {},
+ blockG = buildBlockGraph(g, layering, root, 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();
+ }
+ }
+
+ // First pass, assign smallest coordinates
+ function pass1(elem) {
+ xs[elem] = blockG.inEdges(elem).reduce(function (acc, e) {
+ return Math.max(acc, xs[e.v] + blockG.edge(e));
+ }, 0);
+ }
+
+ // Second pass, assign greatest coordinates
+ function pass2(elem) {
+ var min = blockG.outEdges(elem).reduce(function (acc, e) {
+ return Math.min(acc, xs[e.w] - blockG.edge(e));
+ }, Number.POSITIVE_INFINITY);
+
+ var node = g.node(elem);
+ if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+ xs[elem] = Math.max(xs[elem], min);
+ }
+ }
+
+ iterate(pass1, blockG.predecessors.bind(blockG));
+ iterate(pass2, blockG.successors.bind(blockG));
+
+ // Assign x coordinates to all nodes
+ forEach/* default */.A(align, function (v) {
+ xs[v] = xs[root[v]];
+ });
+
+ return xs;
+}
+
+function buildBlockGraph(g, layering, root, reverseSep) {
+ var blockGraph = new graphlib/* Graph */.T(),
+ graphLabel = g.graph(),
+ sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+
+ forEach/* default */.A(layering, function (layer) {
+ var u;
+ forEach/* default */.A(layer, function (v) {
+ var vRoot = root[v];
+ blockGraph.setNode(vRoot);
+ if (u) {
+ var uRoot = root[u],
+ prevMax = blockGraph.edge(uRoot, vRoot);
+ blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
+ }
+ u = v;
+ });
+ });
+
+ return blockGraph;
+}
+
+/*
+ * Returns the alignment that has the smallest width of the given alignments.
+ */
+function findSmallestWidthAlignment(g, xss) {
+ return lodash_es_minBy(values/* default */.A(xss), function (xs) {
+ var max = Number.NEGATIVE_INFINITY;
+ var min = Number.POSITIVE_INFINITY;
+
+ lodash_es_forIn(xs, function (x, v) {
+ var halfWidth = width(g, v) / 2;
+
+ max = Math.max(x + halfWidth, max);
+ min = Math.min(x - halfWidth, min);
+ });
+
+ return max - min;
+ });
+}
+
+/*
+ * Align the coordinates of each of the layout alignments such that
+ * left-biased alignments have their minimum coordinate at the same point as
+ * the minimum coordinate of the smallest width alignment and right-biased
+ * alignments have their maximum coordinate at the same point as the maximum
+ * coordinate of the smallest width alignment.
+ */
+function alignCoordinates(xss, alignTo) {
+ var alignToVals = values/* default */.A(alignTo),
+ alignToMin = lodash_es_min(alignToVals),
+ alignToMax = lodash_es_max(alignToVals);
+
+ forEach/* default */.A(['u', 'd'], function (vert) {
+ forEach/* default */.A(['l', 'r'], function (horiz) {
+ var alignment = vert + horiz,
+ xs = xss[alignment],
+ delta;
+ if (xs === alignTo) return;
+
+ var xsVals = values/* default */.A(xs);
+ delta = horiz === 'l' ? alignToMin - lodash_es_min(xsVals) : alignToMax - lodash_es_max(xsVals);
+
+ if (delta) {
+ xss[alignment] = lodash_es_mapValues(xs, function (x) {
+ return x + delta;
+ });
+ }
+ });
+ });
+}
+
+function balance(xss, align) {
+ return lodash_es_mapValues(xss.ul, function (ignore, v) {
+ if (align) {
+ return xss[align.toLowerCase()][v];
+ } else {
+ var xs = lodash_es_sortBy(map/* default */.A(xss, v));
+ return (xs[1] + xs[2]) / 2;
+ }
+ });
+}
+
+function positionX(g) {
+ var layering = buildLayerMatrix(g);
+ var conflicts = merge/* default */.A(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+
+ var xss = {};
+ var adjustedLayering;
+ forEach/* default */.A(['u', 'd'], function (vert) {
+ adjustedLayering = vert === 'u' ? layering : values/* default */.A(layering).reverse();
+ forEach/* default */.A(['l', 'r'], function (horiz) {
+ if (horiz === 'r') {
+ adjustedLayering = map/* default */.A(adjustedLayering, function (inner) {
+ return values/* default */.A(inner).reverse();
+ });
+ }
+
+ var neighborFn = (vert === 'u' ? g.predecessors : g.successors).bind(g);
+ var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+ var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === 'r');
+ if (horiz === 'r') {
+ xs = lodash_es_mapValues(xs, function (x) {
+ return -x;
+ });
+ }
+ xss[vert + horiz] = xs;
+ });
+ });
+
+ var smallestWidth = findSmallestWidthAlignment(g, xss);
+ alignCoordinates(xss, smallestWidth);
+ return balance(xss, g.graph().align);
+}
+
+function sep(nodeSep, edgeSep, reverseSep) {
+ return function (g, v, w) {
+ var vLabel = g.node(v);
+ var wLabel = g.node(w);
+ var sum = 0;
+ var delta;
+
+ sum += vLabel.width / 2;
+ if (has/* default */.A(vLabel, 'labelpos')) {
+ switch (vLabel.labelpos.toLowerCase()) {
+ case 'l':
+ delta = -vLabel.width / 2;
+ break;
+ case 'r':
+ delta = vLabel.width / 2;
+ break;
+ }
+ }
+ if (delta) {
+ sum += reverseSep ? delta : -delta;
+ }
+ delta = 0;
+
+ sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+ sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+
+ sum += wLabel.width / 2;
+ if (has/* default */.A(wLabel, 'labelpos')) {
+ switch (wLabel.labelpos.toLowerCase()) {
+ case 'l':
+ delta = wLabel.width / 2;
+ break;
+ case 'r':
+ delta = -wLabel.width / 2;
+ break;
+ }
+ }
+ if (delta) {
+ sum += reverseSep ? delta : -delta;
+ }
+ delta = 0;
+
+ return sum;
+ };
+}
+
+function width(g, v) {
+ return g.node(v).width;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/position/index.js
+
+
+
+
+
+
+function position(g) {
+ g = asNonCompoundGraph(g);
+
+ positionY(g);
+ lodash_es_forOwn(positionX(g), function (x, v) {
+ g.node(v).x = x;
+ });
+}
+
+function positionY(g) {
+ var layering = buildLayerMatrix(g);
+ var rankSep = g.graph().ranksep;
+ var prevY = 0;
+ forEach/* default */.A(layering, function (layer) {
+ var maxHeight = lodash_es_max(
+ map/* default */.A(layer, function (v) {
+ return g.node(v).height;
+ })
+ );
+ forEach/* default */.A(layer, function (v) {
+ g.node(v).y = prevY + maxHeight / 2;
+ });
+ prevY += maxHeight + rankSep;
+ });
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/layout.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function layout(g, opts) {
+ var time = opts && opts.debugTiming ? util_time : notime;
+ time('layout', function () {
+ var layoutGraph = time(' buildLayoutGraph', function () {
+ return buildLayoutGraph(g);
+ });
+ time(' runLayout', function () {
+ runLayout(layoutGraph, time);
+ });
+ time(' updateInputGraph', function () {
+ updateInputGraph(g, layoutGraph);
+ });
+ });
+}
+
+function runLayout(g, time) {
+ time(' makeSpaceForEdgeLabels', function () {
+ makeSpaceForEdgeLabels(g);
+ });
+ time(' removeSelfEdges', function () {
+ removeSelfEdges(g);
+ });
+ time(' acyclic', function () {
+ run(g);
+ });
+ time(' nestingGraph.run', function () {
+ nesting_graph_run(g);
+ });
+ time(' rank', function () {
+ rank(asNonCompoundGraph(g));
+ });
+ time(' injectEdgeLabelProxies', function () {
+ injectEdgeLabelProxies(g);
+ });
+ time(' removeEmptyRanks', function () {
+ removeEmptyRanks(g);
+ });
+ time(' nestingGraph.cleanup', function () {
+ cleanup(g);
+ });
+ time(' normalizeRanks', function () {
+ normalizeRanks(g);
+ });
+ time(' assignRankMinMax', function () {
+ assignRankMinMax(g);
+ });
+ time(' removeEdgeLabelProxies', function () {
+ removeEdgeLabelProxies(g);
+ });
+ time(' normalize.run', function () {
+ normalize_run(g);
+ });
+ time(' parentDummyChains', function () {
+ parentDummyChains(g);
+ });
+ time(' addBorderSegments', function () {
+ addBorderSegments(g);
+ });
+ time(' order', function () {
+ order(g);
+ });
+ time(' insertSelfEdges', function () {
+ insertSelfEdges(g);
+ });
+ time(' adjustCoordinateSystem', function () {
+ adjust(g);
+ });
+ time(' position', function () {
+ position(g);
+ });
+ time(' positionSelfEdges', function () {
+ positionSelfEdges(g);
+ });
+ time(' removeBorderNodes', function () {
+ removeBorderNodes(g);
+ });
+ time(' normalize.undo', function () {
+ normalize_undo(g);
+ });
+ time(' fixupEdgeLabelCoords', function () {
+ fixupEdgeLabelCoords(g);
+ });
+ time(' undoCoordinateSystem', function () {
+ coordinate_system_undo(g);
+ });
+ time(' translateGraph', function () {
+ translateGraph(g);
+ });
+ time(' assignNodeIntersects', function () {
+ assignNodeIntersects(g);
+ });
+ time(' reversePoints', function () {
+ reversePointsForReversedEdges(g);
+ });
+ time(' acyclic.undo', function () {
+ undo(g);
+ });
+}
+
+/*
+ * Copies final layout information from the layout graph back to the input
+ * graph. This process only copies whitelisted attributes from the layout graph
+ * to the input graph, so it serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function updateInputGraph(inputGraph, layoutGraph) {
+ forEach/* default */.A(inputGraph.nodes(), function (v) {
+ var inputLabel = inputGraph.node(v);
+ var layoutLabel = layoutGraph.node(v);
+
+ if (inputLabel) {
+ inputLabel.x = layoutLabel.x;
+ inputLabel.y = layoutLabel.y;
+
+ if (layoutGraph.children(v).length) {
+ inputLabel.width = layoutLabel.width;
+ inputLabel.height = layoutLabel.height;
+ }
+ }
+ });
+
+ forEach/* default */.A(inputGraph.edges(), function (e) {
+ var inputLabel = inputGraph.edge(e);
+ var layoutLabel = layoutGraph.edge(e);
+
+ inputLabel.points = layoutLabel.points;
+ if (has/* default */.A(layoutLabel, 'x')) {
+ inputLabel.x = layoutLabel.x;
+ inputLabel.y = layoutLabel.y;
+ }
+ });
+
+ inputGraph.graph().width = layoutGraph.graph().width;
+ inputGraph.graph().height = layoutGraph.graph().height;
+}
+
+var graphNumAttrs = ['nodesep', 'edgesep', 'ranksep', 'marginx', 'marginy'];
+var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: 'tb' };
+var graphAttrs = ['acyclicer', 'ranker', 'rankdir', 'align'];
+var nodeNumAttrs = ['width', 'height'];
+var nodeDefaults = { width: 0, height: 0 };
+var edgeNumAttrs = ['minlen', 'weight', 'width', 'height', 'labeloffset'];
+var edgeDefaults = {
+ minlen: 1,
+ weight: 1,
+ width: 0,
+ height: 0,
+ labeloffset: 10,
+ labelpos: 'r',
+};
+var edgeAttrs = ['labelpos'];
+
+/*
+ * Constructs a new graph from the input graph, which can be used for layout.
+ * This process copies only whitelisted attributes from the input graph to the
+ * layout graph. Thus this function serves as a good place to determine what
+ * attributes can influence layout.
+ */
+function buildLayoutGraph(inputGraph) {
+ var g = new graphlib/* Graph */.T({ multigraph: true, compound: true });
+ var graph = canonicalize(inputGraph.graph());
+
+ g.setGraph(
+ merge/* default */.A({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), pick/* default */.A(graph, graphAttrs))
+ );
+
+ forEach/* default */.A(inputGraph.nodes(), function (v) {
+ var node = canonicalize(inputGraph.node(v));
+ g.setNode(v, defaults/* default */.A(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+ g.setParent(v, inputGraph.parent(v));
+ });
+
+ forEach/* default */.A(inputGraph.edges(), function (e) {
+ var edge = canonicalize(inputGraph.edge(e));
+ g.setEdge(
+ e,
+ merge/* default */.A({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), pick/* default */.A(edge, edgeAttrs))
+ );
+ });
+
+ return g;
+}
+
+/*
+ * This idea comes from the Gansner paper: to account for edge labels in our
+ * layout we split each rank in half by doubling minlen and halving ranksep.
+ * Then we can place labels at these mid-points between nodes.
+ *
+ * We also add some minimal padding to the width to push the label for the edge
+ * away from the edge itself a bit.
+ */
+function makeSpaceForEdgeLabels(g) {
+ var graph = g.graph();
+ graph.ranksep /= 2;
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ edge.minlen *= 2;
+ if (edge.labelpos.toLowerCase() !== 'c') {
+ if (graph.rankdir === 'TB' || graph.rankdir === 'BT') {
+ edge.width += edge.labeloffset;
+ } else {
+ edge.height += edge.labeloffset;
+ }
+ }
+ });
+}
+
+/*
+ * Creates temporary dummy nodes that capture the rank in which each edge's
+ * label is going to, if it has one of non-zero width and height. We do this
+ * so that we can safely remove empty ranks while preserving balance for the
+ * label's position.
+ */
+function injectEdgeLabelProxies(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ if (edge.width && edge.height) {
+ var v = g.node(e.v);
+ var w = g.node(e.w);
+ var label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
+ addDummyNode(g, 'edge-proxy', label, '_ep');
+ }
+ });
+}
+
+function assignRankMinMax(g) {
+ var maxRank = 0;
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ if (node.borderTop) {
+ node.minRank = g.node(node.borderTop).rank;
+ node.maxRank = g.node(node.borderBottom).rank;
+ // @ts-expect-error
+ maxRank = lodash_es_max(maxRank, node.maxRank);
+ }
+ });
+ g.graph().maxRank = maxRank;
+}
+
+function removeEdgeLabelProxies(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ if (node.dummy === 'edge-proxy') {
+ g.edge(node.e).labelRank = node.rank;
+ g.removeNode(v);
+ }
+ });
+}
+
+function translateGraph(g) {
+ var minX = Number.POSITIVE_INFINITY;
+ var maxX = 0;
+ var minY = Number.POSITIVE_INFINITY;
+ var maxY = 0;
+ var graphLabel = g.graph();
+ var marginX = graphLabel.marginx || 0;
+ var marginY = graphLabel.marginy || 0;
+
+ function getExtremes(attrs) {
+ var x = attrs.x;
+ var y = attrs.y;
+ var w = attrs.width;
+ var h = attrs.height;
+ minX = Math.min(minX, x - w / 2);
+ maxX = Math.max(maxX, x + w / 2);
+ minY = Math.min(minY, y - h / 2);
+ maxY = Math.max(maxY, y + h / 2);
+ }
+
+ forEach/* default */.A(g.nodes(), function (v) {
+ getExtremes(g.node(v));
+ });
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ if (has/* default */.A(edge, 'x')) {
+ getExtremes(edge);
+ }
+ });
+
+ minX -= marginX;
+ minY -= marginY;
+
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ node.x -= minX;
+ node.y -= minY;
+ });
+
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ forEach/* default */.A(edge.points, function (p) {
+ p.x -= minX;
+ p.y -= minY;
+ });
+ if (has/* default */.A(edge, 'x')) {
+ edge.x -= minX;
+ }
+ if (has/* default */.A(edge, 'y')) {
+ edge.y -= minY;
+ }
+ });
+
+ graphLabel.width = maxX - minX + marginX;
+ graphLabel.height = maxY - minY + marginY;
+}
+
+function assignNodeIntersects(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ var nodeV = g.node(e.v);
+ var nodeW = g.node(e.w);
+ var p1, p2;
+ if (!edge.points) {
+ edge.points = [];
+ p1 = nodeW;
+ p2 = nodeV;
+ } else {
+ p1 = edge.points[0];
+ p2 = edge.points[edge.points.length - 1];
+ }
+ edge.points.unshift(intersectRect(nodeV, p1));
+ edge.points.push(intersectRect(nodeW, p2));
+ });
+}
+
+function fixupEdgeLabelCoords(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ if (has/* default */.A(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(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ var edge = g.edge(e);
+ if (edge.reversed) {
+ edge.points.reverse();
+ }
+ });
+}
+
+function removeBorderNodes(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ if (g.children(v).length) {
+ var node = g.node(v);
+ var t = g.node(node.borderTop);
+ var b = g.node(node.borderBottom);
+ var l = g.node(lodash_es_last(node.borderLeft));
+ var r = g.node(lodash_es_last(node.borderRight));
+
+ node.width = Math.abs(r.x - l.x);
+ node.height = Math.abs(b.y - t.y);
+ node.x = l.x + node.width / 2;
+ node.y = t.y + node.height / 2;
+ }
+ });
+
+ forEach/* default */.A(g.nodes(), function (v) {
+ if (g.node(v).dummy === 'border') {
+ g.removeNode(v);
+ }
+ });
+}
+
+function removeSelfEdges(g) {
+ forEach/* default */.A(g.edges(), function (e) {
+ if (e.v === e.w) {
+ var node = g.node(e.v);
+ if (!node.selfEdges) {
+ node.selfEdges = [];
+ }
+ node.selfEdges.push({ e: e, label: g.edge(e) });
+ g.removeEdge(e);
+ }
+ });
+}
+
+function insertSelfEdges(g) {
+ var layers = buildLayerMatrix(g);
+ forEach/* default */.A(layers, function (layer) {
+ var orderShift = 0;
+ forEach/* default */.A(layer, function (v, i) {
+ var node = g.node(v);
+ node.order = i + orderShift;
+ forEach/* default */.A(node.selfEdges, function (selfEdge) {
+ addDummyNode(
+ g,
+ 'selfedge',
+ {
+ width: selfEdge.label.width,
+ height: selfEdge.label.height,
+ rank: node.rank,
+ order: i + ++orderShift,
+ e: selfEdge.e,
+ label: selfEdge.label,
+ },
+ '_se'
+ );
+ });
+ delete node.selfEdges;
+ });
+ });
+}
+
+function positionSelfEdges(g) {
+ forEach/* default */.A(g.nodes(), function (v) {
+ var node = g.node(v);
+ if (node.dummy === 'selfedge') {
+ var selfNode = g.node(node.e.v);
+ var x = selfNode.x + selfNode.width / 2;
+ var y = selfNode.y;
+ var dx = node.x - x;
+ var dy = selfNode.height / 2;
+ g.setEdge(node.e, node.label);
+ g.removeNode(v);
+ node.label.points = [
+ { x: x + (2 * dx) / 3, y: y - dy },
+ { x: x + (5 * dx) / 6, y: y - dy },
+ { x: x + dx, y: y },
+ { x: x + (5 * dx) / 6, y: y + dy },
+ { x: x + (2 * dx) / 3, y: y + dy },
+ ];
+ node.label.x = node.x;
+ node.label.y = node.y;
+ }
+ });
+}
+
+function selectNumberAttrs(obj, attrs) {
+ return lodash_es_mapValues(pick/* default */.A(obj, attrs), Number);
+}
+
+function canonicalize(attrs) {
+ var newAttrs = {};
+ forEach/* default */.A(attrs, function (v, k) {
+ newAttrs[k.toLowerCase()] = v;
+ });
+ return newAttrs;
+}
+
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/dagre/index.js
+
+
+
+
+
+
+
+
+/***/ }),
+
+/***/ 73046:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ T: () => (/* binding */ Graph)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/has.js + 1 modules
+var has = __webpack_require__(48585);
+// EXTERNAL MODULE: ./node_modules/lodash-es/constant.js
+var constant = __webpack_require__(39142);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isFunction.js
+var isFunction = __webpack_require__(89610);
+// EXTERNAL MODULE: ./node_modules/lodash-es/keys.js
+var keys = __webpack_require__(27422);
+// EXTERNAL MODULE: ./node_modules/lodash-es/filter.js + 1 modules
+var filter = __webpack_require__(11662);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isEmpty.js
+var isEmpty = __webpack_require__(66401);
+// EXTERNAL MODULE: ./node_modules/lodash-es/forEach.js
+var forEach = __webpack_require__(8058);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isUndefined.js
+var isUndefined = __webpack_require__(69592);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseFlatten.js + 1 modules
+var _baseFlatten = __webpack_require__(13588);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseRest.js
+var _baseRest = __webpack_require__(24326);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_SetCache.js + 2 modules
+var _SetCache = __webpack_require__(62062);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseFindIndex.js
+var _baseFindIndex = __webpack_require__(25707);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsNaN.js
+/**
+ * The base implementation of `_.isNaN` without support for number objects.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
+ */
+function baseIsNaN(value) {
+ return value !== value;
+}
+
+/* harmony default export */ const _baseIsNaN = (baseIsNaN);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_strictIndexOf.js
+/**
+ * A specialized version of `_.indexOf` which performs strict equality
+ * comparisons of values, i.e. `===`.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function strictIndexOf(array, value, fromIndex) {
+ var index = fromIndex - 1,
+ length = array.length;
+
+ while (++index < length) {
+ if (array[index] === value) {
+ return index;
+ }
+ }
+ return -1;
+}
+
+/* harmony default export */ const _strictIndexOf = (strictIndexOf);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIndexOf.js
+
+
+
+
+/**
+ * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOf(array, value, fromIndex) {
+ return value === value
+ ? _strictIndexOf(array, value, fromIndex)
+ : (0,_baseFindIndex/* default */.A)(array, _baseIsNaN, fromIndex);
+}
+
+/* harmony default export */ const _baseIndexOf = (baseIndexOf);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_arrayIncludes.js
+
+
+/**
+ * A specialized version of `_.includes` for arrays without support for
+ * specifying an index to search from.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludes(array, value) {
+ var length = array == null ? 0 : array.length;
+ return !!length && _baseIndexOf(array, value, 0) > -1;
+}
+
+/* harmony default export */ const _arrayIncludes = (arrayIncludes);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_arrayIncludesWith.js
+/**
+ * This function is like `arrayIncludes` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludesWith(array, value, comparator) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (comparator(value, array[index])) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* harmony default export */ const _arrayIncludesWith = (arrayIncludesWith);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_cacheHas.js
+var _cacheHas = __webpack_require__(64099);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Set.js
+var _Set = __webpack_require__(39857);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/noop.js
+/**
+ * This method returns `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Util
+ * @example
+ *
+ * _.times(2, _.noop);
+ * // => [undefined, undefined]
+ */
+function noop() {
+ // No operation performed.
+}
+
+/* harmony default export */ const lodash_es_noop = (noop);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_setToArray.js
+var _setToArray = __webpack_require__(29959);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_createSet.js
+
+
+
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Creates a set object of `values`.
+ *
+ * @private
+ * @param {Array} values The values to add to the set.
+ * @returns {Object} Returns the new set.
+ */
+var createSet = !(_Set/* default */.A && (1 / (0,_setToArray/* default */.A)(new _Set/* default */.A([,-0]))[1]) == INFINITY) ? lodash_es_noop : function(values) {
+ return new _Set/* default */.A(values);
+};
+
+/* harmony default export */ const _createSet = (createSet);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseUniq.js
+
+
+
+
+
+
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * The base implementation of `_.uniqBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new duplicate free array.
+ */
+function baseUniq(array, iteratee, comparator) {
+ var index = -1,
+ includes = _arrayIncludes,
+ length = array.length,
+ isCommon = true,
+ result = [],
+ seen = result;
+
+ if (comparator) {
+ isCommon = false;
+ includes = _arrayIncludesWith;
+ }
+ else if (length >= LARGE_ARRAY_SIZE) {
+ var set = iteratee ? null : _createSet(array);
+ if (set) {
+ return (0,_setToArray/* default */.A)(set);
+ }
+ isCommon = false;
+ includes = _cacheHas/* default */.A;
+ seen = new _SetCache/* default */.A;
+ }
+ else {
+ seen = iteratee ? [] : result;
+ }
+ outer:
+ while (++index < length) {
+ var value = array[index],
+ computed = iteratee ? iteratee(value) : value;
+
+ value = (comparator || value !== 0) ? value : 0;
+ if (isCommon && computed === computed) {
+ var seenIndex = seen.length;
+ while (seenIndex--) {
+ if (seen[seenIndex] === computed) {
+ continue outer;
+ }
+ }
+ if (iteratee) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ else if (!includes(seen, computed, comparator)) {
+ if (seen !== result) {
+ seen.push(computed);
+ }
+ result.push(value);
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ const _baseUniq = (baseUniq);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArrayLikeObject.js
+var isArrayLikeObject = __webpack_require__(53533);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/union.js
+
+
+
+
+
+/**
+ * Creates an array of unique values, in order, from all given arrays using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.union([2], [1, 2]);
+ * // => [2, 1]
+ */
+var union = (0,_baseRest/* default */.A)(function(arrays) {
+ return _baseUniq((0,_baseFlatten/* default */.A)(arrays, 1, isArrayLikeObject/* default */.A, true));
+});
+
+/* harmony default export */ const lodash_es_union = (union);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/values.js + 1 modules
+var values = __webpack_require__(38207);
+// EXTERNAL MODULE: ./node_modules/lodash-es/reduce.js + 2 modules
+var reduce = __webpack_require__(89463);
+;// CONCATENATED MODULE: ./node_modules/dagre-d3-es/src/graphlib/graph.js
+
+
+var DEFAULT_EDGE_NAME = '\x00';
+var GRAPH_NODE = '\x00';
+var EDGE_KEY_DELIM = '\x01';
+
+// Implementation notes:
+//
+// * Node id query functions should return string ids for the nodes
+// * Edge id query functions should return an "edgeObj", edge object, that is
+// composed of enough information to uniquely identify an edge: {v, w, name}.
+// * Internally we use an "edgeId", a stringified form of the edgeObj, to
+// reference edges. This is because we need a performant way to look these
+// edges up and, object properties, which have string keys, are the closest
+// we're going to get to a performant hashtable in JavaScript.
+
+// Implementation notes:
+//
+// * Node id query functions should return string ids for the nodes
+// * Edge id query functions should return an "edgeObj", edge object, that is
+// composed of enough information to uniquely identify an edge: {v, w, name}.
+// * Internally we use an "edgeId", a stringified form of the edgeObj, to
+// reference edges. This is because we need a performant way to look these
+// edges up and, object properties, which have string keys, are the closest
+// we're going to get to a performant hashtable in JavaScript.
+class Graph {
+ constructor(opts = {}) {
+ this._isDirected = has/* default */.A(opts, 'directed') ? opts.directed : true;
+ this._isMultigraph = has/* default */.A(opts, 'multigraph') ? opts.multigraph : false;
+ this._isCompound = has/* default */.A(opts, 'compound') ? opts.compound : false;
+
+ // Label for the graph itself
+ this._label = undefined;
+
+ // Defaults to be set when creating a new node
+ this._defaultNodeLabelFn = constant/* default */.A(undefined);
+
+ // Defaults to be set when creating a new edge
+ this._defaultEdgeLabelFn = constant/* default */.A(undefined);
+
+ // v -> label
+ this._nodes = {};
+
+ if (this._isCompound) {
+ // v -> parent
+ this._parent = {};
+
+ // v -> children
+ this._children = {};
+ this._children[GRAPH_NODE] = {};
+ }
+
+ // v -> edgeObj
+ this._in = {};
+
+ // u -> v -> Number
+ this._preds = {};
+
+ // v -> edgeObj
+ this._out = {};
+
+ // v -> w -> Number
+ this._sucs = {};
+
+ // e -> edgeObj
+ this._edgeObjs = {};
+
+ // e -> label
+ 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 */.A(newDefault)) {
+ newDefault = constant/* default */.A(newDefault);
+ }
+ this._defaultNodeLabelFn = newDefault;
+ return this;
+ }
+ nodeCount() {
+ return this._nodeCount;
+ }
+ nodes() {
+ return keys/* default */.A(this._nodes);
+ }
+ sources() {
+ var self = this;
+ return filter/* default */.A(this.nodes(), function (v) {
+ return isEmpty/* default */.A(self._in[v]);
+ });
+ }
+ sinks() {
+ var self = this;
+ return filter/* default */.A(this.nodes(), function (v) {
+ return isEmpty/* default */.A(self._out[v]);
+ });
+ }
+ setNodes(vs, value) {
+ var args = arguments;
+ var self = this;
+ forEach/* default */.A(vs, function (v) {
+ if (args.length > 1) {
+ self.setNode(v, value);
+ } else {
+ self.setNode(v);
+ }
+ });
+ return this;
+ }
+ setNode(v, value) {
+ if (has/* default */.A(this._nodes, v)) {
+ if (arguments.length > 1) {
+ this._nodes[v] = value;
+ }
+ return this;
+ }
+
+ // @ts-expect-error
+ this._nodes[v] = arguments.length > 1 ? value : this._defaultNodeLabelFn(v);
+ if (this._isCompound) {
+ this._parent[v] = GRAPH_NODE;
+ this._children[v] = {};
+ this._children[GRAPH_NODE][v] = true;
+ }
+ this._in[v] = {};
+ this._preds[v] = {};
+ this._out[v] = {};
+ this._sucs[v] = {};
+ ++this._nodeCount;
+ return this;
+ }
+ node(v) {
+ return this._nodes[v];
+ }
+ hasNode(v) {
+ return has/* default */.A(this._nodes, v);
+ }
+ removeNode(v) {
+ var self = this;
+ if (has/* default */.A(this._nodes, v)) {
+ var removeEdge = function (e) {
+ self.removeEdge(self._edgeObjs[e]);
+ };
+ delete this._nodes[v];
+ if (this._isCompound) {
+ this._removeFromParentsChildList(v);
+ delete this._parent[v];
+ forEach/* default */.A(this.children(v), function (child) {
+ self.setParent(child);
+ });
+ delete this._children[v];
+ }
+ forEach/* default */.A(keys/* default */.A(this._in[v]), removeEdge);
+ delete this._in[v];
+ delete this._preds[v];
+ forEach/* default */.A(keys/* default */.A(this._out[v]), removeEdge);
+ delete this._out[v];
+ delete this._sucs[v];
+ --this._nodeCount;
+ }
+ return this;
+ }
+ setParent(v, parent) {
+ if (!this._isCompound) {
+ throw new Error('Cannot set parent in a non-compound graph');
+ }
+
+ if (isUndefined/* default */.A(parent)) {
+ parent = GRAPH_NODE;
+ } else {
+ // Coerce parent to string
+ parent += '';
+ for (var ancestor = parent; !isUndefined/* default */.A(ancestor); ancestor = this.parent(ancestor)) {
+ if (ancestor === v) {
+ throw new Error('Setting ' + parent + ' as parent of ' + v + ' would create a cycle');
+ }
+ }
+
+ this.setNode(parent);
+ }
+
+ this.setNode(v);
+ this._removeFromParentsChildList(v);
+ this._parent[v] = parent;
+ this._children[parent][v] = true;
+ return this;
+ }
+ _removeFromParentsChildList(v) {
+ delete this._children[this._parent[v]][v];
+ }
+ parent(v) {
+ if (this._isCompound) {
+ var parent = this._parent[v];
+ if (parent !== GRAPH_NODE) {
+ return parent;
+ }
+ }
+ }
+ children(v) {
+ if (isUndefined/* default */.A(v)) {
+ v = GRAPH_NODE;
+ }
+
+ if (this._isCompound) {
+ var children = this._children[v];
+ if (children) {
+ return keys/* default */.A(children);
+ }
+ } else if (v === GRAPH_NODE) {
+ return this.nodes();
+ } else if (this.hasNode(v)) {
+ return [];
+ }
+ }
+ predecessors(v) {
+ var predsV = this._preds[v];
+ if (predsV) {
+ return keys/* default */.A(predsV);
+ }
+ }
+ successors(v) {
+ var sucsV = this._sucs[v];
+ if (sucsV) {
+ return keys/* default */.A(sucsV);
+ }
+ }
+ neighbors(v) {
+ var preds = this.predecessors(v);
+ if (preds) {
+ return lodash_es_union(preds, this.successors(v));
+ }
+ }
+ isLeaf(v) {
+ var neighbors;
+ if (this.isDirected()) {
+ neighbors = this.successors(v);
+ } else {
+ neighbors = this.neighbors(v);
+ }
+ return neighbors.length === 0;
+ }
+ filterNodes(filter) {
+ // @ts-expect-error
+ var copy = new this.constructor({
+ directed: this._isDirected,
+ multigraph: this._isMultigraph,
+ compound: this._isCompound,
+ });
+
+ copy.setGraph(this.graph());
+
+ var self = this;
+ forEach/* default */.A(this._nodes, function (value, v) {
+ if (filter(v)) {
+ copy.setNode(v, value);
+ }
+ });
+
+ forEach/* default */.A(this._edgeObjs, function (e) {
+ // @ts-expect-error
+ if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
+ copy.setEdge(e, self.edge(e));
+ }
+ });
+
+ var parents = {};
+ function findParent(v) {
+ var parent = self.parent(v);
+ if (parent === undefined || copy.hasNode(parent)) {
+ parents[v] = parent;
+ return parent;
+ } else if (parent in parents) {
+ return parents[parent];
+ } else {
+ return findParent(parent);
+ }
+ }
+
+ if (this._isCompound) {
+ forEach/* default */.A(copy.nodes(), function (v) {
+ copy.setParent(v, findParent(v));
+ });
+ }
+
+ return copy;
+ }
+ /* === Edge functions ========== */
+ setDefaultEdgeLabel(newDefault) {
+ if (!isFunction/* default */.A(newDefault)) {
+ newDefault = constant/* default */.A(newDefault);
+ }
+ this._defaultEdgeLabelFn = newDefault;
+ return this;
+ }
+ edgeCount() {
+ return this._edgeCount;
+ }
+ edges() {
+ return values/* default */.A(this._edgeObjs);
+ }
+ setPath(vs, value) {
+ var self = this;
+ var args = arguments;
+ reduce/* default */.A(vs, function (v, w) {
+ if (args.length > 1) {
+ self.setEdge(v, w, value);
+ } else {
+ self.setEdge(v, w);
+ }
+ return w;
+ });
+ return this;
+ }
+ /*
+ * setEdge(v, w, [value, [name]])
+ * setEdge({ v, w, [name] }, [value])
+ */
+ setEdge() {
+ var v, w, name, value;
+ var valueSpecified = false;
+ var arg0 = arguments[0];
+
+ if (typeof arg0 === 'object' && arg0 !== null && 'v' in arg0) {
+ v = arg0.v;
+ w = arg0.w;
+ name = arg0.name;
+ if (arguments.length === 2) {
+ value = arguments[1];
+ valueSpecified = true;
+ }
+ } else {
+ v = arg0;
+ w = arguments[1];
+ name = arguments[3];
+ if (arguments.length > 2) {
+ value = arguments[2];
+ valueSpecified = true;
+ }
+ }
+
+ v = '' + v;
+ w = '' + w;
+ if (!isUndefined/* default */.A(name)) {
+ name = '' + name;
+ }
+
+ var e = edgeArgsToId(this._isDirected, v, w, name);
+ if (has/* default */.A(this._edgeLabels, e)) {
+ if (valueSpecified) {
+ this._edgeLabels[e] = value;
+ }
+ return this;
+ }
+
+ if (!isUndefined/* default */.A(name) && !this._isMultigraph) {
+ throw new Error('Cannot set a named edge when isMultigraph = false');
+ }
+
+ // It didn't exist, so we need to create it.
+ // First ensure the nodes exist.
+ this.setNode(v);
+ this.setNode(w);
+
+ // @ts-expect-error
+ this._edgeLabels[e] = valueSpecified ? value : this._defaultEdgeLabelFn(v, w, name);
+
+ var edgeObj = edgeArgsToObj(this._isDirected, v, w, name);
+ // Ensure we add undirected edges in a consistent way.
+ v = edgeObj.v;
+ w = edgeObj.w;
+
+ Object.freeze(edgeObj);
+ this._edgeObjs[e] = edgeObj;
+ incrementOrInitEntry(this._preds[w], v);
+ incrementOrInitEntry(this._sucs[v], w);
+ this._in[w][e] = edgeObj;
+ this._out[v][e] = edgeObj;
+ this._edgeCount++;
+ return this;
+ }
+ edge(v, w, name) {
+ var e =
+ arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name);
+ return this._edgeLabels[e];
+ }
+ hasEdge(v, w, name) {
+ var e =
+ arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name);
+ return has/* default */.A(this._edgeLabels, e);
+ }
+ removeEdge(v, w, name) {
+ var e =
+ arguments.length === 1
+ ? edgeObjToId(this._isDirected, arguments[0])
+ : edgeArgsToId(this._isDirected, v, w, name);
+ var edge = this._edgeObjs[e];
+ if (edge) {
+ v = edge.v;
+ w = edge.w;
+ delete this._edgeLabels[e];
+ delete this._edgeObjs[e];
+ decrementOrRemoveEntry(this._preds[w], v);
+ decrementOrRemoveEntry(this._sucs[v], w);
+ delete this._in[w][e];
+ delete this._out[v][e];
+ this._edgeCount--;
+ }
+ return this;
+ }
+ inEdges(v, u) {
+ var inV = this._in[v];
+ if (inV) {
+ var edges = values/* default */.A(inV);
+ if (!u) {
+ return edges;
+ }
+ return filter/* default */.A(edges, function (edge) {
+ return edge.v === u;
+ });
+ }
+ }
+ outEdges(v, w) {
+ var outV = this._out[v];
+ if (outV) {
+ var edges = values/* default */.A(outV);
+ if (!w) {
+ return edges;
+ }
+ return filter/* default */.A(edges, function (edge) {
+ return edge.w === w;
+ });
+ }
+ }
+ nodeEdges(v, w) {
+ var inEdges = this.inEdges(v, w);
+ if (inEdges) {
+ return inEdges.concat(this.outEdges(v, w));
+ }
+ }
+}
+
+/* Number of nodes in the graph. Should only be changed by the implementation. */
+Graph.prototype._nodeCount = 0;
+
+/* Number of edges in the graph. Should only be changed by the implementation. */
+Graph.prototype._edgeCount = 0;
+
+function incrementOrInitEntry(map, k) {
+ if (map[k]) {
+ map[k]++;
+ } else {
+ map[k] = 1;
+ }
+}
+
+function decrementOrRemoveEntry(map, k) {
+ if (!--map[k]) {
+ delete map[k];
+ }
+}
+
+function edgeArgsToId(isDirected, v_, w_, name) {
+ var v = '' + v_;
+ var w = '' + w_;
+ if (!isDirected && v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (isUndefined/* default */.A(name) ? DEFAULT_EDGE_NAME : name);
+}
+
+function edgeArgsToObj(isDirected, v_, w_, name) {
+ var v = '' + v_;
+ var w = '' + w_;
+ if (!isDirected && v > w) {
+ var tmp = v;
+ v = w;
+ w = tmp;
+ }
+ var edgeObj = { v: v, w: w };
+ if (name) {
+ edgeObj.name = name;
+ }
+ return edgeObj;
+}
+
+function edgeObjToId(isDirected, edgeObj) {
+ return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
+}
+
+
+/***/ }),
+
+/***/ 697:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ T: () => (/* reexport safe */ _graph_js__WEBPACK_IMPORTED_MODULE_0__.T)
+/* harmony export */ });
+/* unused harmony export version */
+/* harmony import */ var _graph_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73046);
+// Includes only the "core" of graphlib
+
+
+
+const version = '2.1.9-pre';
+
+
+
+
+/***/ }),
+
+/***/ 62062:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _SetCache)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_MapCache.js + 14 modules
+var _MapCache = __webpack_require__(29471);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_setCacheAdd.js
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Adds `value` to the array cache.
+ *
+ * @private
+ * @name add
+ * @memberOf SetCache
+ * @alias push
+ * @param {*} value The value to cache.
+ * @returns {Object} Returns the cache instance.
+ */
+function setCacheAdd(value) {
+ this.__data__.set(value, HASH_UNDEFINED);
+ return this;
+}
+
+/* harmony default export */ const _setCacheAdd = (setCacheAdd);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_setCacheHas.js
+/**
+ * Checks if `value` is in the array cache.
+ *
+ * @private
+ * @name has
+ * @memberOf SetCache
+ * @param {*} value The value to search for.
+ * @returns {number} Returns `true` if `value` is found, else `false`.
+ */
+function setCacheHas(value) {
+ return this.__data__.has(value);
+}
+
+/* harmony default export */ const _setCacheHas = (setCacheHas);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_SetCache.js
+
+
+
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+ var index = -1,
+ length = values == null ? 0 : values.length;
+
+ this.__data__ = new _MapCache/* default */.A;
+ while (++index < length) {
+ this.add(values[index]);
+ }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
+SetCache.prototype.has = _setCacheHas;
+
+/* harmony default export */ const _SetCache = (SetCache);
+
+
+/***/ }),
+
+/***/ 72641:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (iteratee(array[index], index, array) === false) {
+ break;
+ }
+ }
+ return array;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (arrayEach);
+
+
+/***/ }),
+
+/***/ 2634:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+ var index = -1,
+ length = array == null ? 0 : array.length,
+ resIndex = 0,
+ result = [];
+
+ while (++index < length) {
+ var value = array[index];
+ if (predicate(value, index, array)) {
+ result[resIndex++] = value;
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (arrayFilter);
+
+
+/***/ }),
+
+/***/ 45572:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+ var index = -1,
+ length = array == null ? 0 : array.length,
+ result = Array(length);
+
+ while (++index < length) {
+ result[index] = iteratee(array[index], index, array);
+ }
+ return result;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (arrayMap);
+
+
+/***/ }),
+
+/***/ 76912:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+ var index = -1,
+ length = values.length,
+ offset = array.length;
+
+ while (++index < length) {
+ array[offset + index] = values[index];
+ }
+ return array;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (arrayPush);
+
+
+/***/ }),
+
+/***/ 91641:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _baseClone)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Stack.js + 5 modules
+var _Stack = __webpack_require__(11754);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayEach.js
+var _arrayEach = __webpack_require__(72641);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_assignValue.js
+var _assignValue = __webpack_require__(52851);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_copyObject.js
+var _copyObject = __webpack_require__(22031);
+// EXTERNAL MODULE: ./node_modules/lodash-es/keys.js
+var keys = __webpack_require__(27422);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseAssign.js
+
+
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+ return object && (0,_copyObject/* default */.A)(source, (0,keys/* default */.A)(source), object);
+}
+
+/* harmony default export */ const _baseAssign = (baseAssign);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/keysIn.js + 2 modules
+var keysIn = __webpack_require__(55615);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseAssignIn.js
+
+
+
+/**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssignIn(object, source) {
+ return object && (0,_copyObject/* default */.A)(source, (0,keysIn/* default */.A)(source), object);
+}
+
+/* harmony default export */ const _baseAssignIn = (baseAssignIn);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_cloneBuffer.js
+var _cloneBuffer = __webpack_require__(80154);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_copyArray.js
+var _copyArray = __webpack_require__(39759);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getSymbols.js
+var _getSymbols = __webpack_require__(14792);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_copySymbols.js
+
+
+
+/**
+ * Copies own symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbols(source, object) {
+ return (0,_copyObject/* default */.A)(source, (0,_getSymbols/* default */.A)(source), object);
+}
+
+/* harmony default export */ const _copySymbols = (copySymbols);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayPush.js
+var _arrayPush = __webpack_require__(76912);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getPrototype.js
+var _getPrototype = __webpack_require__(15647);
+// EXTERNAL MODULE: ./node_modules/lodash-es/stubArray.js
+var stubArray = __webpack_require__(13153);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_getSymbolsIn.js
+
+
+
+
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own and inherited enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbolsIn = !nativeGetSymbols ? stubArray/* default */.A : function(object) {
+ var result = [];
+ while (object) {
+ (0,_arrayPush/* default */.A)(result, (0,_getSymbols/* default */.A)(object));
+ object = (0,_getPrototype/* default */.A)(object);
+ }
+ return result;
+};
+
+/* harmony default export */ const _getSymbolsIn = (getSymbolsIn);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_copySymbolsIn.js
+
+
+
+/**
+ * Copies own and inherited symbols of `source` to `object`.
+ *
+ * @private
+ * @param {Object} source The object to copy symbols from.
+ * @param {Object} [object={}] The object to copy symbols to.
+ * @returns {Object} Returns `object`.
+ */
+function copySymbolsIn(source, object) {
+ return (0,_copyObject/* default */.A)(source, _getSymbolsIn(source), object);
+}
+
+/* harmony default export */ const _copySymbolsIn = (copySymbolsIn);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getAllKeys.js
+var _getAllKeys = __webpack_require__(19042);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseGetAllKeys.js
+var _baseGetAllKeys = __webpack_require__(33831);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_getAllKeysIn.js
+
+
+
+
+/**
+ * Creates an array of own and inherited enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeysIn(object) {
+ return (0,_baseGetAllKeys/* default */.A)(object, keysIn/* default */.A, _getSymbolsIn);
+}
+
+/* harmony default export */ const _getAllKeysIn = (getAllKeysIn);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getTag.js + 3 modules
+var _getTag = __webpack_require__(9779);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_initCloneArray.js
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var _initCloneArray_hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Initializes an array clone.
+ *
+ * @private
+ * @param {Array} array The array to clone.
+ * @returns {Array} Returns the initialized clone.
+ */
+function initCloneArray(array) {
+ var length = array.length,
+ result = new array.constructor(length);
+
+ // Add properties assigned by `RegExp#exec`.
+ if (length && typeof array[0] == 'string' && _initCloneArray_hasOwnProperty.call(array, 'index')) {
+ result.index = array.index;
+ result.input = array.input;
+ }
+ return result;
+}
+
+/* harmony default export */ const _initCloneArray = (initCloneArray);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_cloneArrayBuffer.js
+var _cloneArrayBuffer = __webpack_require__(90565);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_cloneDataView.js
+
+
+/**
+ * Creates a clone of `dataView`.
+ *
+ * @private
+ * @param {Object} dataView The data view to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the cloned data view.
+ */
+function cloneDataView(dataView, isDeep) {
+ var buffer = isDeep ? (0,_cloneArrayBuffer/* default */.A)(dataView.buffer) : dataView.buffer;
+ return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+
+/* harmony default export */ const _cloneDataView = (cloneDataView);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_cloneRegExp.js
+/** Used to match `RegExp` flags from their coerced string values. */
+var reFlags = /\w*$/;
+
+/**
+ * Creates a clone of `regexp`.
+ *
+ * @private
+ * @param {Object} regexp The regexp to clone.
+ * @returns {Object} Returns the cloned regexp.
+ */
+function cloneRegExp(regexp) {
+ var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+ result.lastIndex = regexp.lastIndex;
+ return result;
+}
+
+/* harmony default export */ const _cloneRegExp = (cloneRegExp);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Symbol.js
+var _Symbol = __webpack_require__(241);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_cloneSymbol.js
+
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol/* default */.A ? _Symbol/* default */.A.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * Creates a clone of the `symbol` object.
+ *
+ * @private
+ * @param {Object} symbol The symbol object to clone.
+ * @returns {Object} Returns the cloned symbol object.
+ */
+function cloneSymbol(symbol) {
+ return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+
+/* harmony default export */ const _cloneSymbol = (cloneSymbol);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_cloneTypedArray.js
+var _cloneTypedArray = __webpack_require__(1801);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_initCloneByTag.js
+
+
+
+
+
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]',
+ float32Tag = '[object Float32Array]',
+ float64Tag = '[object Float64Array]',
+ int8Tag = '[object Int8Array]',
+ int16Tag = '[object Int16Array]',
+ int32Tag = '[object Int32Array]',
+ uint8Tag = '[object Uint8Array]',
+ uint8ClampedTag = '[object Uint8ClampedArray]',
+ uint16Tag = '[object Uint16Array]',
+ uint32Tag = '[object Uint32Array]';
+
+/**
+ * Initializes an object clone based on its `toStringTag`.
+ *
+ * **Note:** This function only supports cloning values with tags of
+ * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to clone.
+ * @param {string} tag The `toStringTag` of the object to clone.
+ * @param {boolean} [isDeep] Specify a deep clone.
+ * @returns {Object} Returns the initialized clone.
+ */
+function initCloneByTag(object, tag, isDeep) {
+ var Ctor = object.constructor;
+ switch (tag) {
+ case arrayBufferTag:
+ return (0,_cloneArrayBuffer/* default */.A)(object);
+
+ case boolTag:
+ case dateTag:
+ return new Ctor(+object);
+
+ case dataViewTag:
+ return _cloneDataView(object, isDeep);
+
+ case float32Tag: case float64Tag:
+ case int8Tag: case int16Tag: case int32Tag:
+ case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:
+ return (0,_cloneTypedArray/* default */.A)(object, isDeep);
+
+ case mapTag:
+ return new Ctor;
+
+ case numberTag:
+ case stringTag:
+ return new Ctor(object);
+
+ case regexpTag:
+ return _cloneRegExp(object);
+
+ case setTag:
+ return new Ctor;
+
+ case symbolTag:
+ return _cloneSymbol(object);
+ }
+}
+
+/* harmony default export */ const _initCloneByTag = (initCloneByTag);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_initCloneObject.js + 1 modules
+var _initCloneObject = __webpack_require__(18598);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isBuffer.js + 1 modules
+var isBuffer = __webpack_require__(99912);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObjectLike.js
+var isObjectLike = __webpack_require__(53098);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsMap.js
+
+
+
+/** `Object#toString` result references. */
+var _baseIsMap_mapTag = '[object Map]';
+
+/**
+ * The base implementation of `_.isMap` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ */
+function baseIsMap(value) {
+ return (0,isObjectLike/* default */.A)(value) && (0,_getTag/* default */.A)(value) == _baseIsMap_mapTag;
+}
+
+/* harmony default export */ const _baseIsMap = (baseIsMap);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseUnary.js
+var _baseUnary = __webpack_require__(52789);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_nodeUtil.js
+var _nodeUtil = __webpack_require__(64841);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/isMap.js
+
+
+
+
+/* Node.js helper references. */
+var nodeIsMap = _nodeUtil/* default */.A && _nodeUtil/* default */.A.isMap;
+
+/**
+ * Checks if `value` is classified as a `Map` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ * @example
+ *
+ * _.isMap(new Map);
+ * // => true
+ *
+ * _.isMap(new WeakMap);
+ * // => false
+ */
+var isMap = nodeIsMap ? (0,_baseUnary/* default */.A)(nodeIsMap) : _baseIsMap;
+
+/* harmony default export */ const lodash_es_isMap = (isMap);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObject.js
+var isObject = __webpack_require__(23149);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsSet.js
+
+
+
+/** `Object#toString` result references. */
+var _baseIsSet_setTag = '[object Set]';
+
+/**
+ * The base implementation of `_.isSet` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ */
+function baseIsSet(value) {
+ return (0,isObjectLike/* default */.A)(value) && (0,_getTag/* default */.A)(value) == _baseIsSet_setTag;
+}
+
+/* harmony default export */ const _baseIsSet = (baseIsSet);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/isSet.js
+
+
+
+
+/* Node.js helper references. */
+var nodeIsSet = _nodeUtil/* default */.A && _nodeUtil/* default */.A.isSet;
+
+/**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */
+var isSet = nodeIsSet ? (0,_baseUnary/* default */.A)(nodeIsSet) : _baseIsSet;
+
+/* harmony default export */ const lodash_es_isSet = (isSet);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseClone.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+ CLONE_FLAT_FLAG = 2,
+ CLONE_SYMBOLS_FLAG = 4;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ _baseClone_boolTag = '[object Boolean]',
+ _baseClone_dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ funcTag = '[object Function]',
+ genTag = '[object GeneratorFunction]',
+ _baseClone_mapTag = '[object Map]',
+ _baseClone_numberTag = '[object Number]',
+ objectTag = '[object Object]',
+ _baseClone_regexpTag = '[object RegExp]',
+ _baseClone_setTag = '[object Set]',
+ _baseClone_stringTag = '[object String]',
+ _baseClone_symbolTag = '[object Symbol]',
+ weakMapTag = '[object WeakMap]';
+
+var _baseClone_arrayBufferTag = '[object ArrayBuffer]',
+ _baseClone_dataViewTag = '[object DataView]',
+ _baseClone_float32Tag = '[object Float32Array]',
+ _baseClone_float64Tag = '[object Float64Array]',
+ _baseClone_int8Tag = '[object Int8Array]',
+ _baseClone_int16Tag = '[object Int16Array]',
+ _baseClone_int32Tag = '[object Int32Array]',
+ _baseClone_uint8Tag = '[object Uint8Array]',
+ _baseClone_uint8ClampedTag = '[object Uint8ClampedArray]',
+ _baseClone_uint16Tag = '[object Uint16Array]',
+ _baseClone_uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[_baseClone_arrayBufferTag] = cloneableTags[_baseClone_dataViewTag] =
+cloneableTags[_baseClone_boolTag] = cloneableTags[_baseClone_dateTag] =
+cloneableTags[_baseClone_float32Tag] = cloneableTags[_baseClone_float64Tag] =
+cloneableTags[_baseClone_int8Tag] = cloneableTags[_baseClone_int16Tag] =
+cloneableTags[_baseClone_int32Tag] = cloneableTags[_baseClone_mapTag] =
+cloneableTags[_baseClone_numberTag] = cloneableTags[objectTag] =
+cloneableTags[_baseClone_regexpTag] = cloneableTags[_baseClone_setTag] =
+cloneableTags[_baseClone_stringTag] = cloneableTags[_baseClone_symbolTag] =
+cloneableTags[_baseClone_uint8Tag] = cloneableTags[_baseClone_uint8ClampedTag] =
+cloneableTags[_baseClone_uint16Tag] = cloneableTags[_baseClone_uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ * 1 - Deep clone
+ * 2 - Flatten inherited properties
+ * 4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, bitmask, customizer, key, object, stack) {
+ var result,
+ isDeep = bitmask & CLONE_DEEP_FLAG,
+ isFlat = bitmask & CLONE_FLAT_FLAG,
+ isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+ if (customizer) {
+ result = object ? customizer(value, key, object, stack) : customizer(value);
+ }
+ if (result !== undefined) {
+ return result;
+ }
+ if (!(0,isObject/* default */.A)(value)) {
+ return value;
+ }
+ var isArr = (0,isArray/* default */.A)(value);
+ if (isArr) {
+ result = _initCloneArray(value);
+ if (!isDeep) {
+ return (0,_copyArray/* default */.A)(value, result);
+ }
+ } else {
+ var tag = (0,_getTag/* default */.A)(value),
+ isFunc = tag == funcTag || tag == genTag;
+
+ if ((0,isBuffer/* default */.A)(value)) {
+ return (0,_cloneBuffer/* default */.A)(value, isDeep);
+ }
+ if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+ result = (isFlat || isFunc) ? {} : (0,_initCloneObject/* default */.A)(value);
+ if (!isDeep) {
+ return isFlat
+ ? _copySymbolsIn(value, _baseAssignIn(result, value))
+ : _copySymbols(value, _baseAssign(result, value));
+ }
+ } else {
+ if (!cloneableTags[tag]) {
+ return object ? value : {};
+ }
+ result = _initCloneByTag(value, tag, isDeep);
+ }
+ }
+ // Check for circular references and return its corresponding clone.
+ stack || (stack = new _Stack/* default */.A);
+ var stacked = stack.get(value);
+ if (stacked) {
+ return stacked;
+ }
+ stack.set(value, result);
+
+ if (lodash_es_isSet(value)) {
+ value.forEach(function(subValue) {
+ result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+ });
+ } else if (lodash_es_isMap(value)) {
+ value.forEach(function(subValue, key) {
+ result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+ });
+ }
+
+ var keysFunc = isFull
+ ? (isFlat ? _getAllKeysIn : _getAllKeys/* default */.A)
+ : (isFlat ? keysIn/* default */.A : keys/* default */.A);
+
+ var props = isArr ? undefined : keysFunc(value);
+ (0,_arrayEach/* default */.A)(props || value, function(subValue, key) {
+ if (props) {
+ key = subValue;
+ subValue = value[key];
+ }
+ // Recursively populate clone (susceptible to call stack limits).
+ (0,_assignValue/* default */.A)(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+ });
+ return result;
+}
+
+/* harmony default export */ const _baseClone = (baseClone);
+
+
+/***/ }),
+
+/***/ 6240:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _baseEach)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseForOwn.js
+var _baseForOwn = __webpack_require__(79841);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArrayLike.js
+var isArrayLike = __webpack_require__(38446);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_createBaseEach.js
+
+
+/**
+ * Creates a `baseEach` or `baseEachRight` function.
+ *
+ * @private
+ * @param {Function} eachFunc The function to iterate over a collection.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new base function.
+ */
+function createBaseEach(eachFunc, fromRight) {
+ return function(collection, iteratee) {
+ if (collection == null) {
+ return collection;
+ }
+ if (!(0,isArrayLike/* default */.A)(collection)) {
+ return eachFunc(collection, iteratee);
+ }
+ var length = collection.length,
+ index = fromRight ? length : -1,
+ iterable = Object(collection);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (iteratee(iterable[index], index, iterable) === false) {
+ break;
+ }
+ }
+ return collection;
+ };
+}
+
+/* harmony default export */ const _createBaseEach = (createBaseEach);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseEach.js
+
+
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = _createBaseEach(_baseForOwn/* default */.A);
+
+/* harmony default export */ const _baseEach = (baseEach);
+
+
+/***/ }),
+
+/***/ 25707:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+ var length = array.length,
+ index = fromIndex + (fromRight ? 1 : -1);
+
+ while ((fromRight ? index-- : ++index < length)) {
+ if (predicate(array[index], index, array)) {
+ return index;
+ }
+ }
+ return -1;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseFindIndex);
+
+
+/***/ }),
+
+/***/ 13588:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _baseFlatten)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayPush.js
+var _arrayPush = __webpack_require__(76912);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Symbol.js
+var _Symbol = __webpack_require__(241);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArguments.js + 1 modules
+var isArguments = __webpack_require__(52274);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_isFlattenable.js
+
+
+
+
+/** Built-in value references. */
+var spreadableSymbol = _Symbol/* default */.A ? _Symbol/* default */.A.isConcatSpreadable : undefined;
+
+/**
+ * Checks if `value` is a flattenable `arguments` object or array.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+ */
+function isFlattenable(value) {
+ return (0,isArray/* default */.A)(value) || (0,isArguments/* default */.A)(value) ||
+ !!(spreadableSymbol && value && value[spreadableSymbol]);
+}
+
+/* harmony default export */ const _isFlattenable = (isFlattenable);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseFlatten.js
+
+
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, depth, predicate, isStrict, result) {
+ var index = -1,
+ length = array.length;
+
+ predicate || (predicate = _isFlattenable);
+ result || (result = []);
+
+ while (++index < length) {
+ var value = array[index];
+ if (depth > 0 && predicate(value)) {
+ if (depth > 1) {
+ // Recursively flatten arrays (susceptible to call stack limits).
+ baseFlatten(value, depth - 1, predicate, isStrict, result);
+ } else {
+ (0,_arrayPush/* default */.A)(result, value);
+ }
+ } else if (!isStrict) {
+ result[result.length] = value;
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ const _baseFlatten = (baseFlatten);
+
+
+/***/ }),
+
+/***/ 79841:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseFor_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4574);
+/* harmony import */ var _keys_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(27422);
+
+
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+ return object && (0,_baseFor_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(object, iteratee, _keys_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A);
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseForOwn);
+
+
+/***/ }),
+
+/***/ 66318:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _castPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7819);
+/* harmony import */ var _toKey_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30901);
+
+
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+ path = (0,_castPath_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(path, object);
+
+ var index = 0,
+ length = path.length;
+
+ while (object != null && index < length) {
+ object = object[(0,_toKey_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(path[index++])];
+ }
+ return (index && index == length) ? object : undefined;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseGet);
+
+
+/***/ }),
+
+/***/ 33831:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _arrayPush_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(76912);
+/* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92049);
+
+
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+ var result = keysFunc(object);
+ return (0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(object) ? result : (0,_arrayPush_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(result, symbolsFunc(object));
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseGetAllKeys);
+
+
+/***/ }),
+
+/***/ 49574:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _baseIteratee)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Stack.js + 5 modules
+var _Stack = __webpack_require__(11754);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_SetCache.js + 2 modules
+var _SetCache = __webpack_require__(62062);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_arraySome.js
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ * else `false`.
+ */
+function arraySome(array, predicate) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ while (++index < length) {
+ if (predicate(array[index], index, array)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* harmony default export */ const _arraySome = (arraySome);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_cacheHas.js
+var _cacheHas = __webpack_require__(64099);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_equalArrays.js
+
+
+
+
+/** Used to compose bitmasks for value comparisons. */
+var COMPARE_PARTIAL_FLAG = 1,
+ COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for arrays with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Array} array The array to compare.
+ * @param {Array} other The other array to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `array` and `other` objects.
+ * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+ */
+function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+ var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+ arrLength = array.length,
+ othLength = other.length;
+
+ if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+ return false;
+ }
+ // Check that cyclic values are equal.
+ var arrStacked = stack.get(array);
+ var othStacked = stack.get(other);
+ if (arrStacked && othStacked) {
+ return arrStacked == other && othStacked == array;
+ }
+ var index = -1,
+ result = true,
+ seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new _SetCache/* default */.A : undefined;
+
+ stack.set(array, other);
+ stack.set(other, array);
+
+ // Ignore non-index properties.
+ while (++index < arrLength) {
+ var arrValue = array[index],
+ othValue = other[index];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, arrValue, index, other, array, stack)
+ : customizer(arrValue, othValue, index, array, other, stack);
+ }
+ if (compared !== undefined) {
+ if (compared) {
+ continue;
+ }
+ result = false;
+ break;
+ }
+ // Recursively compare arrays (susceptible to call stack limits).
+ if (seen) {
+ if (!_arraySome(other, function(othValue, othIndex) {
+ if (!(0,_cacheHas/* default */.A)(seen, othIndex) &&
+ (arrValue === othValue || equalFunc(arrValue, othValue, 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'](array);
+ stack['delete'](other);
+ return result;
+}
+
+/* harmony default export */ const _equalArrays = (equalArrays);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Symbol.js
+var _Symbol = __webpack_require__(241);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Uint8Array.js
+var _Uint8Array = __webpack_require__(43988);
+// EXTERNAL MODULE: ./node_modules/lodash-es/eq.js
+var eq = __webpack_require__(66984);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_mapToArray.js
+/**
+ * Converts `map` to its key-value pairs.
+ *
+ * @private
+ * @param {Object} map The map to convert.
+ * @returns {Array} Returns the key-value pairs.
+ */
+function mapToArray(map) {
+ var index = -1,
+ result = Array(map.size);
+
+ map.forEach(function(value, key) {
+ result[++index] = [key, value];
+ });
+ return result;
+}
+
+/* harmony default export */ const _mapToArray = (mapToArray);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_setToArray.js
+var _setToArray = __webpack_require__(29959);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_equalByTag.js
+
+
+
+
+
+
+
+/** Used to compose bitmasks for value comparisons. */
+var _equalByTag_COMPARE_PARTIAL_FLAG = 1,
+ _equalByTag_COMPARE_UNORDERED_FLAG = 2;
+
+/** `Object#toString` result references. */
+var boolTag = '[object Boolean]',
+ dateTag = '[object Date]',
+ errorTag = '[object Error]',
+ mapTag = '[object Map]',
+ numberTag = '[object Number]',
+ regexpTag = '[object RegExp]',
+ setTag = '[object Set]',
+ stringTag = '[object String]',
+ symbolTag = '[object Symbol]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+ dataViewTag = '[object DataView]';
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol/* default */.A ? _Symbol/* default */.A.prototype : undefined,
+ symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for comparing objects of
+ * the same `toStringTag`.
+ *
+ * **Note:** This function only supports comparing values with tags of
+ * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {string} tag The `toStringTag` of the objects to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+ switch (tag) {
+ case dataViewTag:
+ if ((object.byteLength != other.byteLength) ||
+ (object.byteOffset != other.byteOffset)) {
+ return false;
+ }
+ object = object.buffer;
+ other = other.buffer;
+
+ case arrayBufferTag:
+ if ((object.byteLength != other.byteLength) ||
+ !equalFunc(new _Uint8Array/* default */.A(object), new _Uint8Array/* default */.A(other))) {
+ return false;
+ }
+ return true;
+
+ case boolTag:
+ case dateTag:
+ case numberTag:
+ // Coerce booleans to `1` or `0` and dates to milliseconds.
+ // Invalid dates are coerced to `NaN`.
+ return (0,eq/* default */.A)(+object, +other);
+
+ case errorTag:
+ return object.name == other.name && object.message == other.message;
+
+ case regexpTag:
+ case stringTag:
+ // Coerce regexes to strings and treat strings, primitives and objects,
+ // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+ // for more details.
+ return object == (other + '');
+
+ case mapTag:
+ var convert = _mapToArray;
+
+ case setTag:
+ var isPartial = bitmask & _equalByTag_COMPARE_PARTIAL_FLAG;
+ convert || (convert = _setToArray/* default */.A);
+
+ if (object.size != other.size && !isPartial) {
+ return false;
+ }
+ // Assume cyclic values are equal.
+ var stacked = stack.get(object);
+ if (stacked) {
+ return stacked == other;
+ }
+ bitmask |= _equalByTag_COMPARE_UNORDERED_FLAG;
+
+ // Recursively compare objects (susceptible to call stack limits).
+ stack.set(object, other);
+ var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+ stack['delete'](object);
+ return result;
+
+ case symbolTag:
+ if (symbolValueOf) {
+ return symbolValueOf.call(object) == symbolValueOf.call(other);
+ }
+ }
+ return false;
+}
+
+/* harmony default export */ const _equalByTag = (equalByTag);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getAllKeys.js
+var _getAllKeys = __webpack_require__(19042);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_equalObjects.js
+
+
+/** Used to compose bitmasks for value comparisons. */
+var _equalObjects_COMPARE_PARTIAL_FLAG = 1;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var _equalObjects_hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqualDeep` for objects with support for
+ * partial deep comparisons.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} stack Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+ var isPartial = bitmask & _equalObjects_COMPARE_PARTIAL_FLAG,
+ objProps = (0,_getAllKeys/* default */.A)(object),
+ objLength = objProps.length,
+ othProps = (0,_getAllKeys/* default */.A)(other),
+ othLength = othProps.length;
+
+ if (objLength != othLength && !isPartial) {
+ return false;
+ }
+ var index = objLength;
+ while (index--) {
+ var key = objProps[index];
+ if (!(isPartial ? key in other : _equalObjects_hasOwnProperty.call(other, key))) {
+ return false;
+ }
+ }
+ // Check that cyclic values are equal.
+ var objStacked = stack.get(object);
+ var othStacked = stack.get(other);
+ if (objStacked && othStacked) {
+ return objStacked == other && othStacked == object;
+ }
+ var result = true;
+ stack.set(object, other);
+ stack.set(other, object);
+
+ var skipCtor = isPartial;
+ while (++index < objLength) {
+ key = objProps[index];
+ var objValue = object[key],
+ othValue = other[key];
+
+ if (customizer) {
+ var compared = isPartial
+ ? customizer(othValue, objValue, key, other, object, stack)
+ : customizer(objValue, othValue, key, object, other, stack);
+ }
+ // Recursively compare objects (susceptible to call stack limits).
+ if (!(compared === undefined
+ ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
+ : compared
+ )) {
+ result = false;
+ break;
+ }
+ skipCtor || (skipCtor = key == 'constructor');
+ }
+ if (result && !skipCtor) {
+ var objCtor = object.constructor,
+ othCtor = other.constructor;
+
+ // Non `Object` object instances with different constructors are not equal.
+ if (objCtor != othCtor &&
+ ('constructor' in object && 'constructor' in other) &&
+ !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
+ typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+ result = false;
+ }
+ }
+ stack['delete'](object);
+ stack['delete'](other);
+ return result;
+}
+
+/* harmony default export */ const _equalObjects = (equalObjects);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_getTag.js + 3 modules
+var _getTag = __webpack_require__(9779);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isBuffer.js + 1 modules
+var isBuffer = __webpack_require__(99912);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isTypedArray.js + 1 modules
+var isTypedArray = __webpack_require__(33858);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsEqualDeep.js
+
+
+
+
+
+
+
+
+
+/** Used to compose bitmasks for value comparisons. */
+var _baseIsEqualDeep_COMPARE_PARTIAL_FLAG = 1;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+ arrayTag = '[object Array]',
+ objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var _baseIsEqualDeep_objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var _baseIsEqualDeep_hasOwnProperty = _baseIsEqualDeep_objectProto.hasOwnProperty;
+
+/**
+ * A specialized version of `baseIsEqual` for arrays and objects which performs
+ * deep comparisons and tracks traversed objects enabling objects with circular
+ * references to be compared.
+ *
+ * @private
+ * @param {Object} object The object to compare.
+ * @param {Object} other The other object to compare.
+ * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+ * @param {Function} customizer The function to customize comparisons.
+ * @param {Function} equalFunc The function to determine equivalents of values.
+ * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+ * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+ */
+function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+ var objIsArr = (0,isArray/* default */.A)(object),
+ othIsArr = (0,isArray/* default */.A)(other),
+ objTag = objIsArr ? arrayTag : (0,_getTag/* default */.A)(object),
+ othTag = othIsArr ? arrayTag : (0,_getTag/* default */.A)(other);
+
+ objTag = objTag == argsTag ? objectTag : objTag;
+ othTag = othTag == argsTag ? objectTag : othTag;
+
+ var objIsObj = objTag == objectTag,
+ othIsObj = othTag == objectTag,
+ isSameTag = objTag == othTag;
+
+ if (isSameTag && (0,isBuffer/* default */.A)(object)) {
+ if (!(0,isBuffer/* default */.A)(other)) {
+ return false;
+ }
+ objIsArr = true;
+ objIsObj = false;
+ }
+ if (isSameTag && !objIsObj) {
+ stack || (stack = new _Stack/* default */.A);
+ return (objIsArr || (0,isTypedArray/* default */.A)(object))
+ ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+ : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+ }
+ if (!(bitmask & _baseIsEqualDeep_COMPARE_PARTIAL_FLAG)) {
+ var objIsWrapped = objIsObj && _baseIsEqualDeep_hasOwnProperty.call(object, '__wrapped__'),
+ othIsWrapped = othIsObj && _baseIsEqualDeep_hasOwnProperty.call(other, '__wrapped__');
+
+ if (objIsWrapped || othIsWrapped) {
+ var objUnwrapped = objIsWrapped ? object.value() : object,
+ othUnwrapped = othIsWrapped ? other.value() : other;
+
+ stack || (stack = new _Stack/* default */.A);
+ return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+ }
+ }
+ if (!isSameTag) {
+ return false;
+ }
+ stack || (stack = new _Stack/* default */.A);
+ return _equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+
+/* harmony default export */ const _baseIsEqualDeep = (baseIsEqualDeep);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObjectLike.js
+var isObjectLike = __webpack_require__(53098);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsEqual.js
+
+
+
+/**
+ * The base implementation of `_.isEqual` which supports partial comparisons
+ * and tracks traversed objects.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @param {boolean} bitmask The bitmask flags.
+ * 1 - Unordered comparison
+ * 2 - Partial comparison
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ */
+function baseIsEqual(value, other, bitmask, customizer, stack) {
+ if (value === other) {
+ return true;
+ }
+ if (value == null || other == null || (!(0,isObjectLike/* default */.A)(value) && !(0,isObjectLike/* default */.A)(other))) {
+ return value !== value && other !== other;
+ }
+ return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+}
+
+/* harmony default export */ const _baseIsEqual = (baseIsEqual);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIsMatch.js
+
+
+
+/** Used to compose bitmasks for value comparisons. */
+var _baseIsMatch_COMPARE_PARTIAL_FLAG = 1,
+ _baseIsMatch_COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.isMatch` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property values to match.
+ * @param {Array} matchData The property names, values, and compare flags to match.
+ * @param {Function} [customizer] The function to customize comparisons.
+ * @returns {boolean} Returns `true` if `object` is a match, else `false`.
+ */
+function baseIsMatch(object, source, matchData, customizer) {
+ var index = matchData.length,
+ length = index,
+ noCustomizer = !customizer;
+
+ if (object == null) {
+ return !length;
+ }
+ object = Object(object);
+ while (index--) {
+ var data = matchData[index];
+ if ((noCustomizer && data[2])
+ ? data[1] !== object[data[0]]
+ : !(data[0] in object)
+ ) {
+ return false;
+ }
+ }
+ while (++index < length) {
+ data = matchData[index];
+ var key = data[0],
+ objValue = object[key],
+ srcValue = data[1];
+
+ if (noCustomizer && data[2]) {
+ if (objValue === undefined && !(key in object)) {
+ return false;
+ }
+ } else {
+ var stack = new _Stack/* default */.A;
+ if (customizer) {
+ var result = customizer(objValue, srcValue, key, object, source, stack);
+ }
+ if (!(result === undefined
+ ? _baseIsEqual(srcValue, objValue, _baseIsMatch_COMPARE_PARTIAL_FLAG | _baseIsMatch_COMPARE_UNORDERED_FLAG, customizer, stack)
+ : result
+ )) {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+/* harmony default export */ const _baseIsMatch = (baseIsMatch);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObject.js
+var isObject = __webpack_require__(23149);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_isStrictComparable.js
+
+
+/**
+ * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` if suitable for strict
+ * equality comparisons, else `false`.
+ */
+function isStrictComparable(value) {
+ return value === value && !(0,isObject/* default */.A)(value);
+}
+
+/* harmony default export */ const _isStrictComparable = (isStrictComparable);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/keys.js
+var keys = __webpack_require__(27422);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_getMatchData.js
+
+
+
+/**
+ * Gets the property names, values, and compare flags of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the match data of `object`.
+ */
+function getMatchData(object) {
+ var result = (0,keys/* default */.A)(object),
+ length = result.length;
+
+ while (length--) {
+ var key = result[length],
+ value = object[key];
+
+ result[length] = [key, value, _isStrictComparable(value)];
+ }
+ return result;
+}
+
+/* harmony default export */ const _getMatchData = (getMatchData);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_matchesStrictComparable.js
+/**
+ * A specialized version of `matchesProperty` for source values suitable
+ * for strict equality comparisons, i.e. `===`.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function matchesStrictComparable(key, srcValue) {
+ return function(object) {
+ if (object == null) {
+ return false;
+ }
+ return object[key] === srcValue &&
+ (srcValue !== undefined || (key in Object(object)));
+ };
+}
+
+/* harmony default export */ const _matchesStrictComparable = (matchesStrictComparable);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseMatches.js
+
+
+
+
+/**
+ * The base implementation of `_.matches` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property values to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatches(source) {
+ var matchData = _getMatchData(source);
+ if (matchData.length == 1 && matchData[0][2]) {
+ return _matchesStrictComparable(matchData[0][0], matchData[0][1]);
+ }
+ return function(object) {
+ return object === source || _baseIsMatch(object, source, matchData);
+ };
+}
+
+/* harmony default export */ const _baseMatches = (baseMatches);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseGet.js
+var _baseGet = __webpack_require__(66318);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/get.js
+
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+ var result = object == null ? undefined : (0,_baseGet/* default */.A)(object, path);
+ return result === undefined ? defaultValue : result;
+}
+
+/* harmony default export */ const lodash_es_get = (get);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/hasIn.js + 1 modules
+var hasIn = __webpack_require__(39188);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_isKey.js
+var _isKey = __webpack_require__(86586);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_toKey.js
+var _toKey = __webpack_require__(30901);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseMatchesProperty.js
+
+
+
+
+
+
+
+
+/** Used to compose bitmasks for value comparisons. */
+var _baseMatchesProperty_COMPARE_PARTIAL_FLAG = 1,
+ _baseMatchesProperty_COMPARE_UNORDERED_FLAG = 2;
+
+/**
+ * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
+ *
+ * @private
+ * @param {string} path The path of the property to get.
+ * @param {*} srcValue The value to match.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseMatchesProperty(path, srcValue) {
+ if ((0,_isKey/* default */.A)(path) && _isStrictComparable(srcValue)) {
+ return _matchesStrictComparable((0,_toKey/* default */.A)(path), srcValue);
+ }
+ return function(object) {
+ var objValue = lodash_es_get(object, path);
+ return (objValue === undefined && objValue === srcValue)
+ ? (0,hasIn/* default */.A)(object, path)
+ : _baseIsEqual(srcValue, objValue, _baseMatchesProperty_COMPARE_PARTIAL_FLAG | _baseMatchesProperty_COMPARE_UNORDERED_FLAG);
+ };
+}
+
+/* harmony default export */ const _baseMatchesProperty = (baseMatchesProperty);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/identity.js
+var identity = __webpack_require__(29008);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseProperty.js
+var _baseProperty = __webpack_require__(70805);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_basePropertyDeep.js
+
+
+/**
+ * A specialized version of `baseProperty` which supports deep paths.
+ *
+ * @private
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function basePropertyDeep(path) {
+ return function(object) {
+ return (0,_baseGet/* default */.A)(object, path);
+ };
+}
+
+/* harmony default export */ const _basePropertyDeep = (basePropertyDeep);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/property.js
+
+
+
+
+
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ * { 'a': { 'b': 2 } },
+ * { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */
+function property(path) {
+ return (0,_isKey/* default */.A)(path) ? (0,_baseProperty/* default */.A)((0,_toKey/* default */.A)(path)) : _basePropertyDeep(path);
+}
+
+/* harmony default export */ const lodash_es_property = (property);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseIteratee.js
+
+
+
+
+
+
+/**
+ * The base implementation of `_.iteratee`.
+ *
+ * @private
+ * @param {*} [value=_.identity] The value to convert to an iteratee.
+ * @returns {Function} Returns the iteratee.
+ */
+function baseIteratee(value) {
+ // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
+ // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
+ if (typeof value == 'function') {
+ return value;
+ }
+ if (value == null) {
+ return identity/* default */.A;
+ }
+ if (typeof value == 'object') {
+ return (0,isArray/* default */.A)(value)
+ ? _baseMatchesProperty(value[0], value[1])
+ : _baseMatches(value);
+ }
+ return lodash_es_property(value);
+}
+
+/* harmony default export */ const _baseIteratee = (baseIteratee);
+
+
+/***/ }),
+
+/***/ 52568:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseEach_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6240);
+/* harmony import */ var _isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38446);
+
+
+
+/**
+ * The base implementation of `_.map` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function baseMap(collection, iteratee) {
+ var index = -1,
+ result = (0,_isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(collection) ? Array(collection.length) : [];
+
+ (0,_baseEach_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(collection, function(value, key, collection) {
+ result[++index] = iteratee(value, key, collection);
+ });
+ return result;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseMap);
+
+
+/***/ }),
+
+/***/ 70805:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * The base implementation of `_.property` without support for deep paths.
+ *
+ * @private
+ * @param {string} key The key of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ */
+function baseProperty(key) {
+ return function(object) {
+ return object == null ? undefined : object[key];
+ };
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseProperty);
+
+
+/***/ }),
+
+/***/ 64099:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * Checks if a `cache` value for `key` exists.
+ *
+ * @private
+ * @param {Object} cache The cache to query.
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function cacheHas(cache, key) {
+ return cache.has(key);
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (cacheHas);
+
+
+/***/ }),
+
+/***/ 99922:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _identity_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29008);
+
+
+/**
+ * Casts `value` to `identity` if it's not a function.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {Function} Returns cast function.
+ */
+function castFunction(value) {
+ return typeof value == 'function' ? value : _identity_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (castFunction);
+
+
+/***/ }),
+
+/***/ 7819:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ _castPath)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_isKey.js
+var _isKey = __webpack_require__(86586);
+// EXTERNAL MODULE: ./node_modules/lodash-es/memoize.js
+var memoize = __webpack_require__(46632);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_memoizeCapped.js
+
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped(func) {
+ var result = (0,memoize/* default */.A)(func, function(key) {
+ if (cache.size === MAX_MEMOIZE_SIZE) {
+ cache.clear();
+ }
+ return key;
+ });
+
+ var cache = result.cache;
+ return result;
+}
+
+/* harmony default export */ const _memoizeCapped = (memoizeCapped);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_stringToPath.js
+
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath = _memoizeCapped(function(string) {
+ var result = [];
+ if (string.charCodeAt(0) === 46 /* . */) {
+ result.push('');
+ }
+ string.replace(rePropName, function(match, number, quote, subString) {
+ result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
+ });
+ return result;
+});
+
+/* harmony default export */ const _stringToPath = (stringToPath);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/toString.js + 1 modules
+var lodash_es_toString = __webpack_require__(28894);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_castPath.js
+
+
+
+
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath(value, object) {
+ if ((0,isArray/* default */.A)(value)) {
+ return value;
+ }
+ return (0,_isKey/* default */.A)(value, object) ? [value] : _stringToPath((0,lodash_es_toString/* default */.A)(value));
+}
+
+/* harmony default export */ const _castPath = (castPath);
+
+
+/***/ }),
+
+/***/ 19042:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseGetAllKeys_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(33831);
+/* harmony import */ var _getSymbols_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(14792);
+/* harmony import */ var _keys_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(27422);
+
+
+
+
+/**
+ * Creates an array of own enumerable property names and symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function getAllKeys(object) {
+ return (0,_baseGetAllKeys_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(object, _keys_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A, _getSymbols_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A);
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getAllKeys);
+
+
+/***/ }),
+
+/***/ 14792:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _arrayFilter_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2634);
+/* harmony import */ var _stubArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13153);
+
+
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Built-in value references. */
+var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+/**
+ * Creates an array of the own enumerable symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of symbols.
+ */
+var getSymbols = !nativeGetSymbols ? _stubArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A : function(object) {
+ if (object == null) {
+ return [];
+ }
+ object = Object(object);
+ return (0,_arrayFilter_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(nativeGetSymbols(object), function(symbol) {
+ return propertyIsEnumerable.call(object, symbol);
+ });
+};
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getSymbols);
+
+
+/***/ }),
+
+/***/ 85054:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _castPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7819);
+/* harmony import */ var _isArguments_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(52274);
+/* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(92049);
+/* harmony import */ var _isIndex_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(25353);
+/* harmony import */ var _isLength_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(5254);
+/* harmony import */ var _toKey_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(30901);
+
+
+
+
+
+
+
+/**
+ * Checks if `path` exists on `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @param {Function} hasFunc The function to check properties.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ */
+function hasPath(object, path, hasFunc) {
+ path = (0,_castPath_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(path, object);
+
+ var index = -1,
+ length = path.length,
+ result = false;
+
+ while (++index < length) {
+ var key = (0,_toKey_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(path[index]);
+ if (!(result = object != null && hasFunc(object, key))) {
+ break;
+ }
+ object = object[key];
+ }
+ if (result || ++index != length) {
+ return result;
+ }
+ length = object == null ? 0 : object.length;
+ return !!length && (0,_isLength_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(length) && (0,_isIndex_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(key, length) &&
+ ((0,_isArray_js__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A)(object) || (0,_isArguments_js__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A)(object));
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (hasPath);
+
+
+/***/ }),
+
+/***/ 86586:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92049);
+/* harmony import */ var _isSymbol_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(61882);
+
+
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+ reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey(value, object) {
+ if ((0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(value)) {
+ return false;
+ }
+ var type = typeof value;
+ if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+ value == null || (0,_isSymbol_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(value)) {
+ return true;
+ }
+ return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+ (object != null && value in Object(object));
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isKey);
+
+
+/***/ }),
+
+/***/ 29959:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * Converts `set` to an array of its values.
+ *
+ * @private
+ * @param {Object} set The set to convert.
+ * @returns {Array} Returns the values.
+ */
+function setToArray(set) {
+ var index = -1,
+ result = Array(set.size);
+
+ set.forEach(function(value) {
+ result[++index] = value;
+ });
+ return result;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (setToArray);
+
+
+/***/ }),
+
+/***/ 30901:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _isSymbol_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(61882);
+
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey(value) {
+ if (typeof value == 'string' || (0,_isSymbol_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(value)) {
+ return value;
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (toKey);
+
+
+/***/ }),
+
+/***/ 23068:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseRest_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(24326);
+/* harmony import */ var _eq_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(66984);
+/* harmony import */ var _isIterateeCall_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6832);
+/* harmony import */ var _keysIn_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(55615);
+
+
+
+
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns own and inherited enumerable string keyed properties of source
+ * objects to the destination object for all destination properties that
+ * resolve to `undefined`. Source objects are applied from left to right.
+ * Once a property is set, additional values of the same property are ignored.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @see _.defaultsDeep
+ * @example
+ *
+ * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
+ * // => { 'a': 1, 'b': 2 }
+ */
+var defaults = (0,_baseRest_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(function(object, sources) {
+ object = Object(object);
+
+ var index = -1;
+ var length = sources.length;
+ var guard = length > 2 ? sources[2] : undefined;
+
+ if (guard && (0,_isIterateeCall_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(sources[0], sources[1], guard)) {
+ length = 1;
+ }
+
+ while (++index < length) {
+ var source = sources[index];
+ var props = (0,_keysIn_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(source);
+ var propsIndex = -1;
+ var propsLength = props.length;
+
+ while (++propsIndex < propsLength) {
+ var key = props[propsIndex];
+ var value = object[key];
+
+ if (value === undefined ||
+ ((0,_eq_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {
+ object[key] = source[key];
+ }
+ }
+ }
+
+ return object;
+});
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (defaults);
+
+
+/***/ }),
+
+/***/ 11662:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_filter)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayFilter.js
+var _arrayFilter = __webpack_require__(2634);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseEach.js + 1 modules
+var _baseEach = __webpack_require__(6240);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseFilter.js
+
+
+/**
+ * The base implementation of `_.filter` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function baseFilter(collection, predicate) {
+ var result = [];
+ (0,_baseEach/* default */.A)(collection, function(value, index, collection) {
+ if (predicate(value, index, collection)) {
+ result.push(value);
+ }
+ });
+ return result;
+}
+
+/* harmony default export */ const _baseFilter = (baseFilter);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseIteratee.js + 16 modules
+var _baseIteratee = __webpack_require__(49574);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/filter.js
+
+
+
+
+
+/**
+ * Iterates over elements of `collection`, returning an array of all elements
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * **Note:** Unlike `_.remove`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ * @see _.reject
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false }
+ * ];
+ *
+ * _.filter(users, function(o) { return !o.active; });
+ * // => objects for ['fred']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.filter(users, { 'age': 36, 'active': true });
+ * // => objects for ['barney']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.filter(users, ['active', false]);
+ * // => objects for ['fred']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.filter(users, 'active');
+ * // => objects for ['barney']
+ *
+ * // Combining several predicates using `_.overEvery` or `_.overSome`.
+ * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));
+ * // => objects for ['fred', 'barney']
+ */
+function filter(collection, predicate) {
+ var func = (0,isArray/* default */.A)(collection) ? _arrayFilter/* default */.A : _baseFilter;
+ return func(collection, (0,_baseIteratee/* default */.A)(predicate, 3));
+}
+
+/* harmony default export */ const lodash_es_filter = (filter);
+
+
+/***/ }),
+
+/***/ 34098:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13588);
+
+
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, [3, [4]], 5]
+ */
+function flatten(array) {
+ var length = array == null ? 0 : array.length;
+ return length ? (0,_baseFlatten_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(array, 1) : [];
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (flatten);
+
+
+/***/ }),
+
+/***/ 8058:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _arrayEach_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72641);
+/* harmony import */ var _baseEach_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(6240);
+/* harmony import */ var _castFunction_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(99922);
+/* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92049);
+
+
+
+
+
+/**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * The iteratee is invoked with three arguments: (value, index|key, collection).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a "length"
+ * property are iterated like arrays. To avoid this behavior use `_.forIn`
+ * or `_.forOwn` for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias each
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEachRight
+ * @example
+ *
+ * _.forEach([1, 2], function(value) {
+ * console.log(value);
+ * });
+ * // => Logs `1` then `2`.
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */
+function forEach(collection, iteratee) {
+ var func = (0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(collection) ? _arrayEach_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A : _baseEach_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A;
+ return func(collection, (0,_castFunction_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(iteratee));
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (forEach);
+
+
+/***/ }),
+
+/***/ 48585:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_has)
+});
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseHas.js
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var _baseHas_hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.has` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHas(object, key) {
+ return object != null && _baseHas_hasOwnProperty.call(object, key);
+}
+
+/* harmony default export */ const _baseHas = (baseHas);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_hasPath.js
+var _hasPath = __webpack_require__(85054);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/has.js
+
+
+
+/**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */
+function has(object, path) {
+ return object != null && (0,_hasPath/* default */.A)(object, path, _baseHas);
+}
+
+/* harmony default export */ const lodash_es_has = (has);
+
+
+/***/ }),
+
+/***/ 39188:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_hasIn)
+});
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseHasIn.js
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+ return object != null && key in Object(object);
+}
+
+/* harmony default export */ const _baseHasIn = (baseHasIn);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_hasPath.js
+var _hasPath = __webpack_require__(85054);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/hasIn.js
+
+
+
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */
+function hasIn(object, path) {
+ return object != null && (0,_hasPath/* default */.A)(object, path, _baseHasIn);
+}
+
+/* harmony default export */ const lodash_es_hasIn = (hasIn);
+
+
+/***/ }),
+
+/***/ 61882:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _baseGetTag_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(88496);
+/* harmony import */ var _isObjectLike_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(53098);
+
+
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+ return typeof value == 'symbol' ||
+ ((0,_isObjectLike_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(value) && (0,_baseGetTag_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(value) == symbolTag);
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isSymbol);
+
+
+/***/ }),
+
+/***/ 69592:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ *
+ * _.isUndefined(null);
+ * // => false
+ */
+function isUndefined(value) {
+ return value === undefined;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isUndefined);
+
+
+/***/ }),
+
+/***/ 27422:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _arrayLikeKeys_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(83607);
+/* harmony import */ var _baseKeys_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(69471);
+/* harmony import */ var _isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(38446);
+
+
+
+
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */
+function keys(object) {
+ return (0,_isArrayLike_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(object) ? (0,_arrayLikeKeys_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(object) : (0,_baseKeys_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A)(object);
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (keys);
+
+
+/***/ }),
+
+/***/ 74722:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _arrayMap_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(45572);
+/* harmony import */ var _baseIteratee_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49574);
+/* harmony import */ var _baseMap_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(52568);
+/* harmony import */ var _isArray_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92049);
+
+
+
+
+
+/**
+ * Creates an array of values by running each element in `collection` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+ * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+ * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+ * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * _.map([4, 8], square);
+ * // => [16, 64]
+ *
+ * _.map({ 'a': 4, 'b': 8 }, square);
+ * // => [16, 64] (iteration order is not guaranteed)
+ *
+ * var users = [
+ * { 'user': 'barney' },
+ * { 'user': 'fred' }
+ * ];
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */
+function map(collection, iteratee) {
+ var func = (0,_isArray_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(collection) ? _arrayMap_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A : _baseMap_js__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A;
+ return func(collection, (0,_baseIteratee_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)(iteratee, 3));
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (map);
+
+
+/***/ }),
+
+/***/ 81942:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_pick)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseGet.js
+var _baseGet = __webpack_require__(66318);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_assignValue.js
+var _assignValue = __webpack_require__(52851);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_castPath.js + 2 modules
+var _castPath = __webpack_require__(7819);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_isIndex.js
+var _isIndex = __webpack_require__(25353);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObject.js
+var isObject = __webpack_require__(23149);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_toKey.js
+var _toKey = __webpack_require__(30901);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseSet.js
+
+
+
+
+
+
+/**
+ * The base implementation of `_.set`.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {Array|string} path The path of the property to set.
+ * @param {*} value The value to set.
+ * @param {Function} [customizer] The function to customize path creation.
+ * @returns {Object} Returns `object`.
+ */
+function baseSet(object, path, value, customizer) {
+ if (!(0,isObject/* default */.A)(object)) {
+ return object;
+ }
+ path = (0,_castPath/* default */.A)(path, object);
+
+ var index = -1,
+ length = path.length,
+ lastIndex = length - 1,
+ nested = object;
+
+ while (nested != null && ++index < length) {
+ var key = (0,_toKey/* default */.A)(path[index]),
+ newValue = value;
+
+ if (key === '__proto__' || key === 'constructor' || key === 'prototype') {
+ return object;
+ }
+
+ if (index != lastIndex) {
+ var objValue = nested[key];
+ newValue = customizer ? customizer(objValue, key, nested) : undefined;
+ if (newValue === undefined) {
+ newValue = (0,isObject/* default */.A)(objValue)
+ ? objValue
+ : ((0,_isIndex/* default */.A)(path[index + 1]) ? [] : {});
+ }
+ }
+ (0,_assignValue/* default */.A)(nested, key, newValue);
+ nested = nested[key];
+ }
+ return object;
+}
+
+/* harmony default export */ const _baseSet = (baseSet);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_basePickBy.js
+
+
+
+
+/**
+ * The base implementation of `_.pickBy` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @param {Function} predicate The function invoked per property.
+ * @returns {Object} Returns the new object.
+ */
+function basePickBy(object, paths, predicate) {
+ var index = -1,
+ length = paths.length,
+ result = {};
+
+ while (++index < length) {
+ var path = paths[index],
+ value = (0,_baseGet/* default */.A)(object, path);
+
+ if (predicate(value, path)) {
+ _baseSet(result, (0,_castPath/* default */.A)(path, object), value);
+ }
+ }
+ return result;
+}
+
+/* harmony default export */ const _basePickBy = (basePickBy);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/hasIn.js + 1 modules
+var hasIn = __webpack_require__(39188);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_basePick.js
+
+
+
+/**
+ * The base implementation of `_.pick` without support for individual
+ * property identifiers.
+ *
+ * @private
+ * @param {Object} object The source object.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Object} Returns the new object.
+ */
+function basePick(object, paths) {
+ return _basePickBy(object, paths, function(value, path) {
+ return (0,hasIn/* default */.A)(object, path);
+ });
+}
+
+/* harmony default export */ const _basePick = (basePick);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/flatten.js
+var flatten = __webpack_require__(34098);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_overRest.js + 1 modules
+var _overRest = __webpack_require__(76875);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_setToString.js + 2 modules
+var _setToString = __webpack_require__(67525);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_flatRest.js
+
+
+
+
+/**
+ * A specialized version of `baseRest` which flattens the rest array.
+ *
+ * @private
+ * @param {Function} func The function to apply a rest parameter to.
+ * @returns {Function} Returns the new function.
+ */
+function flatRest(func) {
+ return (0,_setToString/* default */.A)((0,_overRest/* default */.A)(func, undefined, flatten/* default */.A), func + '');
+}
+
+/* harmony default export */ const _flatRest = (flatRest);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/pick.js
+
+
+
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */
+var pick = _flatRest(function(object, paths) {
+ return object == null ? {} : _basePick(object, paths);
+});
+
+/* harmony default export */ const lodash_es_pick = (pick);
+
+
+/***/ }),
+
+/***/ 91395:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_range)
+});
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseRange.js
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeCeil = Math.ceil,
+ nativeMax = Math.max;
+
+/**
+ * The base implementation of `_.range` and `_.rangeRight` which doesn't
+ * coerce arguments.
+ *
+ * @private
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} step The value to increment or decrement by.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Array} Returns the range of numbers.
+ */
+function baseRange(start, end, step, fromRight) {
+ var index = -1,
+ length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
+ result = Array(length);
+
+ while (length--) {
+ result[fromRight ? length : ++index] = start;
+ start += step;
+ }
+ return result;
+}
+
+/* harmony default export */ const _baseRange = (baseRange);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_isIterateeCall.js
+var _isIterateeCall = __webpack_require__(6832);
+// EXTERNAL MODULE: ./node_modules/lodash-es/toFinite.js + 3 modules
+var toFinite = __webpack_require__(74342);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_createRange.js
+
+
+
+
+/**
+ * Creates a `_.range` or `_.rangeRight` function.
+ *
+ * @private
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {Function} Returns the new range function.
+ */
+function createRange(fromRight) {
+ return function(start, end, step) {
+ if (step && typeof step != 'number' && (0,_isIterateeCall/* default */.A)(start, end, step)) {
+ end = step = undefined;
+ }
+ // Ensure the sign of `-0` is preserved.
+ start = (0,toFinite/* default */.A)(start);
+ if (end === undefined) {
+ end = start;
+ start = 0;
+ } else {
+ end = (0,toFinite/* default */.A)(end);
+ }
+ step = step === undefined ? (start < end ? 1 : -1) : (0,toFinite/* default */.A)(step);
+ return _baseRange(start, end, step, fromRight);
+ };
+}
+
+/* harmony default export */ const _createRange = (createRange);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/range.js
+
+
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to, but not including, `end`. A step of `-1` is used if a negative
+ * `start` is specified without an `end` or `step`. If `end` is not specified,
+ * it's set to `start` with `start` then set to `0`.
+ *
+ * **Note:** JavaScript follows the IEEE-754 standard for resolving
+ * floating-point values which can produce unexpected results.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns the range of numbers.
+ * @see _.inRange, _.rangeRight
+ * @example
+ *
+ * _.range(4);
+ * // => [0, 1, 2, 3]
+ *
+ * _.range(-4);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 5);
+ * // => [1, 2, 3, 4]
+ *
+ * _.range(0, 20, 5);
+ * // => [0, 5, 10, 15]
+ *
+ * _.range(0, -4, -1);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */
+var range = _createRange();
+
+/* harmony default export */ const lodash_es_range = (range);
+
+
+/***/ }),
+
+/***/ 89463:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_reduce)
+});
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_arrayReduce.js
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ * the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+ var index = -1,
+ length = array == null ? 0 : array.length;
+
+ if (initAccum && length) {
+ accumulator = array[++index];
+ }
+ while (++index < length) {
+ accumulator = iteratee(accumulator, array[index], index, array);
+ }
+ return accumulator;
+}
+
+/* harmony default export */ const _arrayReduce = (arrayReduce);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseEach.js + 1 modules
+var _baseEach = __webpack_require__(6240);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_baseIteratee.js + 16 modules
+var _baseIteratee = __webpack_require__(49574);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseReduce.js
+/**
+ * The base implementation of `_.reduce` and `_.reduceRight`, without support
+ * for iteratee shorthands, which iterates over `collection` using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} accumulator The initial value.
+ * @param {boolean} initAccum Specify using the first or last element of
+ * `collection` as the initial value.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the accumulated value.
+ */
+function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
+ eachFunc(collection, function(value, index, collection) {
+ accumulator = initAccum
+ ? (initAccum = false, value)
+ : iteratee(accumulator, value, index, collection);
+ });
+ return accumulator;
+}
+
+/* harmony default export */ const _baseReduce = (baseReduce);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/reduce.js
+
+
+
+
+
+
+/**
+ * Reduces `collection` to a value which is the accumulated result of running
+ * each element in `collection` thru `iteratee`, where each successive
+ * invocation is supplied the return value of the previous. If `accumulator`
+ * is not given, the first element of `collection` is used as the initial
+ * value. The iteratee is invoked with four arguments:
+ * (accumulator, value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.reduce`, `_.reduceRight`, and `_.transform`.
+ *
+ * The guarded methods are:
+ * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
+ * and `sortBy`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @returns {*} Returns the accumulated value.
+ * @see _.reduceRight
+ * @example
+ *
+ * _.reduce([1, 2], function(sum, n) {
+ * return sum + n;
+ * }, 0);
+ * // => 3
+ *
+ * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ * (result[value] || (result[value] = [])).push(key);
+ * return result;
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
+ */
+function reduce(collection, iteratee, accumulator) {
+ var func = (0,isArray/* default */.A)(collection) ? _arrayReduce : _baseReduce,
+ initAccum = arguments.length < 3;
+
+ return func(collection, (0,_baseIteratee/* default */.A)(iteratee, 4), accumulator, initAccum, _baseEach/* default */.A);
+}
+
+/* harmony default export */ const lodash_es_reduce = (reduce);
+
+
+/***/ }),
+
+/***/ 13153:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray() {
+ return [];
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (stubArray);
+
+
+/***/ }),
+
+/***/ 74342:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_toFinite)
+});
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_trimmedEndIndex.js
+/** Used to match a single whitespace character. */
+var reWhitespace = /\s/;
+
+/**
+ * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
+ * character of `string`.
+ *
+ * @private
+ * @param {string} string The string to inspect.
+ * @returns {number} Returns the index of the last non-whitespace character.
+ */
+function trimmedEndIndex(string) {
+ var index = string.length;
+
+ while (index-- && reWhitespace.test(string.charAt(index))) {}
+ return index;
+}
+
+/* harmony default export */ const _trimmedEndIndex = (trimmedEndIndex);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseTrim.js
+
+
+/** Used to match leading whitespace. */
+var reTrimStart = /^\s+/;
+
+/**
+ * The base implementation of `_.trim`.
+ *
+ * @private
+ * @param {string} string The string to trim.
+ * @returns {string} Returns the trimmed string.
+ */
+function baseTrim(string) {
+ return string
+ ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
+ : string;
+}
+
+/* harmony default export */ const _baseTrim = (baseTrim);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/isObject.js
+var isObject = __webpack_require__(23149);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isSymbol.js
+var isSymbol = __webpack_require__(61882);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/toNumber.js
+
+
+
+
+/** Used as references for various `Number` constants. */
+var NAN = 0 / 0;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+ if (typeof value == 'number') {
+ return value;
+ }
+ if ((0,isSymbol/* default */.A)(value)) {
+ return NAN;
+ }
+ if ((0,isObject/* default */.A)(value)) {
+ var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+ value = (0,isObject/* default */.A)(other) ? (other + '') : other;
+ }
+ if (typeof value != 'string') {
+ return value === 0 ? value : +value;
+ }
+ value = _baseTrim(value);
+ var isBinary = reIsBinary.test(value);
+ return (isBinary || reIsOctal.test(value))
+ ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+ : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+/* harmony default export */ const lodash_es_toNumber = (toNumber);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/toFinite.js
+
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+ MAX_INTEGER = 1.7976931348623157e+308;
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+ if (!value) {
+ return value === 0 ? value : 0;
+ }
+ value = lodash_es_toNumber(value);
+ if (value === INFINITY || value === -INFINITY) {
+ var sign = (value < 0 ? -1 : 1);
+ return sign * MAX_INTEGER;
+ }
+ return value === value ? value : 0;
+}
+
+/* harmony default export */ const lodash_es_toFinite = (toFinite);
+
+
+/***/ }),
+
+/***/ 28894:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_toString)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_Symbol.js
+var _Symbol = __webpack_require__(241);
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayMap.js
+var _arrayMap = __webpack_require__(45572);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isArray.js
+var isArray = __webpack_require__(92049);
+// EXTERNAL MODULE: ./node_modules/lodash-es/isSymbol.js
+var isSymbol = __webpack_require__(61882);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseToString.js
+
+
+
+
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = _Symbol/* default */.A ? _Symbol/* default */.A.prototype : undefined,
+ symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString(value) {
+ // Exit early for strings to avoid a performance hit in some environments.
+ if (typeof value == 'string') {
+ return value;
+ }
+ if ((0,isArray/* default */.A)(value)) {
+ // Recursively convert values (susceptible to call stack limits).
+ return (0,_arrayMap/* default */.A)(value, baseToString) + '';
+ }
+ if ((0,isSymbol/* default */.A)(value)) {
+ return symbolToString ? symbolToString.call(value) : '';
+ }
+ var result = (value + '');
+ return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
+}
+
+/* harmony default export */ const _baseToString = (baseToString);
+
+;// CONCATENATED MODULE: ./node_modules/lodash-es/toString.js
+
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString_toString(value) {
+ return value == null ? '' : _baseToString(value);
+}
+
+/* harmony default export */ const lodash_es_toString = (toString_toString);
+
+
+/***/ }),
+
+/***/ 5664:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */ A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _toString_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(28894);
+
+
+/** Used to generate unique IDs. */
+var idCounter = 0;
+
+/**
+ * Generates a unique ID. If `prefix` is given, the ID is appended to it.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {string} [prefix=''] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */
+function uniqueId(prefix) {
+ var id = ++idCounter;
+ return (0,_toString_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A)(prefix) + id;
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (uniqueId);
+
+
+/***/ }),
+
+/***/ 38207:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ A: () => (/* binding */ lodash_es_values)
+});
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/_arrayMap.js
+var _arrayMap = __webpack_require__(45572);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/_baseValues.js
+
+
+/**
+ * The base implementation of `_.values` and `_.valuesIn` which creates an
+ * array of `object` property values corresponding to the property names
+ * of `props`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array} props The property names to get values for.
+ * @returns {Object} Returns the array of property values.
+ */
+function baseValues(object, props) {
+ return (0,_arrayMap/* default */.A)(props, function(key) {
+ return object[key];
+ });
+}
+
+/* harmony default export */ const _baseValues = (baseValues);
+
+// EXTERNAL MODULE: ./node_modules/lodash-es/keys.js
+var keys = __webpack_require__(27422);
+;// CONCATENATED MODULE: ./node_modules/lodash-es/values.js
+
+
+
+/**
+ * Creates an array of the own enumerable string keyed property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */
+function values(object) {
+ return object == null ? [] : _baseValues(object, (0,keys/* default */.A)(object));
+}
+
+/* harmony default export */ const lodash_es_values = (values);
+
+
+/***/ }),
+
+/***/ 79001:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+ diagram: () => (/* binding */ diagram)
+});
+
+// EXTERNAL MODULE: ./node_modules/mermaid/dist/mermaid-f47111a7.js + 8 modules
+var mermaid_f47111a7 = __webpack_require__(76257);
+// EXTERNAL MODULE: ./node_modules/dagre-d3-es/src/graphlib/index.js
+var graphlib = __webpack_require__(697);
+// EXTERNAL MODULE: ./node_modules/d3/src/index.js + 197 modules
+var src = __webpack_require__(26312);
+// EXTERNAL MODULE: ./node_modules/dagre-d3-es/src/dagre/index.js + 64 modules
+var dagre = __webpack_require__(21176);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/stringify.js
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+
+const byteToHex = [];
+
+for (let i = 0; i < 256; ++i) {
+ byteToHex.push((i + 0x100).toString(16).slice(1));
+}
+
+function unsafeStringify(arr, offset = 0) {
+ // Note: Be careful editing this code! It's been tuned for performance
+ // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+ return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+
+function stringify(arr, offset = 0) {
+ const uuid = unsafeStringify(arr, offset); // Consistency check for valid UUID. If this throws, it's likely due to one
+ // of the following:
+ // - One or more input array values don't map to a hex octet (leading to
+ // "undefined" in the uuid)
+ // - Invalid input values for the RFC `version` or `variant` fields
+
+ if (!validate(uuid)) {
+ throw TypeError('Stringified UUID is invalid');
+ }
+
+ return uuid;
+}
+
+/* harmony default export */ const esm_node_stringify = ((/* unused pure expression or super */ null && (stringify)));
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/regex.js
+/* harmony default export */ const regex = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/validate.js
+
+
+function validate_validate(uuid) {
+ return typeof uuid === 'string' && regex.test(uuid);
+}
+
+/* harmony default export */ const esm_node_validate = (validate_validate);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/parse.js
+
+
+function parse(uuid) {
+ if (!esm_node_validate(uuid)) {
+ throw TypeError('Invalid UUID');
+ }
+
+ let v;
+ const arr = new Uint8Array(16); // Parse ########-....-....-....-............
+
+ arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+ arr[1] = v >>> 16 & 0xff;
+ arr[2] = v >>> 8 & 0xff;
+ arr[3] = v & 0xff; // Parse ........-####-....-....-............
+
+ arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+ arr[5] = v & 0xff; // Parse ........-....-####-....-............
+
+ arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+ arr[7] = v & 0xff; // Parse ........-....-....-####-............
+
+ arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+ arr[9] = v & 0xff; // Parse ........-....-....-....-############
+ // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+
+ arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
+ arr[11] = v / 0x100000000 & 0xff;
+ arr[12] = v >>> 24 & 0xff;
+ arr[13] = v >>> 16 & 0xff;
+ arr[14] = v >>> 8 & 0xff;
+ arr[15] = v & 0xff;
+ return arr;
+}
+
+/* harmony default export */ const esm_node_parse = (parse);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v35.js
+
+
+
+function stringToBytes(str) {
+ str = unescape(encodeURIComponent(str)); // UTF8 escape
+
+ const bytes = [];
+
+ for (let i = 0; i < str.length; ++i) {
+ bytes.push(str.charCodeAt(i));
+ }
+
+ return bytes;
+}
+
+const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+function v35(name, version, hashfunc) {
+ function generateUUID(value, namespace, buf, offset) {
+ var _namespace;
+
+ if (typeof value === 'string') {
+ value = stringToBytes(value);
+ }
+
+ if (typeof namespace === 'string') {
+ namespace = esm_node_parse(namespace);
+ }
+
+ if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
+ throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+ } // Compute hash of namespace and value, Per 4.3
+ // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
+ // hashfunc([...namespace, ... value])`
+
+
+ let bytes = new Uint8Array(16 + value.length);
+ bytes.set(namespace);
+ bytes.set(value, namespace.length);
+ bytes = hashfunc(bytes);
+ bytes[6] = bytes[6] & 0x0f | version;
+ bytes[8] = bytes[8] & 0x3f | 0x80;
+
+ if (buf) {
+ offset = offset || 0;
+
+ for (let i = 0; i < 16; ++i) {
+ buf[offset + i] = bytes[i];
+ }
+
+ return buf;
+ }
+
+ return unsafeStringify(bytes);
+ } // Function#name is not settable on some platforms (#270)
+
+
+ try {
+ generateUUID.name = name; // eslint-disable-next-line no-empty
+ } catch (err) {} // For CommonJS default export support
+
+
+ generateUUID.DNS = DNS;
+ generateUUID.URL = URL;
+ return generateUUID;
+}
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(76982);
+var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/sha1.js
+
+
+function sha1(bytes) {
+ if (Array.isArray(bytes)) {
+ bytes = Buffer.from(bytes);
+ } else if (typeof bytes === 'string') {
+ bytes = Buffer.from(bytes, 'utf8');
+ }
+
+ return external_crypto_default().createHash('sha1').update(bytes).digest();
+}
+
+/* harmony default export */ const esm_node_sha1 = (sha1);
+;// CONCATENATED MODULE: ./node_modules/uuid/dist/esm-node/v5.js
+
+
+const v5 = v35('v5', 0x50, esm_node_sha1);
+/* harmony default export */ const esm_node_v5 = (v5);
+// EXTERNAL MODULE: ./node_modules/dayjs/dayjs.min.js
+var dayjs_min = __webpack_require__(74353);
+// EXTERNAL MODULE: ./node_modules/@braintree/sanitize-url/dist/index.js
+var dist = __webpack_require__(16750);
+// EXTERNAL MODULE: ./node_modules/dompurify/dist/purify.es.mjs
+var purify_es = __webpack_require__(99418);
+;// CONCATENATED MODULE: ./node_modules/mermaid/dist/erDiagram-47591fe2.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var parser = function() {
+ var o = function(k, v, o2, l) {
+ for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v)
+ ;
+ return o2;
+ }, $V0 = [6, 8, 10, 20, 22, 24, 26, 27, 28], $V1 = [1, 10], $V2 = [1, 11], $V3 = [1, 12], $V4 = [1, 13], $V5 = [1, 14], $V6 = [1, 15], $V7 = [1, 21], $V8 = [1, 22], $V9 = [1, 23], $Va = [1, 24], $Vb = [1, 25], $Vc = [6, 8, 10, 13, 15, 18, 19, 20, 22, 24, 26, 27, 28, 41, 42, 43, 44, 45], $Vd = [1, 34], $Ve = [27, 28, 46, 47], $Vf = [41, 42, 43, 44, 45], $Vg = [17, 34], $Vh = [1, 54], $Vi = [1, 53], $Vj = [17, 34, 36, 38];
+ var parser2 = {
+ trace: function 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, ":": 13, "role": 14, "BLOCK_START": 15, "attributes": 16, "BLOCK_STOP": 17, "SQS": 18, "SQE": 19, "title": 20, "title_value": 21, "acc_title": 22, "acc_title_value": 23, "acc_descr": 24, "acc_descr_value": 25, "acc_descr_multiline_value": 26, "ALPHANUM": 27, "ENTITY_NAME": 28, "attribute": 29, "attributeType": 30, "attributeName": 31, "attributeKeyTypeList": 32, "attributeComment": 33, "ATTRIBUTE_WORD": 34, "attributeKeyType": 35, "COMMA": 36, "ATTRIBUTE_KEY": 37, "COMMENT": 38, "cardinality": 39, "relType": 40, "ZERO_OR_ONE": 41, "ZERO_OR_MORE": 42, "ONE_OR_MORE": 43, "ONLY_ONE": 44, "MD_PARENT": 45, "NON_IDENTIFYING": 46, "IDENTIFYING": 47, "WORD": 48, "$accept": 0, "$end": 1 },
+ terminals_: { 2: "error", 4: "ER_DIAGRAM", 6: "EOF", 8: "SPACE", 10: "NEWLINE", 13: ":", 15: "BLOCK_START", 17: "BLOCK_STOP", 18: "SQS", 19: "SQE", 20: "title", 21: "title_value", 22: "acc_title", 23: "acc_title_value", 24: "acc_descr", 25: "acc_descr_value", 26: "acc_descr_multiline_value", 27: "ALPHANUM", 28: "ENTITY_NAME", 34: "ATTRIBUTE_WORD", 36: "COMMA", 37: "ATTRIBUTE_KEY", 38: "COMMENT", 41: "ZERO_OR_ONE", 42: "ZERO_OR_MORE", 43: "ONE_OR_MORE", 44: "ONLY_ONE", 45: "MD_PARENT", 46: "NON_IDENTIFYING", 47: "IDENTIFYING", 48: "WORD" },
+ productions_: [0, [3, 3], [5, 0], [5, 2], [7, 2], [7, 1], [7, 1], [7, 1], [9, 5], [9, 4], [9, 3], [9, 1], [9, 7], [9, 6], [9, 4], [9, 2], [9, 2], [9, 2], [9, 1], [11, 1], [11, 1], [16, 1], [16, 2], [29, 2], [29, 3], [29, 3], [29, 4], [30, 1], [31, 1], [32, 1], [32, 3], [35, 1], [33, 1], [12, 3], [39, 1], [39, 1], [39, 1], [39, 1], [39, 1], [40, 1], [40, 1], [14, 1], [14, 1], [14, 1]],
+ performAction: 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 - 3]);
+ yy.addAttributes($$[$0 - 3], $$[$0 - 1]);
+ break;
+ case 10:
+ yy.addEntity($$[$0 - 2]);
+ break;
+ case 11:
+ yy.addEntity($$[$0]);
+ break;
+ case 12:
+ yy.addEntity($$[$0 - 6], $$[$0 - 4]);
+ yy.addAttributes($$[$0 - 6], $$[$0 - 1]);
+ break;
+ case 13:
+ yy.addEntity($$[$0 - 5], $$[$0 - 3]);
+ break;
+ case 14:
+ yy.addEntity($$[$0 - 3], $$[$0 - 1]);
+ break;
+ case 15:
+ case 16:
+ this.$ = $$[$0].trim();
+ yy.setAccTitle(this.$);
+ break;
+ case 17:
+ case 18:
+ this.$ = $$[$0].trim();
+ yy.setAccDescription(this.$);
+ break;
+ case 19:
+ case 43:
+ this.$ = $$[$0];
+ break;
+ case 20:
+ case 41:
+ case 42:
+ this.$ = $$[$0].replace(/"/g, "");
+ break;
+ case 21:
+ case 29:
+ this.$ = [$$[$0]];
+ break;
+ case 22:
+ $$[$0].push($$[$0 - 1]);
+ this.$ = $$[$0];
+ break;
+ case 23:
+ this.$ = { attributeType: $$[$0 - 1], attributeName: $$[$0] };
+ break;
+ case 24:
+ this.$ = { attributeType: $$[$0 - 2], attributeName: $$[$0 - 1], attributeKeyTypeList: $$[$0] };
+ break;
+ case 25:
+ this.$ = { attributeType: $$[$0 - 2], attributeName: $$[$0 - 1], attributeComment: $$[$0] };
+ break;
+ case 26:
+ this.$ = { attributeType: $$[$0 - 3], attributeName: $$[$0 - 2], attributeKeyTypeList: $$[$0 - 1], attributeComment: $$[$0] };
+ break;
+ case 27:
+ case 28:
+ case 31:
+ this.$ = $$[$0];
+ break;
+ case 30:
+ $$[$0 - 2].push($$[$0]);
+ this.$ = $$[$0 - 2];
+ break;
+ case 32:
+ this.$ = $$[$0].replace(/"/g, "");
+ break;
+ case 33:
+ this.$ = { cardA: $$[$0], relType: $$[$0 - 1], cardB: $$[$0 - 2] };
+ break;
+ case 34:
+ this.$ = yy.Cardinality.ZERO_OR_ONE;
+ break;
+ case 35:
+ this.$ = yy.Cardinality.ZERO_OR_MORE;
+ break;
+ case 36:
+ this.$ = yy.Cardinality.ONE_OR_MORE;
+ break;
+ case 37:
+ this.$ = yy.Cardinality.ONLY_ONE;
+ break;
+ case 38:
+ this.$ = yy.Cardinality.MD_PARENT;
+ break;
+ case 39:
+ this.$ = yy.Identification.NON_IDENTIFYING;
+ break;
+ case 40:
+ this.$ = yy.Identification.IDENTIFYING;
+ break;
+ }
+ },
+ table: [{ 3: 1, 4: [1, 2] }, { 1: [3] }, o($V0, [2, 2], { 5: 3 }), { 6: [1, 4], 7: 5, 8: [1, 6], 9: 7, 10: [1, 8], 11: 9, 20: $V1, 22: $V2, 24: $V3, 26: $V4, 27: $V5, 28: $V6 }, o($V0, [2, 7], { 1: [2, 1] }), o($V0, [2, 3]), { 9: 16, 11: 9, 20: $V1, 22: $V2, 24: $V3, 26: $V4, 27: $V5, 28: $V6 }, o($V0, [2, 5]), o($V0, [2, 6]), o($V0, [2, 11], { 12: 17, 39: 20, 15: [1, 18], 18: [1, 19], 41: $V7, 42: $V8, 43: $V9, 44: $Va, 45: $Vb }), { 21: [1, 26] }, { 23: [1, 27] }, { 25: [1, 28] }, o($V0, [2, 18]), o($Vc, [2, 19]), o($Vc, [2, 20]), o($V0, [2, 4]), { 11: 29, 27: $V5, 28: $V6 }, { 16: 30, 17: [1, 31], 29: 32, 30: 33, 34: $Vd }, { 11: 35, 27: $V5, 28: $V6 }, { 40: 36, 46: [1, 37], 47: [1, 38] }, o($Ve, [2, 34]), o($Ve, [2, 35]), o($Ve, [2, 36]), o($Ve, [2, 37]), o($Ve, [2, 38]), o($V0, [2, 15]), o($V0, [2, 16]), o($V0, [2, 17]), { 13: [1, 39] }, { 17: [1, 40] }, o($V0, [2, 10]), { 16: 41, 17: [2, 21], 29: 32, 30: 33, 34: $Vd }, { 31: 42, 34: [1, 43] }, { 34: [2, 27] }, { 19: [1, 44] }, { 39: 45, 41: $V7, 42: $V8, 43: $V9, 44: $Va, 45: $Vb }, o($Vf, [2, 39]), o($Vf, [2, 40]), { 14: 46, 27: [1, 49], 28: [1, 48], 48: [1, 47] }, o($V0, [2, 9]), { 17: [2, 22] }, o($Vg, [2, 23], { 32: 50, 33: 51, 35: 52, 37: $Vh, 38: $Vi }), o([17, 34, 37, 38], [2, 28]), o($V0, [2, 14], { 15: [1, 55] }), o([27, 28], [2, 33]), o($V0, [2, 8]), o($V0, [2, 41]), o($V0, [2, 42]), o($V0, [2, 43]), o($Vg, [2, 24], { 33: 56, 36: [1, 57], 38: $Vi }), o($Vg, [2, 25]), o($Vj, [2, 29]), o($Vg, [2, 32]), o($Vj, [2, 31]), { 16: 58, 17: [1, 59], 29: 32, 30: 33, 34: $Vd }, o($Vg, [2, 26]), { 35: 60, 37: $Vh }, { 17: [1, 61] }, o($V0, [2, 13]), o($Vj, [2, 30]), o($V0, [2, 12])],
+ defaultActions: { 34: [2, 27], 41: [2, 22] },
+ parseError: function parseError(str, hash) {
+ if (hash.recoverable) {
+ this.trace(str);
+ } else {
+ var error = new Error(str);
+ error.hash = hash;
+ throw error;
+ }
+ },
+ parse: function parse(input) {
+ var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, TERROR = 2, EOF = 1;
+ var args = lstack.slice.call(arguments, 1);
+ var lexer2 = Object.create(this.lexer);
+ var sharedState = { yy: {} };
+ for (var k in this.yy) {
+ if (Object.prototype.hasOwnProperty.call(this.yy, k)) {
+ sharedState.yy[k] = this.yy[k];
+ }
+ }
+ 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 lex() {
+ var token;
+ token = tstack.pop() || lexer2.lex() || EOF;
+ if (typeof token !== "number") {
+ if (token instanceof Array) {
+ tstack = token;
+ token = tstack.pop();
+ }
+ token = self.symbols_[token] || token;
+ }
+ return token;
+ }
+ var symbol, state, action, r, yyval = {}, p, len, newState, expected;
+ while (true) {
+ state = stack[stack.length - 1];
+ if (this.defaultActions[state]) {
+ action = this.defaultActions[state];
+ } else {
+ if (symbol === null || typeof symbol == "undefined") {
+ symbol = lex();
+ }
+ action = table[state] && table[state][symbol];
+ }
+ if (typeof action === "undefined" || !action.length || !action[0]) {
+ var errStr = "";
+ expected = [];
+ for (p in table[state]) {
+ if (this.terminals_[p] && p > TERROR) {
+ expected.push("'" + this.terminals_[p] + "'");
+ }
+ }
+ 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 == EOF ? "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: " + state + ", token: " + symbol);
+ }
+ switch (action[0]) {
+ case 1:
+ stack.push(symbol);
+ vstack.push(lexer2.yytext);
+ lstack.push(lexer2.yylloc);
+ stack.push(action[1]);
+ symbol = null;
+ {
+ yyleng = lexer2.yyleng;
+ yytext = lexer2.yytext;
+ yylineno = lexer2.yylineno;
+ yyloc = lexer2.yylloc;
+ }
+ 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]
+ ];
+ }
+ r = this.performAction.apply(yyval, [
+ yytext,
+ yyleng,
+ yylineno,
+ sharedState.yy,
+ action[1],
+ vstack,
+ lstack
+ ].concat(args));
+ if (typeof r !== "undefined") {
+ return r;
+ }
+ 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._$);
+ newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+ stack.push(newState);
+ break;
+ case 3:
+ return true;
+ }
+ }
+ return true;
+ }
+ };
+ var lexer = function() {
+ var lexer2 = {
+ EOF: 1,
+ parseError: function parseError(str, hash) {
+ if (this.yy.parser) {
+ this.yy.parser.parseError(str, hash);
+ } else {
+ throw new Error(str);
+ }
+ },
+ // resets the lexer, sets new input
+ setInput: 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;
+ },
+ // consumes and returns one char from the input
+ input: 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;
+ },
+ // unshifts one char (or a string) into the input
+ unput: 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 r = 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 = [r[0], r[0] + this.yyleng - len];
+ }
+ this.yyleng = this.yytext.length;
+ return this;
+ },
+ // When called from action, caches matched text and appends it on next action
+ more: function() {
+ this._more = true;
+ return this;
+ },
+ // 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: 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;
+ },
+ // retain first n characters of the match
+ less: function(n) {
+ this.unput(this.match.slice(n));
+ },
+ // displays already matched input, i.e. for error messages
+ pastInput: function() {
+ var past = this.matched.substr(0, this.matched.length - this.match.length);
+ return (past.length > 20 ? "..." : "") + past.substr(-20).replace(/\n/g, "");
+ },
+ // displays upcoming input, i.e. for error messages
+ upcomingInput: function() {
+ var next = this.match;
+ if (next.length < 20) {
+ next += this._input.substr(0, 20 - next.length);
+ }
+ return (next.substr(0, 20) + (next.length > 20 ? "..." : "")).replace(/\n/g, "");
+ },
+ // displays the character position where the lexing error occurred, i.e. for error messages
+ showPosition: function() {
+ var pre = this.pastInput();
+ var c = new Array(pre.length + 1).join("-");
+ return pre + this.upcomingInput() + "\n" + c + "^";
+ },
+ // test the lexed token: return FALSE when not a match, otherwise return token
+ test_match: function(match, indexed_rule) {
+ var token, 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 = match[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 + match[0].length
+ };
+ this.yytext += match[0];
+ this.match += match[0];
+ this.matches = match;
+ 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(match[0].length);
+ this.matched += match[0];
+ token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);
+ if (this.done && this._input) {
+ this.done = false;
+ }
+ if (token) {
+ return token;
+ } else if (this._backtrack) {
+ for (var k in backup) {
+ this[k] = backup[k];
+ }
+ return false;
+ }
+ return false;
+ },
+ // return next match in input
+ next: function() {
+ if (this.done) {
+ return this.EOF;
+ }
+ if (!this._input) {
+ this.done = true;
+ }
+ var token, match, tempMatch, index;
+ if (!this._more) {
+ this.yytext = "";
+ this.match = "";
+ }
+ var rules = this._currentRules();
+ for (var i = 0; i < rules.length; i++) {
+ tempMatch = this._input.match(this.rules[rules[i]]);
+ if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+ match = tempMatch;
+ index = i;
+ if (this.options.backtrack_lexer) {
+ token = this.test_match(tempMatch, rules[i]);
+ if (token !== false) {
+ return token;
+ } else if (this._backtrack) {
+ match = false;
+ continue;
+ } else {
+ return false;
+ }
+ } else if (!this.options.flex) {
+ break;
+ }
+ }
+ }
+ if (match) {
+ token = this.test_match(match, rules[index]);
+ if (token !== false) {
+ return token;
+ }
+ 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
+ });
+ }
+ },
+ // return next match that has a token
+ lex: function lex() {
+ var r = this.next();
+ if (r) {
+ return r;
+ } else {
+ return this.lex();
+ }
+ },
+ // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
+ begin: function begin(condition) {
+ this.conditionStack.push(condition);
+ },
+ // pop the previously active lexer condition state off the condition stack
+ popState: function popState() {
+ var n = this.conditionStack.length - 1;
+ if (n > 0) {
+ return this.conditionStack.pop();
+ } else {
+ return this.conditionStack[0];
+ }
+ },
+ // produce the lexer rule set which is active for the currently active lexer condition state
+ _currentRules: 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;
+ }
+ },
+ // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
+ topState: function topState(n) {
+ n = this.conditionStack.length - 1 - Math.abs(n || 0);
+ if (n >= 0) {
+ return this.conditionStack[n];
+ } else {
+ return "INITIAL";
+ }
+ },
+ // alias for begin(condition)
+ pushState: function pushState(condition) {
+ this.begin(condition);
+ },
+ // return the number of states currently on the stack
+ stateStackSize: function stateStackSize() {
+ return this.conditionStack.length;
+ },
+ options: { "case-insensitive": true },
+ performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
+ switch ($avoiding_name_collisions) {
+ case 0:
+ this.begin("acc_title");
+ return 22;
+ case 1:
+ this.popState();
+ return "acc_title_value";
+ case 2:
+ this.begin("acc_descr");
+ return 24;
+ case 3:
+ this.popState();
+ return "acc_descr_value";
+ case 4:
+ this.begin("acc_descr_multiline");
+ break;
+ case 5:
+ this.popState();
+ break;
+ case 6:
+ return "acc_descr_multiline_value";
+ case 7:
+ return 10;
+ case 8:
+ break;
+ case 9:
+ return 8;
+ case 10:
+ return 28;
+ case 11:
+ return 48;
+ case 12:
+ return 4;
+ case 13:
+ this.begin("block");
+ return 15;
+ case 14:
+ return 36;
+ case 15:
+ break;
+ case 16:
+ return 37;
+ case 17:
+ return 34;
+ case 18:
+ return 34;
+ case 19:
+ return 38;
+ case 20:
+ break;
+ case 21:
+ this.popState();
+ return 17;
+ case 22:
+ return yy_.yytext[0];
+ case 23:
+ return 18;
+ case 24:
+ return 19;
+ case 25:
+ return 41;
+ case 26:
+ return 43;
+ case 27:
+ return 43;
+ case 28:
+ return 43;
+ case 29:
+ return 41;
+ case 30:
+ return 41;
+ case 31:
+ return 42;
+ case 32:
+ return 42;
+ case 33:
+ return 42;
+ case 34:
+ return 42;
+ case 35:
+ return 42;
+ case 36:
+ return 43;
+ case 37:
+ return 42;
+ case 38:
+ return 43;
+ case 39:
+ return 44;
+ case 40:
+ return 44;
+ case 41:
+ return 44;
+ case 42:
+ return 44;
+ case 43:
+ return 41;
+ case 44:
+ return 42;
+ case 45:
+ return 43;
+ case 46:
+ return 45;
+ case 47:
+ return 46;
+ case 48:
+ return 47;
+ case 49:
+ return 47;
+ case 50:
+ return 46;
+ case 51:
+ return 46;
+ case 52:
+ return 46;
+ case 53:
+ return 27;
+ case 54:
+ return yy_.yytext[0];
+ case 55:
+ return 6;
+ }
+ },
+ rules: [/^(?:accTitle\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*:\s*)/i, /^(?:(?!\n||)*[^\n]*)/i, /^(?:accDescr\s*\{\s*)/i, /^(?:[\}])/i, /^(?:[^\}]*)/i, /^(?:[\n]+)/i, /^(?:\s+)/i, /^(?:[\s]+)/i, /^(?:"[^"%\r\n\v\b\\]+")/i, /^(?:"[^"]*")/i, /^(?:erDiagram\b)/i, /^(?:\{)/i, /^(?:,)/i, /^(?:\s+)/i, /^(?:\b((?:PK)|(?:FK)|(?:UK))\b)/i, /^(?:(.*?)[~](.*?)*[~])/i, /^(?:[\*A-Za-z_][A-Za-z0-9\-_\[\]\(\)]*)/i, /^(?:"[^"]*")/i, /^(?:[\n]+)/i, /^(?:\})/i, /^(?:.)/i, /^(?:\[)/i, /^(?:\])/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, /^(?:[A-Za-z_][A-Za-z0-9\-_]*)/i, /^(?:.)/i, /^(?:$)/i],
+ conditions: { "acc_descr_multiline": { "rules": [5, 6], "inclusive": false }, "acc_descr": { "rules": [3], "inclusive": false }, "acc_title": { "rules": [1], "inclusive": false }, "block": { "rules": [14, 15, 16, 17, 18, 19, 20, 21, 22], "inclusive": false }, "INITIAL": { "rules": [0, 2, 4, 7, 8, 9, 10, 11, 12, 13, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55], "inclusive": true } }
+ };
+ return lexer2;
+ }();
+ parser2.lexer = lexer;
+ function Parser() {
+ this.yy = {};
+ }
+ Parser.prototype = parser2;
+ parser2.Parser = Parser;
+ return new Parser();
+}();
+parser.parser = parser;
+const erParser = parser;
+let entities = {};
+let relationships = [];
+const 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"
+};
+const Identification = {
+ NON_IDENTIFYING: "NON_IDENTIFYING",
+ IDENTIFYING: "IDENTIFYING"
+};
+const addEntity = function(name, alias = void 0) {
+ if (entities[name] === void 0) {
+ entities[name] = { attributes: [], alias };
+ mermaid_f47111a7.l.info("Added new entity :", name);
+ } else if (entities[name] && !entities[name].alias && alias) {
+ entities[name].alias = alias;
+ mermaid_f47111a7.l.info(`Add alias '${alias}' to entity '${name}'`);
+ }
+ return entities[name];
+};
+const getEntities = () => entities;
+const addAttributes = function(entityName, attribs) {
+ let entity = addEntity(entityName);
+ let i;
+ for (i = attribs.length - 1; i >= 0; i--) {
+ entity.attributes.push(attribs[i]);
+ mermaid_f47111a7.l.debug("Added attribute ", attribs[i].attributeName);
+ }
+};
+const addRelationship = function(entA, rolA, entB, rSpec) {
+ let rel = {
+ entityA: entA,
+ roleA: rolA,
+ entityB: entB,
+ relSpec: rSpec
+ };
+ relationships.push(rel);
+ mermaid_f47111a7.l.debug("Added new relationship :", rel);
+};
+const getRelationships = () => relationships;
+const clear = function() {
+ entities = {};
+ relationships = [];
+ (0,mermaid_f47111a7.v)();
+};
+const erDb = {
+ Cardinality,
+ Identification,
+ getConfig: () => (0,mermaid_f47111a7.c)().er,
+ addEntity,
+ addAttributes,
+ getEntities,
+ addRelationship,
+ getRelationships,
+ clear,
+ setAccTitle: mermaid_f47111a7.s,
+ getAccTitle: mermaid_f47111a7.g,
+ setAccDescription: mermaid_f47111a7.b,
+ getAccDescription: mermaid_f47111a7.a,
+ setDiagramTitle: mermaid_f47111a7.q,
+ getDiagramTitle: mermaid_f47111a7.t
+};
+const ERMarkers = {
+ ONLY_ONE_START: "ONLY_ONE_START",
+ ONLY_ONE_END: "ONLY_ONE_END",
+ ZERO_OR_ONE_START: "ZERO_OR_ONE_START",
+ ZERO_OR_ONE_END: "ZERO_OR_ONE_END",
+ ONE_OR_MORE_START: "ONE_OR_MORE_START",
+ ONE_OR_MORE_END: "ONE_OR_MORE_END",
+ ZERO_OR_MORE_START: "ZERO_OR_MORE_START",
+ ZERO_OR_MORE_END: "ZERO_OR_MORE_END",
+ MD_PARENT_END: "MD_PARENT_END",
+ MD_PARENT_START: "MD_PARENT_START"
+};
+const insertMarkers = function(elem, conf2) {
+ let marker;
+ elem.append("defs").append("marker").attr("id", ERMarkers.MD_PARENT_START).attr("refX", 0).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", ERMarkers.MD_PARENT_END).attr("refX", 19).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");
+ elem.append("defs").append("marker").attr("id", ERMarkers.ONLY_ONE_START).attr("refX", 0).attr("refY", 9).attr("markerWidth", 18).attr("markerHeight", 18).attr("orient", "auto").append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M9,0 L9,18 M15,0 L15,18");
+ elem.append("defs").append("marker").attr("id", ERMarkers.ONLY_ONE_END).attr("refX", 18).attr("refY", 9).attr("markerWidth", 18).attr("markerHeight", 18).attr("orient", "auto").append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M3,0 L3,18 M9,0 L9,18");
+ marker = elem.append("defs").append("marker").attr("id", ERMarkers.ZERO_OR_ONE_START).attr("refX", 0).attr("refY", 9).attr("markerWidth", 30).attr("markerHeight", 18).attr("orient", "auto");
+ marker.append("circle").attr("stroke", conf2.stroke).attr("fill", "white").attr("cx", 21).attr("cy", 9).attr("r", 6);
+ marker.append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M9,0 L9,18");
+ marker = elem.append("defs").append("marker").attr("id", ERMarkers.ZERO_OR_ONE_END).attr("refX", 30).attr("refY", 9).attr("markerWidth", 30).attr("markerHeight", 18).attr("orient", "auto");
+ marker.append("circle").attr("stroke", conf2.stroke).attr("fill", "white").attr("cx", 9).attr("cy", 9).attr("r", 6);
+ marker.append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M21,0 L21,18");
+ elem.append("defs").append("marker").attr("id", ERMarkers.ONE_OR_MORE_START).attr("refX", 18).attr("refY", 18).attr("markerWidth", 45).attr("markerHeight", 36).attr("orient", "auto").append("path").attr("stroke", conf2.stroke).attr("fill", "none").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", ERMarkers.ONE_OR_MORE_END).attr("refX", 27).attr("refY", 18).attr("markerWidth", 45).attr("markerHeight", 36).attr("orient", "auto").append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M3,9 L3,27 M9,18 Q27,0 45,18 Q27,36 9,18");
+ marker = elem.append("defs").append("marker").attr("id", ERMarkers.ZERO_OR_MORE_START).attr("refX", 18).attr("refY", 18).attr("markerWidth", 57).attr("markerHeight", 36).attr("orient", "auto");
+ marker.append("circle").attr("stroke", conf2.stroke).attr("fill", "white").attr("cx", 48).attr("cy", 18).attr("r", 6);
+ marker.append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M0,18 Q18,0 36,18 Q18,36 0,18");
+ marker = elem.append("defs").append("marker").attr("id", ERMarkers.ZERO_OR_MORE_END).attr("refX", 39).attr("refY", 18).attr("markerWidth", 57).attr("markerHeight", 36).attr("orient", "auto");
+ marker.append("circle").attr("stroke", conf2.stroke).attr("fill", "white").attr("cx", 9).attr("cy", 18).attr("r", 6);
+ marker.append("path").attr("stroke", conf2.stroke).attr("fill", "none").attr("d", "M21,18 Q39,0 57,18 Q39,36 21,18");
+ return;
+};
+const erMarkers = {
+ ERMarkers,
+ insertMarkers
+};
+const BAD_ID_CHARS_REGEXP = /[^\dA-Za-z](\W)*/g;
+let conf = {};
+let entityNameIds = /* @__PURE__ */ new Map();
+const setConf = function(cnf) {
+ const keys = Object.keys(cnf);
+ for (const key of keys) {
+ conf[key] = cnf[key];
+ }
+};
+const drawAttributes = (groupNode, entityTextNode, attributes) => {
+ const heightPadding = conf.entityPadding / 3;
+ const widthPadding = conf.entityPadding / 3;
+ const attrFontSize = conf.fontSize * 0.85;
+ const labelBBox = entityTextNode.node().getBBox();
+ const attributeNodes = [];
+ let hasKeyType = false;
+ let hasComment = false;
+ let maxTypeWidth = 0;
+ let maxNameWidth = 0;
+ let maxKeyWidth = 0;
+ let maxCommentWidth = 0;
+ let cumulativeHeight = labelBBox.height + heightPadding * 2;
+ let attrNum = 1;
+ attributes.forEach((item) => {
+ if (item.attributeKeyTypeList !== void 0 && item.attributeKeyTypeList.length > 0) {
+ hasKeyType = true;
+ }
+ if (item.attributeComment !== void 0) {
+ hasComment = true;
+ }
+ });
+ attributes.forEach((item) => {
+ const attrPrefix = `${entityTextNode.node().id}-attr-${attrNum}`;
+ let nodeHeight = 0;
+ const attributeType = (0,mermaid_f47111a7.x)(item.attributeType);
+ const typeNode = groupNode.append("text").classed("er entityLabel", true).attr("id", `${attrPrefix}-type`).attr("x", 0).attr("y", 0).style("dominant-baseline", "middle").style("text-anchor", "left").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", attrFontSize + "px").text(attributeType);
+ const nameNode = groupNode.append("text").classed("er entityLabel", true).attr("id", `${attrPrefix}-name`).attr("x", 0).attr("y", 0).style("dominant-baseline", "middle").style("text-anchor", "left").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", attrFontSize + "px").text(item.attributeName);
+ const attributeNode = {};
+ attributeNode.tn = typeNode;
+ attributeNode.nn = nameNode;
+ const typeBBox = typeNode.node().getBBox();
+ const nameBBox = nameNode.node().getBBox();
+ maxTypeWidth = Math.max(maxTypeWidth, typeBBox.width);
+ maxNameWidth = Math.max(maxNameWidth, nameBBox.width);
+ nodeHeight = Math.max(typeBBox.height, nameBBox.height);
+ if (hasKeyType) {
+ const keyTypeNodeText = item.attributeKeyTypeList !== void 0 ? item.attributeKeyTypeList.join(",") : "";
+ const keyTypeNode = groupNode.append("text").classed("er entityLabel", true).attr("id", `${attrPrefix}-key`).attr("x", 0).attr("y", 0).style("dominant-baseline", "middle").style("text-anchor", "left").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", attrFontSize + "px").text(keyTypeNodeText);
+ attributeNode.kn = keyTypeNode;
+ const keyTypeBBox = keyTypeNode.node().getBBox();
+ maxKeyWidth = Math.max(maxKeyWidth, keyTypeBBox.width);
+ nodeHeight = Math.max(nodeHeight, keyTypeBBox.height);
+ }
+ if (hasComment) {
+ const commentNode = groupNode.append("text").classed("er entityLabel", true).attr("id", `${attrPrefix}-comment`).attr("x", 0).attr("y", 0).style("dominant-baseline", "middle").style("text-anchor", "left").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", attrFontSize + "px").text(item.attributeComment || "");
+ attributeNode.cn = commentNode;
+ const commentNodeBBox = commentNode.node().getBBox();
+ maxCommentWidth = Math.max(maxCommentWidth, commentNodeBBox.width);
+ nodeHeight = Math.max(nodeHeight, commentNodeBBox.height);
+ }
+ attributeNode.height = nodeHeight;
+ attributeNodes.push(attributeNode);
+ cumulativeHeight += nodeHeight + heightPadding * 2;
+ attrNum += 1;
+ });
+ let widthPaddingFactor = 4;
+ if (hasKeyType) {
+ widthPaddingFactor += 2;
+ }
+ if (hasComment) {
+ widthPaddingFactor += 2;
+ }
+ const maxWidth = maxTypeWidth + maxNameWidth + maxKeyWidth + maxCommentWidth;
+ const bBox = {
+ width: Math.max(
+ conf.minEntityWidth,
+ Math.max(
+ labelBBox.width + conf.entityPadding * 2,
+ maxWidth + widthPadding * widthPaddingFactor
+ )
+ ),
+ height: attributes.length > 0 ? cumulativeHeight : Math.max(conf.minEntityHeight, labelBBox.height + conf.entityPadding * 2)
+ };
+ if (attributes.length > 0) {
+ const spareColumnWidth = Math.max(
+ 0,
+ (bBox.width - maxWidth - widthPadding * widthPaddingFactor) / (widthPaddingFactor / 2)
+ );
+ entityTextNode.attr(
+ "transform",
+ "translate(" + bBox.width / 2 + "," + (heightPadding + labelBBox.height / 2) + ")"
+ );
+ let heightOffset = labelBBox.height + heightPadding * 2;
+ let attribStyle = "attributeBoxOdd";
+ attributeNodes.forEach((attributeNode) => {
+ const alignY = heightOffset + heightPadding + attributeNode.height / 2;
+ attributeNode.tn.attr("transform", "translate(" + widthPadding + "," + alignY + ")");
+ const typeRect = groupNode.insert("rect", "#" + attributeNode.tn.node().id).classed(`er ${attribStyle}`, true).attr("x", 0).attr("y", heightOffset).attr("width", maxTypeWidth + widthPadding * 2 + spareColumnWidth).attr("height", attributeNode.height + heightPadding * 2);
+ const nameXOffset = parseFloat(typeRect.attr("x")) + parseFloat(typeRect.attr("width"));
+ attributeNode.nn.attr(
+ "transform",
+ "translate(" + (nameXOffset + widthPadding) + "," + alignY + ")"
+ );
+ const nameRect = groupNode.insert("rect", "#" + attributeNode.nn.node().id).classed(`er ${attribStyle}`, true).attr("x", nameXOffset).attr("y", heightOffset).attr("width", maxNameWidth + widthPadding * 2 + spareColumnWidth).attr("height", attributeNode.height + heightPadding * 2);
+ let keyTypeAndCommentXOffset = parseFloat(nameRect.attr("x")) + parseFloat(nameRect.attr("width"));
+ if (hasKeyType) {
+ attributeNode.kn.attr(
+ "transform",
+ "translate(" + (keyTypeAndCommentXOffset + widthPadding) + "," + alignY + ")"
+ );
+ const keyTypeRect = groupNode.insert("rect", "#" + attributeNode.kn.node().id).classed(`er ${attribStyle}`, true).attr("x", keyTypeAndCommentXOffset).attr("y", heightOffset).attr("width", maxKeyWidth + widthPadding * 2 + spareColumnWidth).attr("height", attributeNode.height + heightPadding * 2);
+ keyTypeAndCommentXOffset = parseFloat(keyTypeRect.attr("x")) + parseFloat(keyTypeRect.attr("width"));
+ }
+ if (hasComment) {
+ attributeNode.cn.attr(
+ "transform",
+ "translate(" + (keyTypeAndCommentXOffset + widthPadding) + "," + alignY + ")"
+ );
+ groupNode.insert("rect", "#" + attributeNode.cn.node().id).classed(`er ${attribStyle}`, "true").attr("x", keyTypeAndCommentXOffset).attr("y", heightOffset).attr("width", maxCommentWidth + widthPadding * 2 + spareColumnWidth).attr("height", attributeNode.height + heightPadding * 2);
+ }
+ heightOffset += attributeNode.height + heightPadding * 2;
+ attribStyle = attribStyle === "attributeBoxOdd" ? "attributeBoxEven" : "attributeBoxOdd";
+ });
+ } else {
+ bBox.height = Math.max(conf.minEntityHeight, cumulativeHeight);
+ entityTextNode.attr("transform", "translate(" + bBox.width / 2 + "," + bBox.height / 2 + ")");
+ }
+ return bBox;
+};
+const drawEntities = function(svgNode, entities2, graph) {
+ const keys = Object.keys(entities2);
+ let firstOne;
+ keys.forEach(function(entityName) {
+ const entityId = generateId(entityName, "entity");
+ entityNameIds.set(entityName, entityId);
+ const groupNode = svgNode.append("g").attr("id", entityId);
+ firstOne = firstOne === void 0 ? entityId : firstOne;
+ const textId = "text-" + entityId;
+ const textNode = groupNode.append("text").classed("er entityLabel", true).attr("id", textId).attr("x", 0).attr("y", 0).style("dominant-baseline", "middle").style("text-anchor", "middle").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", conf.fontSize + "px").text(entities2[entityName].alias ?? entityName);
+ const { width: entityWidth, height: entityHeight } = drawAttributes(
+ groupNode,
+ textNode,
+ entities2[entityName].attributes
+ );
+ const rectNode = groupNode.insert("rect", "#" + textId).classed("er entityBox", true).attr("x", 0).attr("y", 0).attr("width", entityWidth).attr("height", entityHeight);
+ const rectBBox = rectNode.node().getBBox();
+ graph.setNode(entityId, {
+ width: rectBBox.width,
+ height: rectBBox.height,
+ shape: "rect",
+ id: entityId
+ });
+ });
+ return firstOne;
+};
+const adjustEntities = function(svgNode, graph) {
+ graph.nodes().forEach(function(v) {
+ if (v !== void 0 && graph.node(v) !== void 0) {
+ svgNode.select("#" + v).attr(
+ "transform",
+ "translate(" + (graph.node(v).x - graph.node(v).width / 2) + "," + (graph.node(v).y - graph.node(v).height / 2) + " )"
+ );
+ }
+ });
+};
+const getEdgeName = function(rel) {
+ return (rel.entityA + rel.roleA + rel.entityB).replace(/\s/g, "");
+};
+const addRelationships = function(relationships2, g) {
+ relationships2.forEach(function(r) {
+ g.setEdge(
+ entityNameIds.get(r.entityA),
+ entityNameIds.get(r.entityB),
+ { relationship: r },
+ getEdgeName(r)
+ );
+ });
+ return relationships2;
+};
+let relCnt = 0;
+const drawRelationshipFromLayout = function(svg, rel, g, insert, diagObj) {
+ relCnt++;
+ const edge = g.edge(
+ entityNameIds.get(rel.entityA),
+ entityNameIds.get(rel.entityB),
+ getEdgeName(rel)
+ );
+ const lineFunction = (0,src/* line */.n8j)().x(function(d) {
+ return d.x;
+ }).y(function(d) {
+ return d.y;
+ }).curve(src/* curveBasis */.qrM);
+ const svgPath = svg.insert("path", "#" + insert).classed("er relationshipLine", true).attr("d", lineFunction(edge.points)).style("stroke", conf.stroke).style("fill", "none");
+ if (rel.relSpec.relType === diagObj.db.Identification.NON_IDENTIFYING) {
+ svgPath.attr("stroke-dasharray", "8,8");
+ }
+ let url = "";
+ if (conf.arrowMarkerAbsolute) {
+ url = window.location.protocol + "//" + window.location.host + window.location.pathname + window.location.search;
+ url = url.replace(/\(/g, "\\(");
+ url = url.replace(/\)/g, "\\)");
+ }
+ switch (rel.relSpec.cardA) {
+ case diagObj.db.Cardinality.ZERO_OR_ONE:
+ svgPath.attr("marker-end", "url(" + url + "#" + erMarkers.ERMarkers.ZERO_OR_ONE_END + ")");
+ break;
+ case diagObj.db.Cardinality.ZERO_OR_MORE:
+ svgPath.attr("marker-end", "url(" + url + "#" + erMarkers.ERMarkers.ZERO_OR_MORE_END + ")");
+ break;
+ case diagObj.db.Cardinality.ONE_OR_MORE:
+ svgPath.attr("marker-end", "url(" + url + "#" + erMarkers.ERMarkers.ONE_OR_MORE_END + ")");
+ break;
+ case diagObj.db.Cardinality.ONLY_ONE:
+ svgPath.attr("marker-end", "url(" + url + "#" + erMarkers.ERMarkers.ONLY_ONE_END + ")");
+ break;
+ case diagObj.db.Cardinality.MD_PARENT:
+ svgPath.attr("marker-end", "url(" + url + "#" + erMarkers.ERMarkers.MD_PARENT_END + ")");
+ break;
+ }
+ switch (rel.relSpec.cardB) {
+ case diagObj.db.Cardinality.ZERO_OR_ONE:
+ svgPath.attr(
+ "marker-start",
+ "url(" + url + "#" + erMarkers.ERMarkers.ZERO_OR_ONE_START + ")"
+ );
+ break;
+ case diagObj.db.Cardinality.ZERO_OR_MORE:
+ svgPath.attr(
+ "marker-start",
+ "url(" + url + "#" + erMarkers.ERMarkers.ZERO_OR_MORE_START + ")"
+ );
+ break;
+ case diagObj.db.Cardinality.ONE_OR_MORE:
+ svgPath.attr(
+ "marker-start",
+ "url(" + url + "#" + erMarkers.ERMarkers.ONE_OR_MORE_START + ")"
+ );
+ break;
+ case diagObj.db.Cardinality.ONLY_ONE:
+ svgPath.attr("marker-start", "url(" + url + "#" + erMarkers.ERMarkers.ONLY_ONE_START + ")");
+ break;
+ case diagObj.db.Cardinality.MD_PARENT:
+ svgPath.attr("marker-start", "url(" + url + "#" + erMarkers.ERMarkers.MD_PARENT_START + ")");
+ break;
+ }
+ const len = svgPath.node().getTotalLength();
+ const labelPoint = svgPath.node().getPointAtLength(len * 0.5);
+ const labelId = "rel" + relCnt;
+ const labelNode = svg.append("text").classed("er relationshipLabel", true).attr("id", labelId).attr("x", labelPoint.x).attr("y", labelPoint.y).style("text-anchor", "middle").style("dominant-baseline", "middle").style("font-family", (0,mermaid_f47111a7.c)().fontFamily).style("font-size", conf.fontSize + "px").text(rel.roleA);
+ const labelBBox = labelNode.node().getBBox();
+ svg.insert("rect", "#" + labelId).classed("er relationshipLabelBox", true).attr("x", labelPoint.x - labelBBox.width / 2).attr("y", labelPoint.y - labelBBox.height / 2).attr("width", labelBBox.width).attr("height", labelBBox.height);
+};
+const draw = function(text, id, _version, diagObj) {
+ conf = (0,mermaid_f47111a7.c)().er;
+ mermaid_f47111a7.l.info("Drawing ER diagram");
+ const securityLevel = (0,mermaid_f47111a7.c)().securityLevel;
+ let sandboxElement;
+ if (securityLevel === "sandbox") {
+ sandboxElement = (0,src/* select */.Ltv)("#i" + id);
+ }
+ const root = securityLevel === "sandbox" ? (0,src/* select */.Ltv)(sandboxElement.nodes()[0].contentDocument.body) : (0,src/* select */.Ltv)("body");
+ const svg = root.select(`[id='${id}']`);
+ erMarkers.insertMarkers(svg, conf);
+ let g;
+ g = new graphlib/* Graph */.T({
+ multigraph: true,
+ directed: true,
+ compound: false
+ }).setGraph({
+ rankdir: conf.layoutDirection,
+ marginx: 20,
+ marginy: 20,
+ nodesep: 100,
+ edgesep: 100,
+ ranksep: 100
+ }).setDefaultEdgeLabel(function() {
+ return {};
+ });
+ const firstEntity = drawEntities(svg, diagObj.db.getEntities(), g);
+ const relationships2 = addRelationships(diagObj.db.getRelationships(), g);
+ (0,dagre/* layout */.Zp)(g);
+ adjustEntities(svg, g);
+ relationships2.forEach(function(rel) {
+ drawRelationshipFromLayout(svg, rel, g, firstEntity, diagObj);
+ });
+ const padding = conf.diagramPadding;
+ mermaid_f47111a7.u.insertTitle(svg, "entityTitleText", conf.titleTopMargin, diagObj.db.getDiagramTitle());
+ const svgBounds = svg.node().getBBox();
+ const width = svgBounds.width + padding * 2;
+ const height = svgBounds.height + padding * 2;
+ (0,mermaid_f47111a7.i)(svg, height, width, conf.useMaxWidth);
+ svg.attr("viewBox", `${svgBounds.x - padding} ${svgBounds.y - padding} ${width} ${height}`);
+};
+const MERMAID_ERDIAGRAM_UUID = "28e9f9db-3c8d-5aa5-9faf-44286ae5937c";
+function generateId(str = "", prefix = "") {
+ const simplifiedStr = str.replace(BAD_ID_CHARS_REGEXP, "");
+ return `${strWithHyphen(prefix)}${strWithHyphen(simplifiedStr)}${esm_node_v5(
+ str,
+ MERMAID_ERDIAGRAM_UUID
+ )}`;
+}
+function strWithHyphen(str = "") {
+ return str.length > 0 ? `${str}-` : "";
+}
+const erRenderer = {
+ setConf,
+ draw
+};
+const getStyles = (options) => `
+ .entityBox {
+ fill: ${options.mainBkg};
+ stroke: ${options.nodeBorder};
+ }
+
+ .attributeBoxOdd {
+ fill: ${options.attributeBackgroundColorOdd};
+ stroke: ${options.nodeBorder};
+ }
+
+ .attributeBoxEven {
+ fill: ${options.attributeBackgroundColorEven};
+ stroke: ${options.nodeBorder};
+ }
+
+ .relationshipLabelBox {
+ fill: ${options.tertiaryColor};
+ opacity: 0.7;
+ background-color: ${options.tertiaryColor};
+ rect {
+ opacity: 0.5;
+ }
+ }
+
+ .relationshipLine {
+ stroke: ${options.lineColor};
+ }
+
+ .entityTitleText {
+ text-anchor: middle;
+ font-size: 18px;
+ fill: ${options.textColor};
+ }
+ #MD_PARENT_START {
+ fill: #f5f5f5 !important;
+ stroke: ${options.lineColor} !important;
+ stroke-width: 1;
+ }
+ #MD_PARENT_END {
+ fill: #f5f5f5 !important;
+ stroke: ${options.lineColor} !important;
+ stroke-width: 1;
+ }
+
+`;
+const erStyles = getStyles;
+const diagram = {
+ parser: erParser,
+ db: erDb,
+ renderer: erRenderer,
+ styles: erStyles
+};
+
+
+
+/***/ })
+
+};
+; \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2024-11-14 17:33:01 +0000