`;
},
getCss: () => `
.f6-tooltip-container {
position: absolute;
width: 150;
border: 1 solid #e2e2e2;
border-radius: 4;
font-size: 12;
color: #545454;
background-color: rgba(255, 255, 255, 0.9);
padding: 10 8;
}
.f6-tooltip-container div{
height: 20;
}
.tooltip-type {
padding: 0;
margin: 0;
}
.tooltip-id {
color: #531dab;
}
`,
shouldBegin: (e) => {
if (e.target.get("name") === "name-shape") return true;
return true;
},
});
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
...defaultConfig,
...config,
plugins: [tooltip],
extra: {
createImage: this.canvas && this.canvas.createImage,
requestAnimationFrame: this.canvas.requestAnimationFrame,
cancelAnimationFrame: this.canvas.cancelAnimationFrame,
},
});
console.log(
this.canvas.requestAnimationFrame,
this.canvas.cancelAnimationFrame,
);
this.graph.data(mockData);
this.graph.render();
this.graph.fitView();
this.graph.zoom(config.defaultZoom || 1);
const handleCollapse = (e) => {
const { target } = e;
const id = target.get("modelId");
const item = this.graph.findById(id);
const nodeModel = item.getModel();
nodeModel.collapsed = !nodeModel.collapsed;
this.graph.layout();
this.graph.setItemState(item, "collapse", nodeModel.collapsed);
};
this.graph.on("collapse-text:tap", (e) => {
handleCollapse(e);
});
this.graph.on("collapse-back:tap", (e) => {
handleCollapse(e);
});
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/plugins/tool-tip/index.json
================================================
{
"defaultTitle": "提示框",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/plugins/zoom-slider/data.js
================================================
const data = {
nodes: [
{
id: "0",
label: "0",
},
{
id: "1",
label: "1",
},
{
id: "2",
label: "2",
},
{
id: "3",
label: "3",
},
{
id: "4",
label: "4",
},
{
id: "5",
label: "5",
},
{
id: "6",
label: "6",
},
{
id: "7",
label: "7",
},
{
id: "8",
label: "8",
},
{
id: "9",
label: "9",
},
{
id: "10",
label: "10",
},
{
id: "11",
label: "11",
},
{
id: "12",
label: "12",
},
{
id: "13",
label: "13",
},
{
id: "14",
label: "14",
},
{
id: "15",
label: "15",
},
],
edges: [
{
source: "0",
target: "1",
},
{
source: "0",
target: "2",
},
{
source: "0",
target: "3",
},
{
source: "0",
target: "4",
},
{
source: "0",
target: "5",
},
{
source: "0",
target: "7",
},
{
source: "0",
target: "8",
},
{
source: "0",
target: "9",
},
{
source: "0",
target: "10",
},
{
source: "0",
target: "11",
},
{
source: "0",
target: "13",
},
{
source: "0",
target: "14",
},
{
source: "0",
target: "15",
},
{
source: "2",
target: "3",
},
{
source: "4",
target: "5",
},
{
source: "4",
target: "6",
},
{
source: "5",
target: "6",
},
{
source: "7",
target: "13",
},
{
source: "8",
target: "14",
},
{
source: "9",
target: "10",
},
{
source: "10",
target: "14",
},
{
source: "10",
target: "12",
},
{
source: "11",
target: "14",
},
{
source: "12",
target: "13",
},
],
};
export default data;
================================================
FILE: packages/examples-alipay/pages/plugins/zoom-slider/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/plugins/zoom-slider/index.js
================================================
import { ZoomSlider } from "@antv/f6-plugin";
import data from "./data";
import F6 from "@antv/f6";
Page({
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化canvas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
const zoomSlider = new ZoomSlider();
const { width, height, pixelRatio } = this.data;
console.log("------->", ctx, rect, canvas, renderer);
this.graph = new F6.Graph({
context: ctx,
width,
height,
pixelRatio,
linkCenter: true,
renderer,
defaultNode: {
size: 30,
},
modes: {
default: ["drag-canvas", "zoom-canvas", "drag-node"],
},
plugins: [zoomSlider],
});
this.graph.data(data);
this.graph.render();
// 目前在使用plugin时,需要关闭局部刷新
this.graph.get("canvas").set("localRefresh", false);
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/plugins/zoom-slider/index.json
================================================
{
"defaultTitle": "ZoomSlider",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/custom-flow/data.js
================================================
export default {
nodes: [
{
id: "1",
label: "Company1",
},
{
id: "2",
label: "Company2",
},
{
id: "3",
label: "Company3",
},
{
id: "4",
label: "Company4",
},
{
id: "5",
label: "Company5",
},
{
id: "6",
label: "Company6",
},
{
id: "7",
label: "Company7",
},
{
id: "8",
label: "Company8",
},
{
id: "9",
label: "Company9",
},
],
edges: [
{
source: "1",
target: "2",
data: {
type: "A",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "1",
target: "3",
data: {
type: "B",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "2",
target: "5",
data: {
type: "C",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "5",
target: "6",
data: {
type: "B",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "3",
target: "4",
data: {
type: "C",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "4",
target: "7",
data: {
type: "B",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "1",
target: "8",
data: {
type: "B",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
{
source: "1",
target: "9",
data: {
type: "C",
amount: "100,000 Yuan",
date: "2019-08-03",
},
},
],
};
================================================
FILE: packages/examples-alipay/pages/scene-case/custom-flow/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
.f6-canvas {
z-index: 10;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/custom-flow/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/custom-flow/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
import dagreLayout from "@antv/f6/dist/extends/layout/dagreLayout";
/**
* customFlow
*/
import { isObject } from "@antv/util";
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
F6.registerLayout("dagre", dagreLayout);
const colorMap = {
A: "#72CC4A",
B: "#1A91FF",
C: "#FFAA15",
};
F6.registerNode(
"round-rect",
{
drawShape: function drawShape(cfg, group) {
const { width } = cfg.style;
const { stroke } = cfg.style;
const rect = group.addShape("rect", {
attrs: {
x: -width / 2,
y: -15,
width,
height: 30,
radius: 15,
stroke,
lineWidth: 1.2,
fillOpacity: 1,
},
name: "rect-shape",
});
group.addShape("circle", {
attrs: {
x: -width / 2,
y: 0,
r: 3,
fill: stroke,
},
name: "circle-shape",
});
group.addShape("circle", {
attrs: {
x: width / 2,
y: 0,
r: 3,
fill: stroke,
},
name: "circle-shape2",
});
return rect;
},
getAnchorPoints: function getAnchorPoints() {
return [
[0, 0.5],
[1, 0.5],
];
},
update: function update(cfg, item) {
const group = item.getContainer();
const children = group.get("children");
const node = children[0];
const circleLeft = children[1];
const circleRight = children[2];
const { stroke } = cfg.style;
if (stroke) {
node.attr("stroke", stroke);
circleLeft.attr("fill", stroke);
circleRight.attr("fill", stroke);
}
},
},
"single-node",
);
F6.registerEdge("fund-polyline", {
itemType: "edge",
draw: function draw(cfg, group) {
const { startPoint } = cfg;
const { endPoint } = cfg;
const { stroke } = cfg.style;
const Ydiff = endPoint.y - startPoint.y;
const slope = Ydiff !== 0 ? Math.min(500 / Math.abs(Ydiff), 20) : 0;
const cpOffset = slope > 15 ? 0 : 16;
const offset = Ydiff < 0 ? cpOffset : -cpOffset;
const line1EndPoint = {
x: startPoint.x + slope,
y: endPoint.y + offset,
};
const line2StartPoint = {
x: line1EndPoint.x + cpOffset,
y: endPoint.y,
};
// 控制点坐标
const controlPoint = {
x:
((line1EndPoint.x - startPoint.x) * (endPoint.y - startPoint.y)) /
(line1EndPoint.y - startPoint.y) +
startPoint.x,
y: endPoint.y,
};
let path = [
["M", startPoint.x, startPoint.y],
["L", line1EndPoint.x, line1EndPoint.y],
[
"Q",
controlPoint.x,
controlPoint.y,
line2StartPoint.x,
line2StartPoint.y,
],
["L", endPoint.x, endPoint.y],
];
if (Math.abs(Ydiff) <= 5) {
path = [
["M", startPoint.x, startPoint.y],
["L", endPoint.x, endPoint.y],
];
}
const endArrow =
cfg.style && cfg.style.endArrow ? cfg.style.endArrow : false; // 不支持？.
if (isObject(endArrow)) endArrow.fill = stroke;
const line = group.addShape("path", {
attrs: {
path,
stroke: colorMap[cfg.data && cfg.data.type],
lineWidth: 1.2,
endArrow,
},
name: "path-shape",
});
const labelLeftOffset = 0;
const labelTopOffset = 8;
// amount
const amount = group.addShape("text", {
attrs: {
text: cfg.data && cfg.data.amount,
x: line2StartPoint.x + labelLeftOffset,
y: endPoint.y - labelTopOffset - 2,
fontSize: 14,
textAlign: "left",
textBaseline: "middle",
fill: "#000000D9",
},
name: "text-shape-amount",
});
// type
group.addShape("text", {
attrs: {
text: cfg.data && cfg.data.type,
x: line2StartPoint.x + labelLeftOffset,
y: endPoint.y - labelTopOffset - amount.getBBox().height - 2,
fontSize: 10,
textAlign: "left",
textBaseline: "middle",
fill: "#000000D9",
},
name: "text-shape-type",
});
// date
group.addShape("text", {
attrs: {
text: cfg.data && cfg.data.date,
x: line2StartPoint.x + labelLeftOffset,
y: endPoint.y + labelTopOffset + 4,
fontSize: 12,
fontWeight: 300,
textAlign: "left",
textBaseline: "middle",
fill: "#000000D9",
},
name: "text-shape-date",
});
return line;
},
});
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.Graph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
layout: {
type: "dagre",
rankdir: "LR",
nodesep: 30,
ranksep: 100,
},
modes: {
default: ["drag-canvas"],
},
defaultNode: {
type: "round-rect",
labelCfg: {
style: {
fill: "#000000A6",
fontSize: 10,
},
},
style: {
stroke: "#72CC4A",
width: 150,
},
},
defaultEdge: {
type: "fund-polyline",
},
});
this.graph.data(data);
this.graph.render();
// this.graph.fitView();
const edges = this.graph.getEdges();
edges.forEach(function (edge) {
const line = edge.getKeyShape();
const stroke = line.attr("stroke");
const targetNode = edge.getTarget();
targetNode.update({
style: {
stroke,
},
});
});
this.graph.paint();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/custom-flow/index.json
================================================
{
"defaultTitle": "自定义流向图",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/decision-tree/data.js
================================================
export default {
id: "g1",
name: "Name1",
count: 123456,
label: "538.90",
currency: "Yuan",
rate: 1.0,
status: "B",
variableName: "V1",
variableValue: 0.341,
variableUp: false,
children: [
{
id: "g12",
name: "Deal with LONG label LONG label LONG label LONG label",
count: 123456,
label: "338.00",
rate: 0.627,
status: "R",
currency: "Yuan",
variableName: "V2",
variableValue: 0.179,
variableUp: true,
children: [
{
id: "g121",
name: "Name3",
collapsed: true,
count: 123456,
label: "138.00",
rate: 0.123,
status: "B",
currency: "Yuan",
variableName: "V2",
variableValue: 0.27,
variableUp: true,
children: [
{
id: "g1211",
name: "Name4",
count: 123456,
label: "138.00",
rate: 1.0,
status: "B",
currency: "Yuan",
variableName: "V1",
variableValue: 0.164,
variableUp: false,
children: [],
},
],
},
{
id: "g122",
name: "Name5",
collapsed: true,
count: 123456,
label: "100.00",
rate: 0.296,
status: "G",
currency: "Yuan",
variableName: "V1",
variableValue: 0.259,
variableUp: true,
children: [
{
id: "g1221",
name: "Name6",
count: 123456,
label: "40.00",
rate: 0.4,
status: "G",
currency: "Yuan",
variableName: "V1",
variableValue: 0.135,
variableUp: true,
children: [
{
id: "g12211",
name: "Name6-1",
count: 123456,
label: "40.00",
rate: 1.0,
status: "R",
currency: "Yuan",
variableName: "V1",
variableValue: 0.181,
variableUp: true,
children: [],
},
],
},
{
id: "g1222",
name: "Name7",
count: 123456,
label: "60.00",
rate: 0.6,
status: "G",
currency: "Yuan",
variableName: "V1",
variableValue: 0.239,
variableUp: false,
children: [],
},
],
},
{
id: "g123",
name: "Name8",
collapsed: true,
count: 123456,
label: "100.00",
rate: 0.296,
status: "DI",
currency: "Yuan",
variableName: "V2",
variableValue: 0.131,
variableUp: false,
children: [
{
id: "g1231",
name: "Name8-1",
count: 123456,
label: "100.00",
rate: 1.0,
status: "DI",
currency: "Yuan",
variableName: "V2",
variableValue: 0.131,
variableUp: false,
children: [],
},
],
},
],
},
{
id: "g13",
name: "Name9",
count: 123456,
label: "100.90",
rate: 0.187,
status: "B",
currency: "Yuan",
variableName: "V2",
variableValue: 0.221,
variableUp: true,
children: [
{
id: "g131",
name: "Name10",
count: 123456,
label: "33.90",
rate: 0.336,
status: "R",
currency: "Yuan",
variableName: "V1",
variableValue: 0.12,
variableUp: true,
children: [],
},
{
id: "g132",
name: "Name11",
count: 123456,
label: "67.00",
rate: 0.664,
status: "G",
currency: "Yuan",
variableName: "V1",
variableValue: 0.241,
variableUp: false,
children: [],
},
],
},
{
id: "g14",
name: "Name12",
count: 123456,
label: "100.00",
rate: 0.186,
status: "G",
currency: "Yuan",
variableName: "V2",
variableValue: 0.531,
variableUp: true,
children: [],
},
],
};
================================================
FILE: packages/examples-alipay/pages/scene-case/decision-tree/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/decision-tree/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/decision-tree/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import mockData from "./data";
/**
* decisionTree
*/
const colors = {
B: "#5B8FF9",
R: "#F46649",
Y: "#EEBC20",
G: "#5BD8A6",
DI: "#A7A7A7",
};
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 默认配置
const defaultConfig = {
width,
height,
modes: {
default: ["zoom-canvas", "drag-canvas"],
},
fitView: true,
animate: true,
defaultNode: {
type: "flow-rect",
},
defaultEdge: {
type: "cubic-horizontal",
style: {
stroke: "#CED4D9",
},
},
layout: {
type: "indented",
direction: "LR",
dropCap: false,
indent: 300,
getHeight: () => {
return 60;
},
},
};
// 组件props
const props = {
data: mockData,
config: {
padding: [20, 50],
defaultLevel: 3,
defaultZoom: 0.8,
modes: { default: ["zoom-canvas", "drag-canvas"] },
},
};
// 自定义节点、边
const registerFn = () => {
/**
* 自定义节点
*/
F6.registerNode(
"flow-rect",
{
shapeType: "flow-rect",
draw(cfg, group) {
const {
name = "",
variableName,
variableValue,
variableUp,
label,
collapsed,
currency,
status,
// rate,
} = cfg;
const grey = "#CED4D9";
// 逻辑不应该在这里判断
const rectConfig = {
width: 202,
height: 60,
lineWidth: 1,
fontSize: 12,
fill: "#fff",
radius: 4,
stroke: grey,
opacity: 1,
};
const nodeOrigin = {
x: -rectConfig.width / 2,
y: -rectConfig.height / 2,
};
const textConfig = {
textAlign: "left",
textBaseline: "bottom",
};
const rect = group.addShape("rect", {
attrs: {
x: nodeOrigin.x,
y: nodeOrigin.y,
...rectConfig,
},
});
const rectBBox = rect.getBBox();
// label title
group.addShape("text", {
attrs: {
...textConfig,
x: 12 + nodeOrigin.x,
y: 20 + nodeOrigin.y,
text: name.length > 28 ? `${name.substr(0, 28)}...` : name,
fontSize: 12,
opacity: 0.85,
fill: "#000",
cursor: "pointer",
},
name: "name-shape",
});
// price
const price = group.addShape("text", {
attrs: {
...textConfig,
x: 12 + nodeOrigin.x,
y: rectBBox.maxY - 12,
text: label,
fontSize: 16,
fill: "#000",
opacity: 0.85,
},
});
// label currency
group.addShape("text", {
attrs: {
...textConfig,
x: price.getBBox().maxX + 5,
y: rectBBox.maxY - 12,
text: currency,
fontSize: 12,
fill: "#000",
opacity: 0.75,
},
});
// percentage
const percentText = group.addShape("text", {
attrs: {
...textConfig,
x: rectBBox.maxX - 8,
y: rectBBox.maxY - 12,
text: `${((variableValue || 0) * 100).toFixed(2)}%`,
fontSize: 12,
textAlign: "right",
fill: colors[status],
},
});
// percentage triangle
const symbol = variableUp ? "triangle" : "triangle-down";
const triangle = group.addShape("marker", {
attrs: {
...textConfig,
x: percentText.getBBox().minX - 10,
y: rectBBox.maxY - 12 - 6,
symbol,
r: 6,
fill: colors[status],
},
});
// variable name
group.addShape("text", {
attrs: {
...textConfig,
x: triangle.getBBox().minX - 4,
y: rectBBox.maxY - 12,
text: variableName,
fontSize: 12,
textAlign: "right",
fill: "#000",
opacity: 0.45,
},
});
// bottom line background
// const bottomBackRect = group.addShape('rect', {
// attrs: {
// x: nodeOrigin.x,
// y: rectBBox.maxY - 4,
// width: rectConfig.width,
// height: 4,
// radius: [0, 0, rectConfig.radius, rectConfig.radius],
// fill: '#E0DFE3',
// },
// });
// bottom percent
// const bottomRect = group.addShape('rect', {
// attrs: {
// x: nodeOrigin.x,
// y: rectBBox.maxY - 4,
// width: rate * rectBBox.width,
// height: 4,
// radius: [0, 0, 0, rectConfig.radius],
// fill: colors[status],
// },
// });
// collapse rect
if (cfg.children && cfg.children.length) {
group.addShape("rect", {
attrs: {
x: rectConfig.width / 2 - 8,
y: -8,
width: 16,
height: 16,
stroke: "rgba(0, 0, 0, 0.25)",
cursor: "pointer",
fill: "#fff",
},
name: "collapse-back",
modelId: cfg.id,
});
// collpase text
group.addShape("text", {
attrs: {
x: rectConfig.width / 2,
y: -1,
textAlign: "center",
textBaseline: "middle",
text: collapsed ? "+" : "-",
fontSize: 16,
cursor: "pointer",
fill: "rgba(0, 0, 0, 0.25)",
},
name: "collapse-text",
modelId: cfg.id,
});
}
this.drawLinkPoints(cfg, group);
return rect;
},
update(cfg, item) {
const group = item.getContainer();
this.updateLinkPoints(cfg, group);
},
setState(name, value, item) {
if (name === "collapse") {
const group = item.getContainer();
const collapseText = group.find(
(e) => e.get("name") === "collapse-text",
);
if (collapseText) {
if (!value) {
collapseText.attr({
text: "-",
});
} else {
collapseText.attr({
text: "+",
});
}
}
}
},
getAnchorPoints() {
return [
[0, 0.5],
[1, 0.5],
];
},
},
"rect",
);
F6.registerEdge(
"flow-cubic",
{
getControlPoints(cfg) {
let { controlPoints } = cfg; // 指定controlPoints
if (!controlPoints || !controlPoints.length) {
const { startPoint, endPoint, sourceNode, targetNode } = cfg;
const {
x: startX,
y: startY,
coefficientX,
coefficientY,
} = sourceNode ? sourceNode.getModel() : startPoint;
const { x: endX, y: endY } = targetNode
? targetNode.getModel()
: endPoint;
let curveStart = (endX - startX) * coefficientX;
let curveEnd = (endY - startY) * coefficientY;
curveStart = curveStart > 40 ? 40 : curveStart;
curveEnd = curveEnd < -30 ? curveEnd : -30;
controlPoints = [
{ x: startPoint.x + curveStart, y: startPoint.y },
{ x: endPoint.x + curveEnd, y: endPoint.y },
];
}
return controlPoints;
},
getPath(points) {
const path = [];
path.push(["M", points[0].x, points[0].y]);
path.push([
"C",
points[1].x,
points[1].y,
points[2].x,
points[2].y,
points[3].x,
points[3].y,
]);
return path;
},
},
"single-line",
);
};
registerFn();
const { onInit, config } = props;
console.log(onInit);
const tooltip = new F6.Tooltip({
// TODO: _f2.default.Tooltip is not a constructor
// offsetX and offsetY include the padding of the parent container
offsetX: 20,
offsetY: 30,
// the types of items that allow the tooltip show up
// 允许出现 tooltip 的 item 类型
itemTypes: ["node"],
// custom the tooltip's content
// 自定义 tooltip 内容
getContent: (e) => {
const outDiv = document.createElement("div");
// outDiv.style.padding = '0px 0px 20px 0px';
const nodeName = e.item.getModel().name;
let formatedNodeName = "";
for (let i = 0; i < nodeName.length; i++) {
formatedNodeName = `${formatedNodeName}${nodeName[i]}`;
if (i !== 0 && i % 20 === 0)
formatedNodeName = `${formatedNodeName} `;
}
outDiv.innerHTML = `${formatedNodeName}`;
return outDiv;
},
shouldBegin: (e) => {
if (e.target.get("name") === "name-shape") return true;
return false;
},
});
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
...defaultConfig,
...config,
plugins: [tooltip],
});
this.graph.data(mockData);
this.graph.render();
this.graph.fitView();
this.graph.zoom(config.defaultZoom || 1);
const handleCollapse = (e) => {
const { target } = e;
const id = target.get("modelId");
const item = this.graph.findById(id);
const nodeModel = item.getModel();
nodeModel.collapsed = !nodeModel.collapsed;
this.graph.layout();
this.graph.setItemState(item, "collapse", nodeModel.collapsed);
};
this.graph.on("collapse-text:tap", (e) => {
handleCollapse(e);
});
this.graph.on("collapse-back:tap", (e) => {
handleCollapse(e);
});
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/decision-tree/index.json
================================================
{
"defaultTitle": "决策树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/donut-transfer/data.js
================================================
const data = {
nodes: [
{
id: "person A",
label: "person A",
// the attributes for drawing donut
donutAttrs: {
income: 10,
outcome: 20,
unknown: 25,
},
},
{
id: "person B",
label: "person B",
donutAttrs: {
income: 20,
outcome: 10,
unknown: 5,
},
},
{
id: "person C",
label: "person C",
donutAttrs: {
income: 200,
outcome: 20,
unknown: 25,
},
},
{
id: "person D",
label: "person D",
donutAttrs: {
income: 50,
outcome: 10,
unknown: 15,
},
},
{
id: "person E",
label: "person E",
donutAttrs: {
income: 80,
outcome: 40,
unknown: 45,
},
},
{
id: "person F",
label: "person F",
donutAttrs: {
income: 90,
outcome: 110,
unknown: 15,
},
},
],
edges: [
{ source: "person C", target: "person F", size: 10 },
{ source: "person B", target: "person A", size: 5 },
{ source: "person D", target: "person E", size: 20 },
{ source: "person D", target: "person C", size: 5 },
{ source: "person B", target: "person C", size: 10 },
{ source: "person A", target: "person C", size: 5 },
],
};
data.edges.forEach((edge) => {
edge.label = `Transfer $${edge.size}`;
});
const colors = {
income: "#61DDAA",
outcome: "#F08BB4",
unknown: "#65789B",
};
data.nodes.forEach((node) => {
node.donutColorMap = colors;
node.size = 0;
Object.keys(node.donutAttrs).forEach((key) => {
node.size += node.donutAttrs[key];
});
node.size = Math.sqrt(node.size) * 5;
});
const legendData = {
nodes: [
{
id: "income",
label: "Income",
order: 0,
style: {
fill: "#61DDAA",
},
},
{
id: "outcome",
label: "Outcome",
order: 2,
style: {
fill: "#F08BB4",
},
},
{
id: "unknown",
label: "Unknown",
order: 2,
style: {
fill: "#65789B",
},
},
],
};
export { data, legendData };
================================================
FILE: packages/examples-alipay/pages/scene-case/donut-transfer/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
.f6-canvas {
z-index: 10;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/donut-transfer/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/donut-transfer/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import { data, legendData } from "./data";
/**
* donutTransfer
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
const legend = new F6.Legend({
data: legendData,
align: "center",
layout: "horizontal", // vertical
position: "bottom-left",
vertiSep: 12,
horiSep: 24,
offsetY: -24,
padding: [4, 16, 8, 16],
containerStyle: {
fill: "#ccc",
lineWidth: 1,
},
title: " ",
titleConfig: {
offsetY: -8,
},
});
// 创建F6实例
this.graph = new F6.Graph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
fitCenter: true,
plugins: [legend], // 这里的plugin不知道能不能用
modes: {
default: ["drag-canvas", "drag-node"],
},
layout: {
type: "radial",
focusNode: "li",
linkDistance: 200,
unitRadius: 200,
},
defaultEdge: {
style: {
endArrow: true,
},
labelCfg: {
autoRotate: true,
style: {
stroke: "#fff",
lineWidth: 5,
},
},
},
defaultNode: {
type: "donut",
style: {
lineWidth: 0,
},
labelCfg: {
position: "bottom",
},
},
});
this.graph.data(data);
this.graph.render();
// this.graph.fitView();
this.graph.on("node:tap", (evt) => {
const { item } = evt;
this.graph.setItemState(item, "selected", true);
});
this.graph.on("canvas:tap", () => {
this.graph.getNodes().forEach((node) => {
this.graph.clearItemStates(node);
});
});
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/donut-transfer/index.json
================================================
{
"defaultTitle": "甜甜圈转账图",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/knowledge-tree-graph/data.js
================================================
export default {
id: "200000004",
tooltip: "Thing",
label: "事物",
description: null,
descriptionZh: null,
depth: 3,
subTypeCount: 9,
status: 0,
children: [
{
id: "500000061",
tooltip: "Person",
label: "自然人",
description: null,
descriptionZh: null,
depth: 1,
subTypeCount: 1,
status: 0,
children: [
{
id: "707000085",
tooltip: "FilmPerson",
label: "电影人",
description: null,
descriptionZh: null,
depth: 5,
subTypeCount: 3,
status: 1,
children: [
{
id: "707000090",
tooltip: "FilmDirector",
label: "电影导演",
description: null,
descriptionZh: null,
depth: 0,
subTypeCount: 0,
status: 1,
children: [],
},
{
id: "707000091",
tooltip: "FilmWriter",
label: "电影编剧",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 0,
status: 1,
children: [],
},
{
id: "707000092",
tooltip: "FilmStar",
label: "电影主演",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 0,
status: 1,
children: [],
},
],
},
{
id: "707000086",
tooltip: "MusicPerson",
label: "音乐人",
description: null,
descriptionZh: null,
depth: 17,
subTypeCount: 2,
status: 1,
children: [],
},
],
},
{
id: "200000005",
tooltip: "Music",
label: "音乐",
description: null,
descriptionZh: null,
depth: 3,
subTypeCount: 2,
status: 1,
children: [],
},
{
id: "707000128",
tooltip: "Film",
label: "电影",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 0,
status: 1,
children: [
{
id: "7070032328",
tooltip: "Comedy",
label: "喜剧",
description: null,
descriptionZh: null,
depth: 4,
operation: "C",
subTypeCount: 0,
status: 1,
children: [],
},
],
},
{
id: "707000095",
tooltip: "FilmGenre",
label: "电影类别",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 0,
status: 1,
children: [],
},
{
id: "702000021",
tooltip: "Organization",
label: "机构",
description: null,
descriptionZh: null,
depth: 47,
subTypeCount: 1,
status: 0,
children: [
{
id: "500000063",
tooltip: "Company",
label: "公司",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 2,
status: 1,
children: [
{
id: "707000093",
tooltip: "FilmCompany",
label: "电影公司",
description: null,
descriptionZh: null,
depth: 4,
subTypeCount: 0,
status: 1,
children: [],
},
{
id: "707000094",
tooltip: "MusicCompany",
label: "音乐公司",
description: null,
descriptionZh: null,
depth: 2,
subTypeCount: 0,
status: 1,
children: [],
},
],
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/scene-case/knowledge-tree-graph/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/knowledge-tree-graph/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/knowledge-tree-graph/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import data from "./data";
/**
* 知识图谱树
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
const minWidth = 60;
// TODO:这里需要定义两次，因为onLoad()里面传不到,updateChart()里面,如果定义在Page外面是不是就是全局的
const BaseConfig = {
nameFontSize: 12,
childCountWidth: 22,
countMarginLeft: 0,
itemPadding: 16,
nameMarginLeft: 4,
rootPadding: 18,
};
F6.registerNode("treeNode", {
draw: (cfg, group) => {
const { label, collapsed, selected, children, depth } = cfg;
const rootNode = depth === 0;
const hasChildren = children && children.length !== 0;
const {
childCountWidth,
countMarginLeft,
itemPadding,
nameMarginLeft,
rootPadding,
} = BaseConfig;
let width = 0;
const height = 28;
const x = 0;
const y = -height / 2;
// 名称文本
const text = group.addShape("text", {
attrs: {
text: label,
x: x * 2,
y,
textAlign: "left",
textBaseline: "top",
fontFamily: "PingFangSC-Regular",
},
cursor: "pointer",
name: "name-text-shape",
});
const textWidth = text.getBBox().width;
width = textWidth + itemPadding + nameMarginLeft;
width = width < minWidth ? minWidth : width;
if (!rootNode && hasChildren) {
width += countMarginLeft;
width += childCountWidth;
}
const keyShapeAttrs = {
x,
y,
width,
height,
radius: 4,
};
// keyShape根节点选中样式
if (rootNode && selected) {
keyShapeAttrs.fill = "#e8f7ff";
keyShapeAttrs.stroke = "#e8f7ff";
}
const keyShape = group.addShape("rect", {
attrs: keyShapeAttrs,
name: "root-key-shape-rect-shape",
});
if (!rootNode) {
// 底部横线
group.addShape("path", {
attrs: {
path: [
["M", x - 1, 0],
["L", width, 0],
],
stroke: "#AAB7C4",
lineWidth: 1,
},
name: "node-path-shape",
});
}
const mainX = x - 10;
const mainY = -height + 15;
if (rootNode) {
group.addShape("rect", {
attrs: {
x: mainX,
y: mainY,
width: width + 12,
height,
radius: 14,
fill: "#e8f7ff",
cursor: "pointer",
},
name: "main-shape",
});
}
let nameColor = "rgba(0, 0, 0, .65)";
if (selected) {
nameColor = "#40A8FF";
}
// 名称
if (rootNode) {
group.addShape("text", {
attrs: {
text: label,
x: mainX + rootPadding,
y: 1,
textAlign: "left",
textBaseline: "middle",
fill: nameColor,
fontSize: 12,
fontFamily: "PingFangSC-Regular",
cursor: "pointer",
},
name: "root-text-shape",
});
} else {
group.addShape("text", {
attrs: {
text: label,
x: selected ? mainX + 6 + nameMarginLeft : mainX + 6,
y: y - 5,
textAlign: "start",
textBaseline: "top",
fill: nameColor,
fontSize: 12,
fontFamily: "PingFangSC-Regular",
cursor: "pointer",
},
name: "not-root-text-shape",
});
}
// 子类数量
if (hasChildren && !rootNode) {
const childCountHeight = 12;
const childCountX = width - childCountWidth;
const childCountY = -childCountHeight / 2;
group.addShape("rect", {
attrs: {
width: childCountWidth,
height: 12,
stroke: collapsed ? "#1890ff" : "#5CDBD3",
fill: collapsed ? "#fff" : "#E6FFFB",
x: childCountX,
y: childCountY,
radius: 6,
cursor: "pointer",
},
name: "child-count-rect-shape",
});
group.addShape("text", {
attrs: {
text: `${children.length}`,
fill: "rgba(0, 0, 0, .65)",
x: childCountX + childCountWidth / 2,
y: childCountY + 12,
fontSize: 10,
width: childCountWidth,
textAlign: "center",
cursor: "pointer",
},
name: "child-count-text-shape",
});
}
return keyShape;
},
});
F6.registerEdge("smooth", {
draw(cfg, group) {
const { startPoint, endPoint } = cfg;
const hgap = Math.abs(endPoint.x - startPoint.x);
const path = [
["M", startPoint.x, startPoint.y],
[
"C",
startPoint.x + hgap / 4,
startPoint.y,
endPoint.x - hgap / 2,
endPoint.y,
endPoint.x,
endPoint.y,
],
];
const shape = group.addShape("path", {
attrs: {
stroke: "#AAB7C4",
path,
},
name: "smooth-path-shape",
});
return shape;
},
});
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
const BaseConfig = {
nameFontSize: 12,
childCountWidth: 22,
countMarginLeft: 0,
itemPadding: 16,
nameMarginLeft: 4,
rootPadding: 18,
};
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
fitViewPadding: 60,
modes: {
default: [
{
type: "collapse-expand",
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
type: "treeNode",
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "smooth",
},
layout: {
type: "compactBox", // TODO：为什么这里找不到
direction: "LR",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth(d) {
const labelWidth = F6.Util.getTextSize(
d.label,
BaseConfig.nameFontSize,
)[0];
const width_ =
BaseConfig.itemPadding +
BaseConfig.nameMarginLeft +
labelWidth +
BaseConfig.rootPadding +
BaseConfig.childCountWidth;
return width_;
},
getVGap: function getVGap() {
return 15;
},
getHGap: function getHGap() {
return 30;
},
},
});
// 注册数据
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/knowledge-tree-graph/index.json
================================================
{
"defaultTitle": "知识图谱树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/metro-lines/data.js
================================================
const data = {
nodes: [
{
id: "0",
x: 12955418.07889617,
y: 4858516.455509626,
class: "地铁二号线",
name: "地铁二号线 0",
},
{
id: "1",
x: 12955418.07889617,
y: 4858516.455509626,
class: "地铁二号线",
name: "地铁二号线 1",
},
{
id: "2",
x: 12960805.702543395,
y: 4843623.153783939,
class: "地铁五号线",
name: "地铁五号线 0",
},
{
id: "3",
x: 12957909.41496727,
y: 4878612.7284845,
class: "地铁五号线",
name: "地铁五号线 1",
},
{
id: "4",
x: 12924431.591067636,
y: 4826881.565994551,
class: "地铁房山线",
name: "地铁房山线 0",
},
{
id: "5",
x: 12946675.914777644,
y: 4839000.571326079,
class: "地铁房山线",
name: "地铁房山线 1",
},
{
id: "6",
x: 12960805.702543395,
y: 4843623.153783939,
class: "地铁亦庄线",
name: "地铁亦庄线 0",
},
{
id: "7",
x: 12980513.522539986,
y: 4840611.685434834,
class: "地铁亦庄线",
name: "地铁亦庄线 1",
},
{
id: "8",
x: 12970460.425604625,
y: 4852660.505494347,
class: "地铁一号线",
name: "地铁一号线 0",
},
{
id: "9",
x: 12932857.683691781,
y: 4855262.558461167,
class: "地铁一号线",
name: "地铁一号线 1",
},
{
id: "10",
x: 12954336.341521818,
y: 4841957.844498525,
class: "地铁大兴线",
name: "地铁大兴线 0",
},
{
id: "11",
x: 12948661.393356105,
y: 4818156.255552412,
class: "地铁大兴线",
name: "地铁大兴线 1",
},
{
id: "12",
x: 12954336.341521818,
y: 4841957.844498525,
class: "地铁四号线",
name: "地铁四号线 0",
},
{
id: "13",
x: 12943094.565471629,
y: 4868005.960957178,
class: "地铁四号线",
name: "地铁四号线 1",
},
{
id: "14",
x: 12943697.439571828,
y: 4856096.365355702,
class: "地铁六号线",
name: "地铁六号线 0",
},
{
id: "15",
x: 12982538.96049167,
y: 4855210.774849254,
class: "地铁六号线",
name: "地铁六号线 1",
},
{
id: "16",
x: 12946675.914777644,
y: 4839000.571326079,
class: "地铁九号线",
name: "地铁九号线 0",
},
{
id: "17",
x: 12949261.040454354,
y: 4857656.700765552,
class: "地铁九号线",
name: "地铁九号线 1",
},
{
id: "18",
x: 12956918.23852815,
y: 4858529.6221339535,
class: "地铁八号线",
name: "地铁八号线 0",
},
{
id: "19",
x: 12957923.222643975,
y: 4856285.931514598,
class: "地铁八号线",
name: "地铁八号线 1",
},
{
id: "20",
x: 12947165.66572366,
y: 4873622.718414709,
class: "地铁昌平线",
name: "地铁昌平线 0",
},
{
id: "21",
x: 12945101.617382836,
y: 4896059.0154147735,
class: "地铁昌平线",
name: "地铁昌平线 1",
},
{
id: "22",
x: 12970460.425604625,
y: 4852660.505494347,
class: "地铁八通线",
name: "地铁八通线 0",
},
{
id: "23",
x: 12989768.23411335,
y: 4847232.117513346,
class: "地铁八通线",
name: "地铁八通线 1",
},
{
id: "24",
x: 12961385.775293019,
y: 4857425.3359782435,
class: "城铁十三号线",
name: "城铁十三号线 0",
},
{
id: "25",
x: 12952415.003097966,
y: 4857385.42314959,
class: "城铁十三号线",
name: "城铁十三号线 1",
},
{
id: "26",
x: 12964405.448829094,
y: 4849043.663728292,
class: "地铁十号线",
name: "地铁十号线 0",
},
{
id: "27",
x: 12945523.914777555,
y: 4862157.070927259,
class: "地铁十号线",
name: "地铁十号线 1",
},
{
id: "28",
x: 12937182.6004098,
y: 4846484.783681809,
class: "地铁十四号线",
name: "地铁十四号线 0",
},
{
id: "29",
x: 12946851.421569752,
y: 4846551.5626413245,
class: "地铁十四号线",
name: "地铁十四号线 1",
},
{
id: "30",
x: 12975248.324027628,
y: 4879080.29109743,
class: "地铁十五号线",
name: "地铁十五号线 0",
},
{
id: "31",
x: 12962862.26847603,
y: 4865214.088371204,
class: "地铁十五号线",
name: "地铁十五号线 1",
},
{
id: "32",
x: 12981143.037271895,
y: 4871509.161726701,
class: "机场轻轨线",
name: "机场轻轨线 0",
},
{
id: "33",
x: 12961347.967621036,
y: 4857396.841326526,
class: "机场轻轨线",
name: "机场轻轨线 1",
},
],
edges: [
{
id: "0",
source: "0",
target: "1",
class: "地铁二号线",
name: "地铁二号线 0",
controlPoints: [
{
x: 12956158.028659772,
y: 4858523.099945488,
},
{
x: 12956181.882943347,
y: 4858523.313643505,
},
{
x: 12956333.569265882,
y: 4858524.675979247,
},
{
x: 12956722.101097316,
y: 4858528.426228019,
},
{
x: 12956892.09019568,
y: 4858529.577087689,
},
{
x: 12957092.031747662,
y: 4858532.537231651,
},
{
x: 12957285.500773665,
y: 4858534.624581567,
},
{
x: 12958025.324180173,
y: 4858542.359953267,
},
{
x: 12958025.324180173,
y: 4858542.359953267,
},
{
x: 12958040.386887064,
y: 4858542.398858417,
},
{
x: 12958051.381729262,
y: 4858542.39594296,
},
{
x: 12958077.436647858,
y: 4858542.626090849,
},
{
x: 12958156.437099922,
y: 4858543.794072316,
},
{
x: 12958189.185511772,
y: 4858543.944439034,
},
{
x: 12958309.191310784,
y: 4858545.279485739,
},
{
x: 12958458.470410347,
y: 4858547.406977885,
},
{
x: 12958499.690753505,
y: 4858547.988957175,
},
{
x: 12958505.143835366,
y: 4858548.099568159,
},
{
x: 12958552.455966821,
y: 4858548.335831382,
},
{
x: 12958768.467696369,
y: 4858549.399143227,
},
{
x: 12958859.902949648,
y: 4858552.977807331,
},
{
x: 12958924.391812265,
y: 4858556.413893195,
},
{
x: 12958993.172822965,
y: 4858558.959445135,
},
{
x: 12959013.547905065,
y: 4858559.7809649445,
},
{
x: 12959327.7774419,
y: 4858574.063556792,
},
{
x: 12959423.21800485,
y: 4858577.691630111,
},
{
x: 12959426.045447897,
y: 4858577.797144458,
},
{
x: 12959659.119375631,
y: 4858587.989742429,
},
{
x: 12959737.865294052,
y: 4858591.668097373,
},
{
x: 12959846.282077461,
y: 4858596.613007342,
},
{
x: 12959955.561247244,
y: 4858601.256188295,
},
{
x: 12960095.413179535,
y: 4858607.094133126,
},
{
x: 12960179.06451476,
y: 4858611.470739427,
},
{
x: 12960222.914558794,
y: 4858613.727307291,
},
{
x: 12960421.743963502,
y: 4858622.407685848,
},
{
x: 12960445.476249201,
y: 4858623.093869879,
},
{
x: 12960629.592854993,
y: 4858630.086065551,
},
{
x: 12960751.203872466,
y: 4858635.467581922,
},
{
x: 12960848.858819682,
y: 4858639.927849644,
},
{
x: 12960917.431335308,
y: 4858642.696504292,
},
{
x: 12960954.897539183,
y: 4858643.0533597935,
},
{
x: 12960982.959798397,
y: 4858642.704017011,
},
{
x: 12961014.781746428,
y: 4858640.30966017,
},
{
x: 12961051.662476636,
y: 4858634.414079347,
},
{
x: 12961083.478422668,
y: 4858626.929183689,
},
{
x: 12961111.532563318,
y: 4858617.271161616,
},
{
x: 12961140.594020512,
y: 4858604.699543408,
},
{
x: 12961160.7368578,
y: 4858593.842589348,
},
{
x: 12961181.649884878,
y: 4858581.485318099,
},
{
x: 12961198.850660494,
y: 4858569.376089524,
},
{
x: 12961224.140661275,
y: 4858547.942074989,
},
{
x: 12961236.424254648,
y: 4858536.280756947,
},
{
x: 12961250.296104662,
y: 4858521.997990917,
},
{
x: 12961263.585987432,
y: 4858506.114455221,
},
{
x: 12961276.44120637,
y: 4858488.344153348,
},
{
x: 12961286.408321457,
y: 4858473.632750297,
},
{
x: 12961294.63870108,
y: 4858460.527513578,
},
{
x: 12961303.735586522,
y: 4858443.4908795785,
},
{
x: 12961311.961795231,
y: 4858426.312269373,
},
{
x: 12961324.544825437,
y: 4858394.384768109,
},
{
x: 12961332.599563174,
y: 4858367.639883998,
},
{
x: 12961338.437462995,
y: 4858349.099767153,
},
{
x: 12961341.2480161,
y: 4858329.523211644,
},
{
x: 12961344.471828079,
y: 4858307.641213481,
},
{
x: 12961347.327668607,
y: 4858271.276643974,
},
{
x: 12961347.988308016,
y: 4858252.824580443,
},
{
x: 12961348.859027859,
y: 4858200.010594391,
},
{
x: 12961348.859027859,
y: 4858200.0103943935,
},
{
x: 12961347.38216376,
y: 4858144.4708304275,
},
{
x: 12961343.338631237,
y: 4857930.979484696,
},
{
x: 12961343.002661625,
y: 4857896.233210593,
},
{
x: 12961340.747563919,
y: 4857737.363889014,
},
{
x: 12961338.592553958,
y: 4857671.84297017,
},
{
x: 12961341.18922736,
y: 4857596.35911637,
},
{
x: 12961344.975191534,
y: 4857477.302133615,
},
{
x: 12961347.967621036,
y: 4857396.841326526,
},
{
x: 12961350.020733643,
y: 4857318.561403474,
},
{
x: 12961355.68061802,
y: 4857153.852373557,
},
{
x: 12961355.680618014,
y: 4857153.852273558,
},
{
x: 12961359.731217345,
y: 4857006.275839691,
},
{
x: 12961359.731017353,
y: 4857006.131939777,
},
{
x: 12961360.845305737,
y: 4856963.669545529,
},
{
x: 12961366.890092889,
y: 4856784.230691269,
},
{
x: 12961368.58851819,
y: 4856746.131025358,
},
{
x: 12961372.266035046,
y: 4856660.336259479,
},
{
x: 12961372.829975668,
y: 4856646.230202675,
},
{
x: 12961378.034419877,
y: 4856495.295969707,
},
{
x: 12961382.403443811,
y: 4856377.660000789,
},
{
x: 12961384.942063117,
y: 4856311.497820034,
},
{
x: 12961386.465992313,
y: 4856243.30465021,
},
{
x: 12961390.674716666,
y: 4856107.682763318,
},
{
x: 12961394.329897156,
y: 4855999.369524935,
},
{
x: 12961394.516375585,
y: 4855993.8847022,
},
{
x: 12961417.584882293,
y: 4855310.507392769,
},
{
x: 12961417.694868386,
y: 4855307.2384764915,
},
{
x: 12961425.988003194,
y: 4855061.622208351,
},
{
x: 12961440.215299333,
y: 4854643.566032893,
},
{
x: 12961461.215758536,
y: 4854015.5516425,
},
{
x: 12961471.471998505,
y: 4853691.795660701,
},
{
x: 12961471.611776885,
y: 4853686.561937957,
},
{
x: 12961474.998051625,
y: 4853601.811384682,
},
{
x: 12961478.809553925,
y: 4853507.031446198,
},
{
x: 12961480.521483717,
y: 4853483.915660419,
},
{
x: 12961481.521725276,
y: 4853474.174593727,
},
{
x: 12961482.954997385,
y: 4853459.926853736,
},
{
x: 12961485.39370743,
y: 4853441.314944552,
},
{
x: 12961494.966948297,
y: 4853364.78470371,
},
{
x: 12961499.936921315,
y: 4853336.948636642,
},
{
x: 12961547.758241706,
y: 4853069.064103569,
},
{
x: 12961553.642808063,
y: 4853027.336298535,
},
{
x: 12961555.648717735,
y: 4853011.198681677,
},
{
x: 12961558.402478581,
y: 4852968.599887655,
},
{
x: 12961561.595948681,
y: 4852886.1285595605,
},
{
x: 12961562.434182541,
y: 4852851.8992535565,
},
{
x: 12961567.092653673,
y: 4852663.388779601,
},
{
x: 12961567.151841797,
y: 4852661.004664356,
},
{
x: 12961571.615182877,
y: 4852499.601380691,
},
{
x: 12961570.762650162,
y: 4852327.846076672,
},
{
x: 12961554.898502,
y: 4852258.290511526,
},
{
x: 12961533.80510204,
y: 4852226.950476327,
},
{
x: 12961502.181787156,
y: 4852194.501877436,
},
{
x: 12961463.801001186,
y: 4852175.682708853,
},
{
x: 12961419.411661869,
y: 4852168.225375068,
},
{
x: 12961360.726703899,
y: 4852159.287636606,
},
{
x: 12961305.806766747,
y: 4852155.632147181,
},
{
x: 12961091.327734,
y: 4852150.8841911405,
},
{
x: 12961044.05355995,
y: 4852148.93802986,
},
{
x: 12960991.078574985,
y: 4852148.12380065,
},
{
x: 12960926.683247,
y: 4852147.134333183,
},
{
x: 12960858.046176687,
y: 4852148.206427826,
},
{
x: 12960832.258540388,
y: 4852148.44774515,
},
{
x: 12960823.161300883,
y: 4852148.574651271,
},
{
x: 12960804.266769528,
y: 4852149.284002013,
},
{
x: 12960648.459496386,
y: 4852144.033337599,
},
{
x: 12960623.783721833,
y: 4852142.918236917,
},
{
x: 12960610.08653878,
y: 4852142.2999238875,
},
{
x: 12960436.33035975,
y: 4852141.569412107,
},
{
x: 12960425.323876735,
y: 4852141.588789343,
},
{
x: 12960418.062649192,
y: 4852140.894469294,
},
{
x: 12960397.685451128,
y: 4852136.929909052,
},
{
x: 12960381.523315413,
y: 4852132.778561514,
},
{
x: 12960359.877821121,
y: 4852123.64158053,
},
{
x: 12960334.346658466,
y: 4852109.556173046,
},
{
x: 12960318.030734146,
y: 4852101.525721443,
},
{
x: 12960299.754816394,
y: 4852089.551346909,
},
{
x: 12960273.273841146,
y: 4852069.355692289,
},
{
x: 12960250.771053055,
y: 4852047.738776747,
},
{
x: 12960236.237871027,
y: 4852032.227379977,
},
{
x: 12960225.220958065,
y: 4852021.18490097,
},
{
x: 12960202.953132067,
y: 4851998.62513292,
},
{
x: 12960134.803431373,
y: 4851930.302729313,
},
{
x: 12960131.415559309,
y: 4851926.836000303,
},
{
x: 12960033.302394766,
y: 4851823.178699325,
},
{
x: 12959943.550656857,
y: 4851717.754021466,
},
{
x: 12959908.855465326,
y: 4851685.719289181,
},
{
x: 12959858.337924149,
y: 4851648.509466072,
},
{
x: 12959827.947234219,
y: 4851635.216304059,
},
{
x: 12959793.596422547,
y: 4851620.193270011,
},
{
x: 12959764.33089034,
y: 4851609.816513307,
},
{
x: 12959751.845001617,
y: 4851605.540422947,
},
{
x: 12959710.096488312,
y: 4851595.58055257,
},
{
x: 12959644.793413645,
y: 4851583.581423427,
},
{
x: 12959487.546643838,
y: 4851579.1003289465,
},
{
x: 12959322.352977112,
y: 4851573.1751883635,
},
{
x: 12959215.355539855,
y: 4851567.487059426,
},
{
x: 12958906.741867626,
y: 4851555.576738978,
},
{
x: 12958503.588496968,
y: 4851536.078897831,
},
{
x: 12958347.549098158,
y: 4851535.177370091,
},
{
x: 12958020.7967457,
y: 4851519.547451833,
},
{
x: 12958020.774536882,
y: 4851519.546442713,
},
{
x: 12957918.246551817,
y: 4851517.112404003,
},
{
x: 12957847.278726801,
y: 4851508.301972056,
},
{
x: 12957786.075293908,
y: 4851497.8561179675,
},
{
x: 12957620.930185705,
y: 4851464.46553163,
},
{
x: 12957553.206441535,
y: 4851451.069831951,
},
{
x: 12957184.967742233,
y: 4851438.277567215,
},
{
x: 12957151.372959128,
y: 4851442.83206844,
},
{
x: 12956984.39334164,
y: 4851457.2499878295,
},
{
x: 12956887.683125133,
y: 4851467.99801078,
},
{
x: 12956842.417678,
y: 4851471.246557499,
},
{
x: 12956795.847498052,
y: 4851471.877345327,
},
{
x: 12956726.805401612,
y: 4851470.21078116,
},
{
x: 12956719.005096909,
y: 4851470.206809098,
},
{
x: 12956690.032717621,
y: 4851466.331142748,
},
{
x: 12956671.745146377,
y: 4851465.288835637,
},
{
x: 12956647.92701909,
y: 4851464.086883708,
},
{
x: 12956432.678734198,
y: 4851457.009062028,
},
{
x: 12956305.238743283,
y: 4851452.754473514,
},
{
x: 12956260.077742493,
y: 4851451.052139781,
},
{
x: 12956108.520973446,
y: 4851442.943084553,
},
{
x: 12955979.955562841,
y: 4851437.82970239,
},
{
x: 12955830.878658453,
y: 4851433.243655892,
},
{
x: 12955632.99933834,
y: 4851425.357106182,
},
{
x: 12955594.773108216,
y: 4851423.831054184,
},
{
x: 12955514.958767148,
y: 4851420.40654864,
},
{
x: 12955415.916358192,
y: 4851415.173754157,
},
{
x: 12955412.341824232,
y: 4851415.068560076,
},
{
x: 12955220.500590362,
y: 4851409.551334249,
},
{
x: 12955177.214926412,
y: 4851406.5893032905,
},
{
x: 12955161.53826209,
y: 4851406.056397046,
},
{
x: 12955016.683409026,
y: 4851400.736845952,
},
{
x: 12954738.676569056,
y: 4851389.629311211,
},
{
x: 12954418.456831554,
y: 4851372.282889688,
},
{
x: 12954112.367106372,
y: 4851361.821497771,
},
{
x: 12954112.366906373,
y: 4851361.821497775,
},
{
x: 12954095.960447045,
y: 4851361.608137167,
},
{
x: 12954011.183086088,
y: 4851358.621103881,
},
{
x: 12953877.563076375,
y: 4851352.740857408,
},
{
x: 12953853.85732765,
y: 4851351.967020577,
},
{
x: 12953803.748811886,
y: 4851349.749490414,
},
{
x: 12953512.054691948,
y: 4851336.624567439,
},
{
x: 12953304.439376486,
y: 4851326.941645583,
},
{
x: 12953215.990118599,
y: 4851343.405356978,
},
{
x: 12953186.516178105,
y: 4851352.304914633,
},
{
x: 12953160.820809599,
y: 4851360.075985219,
},
{
x: 12953135.6284275,
y: 4851368.607839927,
},
{
x: 12953110.773697035,
y: 4851379.448142389,
},
{
x: 12953078.728780996,
y: 4851396.784940073,
},
{
x: 12953055.671146156,
y: 4851410.242045931,
},
{
x: 12953025.125081131,
y: 4851430.283492892,
},
{
x: 12953002.867918571,
y: 4851441.908865417,
},
{
x: 12952970.9803234,
y: 4851464.194335162,
},
{
x: 12952948.54425685,
y: 4851486.7574834535,
},
{
x: 12952924.669249073,
y: 4851516.663157407,
},
{
x: 12952893.865250975,
y: 4851558.425931095,
},
{
x: 12952868.114842031,
y: 4851601.291024181,
},
{
x: 12952849.72221334,
y: 4851633.9557742765,
},
{
x: 12952840.178024879,
y: 4851649.33032892,
},
{
x: 12952831.61507648,
y: 4851664.098507009,
},
{
x: 12952820.749844346,
y: 4851683.626532975,
},
{
x: 12952808.35960638,
y: 4851712.713968235,
},
{
x: 12952805.20735029,
y: 4851721.38335488,
},
{
x: 12952799.79260895,
y: 4851738.36548495,
},
{
x: 12952789.190178515,
y: 4851772.8758911565,
},
{
x: 12952788.761437649,
y: 4851774.851755323,
},
{
x: 12952777.120529784,
y: 4851828.491181396,
},
{
x: 12952769.442166151,
y: 4851865.129402015,
},
{
x: 12952767.325349899,
y: 4851875.233108534,
},
{
x: 12952767.225566436,
y: 4851887.288016115,
},
{
x: 12952766.931015346,
y: 4851923.099737246,
},
{
x: 12952761.952007528,
y: 4852049.700375895,
},
{
x: 12952753.300309705,
y: 4852305.149185844,
},
{
x: 12952748.81253644,
y: 4852466.605133841,
},
{
x: 12952741.572670683,
y: 4852644.392438163,
},
{
x: 12952738.74974852,
y: 4852719.016327442,
},
{
x: 12952741.79628366,
y: 4852826.032311127,
},
{
x: 12952754.022033157,
y: 4852951.122076449,
},
{
x: 12952755.67102211,
y: 4852968.493352729,
},
{
x: 12952758.734429048,
y: 4853002.058635834,
},
{
x: 12952761.031034866,
y: 4853033.715526356,
},
{
x: 12952761.5816642,
y: 4853041.308351835,
},
{
x: 12952765.105510674,
y: 4853089.883771956,
},
{
x: 12952768.26850136,
y: 4853131.897335772,
},
{
x: 12952769.995078206,
y: 4853158.94429872,
},
{
x: 12952770.288851582,
y: 4853209.010686412,
},
{
x: 12952769.71843731,
y: 4853247.566692912,
},
{
x: 12952767.145004591,
y: 4853346.541922129,
},
{
x: 12952765.253378324,
y: 4853436.619436339,
},
{
x: 12952765.214083849,
y: 4853437.930242571,
},
{
x: 12952764.052342676,
y: 4853458.187819974,
},
{
x: 12952760.168979194,
y: 4853554.878914973,
},
{
x: 12952757.95248891,
y: 4853628.164651818,
},
{
x: 12952754.901710529,
y: 4853716.499504081,
},
{
x: 12952752.129394304,
y: 4853804.555406498,
},
{
x: 12952749.6335356,
y: 4853872.268162026,
},
{
x: 12952743.72513416,
y: 4854014.227085098,
},
{
x: 12952741.487142773,
y: 4854096.795681505,
},
{
x: 12952740.271323254,
y: 4854189.877021544,
},
{
x: 12952735.244090632,
y: 4854295.470985418,
},
{
x: 12952732.246698955,
y: 4854403.93734809,
},
{
x: 12952731.594985832,
y: 4854421.351329048,
},
{
x: 12952728.21683085,
y: 4854497.1336529,
},
{
x: 12952727.968463881,
y: 4854504.109582829,
},
{
x: 12952726.933201442,
y: 4854533.194906944,
},
{
x: 12952726.57184963,
y: 4854544.113349503,
},
{
x: 12952721.050076714,
y: 4854688.295102883,
},
{
x: 12952720.966294285,
y: 4854713.652392979,
},
{
x: 12952718.064468559,
y: 4854769.647643217,
},
{
x: 12952715.044363484,
y: 4854852.440379618,
},
{
x: 12952709.221122695,
y: 4855060.2259299345,
},
{
x: 12952706.836731823,
y: 4855138.965809699,
},
{
x: 12952705.041061016,
y: 4855185.826583675,
},
{
x: 12952701.912666142,
y: 4855297.303072879,
},
{
x: 12952701.774883661,
y: 4855301.000993471,
},
{
x: 12952698.542893687,
y: 4855388.379772971,
},
{
x: 12952694.722481314,
y: 4855513.192139022,
},
{
x: 12952694.351429062,
y: 4855527.489094137,
},
{
x: 12952693.024699595,
y: 4855578.268289678,
},
{
x: 12952691.583080197,
y: 4855615.825893778,
},
{
x: 12952690.241251186,
y: 4855663.662486527,
},
{
x: 12952689.665623294,
y: 4855679.603567254,
},
{
x: 12952688.776130756,
y: 4855688.786687114,
},
{
x: 12952687.754061554,
y: 4855729.323832838,
},
{
x: 12952686.019483153,
y: 4855798.026277147,
},
{
x: 12952677.323277667,
y: 4856106.12994655,
},
{
x: 12952676.787444718,
y: 4856125.15381618,
},
{
x: 12952664.53774193,
y: 4856474.271753169,
},
{
x: 12952649.541640174,
y: 4856902.04310439,
},
{
x: 12952649.394057715,
y: 4856906.40602088,
},
{
x: 12952635.915840019,
y: 4857296.152572144,
},
{
x: 12952629.098613512,
y: 4857468.8577486845,
},
{
x: 12952638.14364149,
y: 4857509.197665979,
},
{
x: 12952650.97963757,
y: 4857566.931901507,
},
{
x: 12952656.040774604,
y: 4857583.179374015,
},
{
x: 12952668.497268757,
y: 4857619.1841071565,
},
{
x: 12952685.776569141,
y: 4857653.8455795515,
},
{
x: 12952706.290524684,
y: 4857693.299857913,
},
{
x: 12952720.33970559,
y: 4857717.258845025,
},
{
x: 12952728.768056454,
y: 4857729.804878156,
},
{
x: 12952742.39713164,
y: 4857747.850560737,
},
{
x: 12952755.039200235,
y: 4857761.81094819,
},
{
x: 12952769.509095559,
y: 4857774.792433353,
},
{
x: 12952782.996884435,
y: 4857785.801023545,
},
{
x: 12952788.77239826,
y: 4857789.984151489,
},
{
x: 12952798.589047497,
y: 4857797.094653569,
},
{
x: 12952808.39067999,
y: 4857802.308737876,
},
{
x: 12952837.452516967,
y: 4857817.2604270065,
},
{
x: 12952881.01716795,
y: 4857832.991883696,
},
{
x: 12952938.897575248,
y: 4857852.0831211675,
},
{
x: 12952998.780647367,
y: 4857874.054135021,
},
{
x: 12953258.491335763,
y: 4857983.238622202,
},
{
x: 12953413.859664995,
y: 4858039.332894681,
},
{
x: 12953461.589598283,
y: 4858056.89652088,
},
{
x: 12953597.722309152,
y: 4858106.241247336,
},
{
x: 12953667.79405445,
y: 4858131.433108243,
},
{
x: 12953748.275540665,
y: 4858167.149194927,
},
{
x: 12953812.476893716,
y: 4858200.790776387,
},
{
x: 12954043.962199515,
y: 4858326.647837333,
},
{
x: 12954069.141445398,
y: 4858340.297104379,
},
{
x: 12954072.957342735,
y: 4858342.340504059,
},
{
x: 12954114.16432913,
y: 4858364.427001315,
},
{
x: 12954137.618859049,
y: 4858375.535725627,
},
{
x: 12954295.058541333,
y: 4858440.811649338,
},
{
x: 12954302.457537467,
y: 4858443.441923854,
},
{
x: 12954310.15020407,
y: 4858445.926167106,
},
{
x: 12954332.638227137,
y: 4858452.508316665,
},
{
x: 12954353.823772585,
y: 4858458.21648571,
},
{
x: 12954389.227238271,
y: 4858467.144308251,
},
{
x: 12954466.181852238,
y: 4858479.982544497,
},
{
x: 12954466.70470393,
y: 4858480.069293314,
},
{
x: 12954681.711705219,
y: 4858497.4227523925,
},
{
x: 12954881.814571371,
y: 4858508.773537354,
},
{
x: 12954977.646000914,
y: 4858510.359249282,
},
{
x: 12955052.400974875,
y: 4858511.444873559,
},
{
x: 12955252.256507836,
y: 4858514.336868981,
},
{
x: 12955253.967495963,
y: 4858514.361726689,
},
{
x: 12955289.19954713,
y: 4858514.5128645515,
},
{
x: 12955354.90360536,
y: 4858516.033826125,
},
{
x: 12955355.483066956,
y: 4858516.047198033,
},
],
},
{
id: "1",
source: "2",
target: "3",
class: "地铁五号线",
name: "地铁五号线 0",
controlPoints: [
{
x: 12960720.74502968,
y: 4843624.831892422,
},
{
x: 12960633.531054523,
y: 4843628.020999428,
},
{
x: 12960615.721414793,
y: 4843628.698697272,
},
{
x: 12960529.018550536,
y: 4843631.993865521,
},
{
x: 12960395.923003213,
y: 4843634.498433887,
},
{
x: 12960303.4487313,
y: 4843658.086022387,
},
{
x: 12960247.83253429,
y: 4843698.236051296,
},
{
x: 12960198.244516307,
y: 4843756.513927734,
},
{
x: 12960152.936239943,
y: 4843826.831983379,
},
{
x: 12960093.80567492,
y: 4844050.470482044,
},
{
x: 12960074.685721893,
y: 4844241.260554531,
},
{
x: 12960067.43941915,
y: 4844443.961097181,
},
{
x: 12960064.463686703,
y: 4844812.802009133,
},
{
x: 12960051.958804457,
y: 4845167.465485617,
},
{
x: 12960045.686471423,
y: 4845319.993679029,
},
{
x: 12960040.290314263,
y: 4845427.501735388,
},
{
x: 12960000.078505961,
y: 4846409.670004274,
},
{
x: 12959967.360368509,
y: 4847353.92871215,
},
{
x: 12959903.599435318,
y: 4849086.018465949,
},
{
x: 12959897.308980407,
y: 4849189.719214646,
},
{
x: 12959894.110421222,
y: 4849203.583410498,
},
{
x: 12959890.4317169,
y: 4849219.531068828,
},
{
x: 12959886.89822709,
y: 4849232.656139195,
},
{
x: 12959877.73105254,
y: 4849260.436420323,
},
{
x: 12959865.561524102,
y: 4849290.043697017,
},
{
x: 12959837.38401807,
y: 4849362.616048384,
},
{
x: 12959808.903257467,
y: 4849435.004427626,
},
{
x: 12959779.115515891,
y: 4849512.45632027,
},
{
x: 12959744.160038425,
y: 4849599.294323696,
},
{
x: 12959725.117032269,
y: 4849657.80245415,
},
{
x: 12959719.313276159,
y: 4849682.1804609,
},
{
x: 12959715.446228703,
y: 4849703.304149181,
},
{
x: 12959711.903727653,
y: 4849724.430177948,
},
{
x: 12959709.011729391,
y: 4849753.676989364,
},
{
x: 12959707.415947258,
y: 4849783.8967948,
},
{
x: 12959706.932266207,
y: 4849809.126489505,
},
{
x: 12959706.941864654,
y: 4849836.458652587,
},
{
x: 12959706.941864647,
y: 4849836.458852586,
},
{
x: 12959706.73825638,
y: 4849843.058438657,
},
{
x: 12959701.188848983,
y: 4850022.751749156,
},
{
x: 12959698.75643586,
y: 4850092.048955763,
},
{
x: 12959696.677162938,
y: 4850153.857703244,
},
{
x: 12959695.78056296,
y: 4850188.632551699,
},
{
x: 12959694.918345,
y: 4850201.721921542,
},
{
x: 12959692.002134146,
y: 4850243.844071576,
},
{
x: 12959688.713196509,
y: 4850307.368296433,
},
{
x: 12959688.399038235,
y: 4850412.527108991,
},
{
x: 12959688.405735636,
y: 4850420.937318844,
},
{
x: 12959688.343863737,
y: 4850445.110083258,
},
{
x: 12959686.127736844,
y: 4850539.017117742,
},
{
x: 12959683.968880652,
y: 4850587.739754507,
},
{
x: 12959680.875828847,
y: 4850658.134830053,
},
{
x: 12959679.529814905,
y: 4850705.839287117,
},
{
x: 12959676.829087818,
y: 4850793.495084584,
},
{
x: 12959675.815426968,
y: 4850823.398964908,
},
{
x: 12959675.182101322,
y: 4850846.066167584,
},
{
x: 12959674.637837825,
y: 4850881.825140678,
},
{
x: 12959674.600854788,
y: 4850900.231972202,
},
{
x: 12959672.17730142,
y: 4850971.880703524,
},
{
x: 12959670.889156122,
y: 4851002.727395804,
},
{
x: 12959670.698638307,
y: 4851010.549985337,
},
{
x: 12959668.117749112,
y: 4851106.755282467,
},
{
x: 12959665.56854209,
y: 4851184.430341829,
},
{
x: 12959663.290916206,
y: 4851257.106068522,
},
{
x: 12959662.369610716,
y: 4851304.277585146,
},
{
x: 12959661.413917739,
y: 4851326.766808909,
},
{
x: 12959657.931598857,
y: 4851433.829044472,
},
{
x: 12959658.028261015,
y: 4851474.80850299,
},
{
x: 12959657.267483199,
y: 4851488.965234568,
},
{
x: 12959651.951822918,
y: 4851544.541841047,
},
{
x: 12959644.793413645,
y: 4851583.581423427,
},
{
x: 12959595.684288755,
y: 4852619.8846618915,
},
{
x: 12959574.465131808,
y: 4853929.7776421,
},
{
x: 12959536.880014552,
y: 4854963.031257658,
},
{
x: 12959497.404227743,
y: 4856298.871464132,
},
{
x: 12959482.020338908,
y: 4856720.60653976,
},
{
x: 12959481.210910158,
y: 4856745.719910398,
},
{
x: 12959480.218744718,
y: 4856801.67083334,
},
{
x: 12959480.657100372,
y: 4856811.732979886,
},
{
x: 12959473.537570594,
y: 4857026.976625398,
},
{
x: 12959472.67316361,
y: 4857117.529377648,
},
{
x: 12959471.826244202,
y: 4857148.4116494795,
},
{
x: 12959471.914116398,
y: 4857157.0041156085,
},
{
x: 12959471.914116394,
y: 4857157.004315607,
},
{
x: 12959468.421265613,
y: 4857243.442849801,
},
{
x: 12959465.42503048,
y: 4857320.248131243,
},
{
x: 12959457.359831337,
y: 4857487.904976163,
},
{
x: 12959441.732397161,
y: 4858203.22983063,
},
{
x: 12959436.13624882,
y: 4858459.380345282,
},
{
x: 12959415.193417262,
y: 4858615.8007214,
},
{
x: 12959400.093169626,
y: 4858713.511716538,
},
{
x: 12959399.09985982,
y: 4858740.126114421,
},
{
x: 12959398.923112214,
y: 4858756.581567208,
},
{
x: 12959400.425177053,
y: 4858770.664816282,
},
{
x: 12959403.329731172,
y: 4858781.277141151,
},
{
x: 12959406.81271103,
y: 4858791.891385901,
},
{
x: 12959411.454041706,
y: 4858801.77406984,
},
{
x: 12959416.960302725,
y: 4858809.912175236,
},
{
x: 12959421.887523,
y: 4858817.179145314,
},
{
x: 12959428.263989503,
y: 4858824.297946437,
},
{
x: 12959438.405571558,
y: 4858834.467323184,
},
{
x: 12959446.951603249,
y: 4858840.418765018,
},
{
x: 12959453.47044277,
y: 4858844.047635263,
},
{
x: 12959461.338227013,
y: 4858847.889734993,
},
{
x: 12959468.530699532,
y: 4858850.719229388,
},
{
x: 12959476.367733365,
y: 4858853.206677165,
},
{
x: 12959486.177776907,
y: 4858855.242211642,
},
{
x: 12959498.356965585,
y: 4858856.501662772,
},
{
x: 12959543.238861157,
y: 4858861.103129856,
},
{
x: 12959564.955544673,
y: 4858862.823145494,
},
{
x: 12959585.658078235,
y: 4858864.541516278,
},
{
x: 12959595.839429364,
y: 4858866.740035375,
},
{
x: 12959604.626178885,
y: 4858869.753969439,
},
{
x: 12959619.393890884,
y: 4858875.118084437,
},
{
x: 12959634.602011,
y: 4858883.533997516,
},
{
x: 12959647.926199682,
y: 4858893.114601357,
},
{
x: 12959659.08101609,
y: 4858903.862660445,
},
{
x: 12959672.122859873,
y: 4858920.571917142,
},
{
x: 12959683.284136135,
y: 4858939.464230514,
},
{
x: 12959691.987331163,
y: 4858961.4122961955,
},
{
x: 12959695.907905033,
y: 4858977.986510597,
},
{
x: 12959696.897168944,
y: 4858990.458458495,
},
{
x: 12959696.95704519,
y: 4859022.197030113,
},
{
x: 12959693.756261105,
y: 4859059.590188502,
},
{
x: 12959690.179340184,
y: 4859134.214310129,
},
{
x: 12959685.340567466,
y: 4859249.237691335,
},
{
x: 12959685.339668898,
y: 4859260.445091072,
},
{
x: 12959679.606577044,
y: 4859423.720155937,
},
{
x: 12959665.286089724,
y: 4859737.709063406,
},
{
x: 12959643.000270054,
y: 4860035.900026235,
},
{
x: 12959632.910441214,
y: 4860295.517810925,
},
{
x: 12959592.233549183,
y: 4861342.088331037,
},
{
x: 12959588.730015729,
y: 4861432.225749819,
},
{
x: 12959556.060278306,
y: 4862388.960503767,
},
{
x: 12959545.695101015,
y: 4862688.364754779,
},
{
x: 12959518.592346862,
y: 4863435.743969738,
},
{
x: 12959485.60762339,
y: 4864345.2318098685,
},
{
x: 12959486.001310887,
y: 4864482.759632916,
},
{
x: 12959486.585650299,
y: 4865230.9384146165,
},
{
x: 12959489.44520427,
y: 4865436.730097548,
},
{
x: 12959497.988421464,
y: 4865529.704413291,
},
{
x: 12959497.988421455,
y: 4865529.704613299,
},
{
x: 12959519.200702442,
y: 4865741.969269226,
},
{
x: 12959522.357194034,
y: 4865776.148131042,
},
{
x: 12959522.573317947,
y: 4865778.504652967,
},
{
x: 12959522.916097239,
y: 4865782.246629099,
},
{
x: 12959551.022895565,
y: 4866071.32380023,
},
{
x: 12959556.838158142,
y: 4866160.7037429465,
},
{
x: 12959551.949571997,
y: 4866262.940886653,
},
{
x: 12959540.38150212,
y: 4866354.7103297105,
},
{
x: 12959539.340979226,
y: 4866362.459925865,
},
{
x: 12959513.475078186,
y: 4866576.75533692,
},
{
x: 12959513.47507818,
y: 4866576.755436918,
},
{
x: 12959497.755400725,
y: 4866692.268572319,
},
{
x: 12959497.610949984,
y: 4866693.40672459,
},
{
x: 12959483.493606979,
y: 4866796.261737931,
},
{
x: 12959466.691132883,
y: 4866917.22829191,
},
{
x: 12959461.210504338,
y: 4866960.1057711635,
},
{
x: 12959426.407796139,
y: 4867225.807957604,
},
{
x: 12959418.801394718,
y: 4867288.213382227,
},
{
x: 12959416.692326868,
y: 4867306.0886218455,
},
{
x: 12959410.47637647,
y: 4867351.37610048,
},
{
x: 12959400.148907803,
y: 4867462.455263302,
},
{
x: 12959399.112409318,
y: 4867478.93856583,
},
{
x: 12959396.256439034,
y: 4867556.841285077,
},
{
x: 12959394.84524912,
y: 4867623.882782224,
},
{
x: 12959402.914618,
y: 4867739.272140503,
},
{
x: 12959407.505976537,
y: 4867797.003244392,
},
{
x: 12959415.808022052,
y: 4867872.177101691,
},
{
x: 12959437.831136882,
y: 4868003.5787004335,
},
{
x: 12959443.098101616,
y: 4868036.394816039,
},
{
x: 12959464.101440175,
y: 4868167.242968876,
},
{
x: 12959478.37498549,
y: 4868261.98680037,
},
{
x: 12959508.23051181,
y: 4868432.816097544,
},
{
x: 12959539.922123043,
y: 4868629.3165109595,
},
{
x: 12959551.24160535,
y: 4868728.22086592,
},
{
x: 12959555.049512597,
y: 4868834.379861189,
},
{
x: 12959557.09776522,
y: 4869178.128956159,
},
{
x: 12959557.46233141,
y: 4869212.439258056,
},
{
x: 12959560.523011155,
y: 4869592.048363338,
},
{
x: 12959577.865984676,
y: 4869718.394291774,
},
{
x: 12959590.012423703,
y: 4869827.204686913,
},
{
x: 12959595.795077762,
y: 4869869.18333726,
},
{
x: 12959598.248023918,
y: 4869952.360503471,
},
{
x: 12959599.56821579,
y: 4870095.040123146,
},
{
x: 12959609.728836436,
y: 4870531.437161518,
},
{
x: 12959603.972221585,
y: 4870603.500963714,
},
{
x: 12959588.040449219,
y: 4870699.62726807,
},
{
x: 12959577.341958042,
y: 4870759.729165575,
},
{
x: 12959552.550153958,
y: 4870890.017106278,
},
{
x: 12959549.504474476,
y: 4870907.895185102,
},
{
x: 12959536.238199469,
y: 4870980.633462292,
},
{
x: 12959519.906514881,
y: 4871059.136581221,
},
{
x: 12959498.606091205,
y: 4871123.470002014,
},
{
x: 12959483.02793797,
y: 4871158.4458806105,
},
{
x: 12959398.579719294,
y: 4871307.904408066,
},
{
x: 12959372.473708287,
y: 4871364.923557604,
},
{
x: 12959355.676189639,
y: 4871417.85108307,
},
{
x: 12959345.382419249,
y: 4871467.110988155,
},
{
x: 12959337.246138988,
y: 4871518.719362454,
},
{
x: 12959331.993689496,
y: 4871552.047085774,
},
{
x: 12959329.720869558,
y: 4871566.954753559,
},
{
x: 12959309.401737848,
y: 4871682.640660545,
},
{
x: 12959284.09575571,
y: 4871813.104051212,
},
{
x: 12959272.141485408,
y: 4871880.577467433,
},
{
x: 12959212.679174809,
y: 4872024.938082188,
},
{
x: 12959122.218527583,
y: 4872236.515550644,
},
{
x: 12959101.497205438,
y: 4872286.842893077,
},
{
x: 12959082.233978389,
y: 4872332.857224708,
},
{
x: 12959064.438388105,
y: 4872374.568487362,
},
{
x: 12959002.833097033,
y: 4872476.910775585,
},
{
x: 12958978.720982237,
y: 4872510.998020613,
},
{
x: 12958934.40716439,
y: 4872572.781793622,
},
{
x: 12958888.474905616,
y: 4872641.302003023,
},
{
x: 12958847.253143456,
y: 4872732.877987774,
},
{
x: 12958840.613299651,
y: 4872775.301160091,
},
{
x: 12958826.01344493,
y: 4872861.8293480575,
},
{
x: 12958817.526527362,
y: 4873017.26494393,
},
{
x: 12958814.054718142,
y: 4873226.284171534,
},
{
x: 12958816.11193364,
y: 4873266.055943593,
},
{
x: 12958816.129135203,
y: 4873290.15488096,
},
{
x: 12958821.354560152,
y: 4873309.887136759,
},
{
x: 12958841.32562995,
y: 4873397.115248937,
},
{
x: 12958844.285408415,
y: 4873409.713148855,
},
{
x: 12958847.915875804,
y: 4873422.442037873,
},
{
x: 12958889.630321097,
y: 4873507.434415227,
},
{
x: 12958925.449787276,
y: 4873574.258471447,
},
{
x: 12959052.396737209,
y: 4873809.916450764,
},
{
x: 12959072.334776778,
y: 4873851.7039971035,
},
{
x: 12959091.382334014,
y: 4873912.579314463,
},
{
x: 12959103.205925986,
y: 4873994.365655067,
},
{
x: 12959105.049669469,
y: 4874040.715385412,
},
{
x: 12959098.781538986,
y: 4874130.696496499,
},
{
x: 12959091.653604891,
y: 4874277.942229356,
},
{
x: 12959073.762015432,
y: 4874560.621555201,
},
{
x: 12959055.88026487,
y: 4874851.491609374,
},
{
x: 12959035.313639542,
y: 4875190.5466335295,
},
{
x: 12959020.984397592,
y: 4875394.165125814,
},
{
x: 12958976.23099209,
y: 4876077.778969328,
},
{
x: 12958959.745692749,
y: 4876337.611516656,
},
{
x: 12958959.782791425,
y: 4876388.517880667,
},
{
x: 12958963.47494545,
y: 4876487.604684548,
},
{
x: 12958978.051701134,
y: 4876614.863733437,
},
{
x: 12959002.615098093,
y: 4876782.118274665,
},
{
x: 12959044.457185756,
y: 4877060.270620597,
},
{
x: 12959067.219679391,
y: 4877241.168949157,
},
{
x: 12959071.783226173,
y: 4877290.243072816,
},
{
x: 12959070.11534219,
y: 4877482.0814475445,
},
{
x: 12959050.419169253,
y: 4877777.579645479,
},
{
x: 12959032.750496056,
y: 4878102.221159315,
},
{
x: 12959032.750496058,
y: 4878102.221259315,
},
{
x: 12959003.26866052,
y: 4878470.802548815,
},
{
x: 12959000.418311324,
y: 4878535.557270987,
},
{
x: 12958996.46075172,
y: 4878573.393290567,
},
{
x: 12958986.710555336,
y: 4878612.325690378,
},
{
x: 12958984.36114175,
y: 4878620.285756933,
},
{
x: 12958979.482719835,
y: 4878633.567604723,
},
{
x: 12958971.70519758,
y: 4878648.669953857,
},
{
x: 12958960.310788708,
y: 4878668.732809022,
},
{
x: 12958954.159688484,
y: 4878678.6962916935,
},
{
x: 12958940.408512954,
y: 4878697.079788669,
},
{
x: 12958920.863620294,
y: 4878718.556967109,
},
{
x: 12958911.0902516,
y: 4878726.568490176,
},
{
x: 12958895.161451222,
y: 4878738.950175331,
},
{
x: 12958883.032721909,
y: 4878747.3254355155,
},
{
x: 12958866.73870309,
y: 4878756.433205192,
},
{
x: 12958839.217742998,
y: 4878769.914421513,
},
{
x: 12958816.400635526,
y: 4878777.388295637,
},
{
x: 12958783.623366289,
y: 4878784.917193882,
},
{
x: 12958771.309150409,
y: 4878786.744063957,
},
{
x: 12958739.429878792,
y: 4878788.584452175,
},
{
x: 12958705.738986243,
y: 4878786.424910058,
},
{
x: 12958578.932445105,
y: 4878772.682927707,
},
{
x: 12958490.16318142,
y: 4878762.546866739,
},
{
x: 12958476.030639933,
y: 4878759.645153562,
},
{
x: 12958398.482079366,
y: 4878738.585155731,
},
{
x: 12958337.60009126,
y: 4878723.697450009,
},
{
x: 12958319.258018306,
y: 4878717.823743411,
},
{
x: 12958285.414545368,
y: 4878706.985809459,
},
{
x: 12958281.24441303,
y: 4878706.124142206,
},
{
x: 12958265.300704759,
y: 4878704.674592208,
},
{
x: 12958248.322873216,
y: 4878700.7330124155,
},
{
x: 12958235.48402549,
y: 4878697.874149074,
},
{
x: 12958209.66504376,
y: 4878694.661718712,
},
{
x: 12958185.394430613,
y: 4878692.518259022,
},
{
x: 12958163.832025072,
y: 4878687.433936088,
},
{
x: 12958149.29817478,
y: 4878683.5722363135,
},
{
x: 12958127.588537483,
y: 4878677.8039692715,
},
{
x: 12958103.488411777,
y: 4878671.445979302,
},
{
x: 12958088.084013943,
y: 4878666.72080967,
},
{
x: 12958073.22210372,
y: 4878661.450932288,
},
{
x: 12958053.105073934,
y: 4878653.090874466,
},
{
x: 12958019.939165607,
y: 4878639.8218743205,
},
{
x: 12957987.498125235,
y: 4878626.005036278,
},
{
x: 12957976.804148829,
y: 4878622.369122046,
},
{
x: 12957959.95128188,
y: 4878618.734327142,
},
{
x: 12957933.674733272,
y: 4878614.921507571,
},
],
},
{
id: "2",
source: "4",
target: "5",
class: "地铁房山线",
name: "地铁房山线 0",
controlPoints: [
{
x: 12924448.17238817,
y: 4826880.333482542,
},
{
x: 12924525.979211709,
y: 4826872.878344628,
},
{
x: 12924651.003975658,
y: 4826850.186382258,
},
{
x: 12924772.909010362,
y: 4826831.637862584,
},
{
x: 12924892.815210382,
y: 4826808.910764785,
},
{
x: 12924979.825081667,
y: 4826797.17955122,
},
{
x: 12925084.39744784,
y: 4826783.365645579,
},
{
x: 12925155.81120956,
y: 4826773.302022665,
},
{
x: 12925191.531802883,
y: 4826763.145386636,
},
{
x: 12925246.401130036,
y: 4826741.508641205,
},
{
x: 12925289.809143692,
y: 4826716.000219138,
},
{
x: 12925328.122217724,
y: 4826687.913828323,
},
{
x: 12925435.446934095,
y: 4826589.547291209,
},
{
x: 12925667.935929714,
y: 4826383.866700324,
},
{
x: 12925703.114335984,
y: 4826349.828286723,
},
{
x: 12925770.622207448,
y: 4826279.8993723765,
},
{
x: 12925812.089063462,
y: 4826236.363691168,
},
{
x: 12925860.064926796,
y: 4826185.624213163,
},
{
x: 12925972.45908047,
y: 4826067.695006573,
},
{
x: 12926072.836947165,
y: 4825968.627523454,
},
{
x: 12926117.70970191,
y: 4825926.122953221,
},
{
x: 12926163.925422803,
y: 4825891.864408059,
},
{
x: 12926224.487089904,
y: 4825859.005237854,
},
{
x: 12926272.713245494,
y: 4825838.833351052,
},
{
x: 12926306.225330409,
y: 4825828.247220456,
},
{
x: 12926323.66112753,
y: 4825823.471552652,
},
{
x: 12926342.999038229,
y: 4825815.638790402,
},
{
x: 12926395.038321048,
y: 4825807.019948717,
},
{
x: 12926456.619666297,
y: 4825801.386693386,
},
{
x: 12926771.931888463,
y: 4825802.616129439,
},
{
x: 12926851.048048986,
y: 4825801.631130125,
},
{
x: 12926918.475671358,
y: 4825800.789146462,
},
{
x: 12927029.359667536,
y: 4825801.827672996,
},
{
x: 12927182.830807276,
y: 4825803.048420769,
},
{
x: 12927499.41885292,
y: 4825801.064920832,
},
{
x: 12927985.316114604,
y: 4825802.302803997,
},
{
x: 12928151.253302878,
y: 4825800.059199896,
},
{
x: 12928748.07329185,
y: 4825800.240476295,
},
{
x: 12929111.030443402,
y: 4825800.274953787,
},
{
x: 12929262.734959431,
y: 4825802.042122076,
},
{
x: 12929411.395781256,
y: 4825802.035455338,
},
{
x: 12929506.992909838,
y: 4825802.706934221,
},
{
x: 12929650.07556503,
y: 4825802.544157764,
},
{
x: 12929720.668591391,
y: 4825802.142241587,
},
{
x: 12929772.983434387,
y: 4825800.887369454,
},
{
x: 12929857.446321096,
y: 4825798.160825567,
},
{
x: 12929912.070413183,
y: 4825797.961849597,
},
{
x: 12930020.049115648,
y: 4825798.40702736,
},
{
x: 12930163.955832295,
y: 4825797.372447041,
},
{
x: 12930397.554672962,
y: 4825796.54976334,
},
{
x: 12930475.738706259,
y: 4825796.886377486,
},
{
x: 12930546.696718559,
y: 4825797.190814849,
},
{
x: 12930678.19064345,
y: 4825796.767765474,
},
{
x: 12930758.84637836,
y: 4825797.611875748,
},
{
x: 12930844.12941692,
y: 4825797.184218957,
},
{
x: 12931658.797219362,
y: 4825797.407901417,
},
{
x: 12932033.235206187,
y: 4825795.320207194,
},
{
x: 12932233.393439343,
y: 4825794.180152587,
},
{
x: 12932721.308799969,
y: 4825803.219910631,
},
{
x: 12932928.523249036,
y: 4825803.557711617,
},
{
x: 12933053.790329,
y: 4825812.987185039,
},
{
x: 12933138.900921563,
y: 4825833.806609662,
},
{
x: 12933190.809829095,
y: 4825856.349271142,
},
{
x: 12933226.429307265,
y: 4825874.795930243,
},
{
x: 12933272.213535246,
y: 4825905.5475769965,
},
{
x: 12933330.19116232,
y: 4825952.706628941,
},
{
x: 12933394.224417783,
y: 4826031.661583878,
},
{
x: 12933434.848204572,
y: 4826099.343443693,
},
{
x: 12933457.160278024,
y: 4826153.699179631,
},
{
x: 12933477.393874265,
y: 4826231.651463547,
},
{
x: 12933483.411973838,
y: 4826283.965274176,
},
{
x: 12933484.24966211,
y: 4826383.467920047,
},
{
x: 12933484.612918697,
y: 4826744.564537366,
},
{
x: 12933484.578816487,
y: 4826763.36453251,
},
{
x: 12933483.779386565,
y: 4826924.895615106,
},
{
x: 12933482.610669505,
y: 4827007.992815708,
},
{
x: 12933492.646572754,
y: 4827092.110644749,
},
{
x: 12933513.41196703,
y: 4827439.884337276,
},
{
x: 12933543.228519833,
y: 4827854.75280781,
},
{
x: 12933566.570100563,
y: 4828176.552121379,
},
{
x: 12933594.643939137,
y: 4828596.572517603,
},
{
x: 12933629.925192222,
y: 4829103.087824667,
},
{
x: 12933645.64381434,
y: 4829320.597027384,
},
{
x: 12933649.89045366,
y: 4829382.144115338,
},
{
x: 12933667.168927083,
y: 4829632.556420974,
},
{
x: 12933676.117122944,
y: 4829774.023766041,
},
{
x: 12933682.081289982,
y: 4829869.157117123,
},
{
x: 12933689.928693485,
y: 4829940.817807672,
},
{
x: 12933703.310192509,
y: 4830006.297419812,
},
{
x: 12933719.154849395,
y: 4830066.214843579,
},
{
x: 12933755.774424188,
y: 4830174.310550475,
},
{
x: 12933810.744445253,
y: 4830313.90749861,
},
{
x: 12933922.503728205,
y: 4830609.788269573,
},
{
x: 12934038.543576436,
y: 4830918.028547641,
},
{
x: 12934058.694520555,
y: 4830974.859139696,
},
{
x: 12934069.58014834,
y: 4831005.072471465,
},
{
x: 12934119.846976575,
y: 4831143.433958218,
},
{
x: 12934149.991077174,
y: 4831222.949836257,
},
{
x: 12934198.033104936,
y: 4831349.678156342,
},
{
x: 12934223.473509623,
y: 4831400.412253144,
},
{
x: 12934259.369952803,
y: 4831461.028016709,
},
{
x: 12934309.114426302,
y: 4831520.072779361,
},
{
x: 12934377.085065225,
y: 4831581.991332408,
},
{
x: 12934396.69835483,
y: 4831595.164926664,
},
{
x: 12934437.243386144,
y: 4831618.212550709,
},
{
x: 12934478.449542966,
y: 4831638.623777254,
},
{
x: 12934524.898399867,
y: 4831655.075704626,
},
{
x: 12934580.515549589,
y: 4831668.889447878,
},
{
x: 12934636.143351322,
y: 4831676.770691342,
},
{
x: 12934666.908025475,
y: 4831679.39163554,
},
{
x: 12934765.756048232,
y: 4831678.685510442,
},
{
x: 12934930.73367185,
y: 4831674.651678714,
},
{
x: 12935250.876591342,
y: 4831667.251747576,
},
{
x: 12935499.671785736,
y: 4831663.187574107,
},
{
x: 12935746.513249094,
y: 4831659.130713738,
},
{
x: 12935815.915508969,
y: 4831660.42132409,
},
{
x: 12935908.050789848,
y: 4831663.982781072,
},
{
x: 12935967.815653212,
y: 4831666.293463208,
},
{
x: 12936241.494185515,
y: 4831674.4963234225,
},
{
x: 12936369.370711273,
y: 4831678.336400013,
},
{
x: 12936425.785732588,
y: 4831676.31555289,
},
{
x: 12936581.316240864,
y: 4831673.037189442,
},
{
x: 12936633.370649267,
y: 4831674.963771561,
},
{
x: 12936737.713978717,
y: 4831679.370178035,
},
{
x: 12936831.315349536,
y: 4831683.322450787,
},
{
x: 12936877.589160608,
y: 4831685.252679165,
},
{
x: 12936910.361308584,
y: 4831690.419854687,
},
{
x: 12936949.558532905,
y: 4831696.881239256,
},
{
x: 12936987.467610013,
y: 4831706.574167675,
},
{
x: 12937022.15788816,
y: 4831719.5039792955,
},
{
x: 12937065.199754963,
y: 4831736.958924886,
},
{
x: 12937110.158974504,
y: 4831760.881236912,
},
{
x: 12937157.036534246,
y: 4831793.8590075895,
},
{
x: 12937199.404558316,
y: 4831833.307823846,
},
{
x: 12937237.91287837,
y: 4831875.343509309,
},
{
x: 12937258.446807722,
y: 4831901.211682247,
},
{
x: 12937284.10526521,
y: 4831938.723324833,
},
{
x: 12937312.95239147,
y: 4831994.991182708,
},
{
x: 12937327.68762551,
y: 4832030.564244142,
},
{
x: 12937343.684707167,
y: 4832083.600788961,
},
{
x: 12937351.972602425,
y: 4832131.461705969,
},
{
x: 12937358.31940185,
y: 4832186.438225887,
},
{
x: 12937355.622857124,
y: 4832274.4059191365,
},
{
x: 12937339.975481886,
y: 4832427.060379704,
},
{
x: 12937324.788945852,
y: 4832705.848365801,
},
{
x: 12937293.01305762,
y: 4832897.32304263,
},
{
x: 12937270.892804373,
y: 4833079.740939002,
},
{
x: 12937248.767915612,
y: 4833263.455352972,
},
{
x: 12937209.689481642,
y: 4833612.138889359,
},
{
x: 12937165.784590699,
y: 4834031.900756954,
},
{
x: 12937138.418116648,
y: 4834222.711592586,
},
{
x: 12937083.08660543,
y: 4834535.844936789,
},
{
x: 12937052.334413424,
y: 4834663.757169239,
},
{
x: 12936994.342385216,
y: 4834895.126983638,
},
{
x: 12936953.854431149,
y: 4835030.737985154,
},
{
x: 12936869.843218748,
y: 4835313.3219827665,
},
{
x: 12936862.532161772,
y: 4835339.778036121,
},
{
x: 12936836.320704404,
y: 4835434.637730703,
},
{
x: 12936827.217503313,
y: 4835519.169988192,
},
{
x: 12936827.124637516,
y: 4835581.758973662,
},
{
x: 12936837.906126408,
y: 4835663.063325517,
},
{
x: 12936864.056538468,
y: 4835757.266142062,
},
{
x: 12936880.668495258,
y: 4835797.917881852,
},
{
x: 12936907.667939143,
y: 4835847.318738415,
},
{
x: 12936952.878761742,
y: 4835914.1082075,
},
{
x: 12937000.216170117,
y: 4835969.234486032,
},
{
x: 12937063.361933991,
y: 4836023.2971759755,
},
{
x: 12937143.36704171,
y: 4836079.4810301885,
},
{
x: 12937217.081887215,
y: 4836115.519519725,
},
{
x: 12937329.790312514,
y: 4836151.556748291,
},
{
x: 12937431.328256749,
y: 4836175.655924688,
},
{
x: 12937851.122850813,
y: 4836275.4876682935,
},
{
x: 12938154.622310877,
y: 4836341.2390868,
},
{
x: 12938362.244614977,
y: 4836390.037264124,
},
{
x: 12938503.041870078,
y: 4836411.664485504,
},
{
x: 12938564.047320768,
y: 4836418.793423229,
},
{
x: 12938988.303480383,
y: 4836457.009886602,
},
{
x: 12939480.568825236,
y: 4836493.208155112,
},
{
x: 12939792.38983277,
y: 4836515.385447704,
},
{
x: 12940262.993302846,
y: 4836548.909357694,
},
{
x: 12940393.59269819,
y: 4836559.504709913,
},
{
x: 12940478.91780255,
y: 4836571.822251312,
},
{
x: 12940790.622461848,
y: 4836636.837138435,
},
{
x: 12941203.633091165,
y: 4836730.122990206,
},
{
x: 12941712.749939607,
y: 4836839.200160033,
},
{
x: 12942167.786199445,
y: 4836936.5137574095,
},
{
x: 12942294.984682916,
y: 4836959.65357408,
},
{
x: 12942610.524821742,
y: 4837005.682620561,
},
{
x: 12942843.547300853,
y: 4837039.413158133,
},
{
x: 12943166.318173433,
y: 4837086.947605261,
},
{
x: 12943510.46784253,
y: 4837134.81698191,
},
{
x: 12943617.3707184,
y: 4837150.799628537,
},
{
x: 12943658.487001108,
y: 4837158.769269097,
},
{
x: 12943691.736804834,
y: 4837167.08383111,
},
{
x: 12943717.587123148,
y: 4837172.921819401,
},
{
x: 12943814.810048617,
y: 4837200.232098826,
},
{
x: 12943917.263605423,
y: 4837238.058053253,
},
{
x: 12943974.78713743,
y: 4837264.277939439,
},
{
x: 12944030.153658753,
y: 4837291.952562648,
},
{
x: 12944135.650915911,
y: 4837354.294186727,
},
{
x: 12944445.141549075,
y: 4837528.417611227,
},
{
x: 12944644.509050895,
y: 4837635.945078776,
},
{
x: 12944685.94060137,
y: 4837654.409708789,
},
{
x: 12944719.086739298,
y: 4837669.359215808,
},
{
x: 12944794.975247588,
y: 4837699.716510274,
},
{
x: 12944947.1976908,
y: 4837760.873124597,
},
{
x: 12945035.745333357,
y: 4837798.266491122,
},
{
x: 12945124.72566364,
y: 4837845.286033468,
},
{
x: 12945270.414963193,
y: 4837921.319729365,
},
{
x: 12945450.582071586,
y: 4838013.632744957,
},
{
x: 12945577.533408465,
y: 4838080.445217846,
},
{
x: 12945834.434212714,
y: 4838202.613398697,
},
{
x: 12946075.31690205,
y: 4838296.146027662,
},
{
x: 12946292.279576164,
y: 4838360.532187274,
},
{
x: 12946521.019224824,
y: 4838491.165573925,
},
{
x: 12946638.949600644,
y: 4838621.542593471,
},
{
x: 12946650.686066799,
y: 4838737.438298838,
},
],
},
{
id: "3",
source: "6",
target: "7",
class: "地铁亦庄线",
name: "地铁亦庄线 0",
controlPoints: [
{
x: 12960801.92985531,
y: 4843268.231642703,
},
{
x: 12960819.048596159,
y: 4842751.648234617,
},
{
x: 12960883.71369413,
y: 4842268.659267911,
},
{
x: 12960932.9503868,
y: 4842163.931739517,
},
{
x: 12961006.927248925,
y: 4842097.692273121,
},
{
x: 12961168.66192465,
y: 4842014.7338780835,
},
{
x: 12962601.717469966,
y: 4841896.79575762,
},
{
x: 12962754.46753597,
y: 4841885.241291034,
},
{
x: 12962943.500290178,
y: 4841880.673982279,
},
{
x: 12963012.112349365,
y: 4841876.615867013,
},
{
x: 12963059.010006737,
y: 4841861.67650217,
},
{
x: 12963116.452138275,
y: 4841834.8158408785,
},
{
x: 12963210.447880082,
y: 4841771.47221078,
},
{
x: 12963235.833946913,
y: 4841754.363392143,
},
{
x: 12963662.654879957,
y: 4841466.647965242,
},
{
x: 12964038.994342858,
y: 4841212.831358209,
},
{
x: 12964154.545155134,
y: 4841070.441342094,
},
{
x: 12964171.735590378,
y: 4841010.993206987,
},
{
x: 12964339.916463993,
y: 4840434.314594529,
},
{
x: 12964343.389385078,
y: 4840399.329742603,
},
{
x: 12964334.817316562,
y: 4840225.397102979,
},
{
x: 12964331.221136974,
y: 4840162.554061632,
},
{
x: 12964328.50535713,
y: 4840100.593094604,
},
{
x: 12964332.779831221,
y: 4840004.0775054535,
},
{
x: 12964346.582668858,
y: 4839794.207556842,
},
{
x: 12964363.097590594,
y: 4839601.773416806,
},
{
x: 12964380.328964364,
y: 4839365.602941362,
},
{
x: 12964385.8482237,
y: 4839211.548689884,
},
{
x: 12964387.499547305,
y: 4839127.002529577,
},
{
x: 12964391.276917182,
y: 4838985.794324284,
},
{
x: 12964392.443018869,
y: 4838864.958482721,
},
{
x: 12964394.955731656,
y: 4838766.690857032,
},
{
x: 12964393.975998627,
y: 4838687.027470687,
},
{
x: 12964387.294707682,
y: 4838617.567328025,
},
{
x: 12964367.416052649,
y: 4838539.309062238,
},
{
x: 12964347.51619,
y: 4838431.650587995,
},
{
x: 12964322.767169563,
y: 4838324.645467618,
},
{
x: 12964313.562428541,
y: 4838262.541243617,
},
{
x: 12964310.411869453,
y: 4838225.729635625,
},
{
x: 12964309.355618041,
y: 4838208.017849213,
},
{
x: 12964309.656222237,
y: 4838174.319843992,
},
{
x: 12964311.684558112,
y: 4838140.960443022,
},
{
x: 12964317.833830703,
y: 4838091.9543595165,
},
{
x: 12964329.018005343,
y: 4838019.745353896,
},
{
x: 12964357.57037216,
y: 4837928.397117701,
},
{
x: 12964379.95742845,
y: 4837836.721116149,
},
{
x: 12964395.761376698,
y: 4837785.937210788,
},
{
x: 12964408.481659109,
y: 4837751.494051737,
},
{
x: 12964423.958059136,
y: 4837713.2194660455,
},
{
x: 12964454.929082762,
y: 4837651.608776794,
},
{
x: 12964485.908545986,
y: 4837599.028090593,
},
{
x: 12964502.078122087,
y: 4837575.000819509,
},
{
x: 12964507.944067815,
y: 4837566.284373945,
},
{
x: 12964538.941616124,
y: 4837526.901722564,
},
{
x: 12964580.623847708,
y: 4837481.571345544,
},
{
x: 12964632.30168787,
y: 4837432.37855521,
},
{
x: 12964707.289879689,
y: 4837377.0810903795,
},
{
x: 12964746.5828552,
y: 4837352.947415166,
},
{
x: 12964787.599945143,
y: 4837330.888655926,
},
{
x: 12964847.234552702,
y: 4837303.540100147,
},
{
x: 12964952.379239444,
y: 4837263.837261641,
},
{
x: 12965041.659042722,
y: 4837228.367036585,
},
{
x: 12965086.817706559,
y: 4837212.190291242,
},
{
x: 12965125.425630035,
y: 4837197.083091712,
},
{
x: 12965198.852510314,
y: 4837173.487209741,
},
{
x: 12965285.035077993,
y: 4837148.788444636,
},
{
x: 12965345.022458684,
y: 4837136.015256971,
},
{
x: 12965376.741696445,
y: 4837131.008352433,
},
{
x: 12965413.288189877,
y: 4837126.675422853,
},
{
x: 12965466.732716972,
y: 4837121.571415942,
},
{
x: 12965495.35177725,
y: 4837119.3559531085,
},
{
x: 12965530.521028334,
y: 4837117.112703386,
},
{
x: 12965593.968191253,
y: 4837116.473776446,
},
{
x: 12965649.486601945,
y: 4837118.648806222,
},
{
x: 12965697.768784914,
y: 4837122.941340376,
},
{
x: 12965780.881747998,
y: 4837133.843576874,
},
{
x: 12965906.431954557,
y: 4837162.43093923,
},
{
x: 12966118.21979879,
y: 4837224.64350029,
},
{
x: 12966330.35727124,
y: 4837296.215654915,
},
{
x: 12966430.728530029,
y: 4837328.721880014,
},
{
x: 12966526.230111593,
y: 4837358.910915481,
},
{
x: 12966643.884234305,
y: 4837396.097468287,
},
{
x: 12966715.9714909,
y: 4837420.053074277,
},
{
x: 12966775.298984269,
y: 4837442.68182159,
},
{
x: 12966834.282130612,
y: 4837464.615069852,
},
{
x: 12966877.402287401,
y: 4837483.848933528,
},
{
x: 12966941.220910013,
y: 4837513.053573998,
},
{
x: 12967048.56698116,
y: 4837567.953487057,
},
{
x: 12967160.356455721,
y: 4837633.033932691,
},
{
x: 12967341.830451151,
y: 4837734.223029286,
},
{
x: 12967598.515018187,
y: 4837876.520746398,
},
{
x: 12967695.550281677,
y: 4837931.8672629995,
},
{
x: 12967769.295083275,
y: 4837973.927233142,
},
{
x: 12967806.210225426,
y: 4837994.921276422,
},
{
x: 12967880.373314308,
y: 4838029.263222194,
},
{
x: 12967942.458581364,
y: 4838054.463929446,
},
{
x: 12968006.949619304,
y: 4838074.960467259,
},
{
x: 12968064.880156811,
y: 4838089.239839763,
},
{
x: 12968160.7317529,
y: 4838106.785960654,
},
{
x: 12968223.818423554,
y: 4838111.656953844,
},
{
x: 12968280.003925696,
y: 4838113.086931953,
},
{
x: 12968326.878944056,
y: 4838112.138498563,
},
{
x: 12968367.54589312,
y: 4838109.4857799625,
},
{
x: 12968389.51656575,
y: 4838106.448409635,
},
{
x: 12968438.187831255,
y: 4838099.719152986,
},
{
x: 12968498.833145326,
y: 4838088.619169914,
},
{
x: 12968538.110375632,
y: 4838079.370846887,
},
{
x: 12968616.314083783,
y: 4838057.750684839,
},
{
x: 12968698.633058043,
y: 4838023.949189746,
},
{
x: 12968811.931290373,
y: 4837966.003419178,
},
{
x: 12968881.824553497,
y: 4837922.53959489,
},
{
x: 12968943.430079784,
y: 4837870.786756742,
},
{
x: 12969022.924111847,
y: 4837800.520362136,
},
{
x: 12969055.9530577,
y: 4837765.945136667,
},
{
x: 12969084.843050089,
y: 4837731.392991392,
},
{
x: 12969120.958078042,
y: 4837688.466172142,
},
{
x: 12969155.332209961,
y: 4837635.4723625,
},
{
x: 12969242.285513127,
y: 4837496.730319538,
},
{
x: 12969333.712761667,
y: 4837355.187852096,
},
{
x: 12969408.647255532,
y: 4837235.936020544,
},
{
x: 12969513.801304353,
y: 4837064.791048047,
},
{
x: 12969590.779687598,
y: 4836941.394981127,
},
{
x: 12969705.899936745,
y: 4836755.955416486,
},
{
x: 12969806.238916375,
y: 4836594.567940544,
},
{
x: 12969938.533153186,
y: 4836382.639398942,
},
{
x: 12970039.8160462,
y: 4836217.531831086,
},
{
x: 12970129.245947173,
y: 4836071.878209337,
},
{
x: 12970220.246216761,
y: 4835926.897614078,
},
{
x: 12970286.073547151,
y: 4835822.025633852,
},
{
x: 12970415.07546836,
y: 4835612.642595116,
},
{
x: 12970568.870650535,
y: 4835365.18734994,
},
{
x: 12970669.724938907,
y: 4835202.376148994,
},
{
x: 12970752.484735584,
y: 4835070.152439515,
},
{
x: 12970832.895625059,
y: 4834939.975857269,
},
{
x: 12970899.569476828,
y: 4834832.910757041,
},
{
x: 12971033.918129083,
y: 4834616.066050077,
},
{
x: 12971144.158073269,
y: 4834433.937266104,
},
{
x: 12971198.069970135,
y: 4834344.871445297,
},
{
x: 12971305.26943295,
y: 4834167.479451596,
},
{
x: 12971364.235194443,
y: 4834074.351988931,
},
{
x: 12971525.71156008,
y: 4833814.364471716,
},
{
x: 12971682.679083303,
y: 4833562.284042895,
},
{
x: 12971812.288419375,
y: 4833350.753875024,
},
{
x: 12972017.979800759,
y: 4833021.125112385,
},
{
x: 12972103.744545488,
y: 4832885.194999167,
},
{
x: 12972135.257382995,
y: 4832846.417732776,
},
{
x: 12972160.077781122,
y: 4832821.220722371,
},
{
x: 12972199.662509607,
y: 4832785.10628778,
},
{
x: 12972264.123885086,
y: 4832742.901302573,
},
{
x: 12972264.12408505,
y: 4832742.901202536,
},
{
x: 12972324.21434308,
y: 4832713.4141902095,
},
{
x: 12972386.305619905,
y: 4832692.675651716,
},
{
x: 12972428.804140508,
y: 4832685.222868618,
},
{
x: 12972485.012097614,
y: 4832680.520476171,
},
{
x: 12972542.168608952,
y: 4832680.834396475,
},
{
x: 12972604.011630796,
y: 4832688.654398485,
},
{
x: 12972644.212348452,
y: 4832699.10386752,
},
{
x: 12972696.734916897,
y: 4832717.642597281,
},
{
x: 12972757.695351638,
y: 4832749.00336457,
},
{
x: 12972859.999908108,
y: 4832813.088811927,
},
{
x: 12972941.093523078,
y: 4832860.97338974,
},
{
x: 12973004.727402989,
y: 4832901.107069043,
},
{
x: 12973063.375094922,
y: 4832939.388312671,
},
{
x: 12973118.709117647,
y: 4832976.2564467145,
},
{
x: 12973157.278549964,
y: 4833001.955820043,
},
{
x: 12973287.045299167,
y: 4833078.76948663,
},
{
x: 12973336.018910544,
y: 4833107.376876498,
},
{
x: 12973532.737387815,
y: 4833234.050880133,
},
{
x: 12973711.056147737,
y: 4833345.140835251,
},
{
x: 12973939.785549805,
y: 4833486.730983602,
},
{
x: 12974177.84357694,
y: 4833635.477147498,
},
{
x: 12974448.095380764,
y: 4833804.380259698,
},
{
x: 12974616.656587714,
y: 4833906.469350846,
},
{
x: 12974744.179042902,
y: 4833983.66343434,
},
{
x: 12974848.457567113,
y: 4834048.738895861,
},
{
x: 12975023.307596708,
y: 4834158.038177878,
},
{
x: 12975344.80631824,
y: 4834362.369596276,
},
{
x: 12975542.195598783,
y: 4834485.718127945,
},
{
x: 12975589.153098417,
y: 4834515.976788436,
},
{
x: 12975743.362999665,
y: 4834615.341611351,
},
{
x: 12976018.28541726,
y: 4834788.58647766,
},
{
x: 12976156.837017762,
y: 4834874.4406398935,
},
{
x: 12976203.26410973,
y: 4834903.209489788,
},
{
x: 12976425.749449603,
y: 4835044.1395141035,
},
{
x: 12976682.803252261,
y: 4835209.05760146,
},
{
x: 12977612.288689816,
y: 4836078.591476348,
},
{
x: 12977703.538800083,
y: 4836157.900805114,
},
{
x: 12977801.888863295,
y: 4836235.662686368,
},
{
x: 12978758.33292605,
y: 4837259.312987513,
},
{
x: 12978842.971959101,
y: 4837349.736883194,
},
{
x: 12979531.54154612,
y: 4838049.719256911,
},
{
x: 12979689.378903074,
y: 4838256.735438744,
},
{
x: 12980051.853140548,
y: 4838731.323685468,
},
{
x: 12980384.15998818,
y: 4839120.990048823,
},
{
x: 12980467.93565266,
y: 4839255.613023306,
},
{
x: 12980521.623321274,
y: 4839397.296177998,
},
{
x: 12980529.827086125,
y: 4839430.697709363,
},
{
x: 12980535.501366084,
y: 4839564.805608976,
},
{
x: 12980538.135068312,
y: 4840222.645451332,
},
{
x: 12980538.379641674,
y: 4840283.5996034695,
},
{
x: 12980538.543424217,
y: 4840324.221498785,
},
{
x: 12980535.067586645,
y: 4840405.430398631,
},
{
x: 12980525.345959615,
y: 4840470.937074263,
},
{
x: 12980513.995958695,
y: 4840544.736949112,
},
],
},
{
id: "4",
source: "8",
target: "9",
class: "地铁一号线",
name: "地铁一号线 0",
controlPoints: [
{
x: 12969787.144385956,
y: 4852662.477041108,
},
{
x: 12969236.284285808,
y: 4852670.237943584,
},
{
x: 12968944.36629118,
y: 4852676.464039239,
},
{
x: 12968472.728321342,
y: 4852684.58530441,
},
{
x: 12968414.420578972,
y: 4852687.842999674,
},
{
x: 12968235.54912727,
y: 4852697.8323459625,
},
{
x: 12968069.523958666,
y: 4852708.845800531,
},
{
x: 12967520.284252618,
y: 4852709.247613191,
},
{
x: 12967117.366149856,
y: 4852665.62205985,
},
{
x: 12966772.612022452,
y: 4852628.17396013,
},
{
x: 12966517.096762186,
y: 4852623.936320605,
},
{
x: 12966223.985369124,
y: 4852617.830735498,
},
{
x: 12964521.542056274,
y: 4852636.984637193,
},
{
x: 12964462.063732337,
y: 4852637.63680008,
},
{
x: 12964380.646967553,
y: 4852638.41249018,
},
{
x: 12964310.636384122,
y: 4852638.548196548,
},
{
x: 12964259.391907305,
y: 4852638.609292217,
},
{
x: 12964063.789477564,
y: 4852640.250627404,
},
{
x: 12964002.433399238,
y: 4852641.068996505,
},
{
x: 12963990.595935801,
y: 4852641.261031478,
},
{
x: 12963890.25903454,
y: 4852642.515969342,
},
{
x: 12963809.987625448,
y: 4852643.546429879,
},
{
x: 12963781.834338633,
y: 4852643.942282169,
},
{
x: 12963774.327120606,
y: 4852643.970398907,
},
{
x: 12963455.081045607,
y: 4852646.588025983,
},
{
x: 12963322.230220675,
y: 4852647.784045951,
},
{
x: 12963223.166991241,
y: 4852649.725733759,
},
{
x: 12963190.819152791,
y: 4852650.417434513,
},
{
x: 12963127.561328052,
y: 4852650.0517423265,
},
{
x: 12963039.607865393,
y: 4852649.766256757,
},
{
x: 12962819.058636826,
y: 4852651.358893755,
},
{
x: 12962593.866965737,
y: 4852653.665194887,
},
{
x: 12962462.408622202,
y: 4852654.791986625,
},
{
x: 12962183.756523842,
y: 4852657.365475698,
},
{
x: 12962157.173752429,
y: 4852659.766562548,
},
{
x: 12961924.104038442,
y: 4852660.11712501,
},
{
x: 12961924.059855,
y: 4852660.116942157,
},
{
x: 12961900.696391538,
y: 4852660.033076115,
},
{
x: 12961567.092653673,
y: 4852663.388779601,
},
{
x: 12961454.569802668,
y: 4852664.505495348,
},
{
x: 12961217.079500727,
y: 4852658.515584384,
},
{
x: 12961149.13715287,
y: 4852657.212458487,
},
{
x: 12961133.237071244,
y: 4852657.247371087,
},
{
x: 12961027.846655574,
y: 4852654.2780048065,
},
{
x: 12960863.900760658,
y: 4852649.966801163,
},
{
x: 12960818.644700909,
y: 4852648.896293183,
},
{
x: 12960637.184863163,
y: 4852644.743311257,
},
{
x: 12960624.025816733,
y: 4852644.477645673,
},
{
x: 12960602.480219977,
y: 4852643.937047354,
},
{
x: 12960506.031680021,
y: 4852641.9318091385,
},
{
x: 12960391.353551494,
y: 4852639.083787939,
},
{
x: 12960320.201913092,
y: 4852637.313773441,
},
{
x: 12960062.18095632,
y: 4852628.1362550985,
},
{
x: 12959904.438548937,
y: 4852627.023597047,
},
{
x: 12959595.684288755,
y: 4852619.8846618915,
},
{
x: 12959323.178066703,
y: 4852609.481755874,
},
{
x: 12958840.802221617,
y: 4852590.942915122,
},
{
x: 12957502.352622895,
y: 4852528.684166141,
},
{
x: 12956620.835296787,
y: 4852504.508925668,
},
{
x: 12955674.942021938,
y: 4852471.61015628,
},
{
x: 12955416.308852747,
y: 4852469.018503432,
},
{
x: 12954706.035138829,
y: 4852461.803325078,
},
{
x: 12953928.716739,
y: 4852464.489858927,
},
{
x: 12952788.83672684,
y: 4852466.54282573,
},
{
x: 12952748.81253644,
y: 4852466.605133841,
},
{
x: 12951563.203060223,
y: 4852477.671537925,
},
{
x: 12951199.751181506,
y: 4852495.122833292,
},
{
x: 12950198.141508736,
y: 4852495.025451202,
},
{
x: 12949965.299984097,
y: 4852495.077305805,
},
{
x: 12949129.26242653,
y: 4852504.598358415,
},
{
x: 12947838.444126923,
y: 4852505.90698292,
},
{
x: 12947589.306786017,
y: 4852505.320736883,
},
{
x: 12945901.390879856,
y: 4852501.577557874,
},
{
x: 12944980.974916212,
y: 4852499.625168126,
},
{
x: 12943548.12132782,
y: 4852497.380847655,
},
{
x: 12942376.001682293,
y: 4852500.03430738,
},
{
x: 12941203.789519304,
y: 4852502.985840143,
},
{
x: 12939774.001753055,
y: 4852500.299665425,
},
{
x: 12938324.854233196,
y: 4852497.834034189,
},
{
x: 12938281.788912078,
y: 4852497.828983922,
},
{
x: 12938058.817138307,
y: 4852497.810737135,
},
{
x: 12937898.86276059,
y: 4852497.3685845565,
},
{
x: 12937671.875809424,
y: 4852496.791572168,
},
{
x: 12937460.220387606,
y: 4852497.967734828,
},
{
x: 12937174.041187,
y: 4852498.731022245,
},
{
x: 12937173.96999806,
y: 4852498.730233027,
},
{
x: 12937136.194604035,
y: 4852498.300376261,
},
{
x: 12936946.821682766,
y: 4852498.918736944,
},
{
x: 12936849.614381388,
y: 4852498.356186343,
},
{
x: 12936692.322356569,
y: 4852497.959326306,
},
{
x: 12936587.17645106,
y: 4852498.5677669365,
},
{
x: 12934252.339824114,
y: 4852499.457888381,
},
{
x: 12934092.666854141,
y: 4852498.783005591,
},
{
x: 12933957.2920676,
y: 4852554.157396755,
},
{
x: 12933867.245068891,
y: 4852636.768727248,
},
{
x: 12933790.29537299,
y: 4852771.049393255,
},
{
x: 12933709.54499776,
y: 4852986.243814959,
},
{
x: 12933275.354659256,
y: 4854146.7353322515,
},
],
},
{
id: "5",
source: "10",
target: "11",
class: "地铁大兴线",
name: "地铁大兴线 0",
controlPoints: [
{
x: 12954320.097829182,
y: 4841755.370768595,
},
{
x: 12954269.565863218,
y: 4841475.231416884,
},
{
x: 12954109.467427691,
y: 4840587.804965775,
},
{
x: 12953795.666789988,
y: 4838847.936111765,
},
{
x: 12953779.74076359,
y: 4838781.406112334,
},
{
x: 12953764.911988458,
y: 4838735.372116771,
},
{
x: 12953728.040718146,
y: 4838684.612972186,
},
{
x: 12953200.942060454,
y: 4837849.787883376,
},
{
x: 12953071.02731984,
y: 4837651.869209399,
},
{
x: 12952979.616992796,
y: 4837589.00545091,
},
{
x: 12952903.159508042,
y: 4837579.42379109,
},
{
x: 12952782.211602798,
y: 4837577.388802782,
},
{
x: 12952678.006507806,
y: 4837568.850794091,
},
{
x: 12952630.246652557,
y: 4837568.346663251,
},
{
x: 12952563.144880537,
y: 4837569.3784104185,
},
{
x: 12952459.727695232,
y: 4837576.654353493,
},
{
x: 12952047.259057738,
y: 4837602.473680529,
},
{
x: 12951992.11263072,
y: 4837607.014363404,
},
{
x: 12951930.600837775,
y: 4837607.287158209,
},
{
x: 12951859.333033504,
y: 4837604.988006545,
},
{
x: 12951659.950799704,
y: 4837590.463923004,
},
{
x: 12951511.86811374,
y: 4837581.708907432,
},
{
x: 12951503.592170091,
y: 4837581.306936129,
},
{
x: 12951471.758692794,
y: 4837579.760443551,
},
{
x: 12951416.434195919,
y: 4837581.464508876,
},
{
x: 12951320.836636368,
y: 4837591.26673181,
},
{
x: 12951208.471245904,
y: 4837608.1171654025,
},
{
x: 12951130.332944639,
y: 4837620.206020496,
},
{
x: 12951053.162266875,
y: 4837624.532130631,
},
{
x: 12950994.073467728,
y: 4837620.818036712,
},
{
x: 12950952.099045333,
y: 4837614.236065724,
},
{
x: 12950903.02068405,
y: 4837603.431351229,
},
{
x: 12950854.265358152,
y: 4837586.804646552,
},
{
x: 12950803.897617934,
y: 4837565.966975064,
},
{
x: 12950750.622557428,
y: 4837538.00750994,
},
{
x: 12950713.171179097,
y: 4837512.0295137195,
},
{
x: 12950613.406373397,
y: 4837431.864322759,
},
{
x: 12950473.803516785,
y: 4837318.037136518,
},
{
x: 12950224.739204535,
y: 4837111.815739738,
},
{
x: 12949781.71624435,
y: 4836761.283068602,
},
{
x: 12949728.565575039,
y: 4836716.7570553925,
},
{
x: 12949703.653419532,
y: 4836690.060944494,
},
{
x: 12949670.437469736,
y: 4836646.1427171705,
},
{
x: 12949640.546313735,
y: 4836599.462744173,
},
{
x: 12949602.355321119,
y: 4836518.919640969,
},
{
x: 12949581.32899617,
y: 4836447.855053628,
},
{
x: 12949571.933781365,
y: 4836366.283691224,
},
{
x: 12949570.99564922,
y: 4836297.018513739,
},
{
x: 12949583.773060184,
y: 4836131.096596216,
},
{
x: 12949630.95790481,
y: 4835587.242148269,
},
{
x: 12949644.605106963,
y: 4835427.978435933,
},
{
x: 12949674.069930378,
y: 4835084.076939791,
},
{
x: 12949741.123785608,
y: 4834412.860058607,
},
{
x: 12949881.255387962,
y: 4833114.597124276,
},
{
x: 12949988.167188657,
y: 4831634.321648644,
},
{
x: 12950011.8904392,
y: 4831024.642033773,
},
{
x: 12950045.949834898,
y: 4830169.250105037,
},
{
x: 12950067.86965607,
y: 4829187.531131907,
},
{
x: 12950068.411119526,
y: 4828643.488667632,
},
{
x: 12950089.439076275,
y: 4827012.598861079,
},
{
x: 12950075.332266735,
y: 4825735.265538567,
},
{
x: 12950077.6177772,
y: 4825610.926281617,
},
{
x: 12950063.743562018,
y: 4825551.423688702,
},
{
x: 12949886.484341538,
y: 4825355.5838901615,
},
{
x: 12949714.24435096,
y: 4825240.542840744,
},
{
x: 12948810.72447873,
y: 4824919.1962220995,
},
{
x: 12948630.372620959,
y: 4824779.957329413,
},
{
x: 12948551.763527192,
y: 4824562.001534207,
},
{
x: 12948571.333401924,
y: 4824233.799839876,
},
{
x: 12948851.677430334,
y: 4820591.681083957,
},
{
x: 12948856.025176648,
y: 4820535.340838382,
},
{
x: 12948857.519128771,
y: 4820485.531178259,
},
],
},
{
id: "6",
source: "12",
target: "13",
class: "地铁四号线",
name: "地铁四号线 0",
controlPoints: [
{
x: 12954373.657756021,
y: 4843560.934009259,
},
{
x: 12954403.308395952,
y: 4844637.092136642,
},
{
x: 12954443.631939387,
y: 4845049.84687948,
},
{
x: 12954465.385927541,
y: 4845230.316998346,
},
{
x: 12954477.104733607,
y: 4845295.713890768,
},
{
x: 12954510.159202749,
y: 4845363.4843960125,
},
{
x: 12954722.716019211,
y: 4845628.35857464,
},
{
x: 12954922.594454948,
y: 4845874.895440882,
},
{
x: 12955211.028271338,
y: 4846209.062552702,
},
{
x: 12955269.78815066,
y: 4846334.5600019405,
},
{
x: 12955267.306704495,
y: 4846529.094981971,
},
{
x: 12955200.99362026,
y: 4846713.313157282,
},
{
x: 12955050.45468214,
y: 4846989.573067081,
},
{
x: 12954853.97442472,
y: 4847378.402945743,
},
{
x: 12954774.906886864,
y: 4847675.2444390515,
},
{
x: 12954731.85449024,
y: 4848212.883938044,
},
{
x: 12954744.79924884,
y: 4848786.391306657,
},
{
x: 12954747.612023802,
y: 4849835.643590178,
},
{
x: 12954747.682216099,
y: 4849861.774043528,
},
{
x: 12954741.08816034,
y: 4850881.230635524,
},
{
x: 12954737.645653786,
y: 4851386.201206222,
},
{
x: 12954721.760149185,
y: 4851926.74810973,
},
{
x: 12954706.035138829,
y: 4852461.803325078,
},
{
x: 12954661.27452527,
y: 4853769.120768002,
},
{
x: 12954633.49377667,
y: 4854880.847809376,
},
{
x: 12954587.535533391,
y: 4856278.18149549,
},
{
x: 12954557.952698175,
y: 4857155.485744631,
},
{
x: 12954557.437163154,
y: 4857170.770202318,
},
{
x: 12954537.64640468,
y: 4857234.798733779,
},
{
x: 12954507.61800925,
y: 4857265.498611502,
},
{
x: 12954448.18840873,
y: 4857290.387739614,
},
{
x: 12954389.022163786,
y: 4857304.787614773,
},
{
x: 12954302.10618948,
y: 4857314.253741188,
},
{
x: 12954046.446788153,
y: 4857314.448443049,
},
{
x: 12952788.718781503,
y: 4857298.136733208,
},
{
x: 12952635.915840019,
y: 4857296.152572144,
},
{
x: 12952564.595755607,
y: 4857295.107641618,
},
{
x: 12952364.409316596,
y: 4857273.12227582,
},
{
x: 12952154.040871462,
y: 4857235.468350076,
},
{
x: 12951969.43909615,
y: 4857201.456667664,
},
{
x: 12951808.104168849,
y: 4857155.825128381,
},
{
x: 12951795.707910977,
y: 4857150.112186163,
},
{
x: 12951672.542241815,
y: 4857093.348351254,
},
{
x: 12951530.459501661,
y: 4857032.392475653,
},
{
x: 12951457.165035697,
y: 4857016.611367204,
},
{
x: 12951413.82925054,
y: 4857010.241801462,
},
{
x: 12951362.398381047,
y: 4857007.948880891,
},
{
x: 12951289.260741765,
y: 4857006.283719927,
},
{
x: 12951243.494159421,
y: 4857003.966436169,
},
{
x: 12951198.613096055,
y: 4857003.604147996,
},
{
x: 12951191.52223199,
y: 4857003.216630181,
},
{
x: 12951176.410532618,
y: 4857002.724713779,
},
{
x: 12950664.103792224,
y: 4856969.636138788,
},
{
x: 12950490.915616779,
y: 4856960.604637075,
},
{
x: 12950376.449417142,
y: 4856957.730451393,
},
{
x: 12950275.412423559,
y: 4856958.095432962,
},
{
x: 12950197.754097624,
y: 4856965.795888429,
},
{
x: 12950087.769172028,
y: 4856976.7011729805,
},
{
x: 12949969.030407438,
y: 4856988.731925641,
},
{
x: 12949611.385620916,
y: 4857033.614270364,
},
{
x: 12949433.088418497,
y: 4857064.900798794,
},
{
x: 12949359.045249254,
y: 4857097.992433988,
},
{
x: 12949324.284422386,
y: 4857141.787668212,
},
{
x: 12949323.829516204,
y: 4857143.221560914,
},
{
x: 12949294.040752294,
y: 4857237.088716105,
},
{
x: 12949290.965819698,
y: 4857281.5241520675,
},
{
x: 12949290.844836328,
y: 4857284.326685918,
},
{
x: 12949286.84859171,
y: 4857363.3786635455,
},
{
x: 12949255.74271649,
y: 4857669.774620552,
},
{
x: 12949251.021282567,
y: 4857716.034187529,
},
{
x: 12949240.534414742,
y: 4857818.781418282,
},
{
x: 12949229.599655101,
y: 4857925.935052169,
},
{
x: 12949223.285025857,
y: 4857987.8014169345,
},
{
x: 12949218.68930698,
y: 4858032.839792737,
},
{
x: 12949202.705857255,
y: 4858189.081518219,
},
{
x: 12949201.91675542,
y: 4858197.081514944,
},
{
x: 12949188.720634252,
y: 4858325.005565848,
},
{
x: 12949171.484932527,
y: 4858492.101118972,
},
{
x: 12949140.242605533,
y: 4858794.965387163,
},
{
x: 12949128.462758997,
y: 4858908.105794337,
},
{
x: 12949119.684607878,
y: 4858997.242106079,
},
{
x: 12949117.630120248,
y: 4859021.712509141,
},
{
x: 12949113.161648553,
y: 4859077.167116614,
},
{
x: 12949110.991163222,
y: 4859101.470621213,
},
{
x: 12949110.099969309,
y: 4859112.821822983,
},
{
x: 12949108.911677599,
y: 4859127.083425599,
},
{
x: 12949101.505333235,
y: 4859206.231246072,
},
{
x: 12949098.141760852,
y: 4859235.087958121,
},
{
x: 12949086.945661454,
y: 4859330.204405712,
},
{
x: 12949080.506525062,
y: 4859390.090037273,
},
{
x: 12949072.760807924,
y: 4859454.574381684,
},
{
x: 12949053.421043288,
y: 4859613.1813176535,
},
{
x: 12949006.291508188,
y: 4860099.103019413,
},
{
x: 12948987.273876615,
y: 4860281.083185734,
},
{
x: 12948981.095505225,
y: 4860340.214580902,
},
{
x: 12948971.386815451,
y: 4860438.818238612,
},
{
x: 12948968.790673513,
y: 4860465.186182631,
},
{
x: 12948957.099444743,
y: 4860583.923590711,
},
{
x: 12948954.944696926,
y: 4860602.30153119,
},
{
x: 12948953.629329322,
y: 4860611.371156355,
},
{
x: 12948945.376137566,
y: 4860665.772419023,
},
{
x: 12948943.371389516,
y: 4860677.809759844,
},
{
x: 12948941.428640455,
y: 4860688.287999877,
},
{
x: 12948940.027077485,
y: 4860695.8687290335,
},
{
x: 12948933.979640268,
y: 4860726.099657515,
},
{
x: 12948928.21129958,
y: 4860754.943783897,
},
{
x: 12948925.53477491,
y: 4860767.8741438445,
},
{
x: 12948914.390798561,
y: 4860816.020402436,
},
{
x: 12948908.818966143,
y: 4860838.981437038,
},
{
x: 12948891.21272109,
y: 4860906.962985634,
},
{
x: 12948891.084425297,
y: 4860907.371989038,
},
{
x: 12948849.368497113,
y: 4861042.125295077,
},
{
x: 12948835.90431828,
y: 4861088.737227414,
},
{
x: 12948830.296142103,
y: 4861108.420813816,
},
{
x: 12948822.04407856,
y: 4861138.651794888,
},
{
x: 12948813.499036651,
y: 4861166.617294492,
},
{
x: 12948805.08019881,
y: 4861193.008798196,
},
{
x: 12948779.113573417,
y: 4861277.779889043,
},
{
x: 12948764.04589559,
y: 4861326.974101848,
},
{
x: 12948764.026496535,
y: 4861327.037202654,
},
{
x: 12948753.359326178,
y: 4861360.815953497,
},
{
x: 12948743.747416658,
y: 4861389.941771785,
},
{
x: 12948718.178381432,
y: 4861470.921841358,
},
{
x: 12948696.13872888,
y: 4861543.199816692,
},
{
x: 12948691.345809,
y: 4861558.918058851,
},
{
x: 12948670.805545585,
y: 4861626.292230624,
},
{
x: 12948635.660998613,
y: 4861741.800393923,
},
{
x: 12948620.137949644,
y: 4861792.813013884,
},
{
x: 12948586.362157172,
y: 4861900.900528574,
},
{
x: 12948570.146171637,
y: 4861955.959000696,
},
{
x: 12948553.55913321,
y: 4862007.46980901,
},
{
x: 12948506.607909067,
y: 4862151.020102147,
},
{
x: 12948474.477154713,
y: 4862249.710439044,
},
{
x: 12948433.854782313,
y: 4862372.508539395,
},
{
x: 12948405.896567902,
y: 4862457.026555028,
},
{
x: 12948387.467864858,
y: 4862540.95750102,
},
{
x: 12948369.72084694,
y: 4862608.589042327,
},
{
x: 12948351.287448928,
y: 4862705.352991365,
},
{
x: 12948349.399856329,
y: 4862717.969572795,
},
{
x: 12948342.9554688,
y: 4862761.161096935,
},
{
x: 12948334.103059907,
y: 4862815.789967469,
},
{
x: 12948330.745336216,
y: 4862847.533998459,
},
{
x: 12948330.324781813,
y: 4862857.667238568,
},
{
x: 12948330.719618713,
y: 4862923.321583864,
},
{
x: 12948329.271456743,
y: 4863030.035711758,
},
{
x: 12948318.983617261,
y: 4863152.700650098,
},
{
x: 12948308.624791207,
y: 4863323.528821448,
},
{
x: 12948305.573238118,
y: 4863383.023344128,
},
{
x: 12948304.882713268,
y: 4863410.205718649,
},
{
x: 12948304.34907461,
y: 4863418.883075538,
},
{
x: 12948304.349074604,
y: 4863418.883175537,
},
{
x: 12948293.57852302,
y: 4863594.090943488,
},
{
x: 12948292.26537664,
y: 4863615.222388438,
},
{
x: 12948285.911429897,
y: 4863694.78289179,
},
{
x: 12948279.888862576,
y: 4863721.625153882,
},
{
x: 12948276.328498306,
y: 4863738.652548549,
},
{
x: 12948273.0212985,
y: 4863779.761424982,
},
{
x: 12948271.391195413,
y: 4863804.060012918,
},
{
x: 12948269.44583099,
y: 4863833.063038297,
},
{
x: 12948268.544436276,
y: 4863862.57964908,
},
{
x: 12948264.951457486,
y: 4863980.229798113,
},
{
x: 12948262.743327497,
y: 4864012.842760259,
},
{
x: 12948253.95970473,
y: 4864163.393230665,
},
{
x: 12948251.540303396,
y: 4864206.470731608,
},
{
x: 12948212.079753308,
y: 4864794.335183325,
},
{
x: 12948192.775449837,
y: 4865057.815886522,
},
{
x: 12948172.296877252,
y: 4865301.5112607,
},
{
x: 12948164.786289226,
y: 4865392.804538419,
},
{
x: 12948154.255917,
y: 4865512.14757284,
},
{
x: 12948154.255917,
y: 4865512.1477728365,
},
{
x: 12948149.74303433,
y: 4865560.011840421,
},
{
x: 12948144.366829144,
y: 4865612.142398512,
},
{
x: 12948143.959623424,
y: 4865618.525997311,
},
{
x: 12948137.439734928,
y: 4865720.508486359,
},
{
x: 12948107.519605923,
y: 4865814.2291544955,
},
{
x: 12948078.069647746,
y: 4865856.462480031,
},
{
x: 12948024.306038419,
y: 4865884.525941556,
},
{
x: 12947948.793208137,
y: 4865895.857790665,
},
{
x: 12947726.110412342,
y: 4865901.65407643,
},
{
x: 12947662.03325602,
y: 4865903.549335554,
},
{
x: 12947582.728775566,
y: 4865884.474219018,
},
{
x: 12947578.428732935,
y: 4865883.43990478,
},
{
x: 12947516.084078891,
y: 4865861.968135664,
},
{
x: 12947457.991019811,
y: 4865841.929292836,
},
{
x: 12947430.320338927,
y: 4865825.17744688,
},
{
x: 12947403.34891173,
y: 4865801.908641243,
},
{
x: 12947385.583410634,
y: 4865783.125515066,
},
{
x: 12947366.462947419,
y: 4865758.28002787,
},
{
x: 12947349.636991477,
y: 4865736.761035594,
},
{
x: 12947325.434427919,
y: 4865705.9521581745,
},
{
x: 12947293.294439247,
y: 4865662.223273893,
},
{
x: 12947280.026460873,
y: 4865645.503535422,
},
{
x: 12947272.790190758,
y: 4865637.152186299,
},
{
x: 12947264.45234974,
y: 4865630.50206878,
},
{
x: 12947253.895662466,
y: 4865622.890310138,
},
{
x: 12947242.3961359,
y: 4865615.799413275,
},
{
x: 12947228.023148427,
y: 4865608.898160762,
},
{
x: 12947219.081559768,
y: 4865605.561492597,
},
{
x: 12947209.673061684,
y: 4865603.139115063,
},
{
x: 12947199.896463385,
y: 4865601.658737004,
},
{
x: 12947170.376100887,
y: 4865598.241728645,
},
{
x: 12947114.262342412,
y: 4865594.002744353,
},
{
x: 12947069.303568143,
y: 4865590.097302363,
},
{
x: 12946996.955287198,
y: 4865580.432522639,
},
{
x: 12946941.228131976,
y: 4865573.255125918,
},
{
x: 12946900.084918642,
y: 4865569.517658332,
},
{
x: 12946822.761463061,
y: 4865560.673446433,
},
{
x: 12946727.614742137,
y: 4865552.84563637,
},
{
x: 12946678.905013254,
y: 4865548.119018174,
},
{
x: 12946642.17997207,
y: 4865544.956115833,
},
{
x: 12946584.893309405,
y: 4865543.859270443,
},
{
x: 12946544.506879704,
y: 4865545.213818521,
},
{
x: 12946501.165103968,
y: 4865545.26638306,
},
{
x: 12946422.048745677,
y: 4865542.2614939865,
},
{
x: 12946366.591065088,
y: 4865538.478497777,
},
{
x: 12946343.54274385,
y: 4865536.796393288,
},
{
x: 12946313.331102742,
y: 4865534.072102609,
},
{
x: 12946276.992936801,
y: 4865530.295722415,
},
{
x: 12946044.983768271,
y: 4865506.53848812,
},
{
x: 12946044.982468616,
y: 4865506.538388461,
},
{
x: 12945999.054564236,
y: 4865501.51634233,
},
{
x: 12945939.11875475,
y: 4865501.919490546,
},
{
x: 12945842.188083762,
y: 4865505.838142619,
},
{
x: 12945841.360324211,
y: 4865506.238193714,
},
{
x: 12945718.088826543,
y: 4865565.803399573,
},
{
x: 12945361.171856038,
y: 4865725.241244186,
},
{
x: 12945288.888034362,
y: 4865771.876347319,
},
{
x: 12944971.787632536,
y: 4865960.501491743,
},
{
x: 12944694.050529143,
y: 4866125.748562615,
},
{
x: 12944571.275779925,
y: 4866175.496896087,
},
{
x: 12944486.984637886,
y: 4866196.026940467,
},
{
x: 12944376.91914833,
y: 4866212.279980763,
},
{
x: 12943875.491423381,
y: 4866303.184805465,
},
{
x: 12943715.625648474,
y: 4866329.140561554,
},
{
x: 12943691.286623739,
y: 4866336.782693048,
},
{
x: 12943666.684753045,
y: 4866355.700580207,
},
{
x: 12943647.036226608,
y: 4866386.77867161,
},
{
x: 12943618.683377,
y: 4866431.5171539625,
},
{
x: 12943575.591938026,
y: 4866503.065200196,
},
{
x: 12943549.272841655,
y: 4866548.372445914,
},
{
x: 12943513.655516205,
y: 4866606.664160266,
},
{
x: 12943464.443157,
y: 4866692.552688016,
},
{
x: 12943362.33352031,
y: 4866844.144888357,
},
{
x: 12943298.332087196,
y: 4866965.865469642,
},
{
x: 12943194.660765983,
y: 4867152.9265388595,
},
{
x: 12943140.884084987,
y: 4867273.386822292,
},
{
x: 12943114.423065275,
y: 4867594.932334096,
},
{
x: 12943113.763426922,
y: 4867602.948598135,
},
{
x: 12943108.181515867,
y: 4867757.799791251,
},
],
},
{
id: "7",
source: "14",
target: "15",
class: "地铁六号线",
name: "地铁六号线 0",
controlPoints: [
{
x: 12944329.792132245,
y: 4856125.732393313,
},
{
x: 12944374.963417206,
y: 4856132.075934602,
},
{
x: 12944438.830775484,
y: 4856136.896376604,
},
{
x: 12944515.16641718,
y: 4856137.056480541,
},
{
x: 12944577.483953971,
y: 4856135.625803216,
},
{
x: 12944642.924413817,
y: 4856126.389908644,
},
{
x: 12944711.48482392,
y: 4856114.036716937,
},
{
x: 12944790.955263415,
y: 4856098.58349056,
},
{
x: 12944854.842780758,
y: 4856089.348004857,
},
{
x: 12944925.484679118,
y: 4856086.034136885,
},
{
x: 12944964.41973033,
y: 4856083.331773158,
},
{
x: 12944978.393002376,
y: 4856082.950699846,
},
{
x: 12945058.975743152,
y: 4856080.754937213,
},
{
x: 12945281.461997462,
y: 4856092.418480259,
},
{
x: 12945643.041754864,
y: 4856110.003093847,
},
{
x: 12945784.907202916,
y: 4856113.134308052,
},
{
x: 12946578.056629626,
y: 4856112.4447421245,
},
{
x: 12947587.39674028,
y: 4856115.133251456,
},
{
x: 12947613.274919279,
y: 4856115.203954564,
},
{
x: 12948409.558918482,
y: 4856120.2980670845,
},
{
x: 12950197.88091994,
y: 4856127.655709365,
},
{
x: 12950522.56167453,
y: 4856128.972474555,
},
{
x: 12952789.177160164,
y: 4856124.15803456,
},
{
x: 12953464.615126304,
y: 4856122.0006891955,
},
{
x: 12954530.376567366,
y: 4856151.814350079,
},
{
x: 12955417.241989752,
y: 4856201.3555319505,
},
{
x: 12956068.761834681,
y: 4856237.46303956,
},
{
x: 12956833.347700687,
y: 4856274.21357933,
},
{
x: 12958297.780383743,
y: 4856277.010194032,
},
{
x: 12958569.623250166,
y: 4856268.920119228,
},
{
x: 12958601.133725567,
y: 4855382.984479329,
},
{
x: 12958611.676282825,
y: 4855232.673994465,
},
{
x: 12958632.866942339,
y: 4855139.665765479,
},
{
x: 12958688.973578054,
y: 4855045.110782978,
},
{
x: 12958728.4139951,
y: 4855000.874038989,
},
{
x: 12958770.892719645,
y: 4854961.207780969,
},
{
x: 12958799.677543039,
y: 4854945.921102297,
},
{
x: 12959324.962061018,
y: 4854945.451113535,
},
{
x: 12959585.872160498,
y: 4854945.153439757,
},
{
x: 12961042.442201044,
y: 4854962.677000188,
},
{
x: 12961432.109595038,
y: 4854972.467899889,
},
{
x: 12961926.386577822,
y: 4854934.294285994,
},
{
x: 12962148.74759053,
y: 4854917.131482158,
},
{
x: 12962283.599321207,
y: 4854895.403863202,
},
{
x: 12962563.81989391,
y: 4854825.953182589,
},
{
x: 12962930.401073314,
y: 4854769.91200932,
},
{
x: 12963190.916752387,
y: 4854738.551506216,
},
{
x: 12964441.84613731,
y: 4854799.404628956,
},
{
x: 12964524.312877567,
y: 4854798.896359394,
},
{
x: 12965180.991672397,
y: 4854794.927301339,
},
{
x: 12965609.29152333,
y: 4854782.320431698,
},
{
x: 12965890.746902762,
y: 4854765.761862335,
},
{
x: 12966166.126872526,
y: 4854749.201512711,
},
{
x: 12966285.65860789,
y: 4854745.572490727,
},
{
x: 12966514.13404955,
y: 4854747.498023047,
},
{
x: 12967120.576418092,
y: 4854750.252015507,
},
{
x: 12968417.872233221,
y: 4854755.563269503,
},
{
x: 12968618.637517042,
y: 4854756.352373138,
},
{
x: 12969113.28223611,
y: 4854778.000756352,
},
{
x: 12969684.88717921,
y: 4854779.300801552,
},
{
x: 12970067.575502042,
y: 4854781.712135722,
},
{
x: 12970534.989097549,
y: 4854786.685865359,
},
{
x: 12970699.884643015,
y: 4854793.3733178545,
},
{
x: 12970823.931856325,
y: 4854795.719200881,
},
{
x: 12970982.830224,
y: 4854826.832892539,
},
{
x: 12971113.005257478,
y: 4854865.732206641,
},
{
x: 12971202.287273336,
y: 4854878.94766238,
},
{
x: 12971370.206297623,
y: 4854874.950868926,
},
{
x: 12972309.189289698,
y: 4854855.496835954,
},
{
x: 12973018.812017871,
y: 4854841.117131226,
},
{
x: 12973547.047963066,
y: 4854830.666734374,
},
{
x: 12974064.854700932,
y: 4854852.350465733,
},
{
x: 12974472.82455872,
y: 4854876.455052272,
},
{
x: 12975051.371356072,
y: 4854904.052996347,
},
{
x: 12975605.826026462,
y: 4854907.507188204,
},
{
x: 12975778.549655946,
y: 4854906.705688043,
},
{
x: 12976205.686714906,
y: 4854908.883752931,
},
{
x: 12977221.096053148,
y: 4854914.252570144,
},
{
x: 12977364.010499585,
y: 4854929.9394761175,
},
{
x: 12977849.475332348,
y: 4854987.676906845,
},
{
x: 12978108.4311247,
y: 4855013.81299573,
},
{
x: 12978521.22706543,
y: 4855058.406105899,
},
{
x: 12980109.377856214,
y: 4855165.781190299,
},
{
x: 12980283.977902222,
y: 4855177.638637634,
},
{
x: 12980489.227525037,
y: 4855187.924099469,
},
{
x: 12980583.71991004,
y: 4855179.543517038,
},
{
x: 12980688.925014246,
y: 4855138.6160322325,
},
{
x: 12980767.103468414,
y: 4855089.631526497,
},
{
x: 12980869.512862012,
y: 4855013.486901767,
},
{
x: 12981090.661572816,
y: 4854899.114190809,
},
{
x: 12981198.816266755,
y: 4854879.956045967,
},
{
x: 12981320.40982718,
y: 4854890.50993648,
},
{
x: 12982163.741886314,
y: 4855124.274679628,
},
],
},
{
id: "8",
source: "16",
target: "17",
class: "地铁九号线",
name: "地铁九号线 0",
controlPoints: [
{
x: 12946648.06073432,
y: 4839260.025729084,
},
{
x: 12946544.074465087,
y: 4839619.202216059,
},
{
x: 12946445.496254807,
y: 4839771.777087536,
},
{
x: 12946363.495286731,
y: 4839808.518510458,
},
{
x: 12946292.702186562,
y: 4839843.812617867,
},
{
x: 12946221.884510016,
y: 4839925.221959326,
},
{
x: 12946200.062497655,
y: 4839988.63678963,
},
{
x: 12946126.464738874,
y: 4840577.558530562,
},
{
x: 12946154.121327115,
y: 4841454.65715364,
},
{
x: 12946159.216413628,
y: 4841615.166540137,
},
{
x: 12946163.133984758,
y: 4841750.3172009885,
},
{
x: 12946166.16397019,
y: 4841854.414496068,
},
{
x: 12946134.718988903,
y: 4842145.305047408,
},
{
x: 12946011.482648093,
y: 4842839.443615038,
},
{
x: 12945967.3702783,
y: 4843175.101744513,
},
{
x: 12945875.098454604,
y: 4843833.607067226,
},
{
x: 12945815.866086949,
y: 4844216.664802826,
},
{
x: 12945773.952396747,
y: 4844701.295741741,
},
{
x: 12945762.960414361,
y: 4844884.183169307,
},
{
x: 12945811.645641796,
y: 4846485.73907944,
},
{
x: 12945821.760873735,
y: 4846713.698002954,
},
{
x: 12945850.240499485,
y: 4847377.283903233,
},
{
x: 12945860.277378498,
y: 4847457.126713241,
},
{
x: 12945889.251105716,
y: 4847545.70699325,
},
{
x: 12946012.904132249,
y: 4847683.799611397,
},
{
x: 12946527.681154523,
y: 4848401.627416125,
},
{
x: 12946550.388778795,
y: 4848450.652934715,
},
{
x: 12946578.885636054,
y: 4848483.879589509,
},
{
x: 12946614.230164707,
y: 4848509.121830013,
},
{
x: 12946687.204717232,
y: 4848555.03996301,
},
{
x: 12946714.570161361,
y: 4848573.402833471,
},
{
x: 12946927.965178315,
y: 4848771.050237301,
},
{
x: 12947039.251749933,
y: 4848874.121019451,
},
{
x: 12947590.671676153,
y: 4849210.0301651545,
},
{
x: 12947894.176283287,
y: 4849394.908355361,
},
{
x: 12948001.161563184,
y: 4849454.528594686,
},
{
x: 12948726.115618171,
y: 4849833.574366419,
},
{
x: 12948780.697656307,
y: 4849859.709410215,
},
{
x: 12948804.10908822,
y: 4849909.061453937,
},
{
x: 12948808.591585146,
y: 4849968.572800762,
},
{
x: 12948813.15515829,
y: 4850598.421530288,
},
{
x: 12949122.850263117,
y: 4852505.623073113,
},
{
x: 12949328.200350346,
y: 4854831.558034923,
},
{
x: 12949353.269647257,
y: 4856109.000245334,
},
{
x: 12949291.632125383,
y: 4857143.131243851,
},
],
},
{
id: "9",
source: "18",
target: "19",
class: "地铁八号线",
name: "地铁八号线 0",
controlPoints: [
{
x: 12957190.97175418,
y: 4856829.187045242,
},
{
x: 12957268.3578042,
y: 4856387.328711017,
},
{
x: 12957289.353013203,
y: 4856359.317449307,
},
{
x: 12957331.343025276,
y: 4856327.797491008,
},
{
x: 12957376.831138888,
y: 4856317.277947678,
},
{
x: 12957891.704380175,
y: 4856296.418069313,
},
],
},
{
id: "10",
source: "20",
target: "21",
class: "地铁昌平线",
name: "地铁昌平线 0",
controlPoints: [
{
x: 12947094.115985483,
y: 4873731.336740117,
},
{
x: 12947072.54413634,
y: 4873784.735931892,
},
{
x: 12947042.017514793,
y: 4873859.579611177,
},
{
x: 12946995.4508778,
y: 4873970.753583026,
},
{
x: 12946943.109137688,
y: 4874095.283923113,
},
{
x: 12946899.787751423,
y: 4874206.107863865,
},
{
x: 12946881.01472949,
y: 4874253.759727108,
},
{
x: 12946789.68802783,
y: 4874467.089710582,
},
{
x: 12946751.78362451,
y: 4874555.5292996485,
},
{
x: 12946700.523958035,
y: 4874674.650758464,
},
{
x: 12946655.766671386,
y: 4874767.410641011,
},
{
x: 12946571.364045683,
y: 4874925.748577232,
},
{
x: 12946510.5646055,
y: 4875031.897509199,
},
{
x: 12946472.444944305,
y: 4875099.449536901,
},
{
x: 12946378.125857558,
y: 4875270.873813889,
},
{
x: 12946315.432537835,
y: 4875442.5781064425,
},
{
x: 12945987.019381497,
y: 4876429.405849195,
},
{
x: 12945494.324537683,
y: 4877247.425781118,
},
{
x: 12945212.872442825,
y: 4877783.708641315,
},
{
x: 12944881.49739096,
y: 4878774.737871047,
},
{
x: 12944906.896743502,
y: 4879158.180641696,
},
{
x: 12945532.959607262,
y: 4879647.417083359,
},
{
x: 12946150.468651066,
y: 4879791.647184245,
},
{
x: 12946905.53928399,
y: 4879921.626008038,
},
{
x: 12947757.621608311,
y: 4880143.70392179,
},
{
x: 12948030.412870025,
y: 4880398.632118471,
},
{
x: 12948052.616659699,
y: 4880692.773681223,
},
{
x: 12947846.20854383,
y: 4881514.465746558,
},
{
x: 12947597.065183768,
y: 4882366.221916524,
},
{
x: 12947351.139175126,
y: 4883370.132124624,
},
{
x: 12947176.67206149,
y: 4883933.272704212,
},
{
x: 12946774.041093351,
y: 4884211.771737467,
},
{
x: 12946459.054291379,
y: 4884228.537864571,
},
{
x: 12945934.213743346,
y: 4884401.946771053,
},
{
x: 12945765.765805947,
y: 4884775.110386402,
},
{
x: 12945765.322226081,
y: 4884788.004333703,
},
{
x: 12945769.507831955,
y: 4885435.210764532,
},
{
x: 12945706.715861775,
y: 4886123.159872877,
},
{
x: 12945619.689717943,
y: 4886769.72363822,
},
{
x: 12945442.673617564,
y: 4887206.479468694,
},
{
x: 12945265.150235325,
y: 4887443.841590078,
},
{
x: 12944956.967706354,
y: 4887910.572665611,
},
{
x: 12944764.2703165,
y: 4888414.954761419,
},
{
x: 12944490.393851373,
y: 4889211.049688148,
},
{
x: 12944158.000725761,
y: 4890227.3009047955,
},
{
x: 12943939.50054619,
y: 4890938.589379339,
},
{
x: 12943741.193033013,
y: 4891765.333179633,
},
{
x: 12943523.89343197,
y: 4892817.059629789,
},
{
x: 12943477.185800951,
y: 4893223.648609116,
},
{
x: 12943632.832055906,
y: 4893581.194364219,
},
{
x: 12944230.352351204,
y: 4893813.015893581,
},
{
x: 12944907.808217492,
y: 4894017.717405242,
},
{
x: 12945120.621122792,
y: 4894152.507246883,
},
{
x: 12945341.919177428,
y: 4894481.916219006,
},
],
},
{
id: "11",
source: "22",
target: "23",
class: "地铁八通线",
name: "地铁八通线 0",
controlPoints: [
{
x: 12970985.252146643,
y: 4852637.932500459,
},
{
x: 12971008.063154463,
y: 4852637.603850775,
},
{
x: 12971057.7816163,
y: 4852638.1331448015,
},
{
x: 12971134.73710355,
y: 4852640.9154947065,
},
{
x: 12971179.237531189,
y: 4852645.416718783,
},
{
x: 12971201.570727265,
y: 4852648.649302951,
},
{
x: 12971249.17801756,
y: 4852658.196621391,
},
{
x: 12971255.746157914,
y: 4852659.512994105,
},
{
x: 12971346.991565293,
y: 4852680.378101265,
},
{
x: 12971465.503559206,
y: 4852715.45222975,
},
{
x: 12971556.44305453,
y: 4852739.194460047,
},
{
x: 12971603.653185746,
y: 4852750.417086441,
},
{
x: 12971652.445129333,
y: 4852760.353265841,
},
{
x: 12971690.783407204,
y: 4852768.115819445,
},
{
x: 12971748.39988629,
y: 4852774.830285477,
},
{
x: 12971832.350691043,
y: 4852785.209187933,
},
{
x: 12971909.010570884,
y: 4852791.801163421,
},
{
x: 12971924.359283764,
y: 4852792.523685262,
},
{
x: 12971999.921089781,
y: 4852796.079471216,
},
{
x: 12972107.290890923,
y: 4852793.567220141,
},
{
x: 12972304.93984065,
y: 4852791.354142118,
},
{
x: 12972304.939940628,
y: 4852791.354142104,
},
{
x: 12972558.358169641,
y: 4852786.198665246,
},
{
x: 12972686.068063304,
y: 4852781.700119552,
},
{
x: 12972843.240578711,
y: 4852778.233391634,
},
{
x: 12972922.890764125,
y: 4852776.13617569,
},
{
x: 12973043.782765854,
y: 4852773.582308092,
},
{
x: 12973160.438646115,
y: 4852771.291533754,
},
{
x: 12973301.369215274,
y: 4852766.977022844,
},
{
x: 12973376.555572206,
y: 4852766.575507644,
},
{
x: 12973483.79407899,
y: 4852764.105804903,
},
{
x: 12973602.57893526,
y: 4852764.972085765,
},
{
x: 12973986.241797326,
y: 4852757.068452248,
},
{
x: 12974216.115580516,
y: 4852753.700414064,
},
{
x: 12974536.719347281,
y: 4852751.372519053,
},
{
x: 12974901.466203645,
y: 4852758.063962363,
},
{
x: 12974983.483695555,
y: 4852759.700171818,
},
{
x: 12975075.477382166,
y: 4852761.366109267,
},
{
x: 12975146.21345055,
y: 4852762.740995125,
},
{
x: 12975252.652350875,
y: 4852765.001749013,
},
{
x: 12975418.029274665,
y: 4852769.231663441,
},
{
x: 12975512.274773095,
y: 4852771.693583396,
},
{
x: 12975667.430020995,
y: 4852774.665220624,
},
{
x: 12975945.482280165,
y: 4852780.652428524,
},
{
x: 12976048.941242512,
y: 4852783.088273825,
},
{
x: 12976157.13466884,
y: 4852786.1686903015,
},
{
x: 12976200.541262798,
y: 4852787.159456441,
},
{
x: 12976234.258291336,
y: 4852787.5677579185,
},
{
x: 12976365.991912834,
y: 4852790.688773559,
},
{
x: 12976483.576280847,
y: 4852793.632750944,
},
{
x: 12976521.657226892,
y: 4852795.637126801,
},
{
x: 12976580.431624653,
y: 4852800.4899075935,
},
{
x: 12976630.833259074,
y: 4852806.145179798,
},
{
x: 12976695.08046594,
y: 4852815.315654606,
},
{
x: 12976729.999958823,
y: 4852820.657543227,
},
{
x: 12976776.474955026,
y: 4852827.352541805,
},
{
x: 12976812.252139,
y: 4852833.2147945,
},
{
x: 12976815.968375333,
y: 4852833.822868197,
},
{
x: 12976885.429953378,
y: 4852844.764512234,
},
{
x: 12976975.596115217,
y: 4852858.43044723,
},
{
x: 12977055.606962522,
y: 4852871.247395306,
},
{
x: 12977150.103301922,
y: 4852886.690040669,
},
{
x: 12977164.484104557,
y: 4852889.144325767,
},
{
x: 12977349.452764807,
y: 4852911.35750741,
},
{
x: 12977396.826802246,
y: 4852914.6312842835,
},
{
x: 12977445.21322845,
y: 4852917.3740233835,
},
{
x: 12977499.905881032,
y: 4852919.653667679,
},
{
x: 12977561.24229945,
y: 4852918.623041482,
},
{
x: 12977618.078808535,
y: 4852916.964759332,
},
{
x: 12977670.621610347,
y: 4852911.879830347,
},
{
x: 12977751.148635335,
y: 4852902.670739922,
},
{
x: 12977786.88548381,
y: 4852897.948010646,
},
{
x: 12977824.596628416,
y: 4852892.215955226,
},
{
x: 12977838.222668163,
y: 4852889.785354156,
},
{
x: 12977897.63684129,
y: 4852879.987122803,
},
{
x: 12978112.587513769,
y: 4852847.147889897,
},
{
x: 12978212.010580407,
y: 4852831.849550509,
},
{
x: 12978289.722346092,
y: 4852819.825778696,
},
{
x: 12978376.198797919,
y: 4852806.369032904,
},
{
x: 12978443.1247446,
y: 4852796.941799674,
},
{
x: 12978511.962721677,
y: 4852789.040221515,
},
{
x: 12978556.675266935,
y: 4852784.800445814,
},
{
x: 12978603.675698506,
y: 4852781.445204418,
},
{
x: 12978657.285893984,
y: 4852778.451914039,
},
{
x: 12978800.565625936,
y: 4852773.68229988,
},
{
x: 12978914.98070244,
y: 4852769.67853182,
},
{
x: 12979058.626918213,
y: 4852765.050844271,
},
{
x: 12979117.93108979,
y: 4852764.395843838,
},
{
x: 12979200.907964638,
y: 4852760.896022486,
},
{
x: 12979376.070149522,
y: 4852755.492429703,
},
{
x: 12979821.264409432,
y: 4852740.865419091,
},
{
x: 12979869.005644636,
y: 4852738.659817284,
},
{
x: 12980006.684293807,
y: 4852733.642694393,
},
{
x: 12980010.412107708,
y: 4852733.505705852,
},
{
x: 12980102.14796544,
y: 4852731.09585125,
},
{
x: 12980102.150365561,
y: 4852731.095751376,
},
{
x: 12980241.426094191,
y: 4852724.458911123,
},
{
x: 12980383.972661799,
y: 4852720.275860491,
},
{
x: 12980452.567191115,
y: 4852718.295604612,
},
{
x: 12980501.279651301,
y: 4852717.168056968,
},
{
x: 12980511.817043953,
y: 4852716.940679275,
},
{
x: 12980527.720170368,
y: 4852714.900895137,
},
{
x: 12980546.205864942,
y: 4852712.0589568885,
},
{
x: 12980556.739903979,
y: 4852710.6345186,
},
{
x: 12980575.024717016,
y: 4852707.192393184,
},
{
x: 12980600.064811092,
y: 4852702.138990685,
},
{
x: 12980620.733107321,
y: 4852697.095017998,
},
{
x: 12980641.992123496,
y: 4852691.0518540675,
},
{
x: 12980667.422524082,
y: 4852682.803530873,
},
{
x: 12980697.81666234,
y: 4852671.350689514,
},
{
x: 12980750.44375973,
y: 4852646.269770028,
},
{
x: 12980789.758654011,
y: 4852625.613153645,
},
{
x: 12980817.158831125,
y: 4852610.176831961,
},
{
x: 12980871.562055342,
y: 4852579.505635189,
},
{
x: 12980917.628692484,
y: 4852553.447517574,
},
{
x: 12981043.583099704,
y: 4852484.690581212,
},
{
x: 12981099.336563937,
y: 4852456.01893319,
},
{
x: 12981140.890511304,
y: 4852432.9686271055,
},
{
x: 12981182.135998141,
y: 4852411.356320457,
},
{
x: 12981255.809566528,
y: 4852369.673110186,
},
{
x: 12981306.254684363,
y: 4852342.213287527,
},
{
x: 12981355.360464152,
y: 4852316.156478455,
},
{
x: 12981380.125408497,
y: 4852304.328818308,
},
{
x: 12981404.370375846,
y: 4852293.9445663355,
},
{
x: 12981411.357722916,
y: 4852291.019192892,
},
{
x: 12981429.138416857,
y: 4852284.705685185,
},
{
x: 12981449.445248626,
y: 4852278.144038033,
},
{
x: 12981466.988468504,
y: 4852273.038244298,
},
{
x: 12981483.934169278,
y: 4852269.01732057,
},
{
x: 12981501.72129354,
y: 4852264.633525485,
},
{
x: 12981521.195052542,
y: 4852260.970876668,
},
{
x: 12981540.429482171,
y: 4852257.912291013,
},
{
x: 12981556.300366443,
y: 4852255.823523872,
},
{
x: 12981570.366991611,
y: 4852253.983978159,
},
{
x: 12981590.808079034,
y: 4852252.37024785,
},
{
x: 12981606.562289793,
y: 4852251.488995252,
},
{
x: 12981636.507357743,
y: 4852250.579113849,
},
{
x: 12981656.356278451,
y: 4852250.896393729,
},
{
x: 12981692.086214192,
y: 4852252.868202504,
},
{
x: 12981714.223939104,
y: 4852254.872887953,
},
{
x: 12981755.862461897,
y: 4852261.416093576,
},
{
x: 12981787.756915031,
y: 4852268.344546958,
},
{
x: 12981824.48947952,
y: 4852277.740325138,
},
{
x: 12982006.994348593,
y: 4852327.843007399,
},
{
x: 12982014.941592565,
y: 4852330.480576966,
},
{
x: 12982026.402121745,
y: 4852333.381042817,
},
{
x: 12982040.946943458,
y: 4852337.063108767,
},
{
x: 12982067.796619976,
y: 4852344.124059822,
},
{
x: 12982082.244231999,
y: 4852347.351909036,
},
{
x: 12982111.255736986,
y: 4852353.085681991,
},
{
x: 12982129.791819442,
y: 4852355.941803544,
},
{
x: 12982150.73459613,
y: 4852358.6745200455,
},
{
x: 12982173.599064307,
y: 4852360.678826859,
},
{
x: 12982199.590729142,
y: 4852362.073329141,
},
{
x: 12982224.25684918,
y: 4852362.508778318,
},
{
x: 12982242.781496631,
y: 4852362.108043774,
},
{
x: 12982265.278136691,
y: 4852361.098500819,
},
{
x: 12982291.742691308,
y: 4852358.874468977,
},
{
x: 12982315.67474395,
y: 4852355.811827975,
},
{
x: 12982335.035976896,
y: 4852352.394862233,
},
{
x: 12982357.042847889,
y: 4852348.851728803,
},
{
x: 12982382.295058098,
y: 4852343.857827946,
},
{
x: 12982417.531268932,
y: 4852337.395309842,
},
{
x: 12982448.197524806,
y: 4852331.785528333,
},
{
x: 12982478.86330164,
y: 4852326.658255823,
},
{
x: 12982531.423479121,
y: 4852319.199320662,
},
{
x: 12982583.51522219,
y: 4852315.239714849,
},
{
x: 12982619.249260034,
y: 4852313.483230399,
},
{
x: 12982707.726446714,
y: 4852311.01354565,
},
{
x: 12982818.643484026,
y: 4852310.195081021,
},
{
x: 12982926.718911368,
y: 4852308.423580399,
},
{
x: 12982969.351654056,
y: 4852307.719497175,
},
{
x: 12983023.546593202,
y: 4852306.599390685,
},
{
x: 12983109.423810175,
y: 4852304.789328974,
},
{
x: 12983167.539974144,
y: 4852304.283514513,
},
{
x: 12983217.219463198,
y: 4852303.191877694,
},
{
x: 12983281.254377576,
y: 4852302.216069689,
},
{
x: 12983366.75675525,
y: 4852300.701005913,
},
{
x: 12983452.20281669,
y: 4852299.1755383825,
},
{
x: 12983534.11611313,
y: 4852296.359641885,
},
{
x: 12983559.667424409,
y: 4852295.629501179,
},
{
x: 12983601.161266102,
y: 4852294.627091015,
},
{
x: 12983611.984969016,
y: 4852293.890433964,
},
{
x: 12983622.368472738,
y: 4852292.692271228,
},
{
x: 12983631.964793393,
y: 4852291.967613732,
},
{
x: 12983642.347676827,
y: 4852290.532228432,
},
{
x: 12983664.288969724,
y: 4852286.790795176,
},
{
x: 12983681.665854465,
y: 4852283.294093203,
},
{
x: 12983691.650165133,
y: 4852280.518425564,
},
{
x: 12983704.937446222,
y: 4852276.871566698,
},
{
x: 12983719.485094307,
y: 4852271.960088485,
},
{
x: 12983734.576153021,
y: 4852266.573224977,
},
{
x: 12983749.349894535,
y: 4852260.636238543,
},
{
x: 12983764.356448224,
y: 4852253.439065454,
},
{
x: 12983783.229950167,
y: 4852243.675282068,
},
{
x: 12983809.54016834,
y: 4852227.647694631,
},
{
x: 12983819.177255707,
y: 4852221.021988448,
},
{
x: 12983830.24508297,
y: 4852212.4117375035,
},
{
x: 12983845.626987867,
y: 4852200.007109512,
},
{
x: 12983856.53356637,
y: 4852190.291205582,
},
{
x: 12983870.184671514,
y: 4852177.732756121,
},
{
x: 12983883.752366735,
y: 4852163.04569551,
},
{
x: 12983893.242055438,
y: 4852153.491082963,
},
{
x: 12983901.156669818,
y: 4852143.226680874,
},
{
x: 12983911.419729222,
y: 4852128.860448257,
},
{
x: 12983920.032326968,
y: 4852115.678436422,
},
{
x: 12983928.333826244,
y: 4852103.047421788,
},
{
x: 12983936.314326718,
y: 4852088.763105886,
},
{
x: 12983946.18360984,
y: 4852068.498493203,
},
{
x: 12984045.08972995,
y: 4851885.404455599,
},
{
x: 12984080.804905687,
y: 4851817.337034466,
},
{
x: 12984134.748354,
y: 4851706.836804487,
},
{
x: 12984195.8623765,
y: 4851591.525543062,
},
{
x: 12984254.587788567,
y: 4851478.621198026,
},
{
x: 12984307.768564539,
y: 4851379.326535712,
},
{
x: 12984344.27421628,
y: 4851308.864740265,
},
{
x: 12984375.225174434,
y: 4851249.609910724,
},
{
x: 12984415.701271733,
y: 4851172.74323114,
},
{
x: 12984461.729403371,
y: 4851084.666569579,
},
{
x: 12984517.277267791,
y: 4850976.575614915,
},
{
x: 12984628.35638987,
y: 4850756.39703862,
},
{
x: 12984643.441411281,
y: 4850729.173746353,
},
{
x: 12984659.718515014,
y: 4850700.1083314745,
},
{
x: 12984681.711487297,
y: 4850670.601281623,
},
{
x: 12984717.725659953,
y: 4850629.896011068,
},
{
x: 12984754.999484044,
y: 4850595.784380661,
},
{
x: 12984794.35474119,
y: 4850566.24036794,
},
{
x: 12984822.179769346,
y: 4850548.063337961,
},
{
x: 12984863.461169159,
y: 4850526.723240278,
},
{
x: 12984915.289983816,
y: 4850505.12020892,
},
{
x: 12984951.72965507,
y: 4850491.149559257,
},
{
x: 12985164.594748862,
y: 4850408.269419757,
},
{
x: 12985223.73663421,
y: 4850386.334720776,
},
{
x: 12985231.332473703,
y: 4850382.288306166,
},
{
x: 12985243.255608164,
y: 4850375.964354305,
},
{
x: 12985309.485768877,
y: 4850350.550316565,
},
{
x: 12985309.485868897,
y: 4850350.550316587,
},
{
x: 12986172.233193466,
y: 4850032.791403444,
},
{
x: 12986172.8663129,
y: 4850032.558329904,
},
{
x: 12986339.175501348,
y: 4849968.327595861,
},
{
x: 12986505.507225916,
y: 4849904.089056084,
},
{
x: 12986656.604391119,
y: 4849847.60963517,
},
{
x: 12986702.483696718,
y: 4849828.918664281,
},
{
x: 12986760.975453354,
y: 4849792.3676841725,
},
{
x: 12986797.326063676,
y: 4849765.012441939,
},
{
x: 12986830.880906345,
y: 4849735.181111031,
},
{
x: 12986886.127819829,
y: 4849677.217710046,
},
{
x: 12987120.13083682,
y: 4849429.888750661,
},
{
x: 12987545.455182405,
y: 4848990.56075093,
},
{
x: 12987572.780970717,
y: 4848962.972667584,
},
{
x: 12987750.347789623,
y: 4848775.995218805,
},
{
x: 12987812.698881118,
y: 4848712.132626582,
},
{
x: 12987888.840439832,
y: 4848629.514697122,
},
{
x: 12987922.383888729,
y: 4848595.374774107,
},
{
x: 12988054.963756831,
y: 4848456.434616343,
},
{
x: 12988203.560175221,
y: 4848293.895912913,
},
{
x: 12988250.566429619,
y: 4848245.193567729,
},
{
x: 12988306.722374829,
y: 4848191.552325912,
},
{
x: 12988429.814042207,
y: 4848060.358476343,
},
{
x: 12988509.892477134,
y: 4847972.732590752,
},
{
x: 12988516.052521963,
y: 4847966.473292817,
},
{
x: 12988531.25232795,
y: 4847951.020837734,
},
{
x: 12988547.774189414,
y: 4847934.22664656,
},
{
x: 12988684.205479793,
y: 4847792.520992836,
},
{
x: 12988709.83813206,
y: 4847765.978322433,
},
{
x: 12988751.064218508,
y: 4847721.917838166,
},
{
x: 12988806.893480845,
y: 4847664.753238427,
},
{
x: 12988838.47984446,
y: 4847638.4005759265,
},
{
x: 12988863.550537288,
y: 4847617.484576525,
},
{
x: 12988871.447747946,
y: 4847610.900250857,
},
{
x: 12988928.71596574,
y: 4847568.305396379,
},
{
x: 12989015.639990052,
y: 4847513.087871169,
},
{
x: 12989070.178705394,
y: 4847482.192075563,
},
{
x: 12989148.863691295,
y: 4847447.998694799,
},
{
x: 12989221.630766438,
y: 4847420.154502207,
},
{
x: 12989339.331564289,
y: 4847380.68202523,
},
{
x: 12989542.519483887,
y: 4847312.531220079,
},
{
x: 12989591.848173946,
y: 4847295.984625068,
},
],
},
{
id: "12",
source: "24",
target: "25",
class: "城铁十三号线",
name: "城铁十三号线 0",
controlPoints: [
{
x: 12961384.821093876,
y: 4857604.895638846,
},
{
x: 12961379.888425605,
y: 4857950.407662031,
},
{
x: 12961378.603161972,
y: 4858178.984029268,
},
{
x: 12961378.251699504,
y: 4858199.941669665,
},
{
x: 12961362.948288757,
y: 4859113.050576728,
},
{
x: 12961351.774871988,
y: 4859246.305776181,
},
{
x: 12961344.673628464,
y: 4859330.995740561,
},
{
x: 12961338.185205506,
y: 4859379.136027955,
},
{
x: 12961326.701474292,
y: 4859430.3762181355,
},
{
x: 12961296.23872469,
y: 4859534.623118192,
},
{
x: 12961279.573160157,
y: 4859595.157872784,
},
{
x: 12961271.432916135,
y: 4859636.755033974,
},
{
x: 12961227.692613533,
y: 4859930.467545727,
},
{
x: 12961219.290961184,
y: 4859990.017196776,
},
{
x: 12961215.868152,
y: 4860031.195887179,
},
{
x: 12961213.956200192,
y: 4860042.603136049,
},
{
x: 12961206.891662417,
y: 4860091.520899557,
},
{
x: 12961188.165871859,
y: 4860211.789308975,
},
{
x: 12961182.052734978,
y: 4860252.9748706035,
},
{
x: 12961177.381970651,
y: 4860285.458304639,
},
{
x: 12961133.584798172,
y: 4861282.165295659,
},
{
x: 12961131.197062261,
y: 4861339.773361728,
},
{
x: 12961125.764970018,
y: 4861465.195775947,
},
{
x: 12961124.551248107,
y: 4861505.652557301,
},
{
x: 12961122.644612342,
y: 4861570.024727552,
},
{
x: 12961122.505511757,
y: 4861612.817632623,
},
{
x: 12961126.125387294,
y: 4861656.679218022,
},
{
x: 12961134.236030966,
y: 4861724.086379644,
},
{
x: 12961147.346890498,
y: 4861783.573658952,
},
{
x: 12961169.949061126,
y: 4861856.88455326,
},
{
x: 12961190.92239628,
y: 4861908.443200537,
},
{
x: 12961244.80679,
y: 4862017.212104109,
},
{
x: 12961785.271410704,
y: 4863090.557436891,
},
{
x: 12962406.945922375,
y: 4864318.974454228,
},
{
x: 12963018.284754738,
y: 4865521.493683898,
},
{
x: 12963018.284854762,
y: 4865521.493783919,
},
{
x: 12963224.051473433,
y: 4866039.3565800125,
},
{
x: 12963500.971012274,
y: 4867139.241053313,
},
{
x: 12963650.819367116,
y: 4867725.703316142,
},
{
x: 12963888.949552327,
y: 4868660.037686641,
},
{
x: 12964153.29996666,
y: 4869706.424707541,
},
{
x: 12964161.049777685,
y: 4869739.748010959,
},
{
x: 12964169.022003202,
y: 4869783.887620618,
},
{
x: 12964169.79918989,
y: 4869788.187596136,
},
{
x: 12964170.396725647,
y: 4869792.28592288,
},
{
x: 12964178.09229784,
y: 4869845.141780633,
},
{
x: 12964182.866363246,
y: 4869906.602764703,
},
{
x: 12964186.742670394,
y: 4869983.180502373,
},
{
x: 12964187.80107099,
y: 4870004.059485736,
},
{
x: 12964194.767189663,
y: 4870141.601109272,
},
{
x: 12964195.586355446,
y: 4870157.791065987,
},
{
x: 12964195.629143188,
y: 4870158.625753281,
},
{
x: 12964197.365642045,
y: 4870232.162939279,
},
{
x: 12964199.986983918,
y: 4870338.989878203,
},
{
x: 12964198.233979,
y: 4870399.4780171625,
},
{
x: 12964195.521848764,
y: 4870426.330630218,
},
{
x: 12964189.688597165,
y: 4870457.628060375,
},
{
x: 12964178.76505046,
y: 4870495.275356304,
},
{
x: 12964167.839258399,
y: 4870529.241804792,
},
{
x: 12964156.90262342,
y: 4870556.635705516,
},
{
x: 12964139.446759911,
y: 4870591.940950339,
},
{
x: 12964119.380342938,
y: 4870629.3612662265,
},
{
x: 12964087.063558495,
y: 4870686.289743977,
},
{
x: 12964065.951472988,
y: 4870723.716488513,
},
{
x: 12964052.918280806,
y: 4870746.119234959,
},
{
x: 12964041.187130783,
y: 4870764.046505531,
},
{
x: 12964018.239456784,
y: 4870796.744059516,
},
{
x: 12963997.373145364,
y: 4870821.018842714,
},
{
x: 12963975.979364637,
y: 4870842.403550631,
},
{
x: 12963943.620649595,
y: 4870869.876901368,
},
{
x: 12963912.565489624,
y: 4870894.189978186,
},
{
x: 12963888.553606404,
y: 4870910.587164291,
},
{
x: 12963855.921490764,
y: 4870928.856058391,
},
{
x: 12963818.847341483,
y: 4870946.088721298,
},
{
x: 12963778.372132206,
y: 4870961.231012497,
},
{
x: 12963730.060326898,
y: 4870976.4015065245,
},
{
x: 12963657.978381645,
y: 4870995.602780929,
},
{
x: 12963622.05854108,
y: 4871004.430416085,
},
{
x: 12963558.724530451,
y: 4871019.810885714,
},
{
x: 12963512.503679566,
y: 4871035.906957649,
},
{
x: 12963453.681321735,
y: 4871059.763481818,
},
{
x: 12963248.80497939,
y: 4871172.328870646,
},
{
x: 12963244.572822267,
y: 4871174.658396504,
},
{
x: 12963038.471529033,
y: 4871288.035313995,
},
{
x: 12962853.820973437,
y: 4871391.186996228,
},
{
x: 12962725.303994041,
y: 4871462.571934574,
},
{
x: 12962724.957375426,
y: 4871462.752610938,
},
{
x: 12962723.887909118,
y: 4871463.345629024,
},
{
x: 12962716.736546198,
y: 4871467.315161244,
},
{
x: 12962716.284189595,
y: 4871467.567097997,
},
{
x: 12962579.957906647,
y: 4871543.225352538,
},
{
x: 12962098.530270364,
y: 4871808.314025743,
},
{
x: 12961985.615570927,
y: 4871875.438409937,
},
{
x: 12961943.360948866,
y: 4871903.003423259,
},
{
x: 12961806.371053975,
y: 4871987.009769704,
},
{
x: 12961737.483883223,
y: 4872026.3265607115,
},
{
x: 12961633.115452316,
y: 4872086.751682198,
},
{
x: 12961545.844782017,
y: 4872134.320089415,
},
{
x: 12961361.563495556,
y: 4872236.98400638,
},
{
x: 12961327.331658702,
y: 4872255.833857056,
},
{
x: 12961251.875342408,
y: 4872297.087065438,
},
{
x: 12961204.826219695,
y: 4872325.325771341,
},
{
x: 12961132.023615833,
y: 4872361.658743605,
},
{
x: 12961052.11865231,
y: 4872405.144750871,
},
{
x: 12960972.646711243,
y: 4872441.930478759,
},
{
x: 12960858.106042854,
y: 4872506.91698905,
},
{
x: 12960760.426450621,
y: 4872559.359681711,
},
{
x: 12960724.908352494,
y: 4872580.416320622,
},
{
x: 12960641.560702814,
y: 4872626.948672511,
},
{
x: 12960409.848923735,
y: 4872755.68364987,
},
{
x: 12960214.328045709,
y: 4872860.212735837,
},
{
x: 12960127.928549424,
y: 4872909.2953869505,
},
{
x: 12960102.655544914,
y: 4872922.969133999,
},
{
x: 12960020.162988434,
y: 4872967.3561403835,
},
{
x: 12959950.134860648,
y: 4873006.403798974,
},
{
x: 12959863.03802686,
y: 4873054.88910155,
},
{
x: 12959777.644680386,
y: 4873104.258241601,
},
{
x: 12959699.508191582,
y: 4873147.282306783,
},
{
x: 12959620.328795532,
y: 4873191.4477808075,
},
{
x: 12959477.877193257,
y: 4873269.404125038,
},
{
x: 12959357.123719096,
y: 4873335.684058211,
},
{
x: 12959338.647690238,
y: 4873345.82380848,
},
{
x: 12958925.449787276,
y: 4873574.258471447,
},
{
x: 12958914.496696375,
y: 4873580.313011027,
},
{
x: 12958908.925432095,
y: 4873583.384761498,
},
{
x: 12958469.664608255,
y: 4873826.333185746,
},
{
x: 12958317.119431961,
y: 4873910.348894859,
},
{
x: 12958173.63725258,
y: 4873989.354939118,
},
{
x: 12958109.864433711,
y: 4874026.411209632,
},
{
x: 12958056.459419694,
y: 4874055.42987156,
},
{
x: 12958035.572431948,
y: 4874066.780988242,
},
{
x: 12957541.464879088,
y: 4874339.316503633,
},
{
x: 12957541.314450411,
y: 4874339.40007746,
},
{
x: 12957515.50602984,
y: 4874353.589680841,
},
{
x: 12957515.424667433,
y: 4874353.63521974,
},
{
x: 12957178.774763126,
y: 4874538.369890689,
},
{
x: 12957143.891148778,
y: 4874557.897348821,
},
{
x: 12956953.433700653,
y: 4874662.620502712,
},
{
x: 12956865.14112665,
y: 4874711.491226545,
},
{
x: 12956730.395010892,
y: 4874784.283691582,
},
{
x: 12956584.60989753,
y: 4874864.17479837,
},
{
x: 12956514.690003015,
y: 4874902.207189248,
},
{
x: 12956415.921079142,
y: 4874957.945257982,
},
{
x: 12956350.318605551,
y: 4874993.942196934,
},
{
x: 12955970.523661379,
y: 4875204.572856644,
},
{
x: 12955961.168925371,
y: 4875209.826648806,
},
{
x: 12955608.616340334,
y: 4875403.58048848,
},
{
x: 12955424.989326235,
y: 4875505.19312055,
},
{
x: 12955208.191654494,
y: 4875621.246472876,
},
{
x: 12955106.685266893,
y: 4875676.949542184,
},
{
x: 12954909.088653814,
y: 4875785.6214146055,
},
{
x: 12954898.699293226,
y: 4875791.33469513,
},
{
x: 12954809.86015897,
y: 4875840.183103034,
},
{
x: 12954515.78755851,
y: 4876003.857567704,
},
{
x: 12954425.351083811,
y: 4876047.515434021,
},
{
x: 12954361.536701877,
y: 4876075.173523097,
},
{
x: 12954318.522177251,
y: 4876092.11950955,
},
{
x: 12954285.295954525,
y: 4876103.586379883,
},
{
x: 12954230.248733655,
y: 4876121.545707381,
},
{
x: 12954175.140615348,
y: 4876137.686398102,
},
{
x: 12954117.372576779,
y: 4876152.031328337,
},
{
x: 12954117.372476779,
y: 4876152.031328334,
},
{
x: 12954063.303781305,
y: 4876163.662863832,
},
{
x: 12954007.331071056,
y: 4876172.399246002,
},
{
x: 12953967.211788474,
y: 4876178.65975709,
},
{
x: 12953802.621925015,
y: 4876196.237827291,
},
{
x: 12953668.73601341,
y: 4876199.186105529,
},
{
x: 12953503.298073018,
y: 4876194.053015986,
},
{
x: 12953435.898150826,
y: 4876195.031116625,
},
{
x: 12952907.1719517,
y: 4876202.110021278,
},
{
x: 12952854.57708836,
y: 4876202.818902422,
},
{
x: 12952810.046254802,
y: 4876203.418551955,
},
{
x: 12952736.613090457,
y: 4876203.294253911,
},
{
x: 12952624.4348891,
y: 4876204.555723625,
},
{
x: 12952552.43031391,
y: 4876204.964896776,
},
{
x: 12952497.943888191,
y: 4876207.608055034,
},
{
x: 12952468.042451413,
y: 4876210.829014632,
},
{
x: 12952437.79969268,
y: 4876214.509841102,
},
{
x: 12952375.588643614,
y: 4876223.886731359,
},
{
x: 12952301.856311196,
y: 4876236.1209624605,
},
{
x: 12952251.31522576,
y: 4876242.8451233655,
},
{
x: 12952214.021838313,
y: 4876246.965370512,
},
{
x: 12952162.807325037,
y: 4876250.527753233,
},
{
x: 12952103.452750135,
y: 4876251.697783142,
},
{
x: 12952023.611417918,
y: 4876253.082581543,
},
{
x: 12951892.55511939,
y: 4876253.812631988,
},
{
x: 12951846.328905031,
y: 4876253.171084735,
},
{
x: 12951802.992080217,
y: 4876249.116505366,
},
{
x: 12951766.843265098,
y: 4876244.26441203,
},
{
x: 12951714.743373726,
y: 4876233.633230178,
},
{
x: 12951654.073062496,
y: 4876222.691277131,
},
{
x: 12951616.46554052,
y: 4876216.252301995,
},
{
x: 12951584.63468386,
y: 4876213.574076274,
},
{
x: 12951561.015438031,
y: 4876212.359467597,
},
{
x: 12951502.289814433,
y: 4876212.143345088,
},
{
x: 12951293.085304,
y: 4876214.875420837,
},
{
x: 12951031.075470097,
y: 4876215.897535212,
},
{
x: 12950959.097605025,
y: 4876216.275884133,
},
{
x: 12950894.730929183,
y: 4876215.974946514,
},
{
x: 12950773.64057589,
y: 4876216.703301484,
},
{
x: 12950673.746751422,
y: 4876225.670588799,
},
{
x: 12950616.565179903,
y: 4876229.034309006,
},
{
x: 12950568.486162541,
y: 4876230.042798452,
},
{
x: 12950375.145719487,
y: 4876231.976121928,
},
{
x: 12950194.78158641,
y: 4876234.464466195,
},
{
x: 12950048.658437809,
y: 4876236.2574803205,
},
{
x: 12950001.4772779,
y: 4876235.293804152,
},
{
x: 12949948.747199,
y: 4876229.307334167,
},
{
x: 12949849.140274497,
y: 4876224.443260822,
},
{
x: 12948886.90103617,
y: 4876237.644317312,
},
{
x: 12948886.90093617,
y: 4876237.644317315,
},
{
x: 12948715.380098497,
y: 4876239.997015189,
},
{
x: 12948425.68643085,
y: 4876243.705096172,
},
{
x: 12948424.112088347,
y: 4876243.72353365,
},
{
x: 12948407.06491928,
y: 4876243.944145824,
},
{
x: 12948405.98243078,
y: 4876243.95624331,
},
{
x: 12948361.171213618,
y: 4876244.531933125,
},
{
x: 12948356.092076505,
y: 4876244.596227219,
},
{
x: 12948294.145588111,
y: 4876245.390073654,
},
{
x: 12948293.421376245,
y: 4876245.398151391,
},
{
x: 12948245.081662236,
y: 4876246.017528498,
},
{
x: 12948244.258669348,
y: 4876246.030423269,
},
{
x: 12948227.313400865,
y: 4876246.246399225,
},
{
x: 12948226.443416782,
y: 4876246.256701933,
},
{
x: 12948223.250043418,
y: 4876246.298279974,
},
{
x: 12947945.409350824,
y: 4876250.961636466,
},
{
x: 12947934.332267188,
y: 4876250.890472651,
},
{
x: 12947877.07401595,
y: 4876250.914315445,
},
{
x: 12947815.021065967,
y: 4876253.851354821,
},
{
x: 12947763.487477783,
y: 4876261.1465055365,
},
{
x: 12947725.059790507,
y: 4876269.052617193,
},
{
x: 12947653.430817837,
y: 4876293.225426714,
},
{
x: 12947609.2695425,
y: 4876314.985599062,
},
{
x: 12947579.101654992,
y: 4876329.096570221,
},
{
x: 12947532.916624067,
y: 4876357.08904473,
},
{
x: 12947462.2262063,
y: 4876393.072714213,
},
{
x: 12947421.555621969,
y: 4876408.477083252,
},
{
x: 12947369.78948997,
y: 4876424.051528886,
},
{
x: 12947316.08051995,
y: 4876430.96623273,
},
{
x: 12947288.108453162,
y: 4876433.523245403,
},
{
x: 12947233.34126908,
y: 4876432.790803788,
},
{
x: 12947188.401168212,
y: 4876429.088000529,
},
{
x: 12947141.165666422,
y: 4876420.772086076,
},
{
x: 12947111.803456603,
y: 4876412.760024161,
},
{
x: 12947064.825877437,
y: 4876399.584901326,
},
{
x: 12947029.14763327,
y: 4876383.288698463,
},
{
x: 12947000.45767468,
y: 4876366.611471653,
},
{
x: 12946972.12493202,
y: 4876348.110056718,
},
{
x: 12946952.979055353,
y: 4876335.007395409,
},
{
x: 12946936.827550543,
y: 4876323.077202845,
},
{
x: 12946921.333707113,
y: 4876310.548771458,
},
{
x: 12946816.8297496,
y: 4876219.287650481,
},
{
x: 12946732.699527778,
y: 4876127.270037018,
},
{
x: 12946657.488720905,
y: 4876045.210086455,
},
{
x: 12946622.587940522,
y: 4875983.965371542,
},
{
x: 12946496.471341081,
y: 4875762.643722024,
},
{
x: 12946423.522392513,
y: 4875557.850478406,
},
{
x: 12946399.995473424,
y: 4875459.537530149,
},
{
x: 12946396.978958678,
y: 4875437.0025600875,
},
{
x: 12946396.993859813,
y: 4875409.162322274,
},
{
x: 12946399.79561764,
y: 4875362.09033934,
},
{
x: 12946402.86393251,
y: 4875338.563648224,
},
{
x: 12946405.625597931,
y: 4875320.088412483,
},
{
x: 12946410.942566253,
y: 4875295.299492259,
},
{
x: 12946416.254743187,
y: 4875274.811186232,
},
{
x: 12946428.647654204,
y: 4875238.394850413,
},
{
x: 12946449.128231185,
y: 4875187.827926565,
},
{
x: 12946468.842936842,
y: 4875151.68413807,
},
{
x: 12946489.817988945,
y: 4875118.8342050975,
},
{
x: 12946522.546502326,
y: 4875072.470895908,
},
{
x: 12946570.68181112,
y: 4875007.932055009,
},
{
x: 12946590.31852286,
y: 4874978.982263895,
},
{
x: 12946617.815584973,
y: 4874935.88435813,
},
{
x: 12946646.325475948,
y: 4874873.520782715,
},
{
x: 12946820.499390153,
y: 4874459.418667514,
},
{
x: 12946888.30456704,
y: 4874294.857213484,
},
{
x: 12946930.646429846,
y: 4874192.6851136675,
},
{
x: 12946949.005201655,
y: 4874148.378390104,
},
{
x: 12947044.284756513,
y: 4873918.4637040915,
},
{
x: 12947056.289818808,
y: 4873889.083139696,
},
{
x: 12947165.66572366,
y: 4873622.718414709,
},
{
x: 12947202.737800827,
y: 4873531.999517411,
},
{
x: 12947209.63262473,
y: 4873515.652391753,
},
{
x: 12947273.282788856,
y: 4873364.7546024555,
},
{
x: 12947273.708122,
y: 4873363.743532597,
},
{
x: 12947287.460317507,
y: 4873331.140831067,
},
{
x: 12947304.830566434,
y: 4873289.959057868,
},
{
x: 12947411.8537799,
y: 4873054.533746381,
},
{
x: 12947541.50808741,
y: 4872842.7485984,
},
{
x: 12947580.982706897,
y: 4872777.370338213,
},
{
x: 12947615.711724276,
y: 4872723.318503141,
},
{
x: 12947649.183798542,
y: 4872667.856626571,
},
{
x: 12947675.12323022,
y: 4872624.93555951,
},
{
x: 12947696.263067583,
y: 4872593.158431816,
},
{
x: 12947734.29565014,
y: 4872530.60731087,
},
{
x: 12947764.795609327,
y: 4872480.528620551,
},
{
x: 12947824.300805386,
y: 4872380.158015446,
},
{
x: 12947865.335921923,
y: 4872300.691582129,
},
{
x: 12947868.4019642,
y: 4872293.260799115,
},
{
x: 12947877.607004203,
y: 4872273.69886109,
},
{
x: 12947897.445241943,
y: 4872226.595834379,
},
{
x: 12947927.647142874,
y: 4872153.107787066,
},
{
x: 12947994.798658265,
y: 4871994.343646774,
},
{
x: 12948026.296440713,
y: 4871921.612665893,
},
{
x: 12948040.948586507,
y: 4871894.217878682,
},
{
x: 12948057.308193548,
y: 4871865.8032324435,
},
{
x: 12948067.326472418,
y: 4871850.338413439,
},
{
x: 12948081.773480348,
y: 4871830.043075507,
},
{
x: 12948106.005618699,
y: 4871796.572364472,
},
{
x: 12948147.255517324,
y: 4871752.044003956,
},
{
x: 12948212.569000661,
y: 4871679.780786607,
},
{
x: 12948214.328663053,
y: 4871677.809478982,
},
{
x: 12948273.504086189,
y: 4871611.484093596,
},
{
x: 12948317.798932584,
y: 4871561.862160343,
},
{
x: 12948344.377879875,
y: 4871527.5162396645,
},
{
x: 12948380.890677512,
y: 4871477.605026336,
},
{
x: 12948413.38959998,
y: 4871425.5829799725,
},
{
x: 12948414.44249342,
y: 4871423.82499065,
},
{
x: 12948447.049964357,
y: 4871369.071132418,
},
{
x: 12948447.986775042,
y: 4871367.444350426,
},
{
x: 12948505.566148069,
y: 4871267.333064074,
},
{
x: 12948544.503004055,
y: 4871190.001687928,
},
{
x: 12948579.413090972,
y: 4871111.04819233,
},
{
x: 12948621.84723699,
y: 4871002.001678927,
},
{
x: 12948649.245005308,
y: 4870919.800386681,
},
{
x: 12948729.034075115,
y: 4870659.041565615,
},
{
x: 12948806.660201645,
y: 4870408.542141671,
},
{
x: 12948816.10369674,
y: 4870377.056894108,
},
{
x: 12948817.112454178,
y: 4870373.69505771,
},
{
x: 12948822.827115472,
y: 4870354.633454126,
},
{
x: 12948823.264697373,
y: 4870353.177438731,
},
{
x: 12948871.583647873,
y: 4870192.062297062,
},
{
x: 12948888.256377492,
y: 4870137.412837239,
},
{
x: 12948888.256477488,
y: 4870137.412437243,
},
{
x: 12948981.13241698,
y: 4869833.0181290535,
},
{
x: 12949020.38513926,
y: 4869703.696545276,
},
{
x: 12949062.757994082,
y: 4869570.843921744,
},
{
x: 12949090.169382466,
y: 4869479.2850293545,
},
{
x: 12949123.989708498,
y: 4869371.588525548,
},
{
x: 12949143.001308247,
y: 4869300.813594804,
},
{
x: 12949146.761492698,
y: 4869288.429210793,
},
{
x: 12949163.7803404,
y: 4869233.145301005,
},
{
x: 12949175.026622072,
y: 4869195.787679086,
},
{
x: 12949196.938022848,
y: 4869123.013569744,
},
{
x: 12949208.873643316,
y: 4869083.2070951825,
},
{
x: 12949223.461787153,
y: 4869036.1056654295,
},
{
x: 12949242.728116639,
y: 4868973.956351733,
},
{
x: 12949271.681629652,
y: 4868877.983261017,
},
{
x: 12949297.10128093,
y: 4868796.606128646,
},
{
x: 12949301.07802554,
y: 4868786.43636378,
},
{
x: 12949316.770515563,
y: 4868745.313714858,
},
{
x: 12949322.956596527,
y: 4868730.50358208,
},
{
x: 12949339.748933367,
y: 4868696.689288448,
},
{
x: 12949362.183788385,
y: 4868657.470406632,
},
{
x: 12949389.99988878,
y: 4868612.036959275,
},
{
x: 12949405.211090067,
y: 4868588.465232985,
},
{
x: 12949424.342096223,
y: 4868564.828507317,
},
{
x: 12949513.190764954,
y: 4868460.242782986,
},
{
x: 12949542.465744024,
y: 4868426.322580645,
},
{
x: 12949544.338502375,
y: 4868424.150033486,
},
{
x: 12949600.872280473,
y: 4868356.658526145,
},
{
x: 12949646.996273136,
y: 4868303.803243655,
},
{
x: 12949696.144125719,
y: 4868246.537783951,
},
{
x: 12949755.723785738,
y: 4868181.855453389,
},
{
x: 12949832.37526342,
y: 4868093.127098315,
},
{
x: 12949851.813717443,
y: 4868068.399532126,
},
{
x: 12949894.667583121,
y: 4868017.630119035,
},
{
x: 12949932.221547332,
y: 4867975.033422636,
},
{
x: 12949984.350867936,
y: 4867915.6628556745,
},
{
x: 12950051.280432409,
y: 4867836.640979047,
},
{
x: 12950119.532814305,
y: 4867759.173557603,
},
{
x: 12950170.049738903,
y: 4867700.545102677,
},
{
x: 12950196.18372548,
y: 4867669.647630281,
},
{
x: 12950245.012623828,
y: 4867612.641024118,
},
{
x: 12950366.341310102,
y: 4867472.554440256,
},
{
x: 12950396.016682621,
y: 4867437.159853344,
},
{
x: 12950433.41414459,
y: 4867388.174952161,
},
{
x: 12950467.047766922,
y: 4867337.197051575,
},
{
x: 12950472.727024797,
y: 4867327.624837841,
},
{
x: 12950504.43931956,
y: 4867270.541731104,
},
{
x: 12950506.66515916,
y: 4867265.686943075,
},
{
x: 12950513.328076823,
y: 4867251.147877864,
},
{
x: 12950522.125427773,
y: 4867231.948518946,
},
{
x: 12950543.25084689,
y: 4867180.747377998,
},
{
x: 12950554.610753339,
y: 4867148.755648968,
},
{
x: 12950565.938845547,
y: 4867113.7289358685,
},
{
x: 12950577.077540115,
y: 4867070.725547691,
},
{
x: 12950584.992247868,
y: 4867034.253515085,
},
{
x: 12950597.570781464,
y: 4866945.446932178,
},
{
x: 12950602.621253733,
y: 4866858.218872007,
},
{
x: 12950604.351725787,
y: 4866798.591035709,
},
{
x: 12950604.673463916,
y: 4866769.830411211,
},
{
x: 12950608.500044588,
y: 4866652.0108254915,
},
{
x: 12950610.319620667,
y: 4866589.554543856,
},
{
x: 12950610.359324489,
y: 4866588.2321465295,
},
{
x: 12950610.80126891,
y: 4866566.6265690895,
},
{
x: 12950612.409021743,
y: 4866522.173389596,
},
{
x: 12950616.621330654,
y: 4866372.98018754,
},
{
x: 12950618.97605836,
y: 4866293.007567341,
},
{
x: 12950619.842244353,
y: 4866255.184129226,
},
{
x: 12950625.910927346,
y: 4866063.848140013,
},
{
x: 12950628.387367597,
y: 4865977.081155829,
},
{
x: 12950629.753005603,
y: 4865908.9763710955,
},
{
x: 12950632.086528255,
y: 4865841.0262908945,
},
{
x: 12950632.35165354,
y: 4865833.33471617,
},
{
x: 12950633.79978892,
y: 4865801.28505746,
},
{
x: 12950635.690965662,
y: 4865759.427843475,
},
{
x: 12950637.922484085,
y: 4865674.26866093,
},
{
x: 12950641.139187874,
y: 4865591.213986744,
},
{
x: 12950643.134781921,
y: 4865519.6466930285,
},
{
x: 12950643.368005117,
y: 4865509.419217591,
},
{
x: 12950643.529421674,
y: 4865500.599934787,
},
{
x: 12950643.977363357,
y: 4865491.176881495,
},
{
x: 12950644.362001631,
y: 4865474.307022515,
},
{
x: 12950644.872350669,
y: 4865458.107876617,
},
{
x: 12950645.130576981,
y: 4865444.560304754,
},
{
x: 12950645.57682058,
y: 4865427.882852814,
},
{
x: 12950645.993461674,
y: 4865410.917198133,
},
{
x: 12950646.667225737,
y: 4865391.909170426,
},
{
x: 12950647.177975576,
y: 4865372.994126345,
},
{
x: 12950647.75493018,
y: 4865357.594288625,
},
{
x: 12950648.042257652,
y: 4865348.937219927,
},
{
x: 12950648.42689613,
y: 4865331.427963337,
},
{
x: 12950649.226270262,
y: 4865315.3585491525,
},
{
x: 12950650.507293697,
y: 4865273.423391737,
},
{
x: 12950650.697711246,
y: 4865269.97251224,
},
{
x: 12950651.401779896,
y: 4865244.094692232,
},
{
x: 12950652.233156506,
y: 4865229.016682226,
},
{
x: 12950652.74640693,
y: 4865208.822741665,
},
{
x: 12950653.64269155,
y: 4865185.438841808,
},
{
x: 12950654.09033895,
y: 4865156.015598994,
},
{
x: 12950655.11473383,
y: 4865135.615712103,
},
{
x: 12950655.81880249,
y: 4865109.7205952415,
},
{
x: 12950656.266944723,
y: 4865098.219646195,
},
{
x: 12950656.776491228,
y: 4865090.42570183,
},
{
x: 12950657.610074416,
y: 4865053.173004747,
},
{
x: 12950657.80429587,
y: 4865037.45393246,
},
{
x: 12950665.057790544,
y: 4864813.469608394,
},
{
x: 12950666.31470639,
y: 4864789.756353396,
},
{
x: 12950666.825456835,
y: 4864768.799620799,
},
{
x: 12950667.593330417,
y: 4864744.839817025,
},
{
x: 12950667.977868663,
y: 4864728.163469017,
},
{
x: 12950669.195489043,
y: 4864677.813533126,
},
{
x: 12950669.835947098,
y: 4864668.869905654,
},
{
x: 12950670.091873968,
y: 4864653.088344843,
},
{
x: 12950670.988058263,
y: 4864630.3428553175,
},
{
x: 12950670.92435391,
y: 4864626.509652139,
},
{
x: 12950671.691826217,
y: 4864606.63864744,
},
{
x: 12950672.203278288,
y: 4864580.504222692,
},
{
x: 12950673.228074549,
y: 4864554.884550185,
},
{
x: 12950673.73952671,
y: 4864528.497326723,
},
{
x: 12950674.890434487,
y: 4864500.769470086,
},
{
x: 12950675.2757754,
y: 4864475.593033784,
},
{
x: 12950675.409487799,
y: 4864472.776850138,
},
{
x: 12950676.010148842,
y: 4864442.529341358,
},
{
x: 12950677.468085546,
y: 4864406.737226046,
},
{
x: 12950678.344374934,
y: 4864361.629262644,
},
{
x: 12950681.645047376,
y: 4864252.127616024,
},
{
x: 12950682.9547692,
y: 4864216.335625385,
},
{
x: 12950683.100682352,
y: 4864214.154238779,
},
{
x: 12950684.236285895,
y: 4864191.999439908,
},
{
x: 12950685.866634507,
y: 4864160.1778856525,
},
{
x: 12950689.79278639,
y: 4864108.3870529765,
},
{
x: 12950689.938599342,
y: 4864106.931066905,
},
{
x: 12950697.064031562,
y: 4864036.379448896,
},
{
x: 12950699.534748787,
y: 4864019.216889406,
},
{
x: 12950699.680561578,
y: 4864018.345103669,
},
{
x: 12950716.396330617,
y: 4863888.161824789,
},
{
x: 12950718.57772101,
y: 4863874.636737837,
},
{
x: 12950718.577821152,
y: 4863874.05533762,
},
{
x: 12950732.387228379,
y: 4863767.873478454,
},
{
x: 12950748.375318805,
y: 4863648.896232093,
},
{
x: 12950765.67291641,
y: 4863514.502311158,
},
{
x: 12950777.731654065,
y: 4863426.117281793,
},
{
x: 12950782.448058736,
y: 4863391.472539309,
},
{
x: 12950787.587200012,
y: 4863348.835337318,
},
{
x: 12950801.256266356,
y: 4863250.146561549,
},
{
x: 12950805.275908938,
y: 4863217.932650578,
},
{
x: 12950818.28101368,
y: 4863113.762708521,
},
{
x: 12950822.999512516,
y: 4863078.5401642835,
},
{
x: 12950827.797217675,
y: 4863040.997227563,
},
{
x: 12950833.851926966,
y: 4862997.421011249,
},
{
x: 12950838.379305013,
y: 4862973.344145836,
},
{
x: 12950848.476446522,
y: 4862915.367113537,
},
{
x: 12950856.118280582,
y: 4862873.256843487,
},
{
x: 12950862.060671719,
y: 4862842.477409358,
},
{
x: 12950882.653269414,
y: 4862709.589368273,
},
{
x: 12950907.883131918,
y: 4862524.421459502,
},
{
x: 12950907.90533372,
y: 4862524.26986159,
},
{
x: 12950920.067918759,
y: 4862435.001208198,
},
{
x: 12950928.527198693,
y: 4862379.783399951,
},
{
x: 12950939.681083987,
y: 4862336.514125757,
},
{
x: 12950954.29343263,
y: 4862293.863553435,
},
{
x: 12950967.571566563,
y: 4862263.107846068,
},
{
x: 12950978.195387682,
y: 4862240.704492119,
},
{
x: 12950999.06198339,
y: 4862206.546426427,
},
{
x: 12951021.446772633,
y: 4862168.969866098,
},
{
x: 12951097.70213785,
y: 4862042.200138503,
},
{
x: 12951174.075577334,
y: 4861915.693221821,
},
{
x: 12951267.776776478,
y: 4861760.078948706,
},
{
x: 12951395.236453552,
y: 4861519.784399533,
},
{
x: 12951412.303520849,
y: 4861476.874540171,
},
{
x: 12951451.654131988,
y: 4861334.408202046,
},
{
x: 12951451.745536273,
y: 4861334.052106667,
},
{
x: 12951466.623726709,
y: 4861241.564646258,
},
{
x: 12951489.13393889,
y: 4861018.001826673,
},
{
x: 12951490.383194035,
y: 4860999.999285448,
},
{
x: 12951491.439840542,
y: 4860985.560035131,
},
{
x: 12951503.010040093,
y: 4860889.175072468,
},
{
x: 12951531.140403,
y: 4860680.970427163,
},
{
x: 12951557.758936353,
y: 4860485.587344637,
},
{
x: 12951565.10420882,
y: 4860453.124738692,
},
{
x: 12951575.364280945,
y: 4860406.458640103,
},
{
x: 12951581.065583235,
y: 4860384.268158007,
},
{
x: 12951610.884689623,
y: 4860288.296338669,
},
{
x: 12951620.19888619,
y: 4860261.224956072,
},
{
x: 12951627.274605729,
y: 4860242.081190622,
},
{
x: 12951637.413111666,
y: 4860215.23171692,
},
{
x: 12951657.721893568,
y: 4860163.979635463,
},
{
x: 12951666.949544173,
y: 4860142.223200858,
},
{
x: 12951668.869595224,
y: 4860137.696654858,
},
{
x: 12951693.982928237,
y: 4860078.331821876,
},
{
x: 12951736.262245214,
y: 4859972.802878212,
},
{
x: 12951779.310281485,
y: 4859859.063131411,
},
{
x: 12951799.296553789,
y: 4859804.14710355,
},
{
x: 12951825.224839896,
y: 4859739.862680752,
},
{
x: 12951906.509982908,
y: 4859546.26065336,
},
{
x: 12951960.443026407,
y: 4859429.470375646,
},
{
x: 12951999.771882042,
y: 4859335.105420177,
},
{
x: 12952032.435444733,
y: 4859254.969474848,
},
{
x: 12952037.41706581,
y: 4859242.9403781,
},
{
x: 12952060.923649335,
y: 4859187.91377235,
},
{
x: 12952072.317820875,
y: 4859160.3641980635,
},
{
x: 12952084.970246904,
y: 4859131.4834706,
},
{
x: 12952113.084959969,
y: 4859065.12985738,
},
{
x: 12952130.693674402,
y: 4859023.732486952,
},
{
x: 12952141.643150551,
y: 4858996.55370852,
},
{
x: 12952162.804377414,
y: 4858947.308924186,
},
{
x: 12952171.755373834,
y: 4858927.981571281,
},
{
x: 12952175.604139445,
y: 4858917.094515989,
},
{
x: 12952180.82205369,
y: 4858900.9651018735,
},
{
x: 12952184.554718394,
y: 4858889.243946094,
},
{
x: 12952190.769288482,
y: 4858868.280381973,
},
{
x: 12952193.507485226,
y: 4858857.610563799,
},
{
x: 12952195.947291974,
y: 4858845.681757747,
},
{
x: 12952197.797320686,
y: 4858836.642376694,
},
{
x: 12952199.129268397,
y: 4858825.304718492,
},
{
x: 12952203.716285268,
y: 4858778.431416472,
},
{
x: 12952205.964993557,
y: 4858749.46331663,
},
{
x: 12952207.408630643,
y: 4858703.901754291,
},
{
x: 12952205.633196818,
y: 4858677.13773786,
},
{
x: 12952200.97007183,
y: 4858631.018552714,
},
{
x: 12952196.971420817,
y: 4858601.209733323,
},
{
x: 12952192.67917836,
y: 4858569.843524169,
},
{
x: 12952188.386933465,
y: 4858539.217911885,
},
{
x: 12952168.84610709,
y: 4858394.254627763,
},
{
x: 12952159.519210786,
y: 4858329.002694597,
},
{
x: 12952158.632838566,
y: 4858318.547228751,
},
{
x: 12952157.151183436,
y: 4858288.818485506,
},
{
x: 12952156.706496444,
y: 4858276.218902411,
},
{
x: 12952157.149780104,
y: 4858257.685985396,
},
{
x: 12952159.218710119,
y: 4858232.933605842,
},
{
x: 12952159.810389748,
y: 4858223.449482893,
},
{
x: 12952162.532997137,
y: 4858196.9427767545,
},
{
x: 12952172.755045319,
y: 4858146.897168553,
},
{
x: 12952179.958089378,
y: 4858120.216771117,
},
{
x: 12952191.658258049,
y: 4858079.657970377,
},
{
x: 12952208.58059935,
y: 4858022.51880722,
},
{
x: 12952216.501576891,
y: 4857997.283134168,
},
{
x: 12952225.680391517,
y: 4857966.100288983,
},
{
x: 12952269.24519301,
y: 4857823.342887307,
},
{
x: 12952302.724863112,
y: 4857711.949002681,
},
],
},
{
id: "13",
source: "26",
target: "27",
class: "地铁十号线",
name: "地铁十号线 0",
controlPoints: [
{
x: 12964391.173261674,
y: 4847959.964747035,
},
{
x: 12964381.421162914,
y: 4847238.950861313,
},
{
x: 12964379.013229802,
y: 4847130.369249381,
},
{
x: 12964369.707333228,
y: 4846953.233573841,
},
{
x: 12964365.098653296,
y: 4846899.529372901,
},
{
x: 12964350.271597194,
y: 4846844.7236321755,
},
{
x: 12964328.613459915,
y: 4846773.943192761,
},
{
x: 12964303.571447244,
y: 4846720.321707801,
},
{
x: 12964261.49123042,
y: 4846658.767114734,
},
{
x: 12964219.422329223,
y: 4846606.356004327,
},
{
x: 12964163.72308854,
y: 4846548.283066274,
},
{
x: 12964117.115347376,
y: 4846498.174184149,
},
{
x: 12963719.24125982,
y: 4846081.363070078,
},
{
x: 12963666.940189386,
y: 4846020.980269377,
},
{
x: 12963651.029381108,
y: 4846008.466281171,
},
{
x: 12963640.792827746,
y: 4845993.645627467,
},
{
x: 12963630.555030722,
y: 4845977.682026026,
},
{
x: 12963622.579870086,
y: 4845954.85254285,
},
{
x: 12963622.547271827,
y: 4845927.422297171,
},
{
x: 12963624.705055857,
y: 4845832.5516995825,
},
{
x: 12963605.106422728,
y: 4844950.156548626,
},
{
x: 12963600.552929461,
y: 4844939.887775902,
},
{
x: 12963641.28504856,
y: 4844029.840890613,
},
{
x: 12963635.07102118,
y: 4843895.785437119,
},
{
x: 12963592.56494142,
y: 4843790.304489117,
},
{
x: 12963515.79594813,
y: 4843723.544249312,
},
{
x: 12963437.02641232,
y: 4843673.039785006,
},
{
x: 12963372.392513098,
y: 4843630.608396946,
},
{
x: 12963273.452605404,
y: 4843594.387913362,
},
{
x: 12963212.653908446,
y: 4843577.914113967,
},
{
x: 12963206.82489125,
y: 4843576.334664474,
},
{
x: 12963057.427614385,
y: 4843550.431693091,
},
{
x: 12962954.477380954,
y: 4843548.741287049,
},
{
x: 12962788.932332132,
y: 4843539.119846538,
},
{
x: 12960734.413928954,
y: 4843579.436506579,
},
{
x: 12960615.677401308,
y: 4843579.296389959,
},
{
x: 12959224.804679275,
y: 4843577.132908265,
},
{
x: 12958165.962075146,
y: 4843552.786071934,
},
{
x: 12958015.842937116,
y: 4843539.299682281,
},
{
x: 12957633.083574392,
y: 4843505.052930688,
},
{
x: 12956758.552751072,
y: 4843474.381786778,
},
{
x: 12956086.236845858,
y: 4843457.686331021,
},
{
x: 12955417.836020822,
y: 4843562.642953932,
},
{
x: 12955413.075883733,
y: 4843564.0987397935,
},
{
x: 12955318.578314304,
y: 4843592.994666116,
},
{
x: 12955279.765356282,
y: 4843598.897849127,
},
{
x: 12955190.622782081,
y: 4843602.847728858,
},
{
x: 12953646.394080758,
y: 4843575.957979132,
},
{
x: 12953060.552869217,
y: 4843574.760301962,
},
{
x: 12952787.031931885,
y: 4843571.511276698,
},
{
x: 12951953.230827896,
y: 4843561.903501986,
},
{
x: 12951924.357645055,
y: 4843559.360785293,
},
{
x: 12951835.590379665,
y: 4843551.541948503,
},
{
x: 12951527.588141518,
y: 4843484.482094485,
},
{
x: 12951075.84273588,
y: 4843410.169546208,
},
{
x: 12950795.208394462,
y: 4843386.56777375,
},
{
x: 12950199.79003986,
y: 4843370.818621907,
},
{
x: 12950187.299179578,
y: 4843370.485690744,
},
{
x: 12948755.739655264,
y: 4843370.555741397,
},
{
x: 12948301.7684026,
y: 4843375.188304583,
},
{
x: 12948278.325845689,
y: 4843375.123114149,
},
{
x: 12947913.423896424,
y: 4843373.865129756,
},
{
x: 12947592.303468505,
y: 4843394.1161822025,
},
{
x: 12947581.215097992,
y: 4843394.815685296,
},
{
x: 12947415.424213238,
y: 4843437.701399312,
},
{
x: 12947274.850617228,
y: 4843509.5493655335,
},
{
x: 12947145.066987505,
y: 4843631.989033849,
},
{
x: 12947083.745603528,
y: 4843765.448522134,
},
{
x: 12947029.622192265,
y: 4843916.987015813,
},
{
x: 12946979.091048203,
y: 4844090.2070025485,
},
{
x: 12946955.102622215,
y: 4844184.990607465,
},
{
x: 12946945.915349547,
y: 4844319.830258014,
},
{
x: 12946923.770701075,
y: 4845315.372927731,
},
{
x: 12946851.421569752,
y: 4846551.5626413245,
},
{
x: 12946848.88594415,
y: 4846594.6202231655,
},
{
x: 12946848.609652413,
y: 4846598.19993173,
},
{
x: 12946696.54362537,
y: 4848569.1295227185,
},
{
x: 12946757.730386814,
y: 4848764.400754196,
},
{
x: 12946757.762984468,
y: 4848770.602855413,
},
{
x: 12946761.025258096,
y: 4849389.514336067,
},
{
x: 12946767.82605037,
y: 4850217.041711847,
},
{
x: 12946789.423173606,
y: 4850282.143556595,
},
{
x: 12946825.465052422,
y: 4850311.148186556,
},
{
x: 12947052.561481878,
y: 4850452.686121019,
},
{
x: 12947214.803034527,
y: 4850514.554585377,
},
{
x: 12947308.555685857,
y: 4850529.261912783,
},
{
x: 12947449.196901781,
y: 4850533.256072254,
},
{
x: 12947590.121115766,
y: 4850533.639384969,
},
{
x: 12947604.269979956,
y: 4850533.6780554075,
},
{
x: 12947595.595432382,
y: 4853171.930337626,
},
{
x: 12947588.6332791,
y: 4853230.507756927,
},
{
x: 12947570.25534986,
y: 4853385.134998881,
},
{
x: 12947534.132989677,
y: 4853500.7123848,
},
{
x: 12947451.113532243,
y: 4853616.16379296,
},
{
x: 12947332.03107398,
y: 4853706.215145492,
},
{
x: 12947133.576039799,
y: 4853828.591678857,
},
{
x: 12946866.97284939,
y: 4854028.085858982,
},
{
x: 12946608.167520212,
y: 4854187.260197411,
},
{
x: 12946364.738988684,
y: 4854328.7254704805,
},
{
x: 12946303.257037977,
y: 4854430.402571901,
},
{
x: 12946252.383757986,
y: 4854573.552461346,
},
{
x: 12946214.461752877,
y: 4854793.706838007,
},
{
x: 12946220.215499429,
y: 4854990.273434222,
},
{
x: 12946219.011349382,
y: 4855034.084710322,
},
{
x: 12946156.333146382,
y: 4855155.899273862,
},
{
x: 12946061.71710423,
y: 4855352.240931815,
},
{
x: 12946050.635431375,
y: 4855405.652363556,
},
{
x: 12946036.841429455,
y: 4855472.970938698,
},
{
x: 12945937.184814524,
y: 4856212.898218268,
},
{
x: 12945963.10362221,
y: 4857094.046675076,
},
{
x: 12945958.921351675,
y: 4857134.026535522,
},
{
x: 12945884.03047807,
y: 4857857.218830575,
},
{
x: 12945847.638054904,
y: 4858399.611054495,
},
{
x: 12945847.280553274,
y: 4859007.224022067,
},
{
x: 12945860.526034107,
y: 4859226.599693325,
},
{
x: 12945864.842806887,
y: 4859298.0925262105,
},
{
x: 12945879.5175261,
y: 4859405.1651427485,
},
{
x: 12945886.625513952,
y: 4859589.651325276,
},
{
x: 12945864.662784807,
y: 4859694.379973758,
},
{
x: 12945784.912348324,
y: 4859882.159043464,
},
{
x: 12945727.11821354,
y: 4859994.151868572,
},
{
x: 12945701.784202412,
y: 4860124.311216468,
},
{
x: 12945698.14559977,
y: 4860174.944243185,
},
{
x: 12945452.47590781,
y: 4860713.3477798365,
},
{
x: 12945196.058016783,
y: 4861128.770078741,
},
{
x: 12945092.686995683,
y: 4861317.482488749,
},
{
x: 12945051.578445194,
y: 4861392.531520205,
},
{
x: 12945015.437229244,
y: 4861490.129152049,
},
{
x: 12945008.163701242,
y: 4861576.939256895,
},
{
x: 12945015.284018965,
y: 4861718.049761452,
},
{
x: 12945022.23002506,
y: 4861756.836245517,
},
{
x: 12945035.651318152,
y: 4861797.3254907355,
},
{
x: 12945054.888690906,
y: 4861837.528089324,
},
{
x: 12945105.325637072,
y: 4861946.179124048,
},
{
x: 12945125.370065786,
y: 4861974.055941134,
},
{
x: 12945163.446826743,
y: 4862019.098382124,
},
{
x: 12945194.809906306,
y: 4862048.391273372,
},
{
x: 12945228.090067945,
y: 4862073.16642714,
},
{
x: 12945255.305523323,
y: 4862092.36230406,
},
{
x: 12945285.556679495,
y: 4862110.414454173,
},
{
x: 12945315.808265274,
y: 4862128.467023728,
},
{
x: 12945361.54760602,
y: 4862142.217026062,
},
{
x: 12945487.830327151,
y: 4862156.985505024,
},
],
},
{
id: "14",
source: "28",
target: "29",
class: "地铁十四号线",
name: "地铁十四号线 0",
controlPoints: [
{
x: 12937234.877597623,
y: 4846515.674866713,
},
{
x: 12937368.988537306,
y: 4846593.191490097,
},
{
x: 12937461.335291399,
y: 4846647.398606839,
},
{
x: 12937532.375518117,
y: 4846688.019702177,
},
{
x: 12937591.769328088,
y: 4846720.059432032,
},
{
x: 12937621.188342465,
y: 4846732.002843995,
},
{
x: 12937671.789557256,
y: 4846748.737535954,
},
{
x: 12937709.602904188,
y: 4846758.320650579,
},
{
x: 12937735.762316125,
y: 4846763.326932602,
},
{
x: 12937752.397758542,
y: 4846765.615152837,
},
{
x: 12937773.44091199,
y: 4846768.332774585,
},
{
x: 12937804.297495496,
y: 4846770.764304414,
},
{
x: 12937827.33427437,
y: 4846772.051537565,
},
{
x: 12937868.008451082,
y: 4846771.479321919,
},
{
x: 12937892.32897584,
y: 4846770.33498424,
},
{
x: 12937918.075058706,
y: 4846766.901995257,
},
{
x: 12937940.834554123,
y: 4846763.6122220345,
},
{
x: 12937968.574529182,
y: 4846758.463006948,
},
{
x: 12937995.180239107,
y: 4846751.025023762,
},
{
x: 12938017.517118562,
y: 4846745.160619812,
},
{
x: 12938042.132414829,
y: 4846737.43681869,
},
{
x: 12938076.570282334,
y: 4846723.276240112,
},
{
x: 12938122.822349729,
y: 4846702.393192925,
},
{
x: 12938155.702757211,
y: 4846683.512634498,
},
{
x: 12938188.444042044,
y: 4846662.62954278,
},
{
x: 12938219.76602793,
y: 4846639.600848661,
},
{
x: 12938250.095861865,
y: 4846614.140497331,
},
{
x: 12938278.438376905,
y: 4846585.962328421,
},
{
x: 12938304.220769178,
y: 4846557.783944012,
},
{
x: 12938329.579807637,
y: 4846527.173999285,
},
{
x: 12938353.520818293,
y: 4846493.274026497,
},
{
x: 12938372.907309297,
y: 4846461.6623603245,
},
{
x: 12938391.017690128,
y: 4846427.046785262,
},
{
x: 12938412.561981687,
y: 4846377.125676343,
},
{
x: 12938434.974010698,
y: 4846316.476277426,
},
{
x: 12938448.248669473,
y: 4846281.574595996,
},
{
x: 12938475.656359944,
y: 4846207.766580478,
},
{
x: 12938490.211433839,
y: 4846172.579389068,
},
{
x: 12938507.041724533,
y: 4846137.6790905995,
},
{
x: 12938526.29072453,
y: 4846102.493274418,
},
{
x: 12938542.26056133,
y: 4846073.028826507,
},
{
x: 12938584.740041988,
y: 4846003.660309321,
},
{
x: 12938633.06400581,
y: 4845924.638571542,
},
{
x: 12938715.454181843,
y: 4845792.771941782,
},
{
x: 12938776.553557053,
y: 4845700.585488995,
},
{
x: 12938781.398345944,
y: 4845694.149817628,
},
{
x: 12938800.081236716,
y: 4845673.873968367,
},
{
x: 12938830.820290571,
y: 4845645.815687927,
},
{
x: 12938844.393556165,
y: 4845633.390067325,
},
{
x: 12938873.132778017,
y: 4845610.143030206,
},
{
x: 12938936.183000699,
y: 4845573.274183875,
},
{
x: 12938969.9751077,
y: 4845523.292870295,
},
{
x: 12939008.30658488,
y: 4845483.611718048,
},
{
x: 12939046.62636937,
y: 4845453.553428374,
},
{
x: 12939107.67397802,
y: 4845425.508528395,
},
{
x: 12939139.988430338,
y: 4845415.095566754,
},
{
x: 12939215.636890687,
y: 4845415.718690437,
},
{
x: 12939308.039270518,
y: 4845421.266472513,
},
{
x: 12939491.25690715,
y: 4845458.350894194,
},
{
x: 12939790.511140315,
y: 4845556.207267058,
},
{
x: 12939988.628771447,
y: 4845616.1622475535,
},
{
x: 12940117.839141306,
y: 4845661.911291016,
},
{
x: 12940686.897376765,
y: 4845952.2196258595,
},
{
x: 12941074.89764744,
y: 4846157.503429323,
},
{
x: 12941335.171058182,
y: 4846317.370755986,
},
{
x: 12941559.500148436,
y: 4846435.253157876,
},
{
x: 12941942.0737714,
y: 4846649.584496282,
},
{
x: 12942044.003008543,
y: 4846663.89086179,
},
{
x: 12942128.18335582,
y: 4846652.232800751,
},
{
x: 12942566.46418881,
y: 4846526.042660932,
},
{
x: 12942889.715147126,
y: 4846450.953434545,
},
{
x: 12943968.393642,
y: 4846408.250017698,
},
{
x: 12944809.837601995,
y: 4846425.649451,
},
{
x: 12944985.099897848,
y: 4846441.60822536,
},
{
x: 12945546.215890277,
y: 4846492.747584046,
},
{
x: 12946211.229001617,
y: 4846547.780306945,
},
],
},
{
id: "15",
source: "30",
target: "31",
class: "地铁十五号线",
name: "地铁十五号线 0",
controlPoints: [
{
x: 12975220.360613192,
y: 4878868.526210992,
},
{
x: 12975170.101829547,
y: 4878482.810853661,
},
{
x: 12975127.393577926,
y: 4878166.084186471,
},
{
x: 12975102.3383307,
y: 4877971.094415046,
},
{
x: 12975067.230635904,
y: 4877703.212676576,
},
{
x: 12975028.196639525,
y: 4877408.433615002,
},
{
x: 12974992.782733576,
y: 4877135.782488413,
},
{
x: 12974961.616855532,
y: 4876898.418269849,
},
{
x: 12974957.635438241,
y: 4876867.667671654,
},
{
x: 12974924.692424836,
y: 4876613.225913413,
},
{
x: 12974904.122140514,
y: 4876457.185169152,
},
{
x: 12974891.114395186,
y: 4876358.838107704,
},
{
x: 12974881.80755435,
y: 4876318.801830084,
},
{
x: 12974850.30174708,
y: 4876128.145737729,
},
{
x: 12974841.600142721,
y: 4876060.242186066,
},
{
x: 12974833.693115635,
y: 4875993.44712488,
},
{
x: 12974824.851303473,
y: 4875896.879010218,
},
{
x: 12974823.581860177,
y: 4875861.890374971,
},
{
x: 12974804.231609207,
y: 4875717.818793602,
},
{
x: 12974793.363254767,
y: 4875644.593833729,
},
{
x: 12974780.733046675,
y: 4875579.452634726,
},
{
x: 12974765.457217943,
y: 4875526.588724708,
},
{
x: 12974748.090285787,
y: 4875469.247595661,
},
{
x: 12974731.657055452,
y: 4875430.44830189,
},
{
x: 12974707.759133428,
y: 4875374.935044397,
},
{
x: 12974682.982388051,
y: 4875324.213162166,
},
{
x: 12974660.60794111,
y: 4875285.743106426,
},
{
x: 12974635.85688353,
y: 4875245.7891169265,
},
{
x: 12974592.33221722,
y: 4875182.6007377645,
},
{
x: 12974565.515120054,
y: 4875148.641781552,
},
{
x: 12974477.340428105,
y: 4875046.200795493,
},
{
x: 12974324.23997027,
y: 4874868.727412534,
},
{
x: 12974285.225031873,
y: 4874824.06709895,
},
{
x: 12974250.676817749,
y: 4874784.765451768,
},
{
x: 12974226.548435159,
y: 4874754.982961457,
},
{
x: 12974179.793554721,
y: 4874702.287665765,
},
{
x: 12974152.700378012,
y: 4874674.611620291,
},
{
x: 12974102.993937358,
y: 4874629.4094777135,
},
{
x: 12974057.281876976,
y: 4874592.149864237,
},
{
x: 12974010.571259402,
y: 4874557.10058754,
},
{
x: 12973965.349593911,
y: 4874523.243715123,
},
{
x: 12973927.86306645,
y: 4874495.325444062,
},
{
x: 12973778.829987278,
y: 4874388.442810681,
},
{
x: 12973631.292726409,
y: 4874281.260318043,
},
{
x: 12973511.128084678,
y: 4874193.07702723,
},
{
x: 12973457.885669941,
y: 4874152.090015151,
},
{
x: 12973424.569167605,
y: 4874125.653511811,
},
{
x: 12973401.064728435,
y: 4874103.948181291,
},
{
x: 12973364.466450525,
y: 4874069.155318013,
},
{
x: 12973343.040548371,
y: 4874047.737895291,
},
{
x: 12973301.971003683,
y: 4874004.595285215,
},
{
x: 12973268.333740914,
y: 4873965.001992706,
},
{
x: 12973223.968151508,
y: 4873907.523655236,
},
{
x: 12973200.145078428,
y: 4873874.757068463,
},
{
x: 12973184.359140303,
y: 4873851.817254196,
},
{
x: 12973151.288220981,
y: 4873799.065100245,
},
{
x: 12973133.104508085,
y: 4873765.071843533,
},
{
x: 12973115.220516248,
y: 4873731.975402937,
},
{
x: 12973083.514099035,
y: 4873666.6145877475,
},
{
x: 12972958.272448545,
y: 4873409.226124313,
},
{
x: 12972918.910218379,
y: 4873326.610352403,
},
{
x: 12972826.476255693,
y: 4873134.840144364,
},
{
x: 12972795.763337882,
y: 4873070.719005933,
},
{
x: 12972744.76742065,
y: 4872959.163678453,
},
{
x: 12972720.60264992,
y: 4872901.886303345,
},
{
x: 12972659.997036628,
y: 4872735.667320859,
},
{
x: 12972643.299525585,
y: 4872699.580940345,
},
{
x: 12972559.100747146,
y: 4872455.805418115,
},
{
x: 12972532.783339068,
y: 4872369.677216135,
},
{
x: 12972491.590280673,
y: 4872256.099208747,
},
{
x: 12972431.316032,
y: 4872100.655541013,
},
{
x: 12972411.705557901,
y: 4872052.949093282,
},
{
x: 12972344.317184499,
y: 4871873.754390362,
},
{
x: 12972344.317084517,
y: 4871873.754090381,
},
{
x: 12972283.901539784,
y: 4871713.096747656,
},
{
x: 12972231.51025757,
y: 4871590.704161345,
},
{
x: 12972220.786418218,
y: 4871568.055674147,
},
{
x: 12972187.677583814,
y: 4871506.46596912,
},
{
x: 12972159.917606726,
y: 4871462.740223999,
},
{
x: 12972122.405523332,
y: 4871409.778587388,
},
{
x: 12972070.897276413,
y: 4871345.708445298,
},
{
x: 12972018.521820415,
y: 4871290.250138916,
},
{
x: 12971949.740475345,
y: 4871227.65827687,
},
{
x: 12971856.352377752,
y: 4871157.9745282065,
},
{
x: 12971744.543129945,
y: 4871096.1426233165,
},
{
x: 12971666.305498093,
y: 4871059.28347291,
},
{
x: 12971573.517186211,
y: 4871028.317100962,
},
{
x: 12971543.275268642,
y: 4871019.710796947,
},
{
x: 12970313.75580163,
y: 4871029.4038401535,
},
{
x: 12969743.624482477,
y: 4871013.157693107,
},
{
x: 12969526.746136123,
y: 4871006.97216711,
},
{
x: 12969268.713759044,
y: 4870954.619065353,
},
{
x: 12969027.21710455,
y: 4870806.293398591,
},
{
x: 12968695.732934553,
y: 4870386.919417365,
},
{
x: 12968267.842089783,
y: 4869845.614706303,
},
{
x: 12968041.977084596,
y: 4869507.853755934,
},
{
x: 12967897.801472468,
y: 4868972.889715916,
},
{
x: 12967878.337220326,
y: 4867594.394019558,
},
{
x: 12967868.77862341,
y: 4866238.919959571,
},
{
x: 12967801.717744218,
y: 4865970.777359848,
},
{
x: 12967494.283058798,
y: 4865925.768674796,
},
{
x: 12965837.973847104,
y: 4865743.023798019,
},
{
x: 12965348.196035301,
y: 4865688.751628207,
},
{
x: 12964443.21307059,
y: 4865516.203149938,
},
],
},
{
id: "16",
source: "32",
target: "33",
class: "机场轻轨线",
name: "机场轻轨线 0",
controlPoints: [
{
x: 12981108.370146083,
y: 4871488.68313175,
},
{
x: 12981018.508214273,
y: 4871439.9092021575,
},
{
x: 12980902.535834748,
y: 4871405.203097882,
},
{
x: 12980821.525095403,
y: 4871396.07635756,
},
{
x: 12980751.756629316,
y: 4871395.085485736,
},
{
x: 12980685.769679295,
y: 4871406.921907764,
},
{
x: 12980609.835639,
y: 4871428.117243195,
},
{
x: 12980553.791983627,
y: 4871454.35924438,
},
{
x: 12980504.260708505,
y: 4871483.782440005,
},
{
x: 12980435.350114407,
y: 4871539.621344493,
},
{
x: 12980398.504969673,
y: 4871582.03131289,
},
{
x: 12980362.007896207,
y: 4871632.577822356,
},
{
x: 12980332.654508604,
y: 4871686.360369531,
},
{
x: 12980319.13294245,
y: 4871720.246401924,
},
{
x: 12980306.26908758,
y: 4871757.385237568,
},
{
x: 12980293.763164897,
y: 4871806.2405863255,
},
{
x: 12980277.698010115,
y: 4871929.260816189,
},
{
x: 12980261.290169481,
y: 4871965.0230897125,
},
{
x: 12980254.749320468,
y: 4871910.852033942,
},
{
x: 12980243.756181171,
y: 4871816.594568528,
},
{
x: 12980227.70573535,
y: 4871752.941176994,
},
{
x: 12980203.072226636,
y: 4871672.165283503,
},
{
x: 12980150.33990551,
y: 4871582.889266779,
},
{
x: 12980101.34029352,
y: 4871516.884384831,
},
{
x: 12980048.722460367,
y: 4871461.910039693,
},
{
x: 12979996.111785132,
y: 4871413.06501025,
},
{
x: 12979909.333892826,
y: 4871359.422428334,
},
{
x: 12979799.058829894,
y: 4871312.3731178045,
},
{
x: 12979720.936799372,
y: 4871295.456660487,
},
{
x: 12979624.500482768,
y: 4871274.924462654,
},
{
x: 12979479.39873571,
y: 4871277.213494264,
},
{
x: 12979085.453077132,
y: 4871280.917372964,
},
{
x: 12978992.156225236,
y: 4871279.384364794,
},
{
x: 12978956.177897697,
y: 4871277.666599098,
},
{
x: 12978900.674255166,
y: 4871271.113841657,
},
{
x: 12978860.293281717,
y: 4871262.702607095,
},
{
x: 12978764.752916442,
y: 4871245.472966051,
},
{
x: 12978664.480746558,
y: 4871226.718917767,
},
{
x: 12978629.714270562,
y: 4871220.650472208,
},
{
x: 12978620.414652059,
y: 4871219.068466421,
},
{
x: 12978564.580504624,
y: 4871213.590081386,
},
{
x: 12978460.737579372,
y: 4871195.649671084,
},
{
x: 12978328.733081415,
y: 4871172.822299577,
},
{
x: 12978213.58406164,
y: 4871153.546776074,
},
{
x: 12978126.884770632,
y: 4871139.996553964,
},
{
x: 12978030.808147773,
y: 4871127.039056859,
},
{
x: 12977949.096244726,
y: 4871117.637013953,
},
{
x: 12977857.7281794,
y: 4871107.719554274,
},
{
x: 12977818.256715368,
y: 4871103.431990254,
},
{
x: 12977782.926936783,
y: 4871099.961185381,
},
{
x: 12977738.76375114,
y: 4871094.860768784,
},
{
x: 12977699.015983863,
y: 4871089.466841593,
},
{
x: 12977670.034107389,
y: 4871085.695982234,
},
{
x: 12977617.58207723,
y: 4871075.083050405,
},
{
x: 12977586.096101644,
y: 4871069.051658005,
},
{
x: 12977553.816080883,
y: 4871065.107010753,
},
{
x: 12977547.258727068,
y: 4871063.901849335,
},
{
x: 12977530.618654177,
y: 4871060.843754747,
},
{
x: 12977510.63402144,
y: 4871057.271591576,
},
{
x: 12977488.410456756,
y: 4871052.304085646,
},
{
x: 12977476.108263735,
y: 4871049.825167599,
},
{
x: 12977449.974956136,
y: 4871043.750099359,
},
{
x: 12977426.211063186,
y: 4871036.9651420405,
},
{
x: 12977355.623273922,
y: 4871014.777517495,
},
{
x: 12977296.479809767,
y: 4870992.125603299,
},
{
x: 12977282.77631216,
y: 4870986.002440447,
},
{
x: 12977251.719621776,
y: 4870972.154493815,
},
{
x: 12977247.24550043,
y: 4870969.812148521,
},
{
x: 12977238.854476603,
y: 4870965.421079147,
},
{
x: 12977209.761773894,
y: 4870950.136411922,
},
{
x: 12977096.757856315,
y: 4870889.44525773,
},
{
x: 12976968.08990173,
y: 4870816.956775016,
},
{
x: 12976780.16768485,
y: 4870720.01310895,
},
{
x: 12976677.82368606,
y: 4870666.528023298,
},
{
x: 12976655.8764118,
y: 4870655.5205783425,
},
{
x: 12976529.223142704,
y: 4870592.317432991,
},
{
x: 12976428.586317737,
y: 4870542.427981049,
},
{
x: 12976366.5421185,
y: 4870518.407870099,
},
{
x: 12976329.380473636,
y: 4870506.354736436,
},
{
x: 12976271.82754423,
y: 4870490.321866817,
},
{
x: 12976228.111302977,
y: 4870481.388277324,
},
{
x: 12976188.09288433,
y: 4870478.038546045,
},
{
x: 12976149.436712662,
y: 4870471.373423314,
},
{
x: 12976071.072179394,
y: 4870465.607346994,
},
{
x: 12975965.86990555,
y: 4870455.646798379,
},
{
x: 12975917.917454332,
y: 4870449.027466127,
},
{
x: 12975868.894021038,
y: 4870442.773831003,
},
{
x: 12975820.580020344,
y: 4870433.638390911,
},
{
x: 12975790.158459982,
y: 4870426.94054179,
},
{
x: 12975775.838848663,
y: 4870422.328125062,
},
{
x: 12975751.13866662,
y: 4870414.524700168,
},
{
x: 12975725.00528259,
y: 4870405.648373743,
},
{
x: 12975714.620193584,
y: 4870400.657944233,
},
{
x: 12975694.938773984,
y: 4870397.150636553,
},
{
x: 12975674.888572035,
y: 4870388.966441453,
},
{
x: 12975636.937384691,
y: 4870373.667942694,
},
{
x: 12975612.227725828,
y: 4870361.187195985,
},
{
x: 12975582.510264473,
y: 4870348.370360326,
},
{
x: 12975500.513648823,
y: 4870309.887833572,
},
{
x: 12975383.793644667,
y: 4870256.097796813,
},
{
x: 12975133.184359929,
y: 4870136.739612404,
},
{
x: 12974949.40711058,
y: 4870050.794763821,
},
{
x: 12974941.365436705,
y: 4870047.009858454,
},
{
x: 12974724.15676446,
y: 4869944.777526178,
},
{
x: 12974559.111049827,
y: 4869868.410730108,
},
{
x: 12974550.453614099,
y: 4869864.520617537,
},
{
x: 12974441.55043712,
y: 4869814.212693192,
},
{
x: 12974270.106768792,
y: 4869734.071269941,
},
{
x: 12974091.838388277,
y: 4869651.027056911,
},
{
x: 12973885.444597295,
y: 4869555.245051317,
},
{
x: 12973766.248404168,
y: 4869500.831533556,
},
{
x: 12973540.981958374,
y: 4869392.930468844,
},
{
x: 12973391.381564768,
y: 4869323.244557277,
},
{
x: 12973283.232700225,
y: 4869272.859937838,
},
{
x: 12972573.852092165,
y: 4868943.251794805,
},
{
x: 12970368.479611576,
y: 4867801.281579257,
},
{
x: 12970186.368543653,
y: 4867581.247939134,
},
{
x: 12970138.160652429,
y: 4867522.999803067,
},
{
x: 12970014.83652081,
y: 4867376.428914912,
},
{
x: 12969982.687756885,
y: 4867339.028822399,
},
{
x: 12969938.176704682,
y: 4867288.1582316635,
},
{
x: 12969884.318320546,
y: 4867223.8002079725,
},
{
x: 12969842.279029265,
y: 4867174.850547206,
},
{
x: 12969736.51761531,
y: 4867052.928304552,
},
{
x: 12969715.618553909,
y: 4867028.835423228,
},
{
x: 12969620.004793288,
y: 4866917.186788599,
},
{
x: 12969438.04374979,
y: 4866711.844669058,
},
{
x: 12969408.156057132,
y: 4866677.285747163,
},
{
x: 12969324.820910655,
y: 4866578.791680055,
},
{
x: 12969226.67533753,
y: 4866469.379122947,
},
{
x: 12968956.364812195,
y: 4866149.976631404,
},
{
x: 12968801.20089387,
y: 4865953.939934027,
},
{
x: 12968661.628187554,
y: 4865774.016041136,
},
{
x: 12968440.203180425,
y: 4865520.086029257,
},
{
x: 12968418.752663735,
y: 4865496.720383862,
},
{
x: 12968265.16366474,
y: 4865329.4158122465,
},
{
x: 12968082.376416814,
y: 4865118.794538391,
},
{
x: 12967977.74367467,
y: 4865003.326373822,
},
{
x: 12967875.580874648,
y: 4864890.602510729,
},
{
x: 12967828.859212246,
y: 4864840.529032915,
},
{
x: 12967771.529788392,
y: 4864773.642307851,
},
{
x: 12967754.0789727,
y: 4864752.1729925005,
},
{
x: 12967615.98897636,
y: 4864590.439552254,
},
{
x: 12967559.654778784,
y: 4864523.543494982,
},
{
x: 12967512.793535465,
y: 4864468.1316355625,
},
{
x: 12967489.97373297,
y: 4864440.960919648,
},
{
x: 12967391.600998314,
y: 4864324.055311191,
},
{
x: 12967258.997379664,
y: 4864167.803726059,
},
{
x: 12967157.800077152,
y: 4864048.489056851,
},
{
x: 12967072.064892631,
y: 4863952.160647396,
},
{
x: 12966932.938263306,
y: 4863786.109663975,
},
{
x: 12966772.422852328,
y: 4863597.399173657,
},
{
x: 12966615.568496268,
y: 4863412.808523439,
},
{
x: 12966305.336633127,
y: 4863047.703772259,
},
{
x: 12966269.190687215,
y: 4863001.279273752,
},
{
x: 12965833.711641828,
y: 4862475.155696717,
},
{
x: 12965806.851898653,
y: 4862442.704151941,
},
{
x: 12964858.528949967,
y: 4861327.4237803,
},
{
x: 12964224.475284964,
y: 4860561.038983111,
},
{
x: 12963811.623681322,
y: 4860051.71716615,
},
{
x: 12963154.244359475,
y: 4859240.959120094,
},
{
x: 12962659.851017611,
y: 4858630.950164011,
},
{
x: 12962035.08051321,
y: 4857953.39954861,
},
{
x: 12961929.533509394,
y: 4857864.163282811,
},
{
x: 12961663.821656032,
y: 4857639.499910775,
},
{
x: 12961465.562880669,
y: 4857485.1627320545,
},
{
x: 12961385.775293019,
y: 4857425.3359782435,
},
],
},
],
};
const colors = [
"rgb(64, 174, 247)",
"rgb(108, 207, 169)",
"rgb(157, 223, 125)",
"rgb(240, 198, 74)",
"rgb(221, 158, 97)",
"rgb(141, 163, 112)",
"rgb(115, 136, 220)",
"rgb(133, 88, 219)",
"rgb(203, 135, 226)",
"rgb(227, 137, 163)",
];
const { nodes } = data;
const { edges } = data;
const classMap = new Map();
let classId = 0;
nodes.forEach(function (node) {
node.y = -node.y;
});
edges.forEach(function (edge) {
edge.id = `edge-${edge.id}`;
// edge cluster
if (edge.class && classMap.get(edge.class) === undefined) {
classMap.set(edge.class, classId);
classId++;
}
const cid = classMap.get(edge.class);
edge.color = colors[cid % colors.length];
const { controlPoints } = edge;
controlPoints.forEach(function (cp) {
cp.y = -cp.y;
});
});
export { nodes, edges, data };
================================================
FILE: packages/examples-alipay/pages/scene-case/metro-lines/index.acss
================================================
page {
background-color: #101424;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
.canvas {
margin-top: 200rpx;
background: url("https://gw.alipayobjects.com/mdn/rms_f8c6a0/afts/img/A*G23iRqkiibIAAAAAAAAAAABkARQnAQ");
background-size: 100% 100%;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/metro-lines/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/metro-lines/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import { nodes, edges, data } from "./data";
/**
* metroLines
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 412,
height: 412,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 同步获取window的宽高
const { pixelRatio } = my.getSystemInfoSync();
my.setBackgroundColor({
backgroundColorTop: "#000000",
backgroundColorBottom: "#000000",
});
// custom the node
F6.registerNode(
"breath-node",
{
afterDraw(cfg, group) {
const r = cfg.size / 2;
const back1 = group.addShape("circle", {
zIndex: -3,
attrs: {
x: 0,
y: 0,
r,
fill: cfg.color || (cfg.style && cfg.style.fill),
opacity: 0.6,
},
name: "back1-shape",
});
const back2 = group.addShape("circle", {
zIndex: -2,
attrs: {
x: 0,
y: 0,
r,
fill: cfg.color,
// 为了显示清晰，随意设置了颜色
opacity: 0.6,
},
name: "back2-shape",
});
const back3 = group.addShape("circle", {
zIndex: -1,
attrs: {
x: 0,
y: 0,
r,
fill: cfg.color,
opacity: 0.6,
},
name: "back3-shape",
});
group.sort(); // 排序，根据zIndex 排序
const delayBase = Math.random() * 2000;
back1.animate(
{
// 逐渐放大，并消失
r: r + 10,
opacity: 0.0,
},
{
repeat: true, // 循环
duration: 3000,
easing: "easeCubic",
delay: delayBase, // 无延迟
},
);
back2.animate(
{
// 逐渐放大，并消失
r: r + 10,
opacity: 0.0,
},
{
repeat: true, // 循环
duration: 3000,
easing: "easeCubic",
delay: delayBase + 1000, // 1 秒延迟
},
);
back3.animate(
{
// 逐渐放大，并消失
r: r + 10,
opacity: 0.0,
},
{
repeat: true, // 循环
duration: 3000,
easing: "easeCubic",
delay: delayBase + 2000, // 2 秒延迟
},
);
},
},
"circle",
);
// custom the edge
F6.registerEdge(
"running-polyline",
{
afterDraw(cfg, group) {
const shape = group.get("children")[0];
const length = shape.getTotalLength();
let circleCount = Math.ceil(length / 20);
circleCount = circleCount === 0 ? 1 : circleCount;
const _loop = function _loop(i) {
const delay = Math.random() * 1000;
const start = shape.getPoint(i / circleCount);
const circle = group.addShape("circle", {
attrs: {
x: start.x,
y: start.y,
r: 0.8,
fill: "#A0F3AF",
shadowColor: "#fff",
shadowBlur: 30,
},
name: "circle-shape",
});
circle.animate(
(ratio) => {
ratio += i / circleCount;
if (ratio > 1) {
ratio %= 1;
}
const tmpPoint = shape.getPoint(ratio);
return {
x: tmpPoint.x,
y: tmpPoint.y,
};
},
{
repeat: true,
duration: 10 * length,
easing: "easeCubic",
delay,
},
);
};
for (let i = 0; i < circleCount; i++) {
_loop(i);
}
},
},
"polyline",
);
this.setData({
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
function scaleNodesPoints(nodes_, edges_, graphSize) {
const size = graphSize[0] < graphSize[1] ? graphSize[0] : graphSize[1];
let minX = 99999999999999999;
let maxX = -99999999999999999;
let minY = 99999999999999999;
let maxY = -99999999999999999;
nodes_.forEach(function (node) {
if (node.x > maxX) maxX = node.x;
if (node.x < minX) minX = node.x;
if (node.y > maxY) maxY = node.y;
if (node.y < minY) minY = node.y;
});
edges_.forEach(function (edge) {
const { controlPoints } = edge;
controlPoints.forEach(function (cp) {
if (cp.x > maxX) maxX = cp.x;
if (cp.x < minX) minX = cp.x;
if (cp.y > maxY) maxY = cp.y;
if (cp.y < minY) minY = cp.y;
});
});
const xScale = maxX - minX;
const yScale = maxY - minY;
nodes_.forEach(function (node) {
node.orix = node.x;
node.oriy = node.y;
node.x = ((node.x - minX) / xScale) * size;
node.y = ((node.y - minY) / yScale) * size;
});
edges_.forEach(function (edge) {
const { controlPoints } = edge;
controlPoints.forEach(function (cp) {
cp.x = ((cp.x - minX) / xScale) * size;
cp.y = ((cp.y - minY) / yScale) * size;
});
});
}
// 创建F6实例
this.graph = new F6.Graph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
linkCenter: true,
fitView: true,
modes: {
default: [
{
type: "edge-tooltip",
formatText: function formatText(model) {
const text = model.class;
return text;
},
},
],
},
defaultNode: {
type: "breath-node",
size: 3,
style: {
lineWidth: 0,
fill: "rgb(240, 223, 83)",
},
},
defaultEdge: {
type: "running-polyline",
size: 1,
color: "rgb(14,142,63)",
style: {
opacity: 0.8,
lineAppendWidth: 3,
},
},
});
const graphSize = [500, 500];
scaleNodesPoints(nodes, edges, graphSize);
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/metro-lines/index.json
================================================
{
"defaultTitle": "地铁路线图",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/mind-map/data.js
================================================
const rawData = {
label: "Modeling Methods",
id: "0",
children: [
{
label: "Classification",
id: "0-1",
color: "#5AD8A6",
children: [
{
label: "Logistic regression",
id: "0-1-1",
},
{
label: "Linear discriminant analysis",
id: "0-1-2",
},
{
label: "Rules",
id: "0-1-3",
},
{
label: "Decision trees",
id: "0-1-4",
},
{
label: "Naive Bayes",
id: "0-1-5",
},
{
label: "K nearest neighbor",
id: "0-1-6",
},
{
label: "Probabilistic neural network",
id: "0-1-7",
},
{
label: "Support vector machine",
id: "0-1-8",
},
],
},
{
label: "Consensus",
id: "0-2",
color: "#F6BD16",
children: [
{
label: "Models diversity",
id: "0-2-1",
children: [
{
label: "Different initializations",
id: "0-2-1-1",
},
{
label: "Different parameter choices",
id: "0-2-1-2",
},
{
label: "Different architectures",
id: "0-2-1-3",
},
{
label: "Different modeling methods",
id: "0-2-1-4",
},
{
label: "Different training sets",
id: "0-2-1-5",
},
{
label: "Different feature sets",
id: "0-2-1-6",
},
],
},
{
label: "Methods",
id: "0-2-2",
children: [
{
label: "Classifier selection",
id: "0-2-2-1",
},
{
label: "Classifier fusion",
id: "0-2-2-2",
},
],
},
{
label: "Common",
id: "0-2-3",
children: [
{
label: "Bagging",
id: "0-2-3-1",
},
{
label: "Boosting",
id: "0-2-3-2",
},
{
label: "AdaBoost",
id: "0-2-3-3",
},
],
},
],
},
{
label: "Regression",
id: "0-3",
color: "#269A99",
children: [
{
label: "Multiple linear regression",
id: "0-3-1",
},
{
label: "Partial least squares",
id: "0-3-2",
},
{
label: "Multi-layer feedforward neural network",
id: "0-3-3",
},
{
label: "General regression neural network",
id: "0-3-4",
},
{
label: "Support vector regression",
id: "0-3-5",
},
],
},
],
};
const dataTransform = (data_) => {
const changeData = (d, level = 0, color) => {
const data = {
...d,
};
switch (level) {
case 0:
data.type = "dice-mind-map-root";
break;
case 1:
data.type = "dice-mind-map-sub";
break;
default:
data.type = "dice-mind-map-leaf";
break;
}
data.hover = false;
if (color) {
data.color = color;
}
if (level === 1 && !d.direction) {
if (!d.direction) {
data.direction =
d.id.charCodeAt(d.id.length - 1) % 2 === 0 ? "right" : "left";
}
}
if (d.children) {
data.children = d.children.map((child) =>
changeData(child, level + 1, data.color),
);
}
return data;
};
return changeData(data_);
};
const result = dataTransform(rawData);
export default result;
================================================
FILE: packages/examples-alipay/pages/scene-case/mind-map/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
.f6-canvas {
z-index: 10;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/mind-map/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/mind-map/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import result from "./data";
/**
* mindMap
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
const { Util } = F6;
// const colorArr = [
// '#5B8FF9',
// '#5AD8A6',
// '#5D7092',
// '#F6BD16',
// '#6F5EF9',
// '#6DC8EC',
// '#D3EEF9',
// '#DECFEA',
// '#FFE0C7',
// '#1E9493',
// '#BBDEDE',
// '#FF99C3',
// '#FFE0ED',
// '#CDDDFD',
// '#CDF3E4',
// '#CED4DE',
// '#FCEBB9',
// '#D3CEFD',
// '#945FB9',
// '#FF9845',
// ];
F6.registerNode(
"dice-mind-map-root",
{
jsx: (cfg) => {
const width = Util.getTextSize(cfg.label, 16)[0] + 24;
const stroke = cfg.style.stroke || "#096dd9";
return `
${
cfg.label
}+
`;
},
getAnchorPoints() {
return [
[0, 0.5],
[1, 0.5],
];
},
},
"single-node",
);
F6.registerNode(
"dice-mind-map-sub",
{
jsx: (cfg) => {
const width = Util.getTextSize(cfg.label, 14)[0] + 24;
const color = cfg.color || cfg.style.stroke;
return `
${
cfg.label
}+-
`;
},
getAnchorPoints() {
return [
[0, 0.965],
[1, 0.965],
];
},
},
"single-node",
);
F6.registerNode(
"dice-mind-map-leaf",
{
jsx: (cfg) => {
const width = Util.getTextSize(cfg.label, 12)[0] + 24;
const color = cfg.color || cfg.style.stroke;
return `
${
cfg.label
}+-
`;
},
getAnchorPoints() {
return [
[0, 0.965],
[1, 0.965],
];
},
},
"single-node",
);
F6.registerBehavior("dice-mindmap", {
getEvents() {
return {
"node:click": "clickNode",
"node:dblclick": "editNode",
"node:mouseenter": "hoverNode",
"node:mouseleave": "hoverNodeOut",
};
},
clickNode(evt) {
// const model = evt.item.get('model');
const name = evt.target.get("action");
switch (name) {
// TODO:这里没办法过语法检查
// case 'add':
// const newId = `${model.id}-${
// ((model.children || []).reduce((a, b) => {
// const num = Number(b.id.split('-').pop());
// return a < num ? num : a;
// }, 0) || 0) + 1
// }`;
// evt.currentTarget.updateItem(evt.item, {
// children: (model.children || []).concat([
// {
// id: newId,
// direction: newId.charCodeAt(newId.length - 1) % 2 === 0 ? 'right' : 'left',
// label: 'New',
// type: 'dice-mind-map-leaf',
// color: model.color || colorArr[Math.floor(Math.random() * colorArr.length)],
// },
// ]),
// });
// evt.currentTarget.layout(false);
// break;
// case 'delete':
// const parent = evt.item.get('parent');
// evt.currentTarget.updateItem(parent, {
// children: (parent.get('model').children || []).filter((e) => e.id !== model.id),
// });
// evt.currentTarget.layout(false);
// break;
case "edit":
break;
default:
}
},
editNode(evt) {
const { item } = evt;
const model = item.get("model");
const { x, y } = item.calculateBBox();
const graph = evt.currentTarget;
const realPosition = evt.currentTarget.getClientByPoint(x, y);
const el = document.createElement("div");
const fontSizeMap = {
"dice-mind-map-root": 24,
"dice-mind-map-sub": 18,
"dice-mind-map-leaf": 16,
};
el.style.fontSize = `${fontSizeMap[model.type]}px`;
el.style.position = "fixed";
el.style.top = `${realPosition.y}px`;
el.style.left = `${realPosition.x}px`;
el.style.paddingLeft = "12px";
el.style.transformOrigin = "top left";
el.style.transform = `scale(${evt.currentTarget.getZoom()})`;
const input = document.createElement("input");
input.style.border = "none";
input.value = model.label;
input.style.width = `${
Util.getTextSize(model.label, fontSizeMap[model.type])[0]
}px`;
input.className = "dice-input";
el.className = "dice-input";
el.appendChild(input);
document.body.appendChild(el);
const destroyEl = () => {
document.body.removeChild(el);
};
const clickEvt = (event) => {
if (
!(
event.target &&
event.target.className &&
event.target.className.includes("dice-input")
)
) {
window.removeEventListener("mousedown", clickEvt);
window.removeEventListener("scroll", clickEvt);
graph.updateItem(item, {
label: input.value,
});
graph.layout(false);
graph.off("wheelZoom", clickEvt);
destroyEl();
}
};
graph.on("wheelZoom", clickEvt);
window.addEventListener("mousedown", clickEvt);
window.addEventListener("scroll", clickEvt);
input.addEventListener("keyup", (event) => {
if (event.key === "Enter") {
clickEvt({
target: {},
});
}
});
},
hoverNode(evt) {
evt.currentTarget.updateItem(evt.item, {
hover: true,
});
},
hoverNodeOut(evt) {
evt.currentTarget.updateItem(evt.item, {
hover: false,
});
},
});
F6.registerBehavior("scroll-canvas", {
getEvents: function getEvents() {
return {
wheel: "onWheel",
};
},
onWheel: function onWheel(ev) {
const { graph } = this;
if (!graph) {
return;
}
if (ev.ctrlKey) {
const canvas = graph.get("canvas");
const point = canvas.getPointByClient(ev.clientX, ev.clientY);
let ratio = graph.getZoom();
if (ev.wheelDelta > 0) {
ratio += ratio * 0.05;
} else {
ratio *= ratio * 0.05;
}
graph.zoomTo(ratio, {
x: point.x,
y: point.y,
});
} else {
const x = ev.deltaX || ev.movementX;
const y = ev.deltaY || ev.movementY || (-ev.wheelDelta * 125) / 3;
graph.translate(-x, -y);
}
ev.preventDefault();
},
});
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.Graph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
fitViewPadding: [10, 20],
layout: {
type: "mindmap",
direction: "H",
getHeight: () => {
return 16;
},
getWidth: (node) => {
return node.level === 0
? F6.Util.getTextSize(node.label, 16)[0] + 12
: F6.Util.getTextSize(node.label, 12)[0];
},
getVGap: () => {
return 10;
},
getHGap: () => {
return 60;
},
getSide: (node) => {
return node.data.direction;
},
},
defaultEdge: {
type: "cubic-horizontal",
style: {
lineWidth: 2,
},
},
minZoom: 0.5,
modes: {
default: ["drag-canvas", "zoom-canvas", "dice-mindmap"],
},
});
this.graph.data(result);
this.graph.render();
// this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/mind-map/index.json
================================================
{
"defaultTitle": "思维导图",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/scene-case/sankey/data.js
================================================
const colorArr = [
"#5B8FF9",
"#5AD8A6",
"#5D7092",
"#F6BD16",
"#6F5EF9",
"#6DC8EC",
"#D3EEF9",
"#DECFEA",
"#FFE0C7",
"#1E9493",
"#BBDEDE",
"#FF99C3",
"#FFE0ED",
"#CDDDFD",
"#CDF3E4",
"#CED4DE",
"#FCEBB9",
"#D3CEFD",
"#945FB9",
"#FF9845",
];
const rawData = [
{
label: "A",
id: "A",
to: [
{
target: "C",
value: 200,
},
],
},
{
label: "B",
id: "B",
to: [
{
target: "C",
value: 400,
},
],
},
{
label: "C",
id: "C",
to: [
{
target: "D",
value: 300,
},
{
target: "E",
value: 300,
},
],
},
{
label: "D",
id: "D",
to: [
{
target: "F",
value: 100,
},
{
target: "G",
value: 200,
},
],
},
{
label: "E",
id: "E",
to: [
{
target: "F",
value: 200,
},
{
target: "G",
value: 100,
},
],
},
{
label: "F",
id: "F",
},
{
label: "G",
id: "G",
},
];
const dataTransform = (data) => {
const nodes = [];
const edges = [];
const nodeRecvMap = {};
data.forEach((node, i) => {
const { id, label, color = colorArr[i % colorArr.length], to = [] } = node;
let index = 0;
to.forEach((rel) => {
edges.push({
source: id,
target: rel.target,
value: rel.value,
color,
sourceIndex: index,
targetIndex: nodeRecvMap[rel.target] || 0,
});
index += rel.value || 0;
if (rel.value) {
nodeRecvMap[rel.target] = (nodeRecvMap[rel.target] || 0) + rel.value;
}
});
nodes.push({
id,
label,
color,
outSize: index,
});
});
nodes.forEach((node) => {
node.inSize = nodeRecvMap[node.id] || 0;
node.size = [4, Math.max(4, node.inSize, node.outSize)];
});
return {
nodes,
edges,
};
};
const result = dataTransform(rawData);
export default result;
================================================
FILE: packages/examples-alipay/pages/scene-case/sankey/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
.f6-canvas {
z-index: 10;
}
================================================
FILE: packages/examples-alipay/pages/scene-case/sankey/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/scene-case/sankey/index.js
================================================
import F6 from "@antv/f6";
import { wrapContext } from "../../../common/utils/context";
import result from "./data";
import dagreLayout from "@antv/f6/dist/extends/layout/dagreLayout";
/**
* sankey
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
F6.registerLayout("dagre", dagreLayout);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
F6.registerNode(
"dice-sankey-node",
{
jsx: (cfg) => `
${cfg.label} ${cfg.size[1]}
`,
getAnchorPoints() {
return [[0, 0]];
},
},
"single-node",
);
F6.registerEdge("dice-sankey-edge", {
draw(cfg, group) {
const { startPoint, endPoint, color } = cfg;
const deltaY1 = Number(cfg.sourceIndex);
const deltaY2 = Number(cfg.sourceIndex) + Number(cfg.value);
const deltaY3 = Number(cfg.targetIndex);
const deltaY4 = Number(cfg.targetIndex) + Number(cfg.value);
const quaterX = (Math.abs(endPoint.x - startPoint.x) / 5) * 3;
return group.addShape("path", {
attrs: {
fill: color,
opacity: 0.6,
path: [
["M", startPoint.x, startPoint.y + deltaY1],
[
"C",
endPoint.x - quaterX,
startPoint.y + deltaY1,
startPoint.x + quaterX,
endPoint.y + deltaY3,
endPoint.x,
endPoint.y + deltaY3,
],
["L", endPoint.x, endPoint.y + deltaY4],
[
"C",
startPoint.x + quaterX,
endPoint.y + deltaY4,
endPoint.x - quaterX,
startPoint.y + deltaY2,
startPoint.x,
startPoint.y + deltaY2,
],
["L", startPoint.x, startPoint.y + deltaY1],
["Z"],
],
},
});
},
});
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.Graph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
defaultNode: {
type: "dice-sankey-node",
},
defaultEdge: {
type: "dice-sankey-edge",
},
fitView: true,
fitViewPadding: 60,
layout: {
type: "dagre",
rankdir: "LR",
nodesep: 10,
ranksep: 130,
align: "ul",
},
});
this.graph.data(result);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/scene-case/sankey/index.json
================================================
{
"defaultTitle": "桑基图",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/search/search.acss
================================================
page {
background-color: #fff;
}
.page {
padding: 0;
}
.search-bar {
position: sticky;
top: 0;
background-color: #fff;
z-index: 2;
padding-top: 14rpx;
overflow: hidden;
}
.am-search-input {
height: 35px;
line-height: 35px;
}
.am-search-synthetic {
height: 35px;
line-height: 35px;
}
.am-search-value {
height: 35px;
}
.am-search-clear {
height: 35px;
width: 35px;
}
.am-search-cancel {
color: #333;
}
.search-bar .am-search-input {
background-color: rgba(0, 0, 0, 0.05);
}
.search-container {
box-sizing: border-box;
padding: 20px 12px;
}
.history {
position: relative;
padding-left: 2px;
padding-bottom: 1px;
color: #333;
font-size: 36rpx;
font-weight: bold;
}
.history .clear {
position: absolute;
right: 10px;
top: 50%;
transform: translateY(-50%);
height: 40rpx;
width: 40rpx;
background-image: url('/image/clear.png');
background-size: 50%;
background-position: center;
background-repeat: no-repeat;
}
.history-list {
margin-top: 10px;
}
.hot {
padding-left: 2px;
padding-bottom: 2px;
color: #333;
font-size: 36rpx;
font-weight: bold;
}
.hot-list {
margin-top: 10px;
}
.search-results {
padding: 16px 12 0 0;
}
.component-name {
color: #333;
margin-right: 10rpx;
}
.thumb {
height: 60rpx;
width: 60rpx;
margin-right: 30rpx;
}
.component .am-list-line-bottom::after {
left: auto;
right: 0;
width: calc(100% - 80rpx);
}
.am-list-body::before {
display: none;
}
.am-list-body::after {
display: none;
}
.list-header {
height: 100rpx;
display: flex;
align-items: center;
background-color: #fff;
color: #333;
font-weight: bold;
font-size: 34rpx;
}
.am-list-header {
padding: 8px 16px 0;
}
.no-search-result {
height: 300px;
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
}
.no-search-result image {
width: 87rpx;
height: 87rpx;
}
.no-search-result text {
margin-top: 37rpx;
color: #999;
font-size: 28rpx;
}
.am-list-text-wrapper {
width: 100%;
}
================================================
FILE: packages/examples-alipay/pages/search/search.axml
================================================
历史热门未找到搜索结果组件{{item.name}}API{{item.name}}
================================================
FILE: packages/examples-alipay/pages/search/search.js
================================================
import { debounce } from "../../common/utils/common";
import { componentList } from "../../common/utils/process";
// 搜索推荐
const apiList = [];
Page({
data: {
value: "",
history: my.getStorageSync({ key: "searchHistory" }).data || [],
hot: [
{ name: "知识图谱树", url: "../../SceneCase/knowledgeTreeGraph/index" },
{ name: "基本弧线图", url: "../../GeneralGraph/basicArcDiagram/index" },
{ name: "FA气泡图", url: "../../GeneralGraph/forceBubbles/index" },
{ name: "无到有的边", url: "../../Animation/edge_lineGrowth/index" },
{ name: "自定义流向图", url: "../../SceneCase/customFlow/index" },
{ name: "生态树", url: "../../TreeGraph/BasicDendrogram/index" },
{ name: "自定义树中的边", url: "../../TreeGraph/customEdgeTree/index" },
{
name: "基本同心圆布局",
url: "../../GeneralGraph/basicConcentric/index",
},
{ name: "布局切换", url: "../../GeneralGraph/layoutTranslate/index" },
],
componentSuggestions: [],
apiSuggestions: [],
},
onLoad() {
this.setData({
history: my.getStorageSync({ key: "searchHistory" }).data,
});
console.log(my.getStorageSync({ key: "searchHistory" }).data);
this.onInput = debounce(this.onInput.bind(this), 400);
my.setNavigationBar({
borderBottomColor: "#fff",
});
},
clear() {
my.confirm({
content: "确定删除相关历史？",
success: (res) => {
if (res.confirm) {
my.clearStorage();
this.setData({
history: [],
});
}
},
});
},
onInput(keyword) {
this.setData({
value: keyword,
});
const regExp = /[A-Za-z]/;
if (keyword === "" || (regExp.test(keyword) && keyword.length === 1)) {
this.setData({
componentSuggestions: [],
apiSuggestions: [],
});
return;
}
const componentSuggestions = [];
const apiSuggestions = [];
for (let i = 0; i < componentList.length; i++) {
if (
componentList[i].suggestion
.toLocaleLowerCase()
.indexOf(keyword.toLocaleLowerCase()) != -1
) {
componentSuggestions.push(componentList[i]);
}
}
for (let i = 0; i < apiList.length; i++) {
if (
apiList[i].suggestion
.toLocaleLowerCase()
.indexOf(keyword.toLocaleLowerCase()) != -1
) {
apiSuggestions.push(apiList[i]);
}
}
this.setData({ componentSuggestions, apiSuggestions });
},
onClear() {
this.setData({
value: "",
});
},
onCancel() {
this.setData({
componentSuggestions: [],
apiSuggestions: [],
value: "",
});
my.navigateBack();
},
onItemTap({ name }) {
this.setData({
value: name,
});
this.onInput(name);
},
onListItemTap(e) {
const { name, url } = e.target.dataset;
this.addToHistory(name);
console.log(url);
my.navigateTo({ url });
},
addToHistory(keyword) {
const searchHistory =
my.getStorageSync({ key: "searchHistory" }).data || [];
let index = -1;
for (let i = 0; i < searchHistory.length; i++) {
if (searchHistory[i].name === keyword) {
index = i;
break;
}
}
let history = [];
if (searchHistory.length >= 8) {
if (index === -1) {
history = [{ name: keyword }, ...searchHistory.slice(0, 7)];
} else {
searchHistory.splice(index, 1).slice(0, 7);
history = [{ name: keyword }, ...searchHistory];
}
} else if (index === -1) {
history = [{ name: keyword }, ...searchHistory];
} else {
searchHistory.splice(index, 1);
history = [{ name: keyword }, ...searchHistory];
}
my.setStorageSync({
key: "searchHistory",
data: history,
});
this.setData({
history,
});
},
});
================================================
FILE: packages/examples-alipay/pages/search/search.json
================================================
{
"defaultTitle": "搜索",
"transparentTitle": "none",
"allowsBounceVertical": "NO",
"usingComponents": {
"search-bar": "mini-ali-ui/es/search-bar/index",
"block-list": "../../common/components/block-list/block-list",
"list": "mini-ali-ui/es/list/index",
"list-item": "mini-ali-ui/es/list/list-item/index"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/basic-dendrogram/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{ id: "Logistic regression" },
{ id: "Linear discriminant analysis" },
{ id: "Rules" },
{ id: "Decision trees" },
{ id: "Naive Bayes" },
{ id: "K nearest neighbor" },
{ id: "Probabilistic neural network" },
{ id: "Support vector machine" },
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{ id: "Different initializations" },
{ id: "Different parameter choices" },
{ id: "Different architectures" },
{ id: "Different modeling methods" },
{ id: "Different training sets" },
{ id: "Different feature sets" },
],
},
{
id: "Methods",
children: [
{ id: "Classifier selection" },
{ id: "Classifier fusion" },
],
},
{
id: "Common",
children: [{ id: "Bagging" }, { id: "Boosting" }, { id: "AdaBoost" }],
},
],
},
{
id: "Regression",
children: [
{ id: "Multiple linear regression" },
{ id: "Partial least squares" },
{ id: "Multi-layer feedforward neural network" },
{ id: "General regression neural network" },
{ id: "Support vector regression" },
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/basic-dendrogram/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/basic-dendrogram/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/basic-dendrogram/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 生态树
*/
Page({
canvas: null,
ctx: null, // 延迟获取的2d context
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const model = item.getModel();
model.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "dendrogram",
direction: "LR",
nodeSep: 30,
rankSep: 100,
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 10;
},
getHGap: function getHGap() {
return 100;
},
},
});
this.graph.node(function (node) {
return {
label: node.id,
labelCfg: {
offset: 5,
position:
node.children && node.children.length > 0 ? "left" : "right",
},
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/basic-dendrogram/index.json
================================================
{
"defaultTitle": "生态树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{ id: "Logistic regression" },
{ id: "Linear discriminant analysis" },
{ id: "Rules" },
{ id: "Decision trees" },
{ id: "Naive Bayes" },
{ id: "K nearest neighbor" },
{ id: "Probabilistic neural network" },
{ id: "Support vector machine" },
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{ id: "Different initializations" },
{ id: "Different parameter choices" },
{ id: "Different architectures" },
{ id: "Different modeling methods" },
{ id: "Different training sets" },
{ id: "Different feature sets" },
],
},
{
id: "Methods",
children: [
{ id: "Classifier selection" },
{ id: "Classifier fusion" },
],
},
{
id: "Common",
children: [{ id: "Bagging" }, { id: "Boosting" }, { id: "AdaBoost" }],
},
],
},
{
id: "Regression",
children: [
{ id: "Multiple linear regression" },
{ id: "Partial least squares" },
{ id: "Multi-layer feedforward neural network" },
{ id: "General regression neural network" },
{ id: "Support vector regression" },
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data.js";
/**
* 紧凑树
*/
Page({
canvas: null,
ctx: null, // 延迟获取的2d context
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化canvas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const model = item.getModel();
model.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "compactBox",
direction: "LR",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 10;
},
getHGap: function getHGap() {
return 100;
},
},
});
this.graph.node(function (node) {
return {
label: node.id,
labelCfg: {
offset: 10,
position:
node.children && node.children.length > 0 ? "left" : "right",
},
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box/index.json
================================================
{
"defaultTitle": "紧凑树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box-left-align/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box-left-align/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box-left-align/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box-left-align/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data.js";
/**
* 节点左右对齐的紧凑树
*/
Page({
canvas: null,
ctx: null, // 延迟获取的2d context
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化canvas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const fontSize = 15;
F6.registerNode("crect", {
draw: (cfg, group) => {
const width = cfg.id.length * 10;
const rect = group.addShape("rect", {
attrs: {
x: 0,
y: -10,
...cfg.style,
width,
height: 20,
lineWidth: 0,
opacity: 0,
},
name: "rect-shape",
draggable: true,
});
const label = group.addShape("text", {
attrs: {
text: cfg.id,
fill: "#ccc",
fontSize,
x: 0,
y: 0,
},
name: "label-shape",
draggable: true,
});
const bboxWidth = label.getBBox().width + 20;
rect.attr({ width: bboxWidth });
group.addShape("path", {
attrs: {
lineWidth: 1,
fill: "#ccc",
stroke: "#ccc",
path: [
["M", 0, 0],
["L", bboxWidth, 0],
],
},
name: "path-shape",
draggable: true,
});
return rect;
},
getAnchorPoints: () => {
return [
[0, 0.5],
[1, 0.5],
];
},
});
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: ["collapse-expand", "drag-canvas", "zoom-canvas"],
},
defaultNode: {
type: "crect",
},
defaultEdge: {
type: "cubic-horizontal",
style: {
stroke: "#A3B1BF",
},
},
layout: {
type: "compactBox",
direction: "LR",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getVGap: function getVGap() {
return 10;
},
getHGap: function getHGap() {
return 100;
},
getWidth: function getWidth(d) {
return F6.Util.getTextSize(d.id, fontSize)[0] + 20;
},
},
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/compact-box-left-align/index.json
================================================
{
"defaultTitle": "节点左右对齐的紧凑树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-edge-tree/data.js
================================================
export default {
id: "root",
label: "root",
children: [
{
id: "c1",
label: "c1",
children: [
{
id: "c1-1",
label: "c1-1",
},
{
id: "c1-2",
label: "c1-2",
children: [
{
id: "c1-2-1",
label: "c1-2-1",
},
{
id: "c1-2-2",
label: "c1-2-2",
},
],
},
],
},
{
id: "c2",
label: "c2",
},
{
id: "c3",
label: "c3",
children: [
{
id: "c3-1",
label: "c3-1",
},
{
id: "c3-2",
label: "c3-2",
children: [
{
id: "c3-2-1",
label: "c3-2-1",
},
{
id: "c3-2-2",
label: "c3-2-2",
},
{
id: "c3-2-3",
label: "c3-2-3",
},
],
},
{
id: "c3-3",
label: "c3-3",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-edge-tree/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-edge-tree/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-edge-tree/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 自定义图中的边
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
const COLLAPSE_ICON = function COLLAPSE_ICON(x, y, r) {
return [
["M", x - r, y - r],
["a", r, r, 0, 1, 0, r * 2, 0],
["a", r, r, 0, 1, 0, -r * 2, 0],
["M", x + 2 - r, y - r],
["L", x + r - 2, y - r],
];
};
const EXPAND_ICON = function EXPAND_ICON(x, y, r) {
return [
["M", x - r, y - r],
["a", r, r, 0, 1, 0, r * 2, 0],
["a", r, r, 0, 1, 0, -r * 2, 0],
["M", x + 2 - r, y - r],
["L", x + r - 2, y - r],
["M", x, y - 2 * r + 2],
["L", x, y - 2],
];
};
F6.Util.traverseTree(data, (d) => {
d.leftIcon = {
style: {
fill: "#e6fffb",
stroke: "#e6fffb",
},
img: "https://gw.alipayobjects.com/mdn/rms_f8c6a0/afts/img/A*Q_FQT6nwEC8AAAAAAAAAAABkARQnAQ",
};
return true;
});
F6.registerNode(
"icon-node",
{
options: {
size: [60, 20],
stroke: "#91d5ff",
fill: "#91d5ff",
},
draw(cfg, group) {
const styles = this.getShapeStyle(cfg);
const { labelCfg = {} } = cfg;
const w = styles.width;
const h = styles.height;
const keyShape = group.addShape("rect", {
attrs: {
...styles,
x: -w / 2,
y: -h / 2,
},
});
/**
* leftIcon 格式如下：
* {
* style: ShapeStyle;
* img: ''
* }
*/
console.log("cfg.leftIcon", cfg.leftIcon);
if (cfg.leftIcon) {
const { style, img } = cfg.leftIcon;
group.addShape("rect", {
attrs: {
x: 1 - w / 2,
y: 1 - h / 2,
width: 38,
height: styles.height - 2,
fill: "#8c8c8c",
...style,
},
});
group.addShape("image", {
attrs: {
x: 8 - w / 2,
y: 8 - h / 2,
width: 24,
height: 24,
img:
img ||
"https://g.alicdn.com/cm-design/arms-trace/1.0.155/styles/armsTrace/images/TAIR.png",
},
name: "image-shape",
});
}
// 如果不需要动态增加或删除元素，则不需要 add 这两个 marker
group.addShape("marker", {
attrs: {
x: 40 - w / 2,
y: 52 - h / 2,
r: 6,
stroke: "#73d13d",
cursor: "pointer",
symbol: EXPAND_ICON,
},
name: "add-item",
});
group.addShape("marker", {
attrs: {
x: 80 - w / 2,
y: 52 - h / 2,
r: 6,
stroke: "#ff4d4f",
cursor: "pointer",
symbol: COLLAPSE_ICON,
},
name: "remove-item",
});
if (cfg.label) {
group.addShape("text", {
attrs: {
...labelCfg.style,
text: cfg.label,
x: 50 - w / 2,
y: 25 - h / 2,
},
});
}
return keyShape;
},
update: undefined,
},
"rect",
);
F6.registerEdge("flow-line", {
draw(cfg, group) {
const { startPoint } = cfg;
const { endPoint } = cfg;
const { style } = cfg;
const shape = group.addShape("path", {
attrs: {
stroke: style.stroke,
endArrow: style.endArrow,
path: [
["M", startPoint.x, startPoint.y],
["L", startPoint.x, (startPoint.y + endPoint.y) / 2],
["L", endPoint.x, (startPoint.y + endPoint.y) / 2],
["L", endPoint.x, endPoint.y],
],
},
});
return shape;
},
});
const defaultStateStyles = {
hover: {
stroke: "#1890ff",
lineWidth: 2,
},
};
const defaultNodeStyle = {
fill: "#91d5ff",
stroke: "#40a9ff",
radius: 5,
};
const defaultEdgeStyle = {
stroke: "#91d5ff",
endArrow: {
path: "M 0,0 L 12, 6 L 9,0 L 12, -6 Z",
fill: "#91d5ff",
d: -20,
},
};
const defaultLayout = {
type: "compactBox",
direction: "TB",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 40;
},
getHGap: function getHGap() {
return 70;
},
};
const defaultLabelCfg = {
style: {
fill: "#000",
fontSize: 12,
},
};
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
// plugins: [minimap],
modes: {
default: ["drag-canvas", "zoom-canvas"],
},
defaultNode: {
type: "icon-node",
size: [120, 40],
style: defaultNodeStyle,
labelCfg: defaultLabelCfg,
},
defaultEdge: {
type: "flow-line",
style: defaultEdgeStyle,
},
nodeStateStyles: defaultStateStyles,
edgeStateStyles: defaultStateStyles,
layout: defaultLayout,
});
// 监听
this.graph.on("node:tap", (evt) => {
const { item, target } = evt;
const targetType = target.get("type");
const name = target.get("name");
// 增加元素
if (targetType === "marker") {
const model = item.getModel();
if (name === "add-item") {
if (!model.children) {
model.children = [];
}
const id = `n-${Math.random()}`;
model.children.push({
id,
label: id.substr(0, 8),
leftIcon: {
style: {
fill: "#e6fffb",
stroke: "#e6fffb",
},
img: "https://gw.alipayobjects.com/mdn/rms_f8c6a0/afts/img/A*Q_FQT6nwEC8AAAAAAAAAAABkARQnAQ",
},
});
this.graph.updateChild(model, model.id);
} else if (name === "remove-item") {
this.graph.removeChild(model.id);
}
}
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-edge-tree/index.json
================================================
{
"defaultTitle": "自定义树中的边",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-side-mind-map/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-side-mind-map/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-side-mind-map/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-side-mind-map/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 脑图-自定义子节点分布
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "mindmap",
direction: "H",
getHeight: () => {
return 16;
},
getWidth: () => {
return 16;
},
getVGap: () => {
return 10;
},
getHGap: () => {
return 50;
},
getSide: (d) => {
if (d.id === "Classification") {
return "left";
}
return "right";
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
let pos = "";
if (node.children && node.children.length > 0) {
pos = "right";
} else if (node.x > centerX) pos = "right";
else pos = "left";
return {
label: node.id,
labelCfg: {
position: pos,
offset: 5,
},
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-side-mind-map/index.json
================================================
{
"defaultTitle": "自定义子节点分布",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-tree/data.js
================================================
export default {
name: "Modeling Methods",
children: [
{
name: "Classification",
children: [
{
name: "Logistic regression",
},
{
name: "Linear discriminant analysis",
},
{
name: "Rules",
},
{
name: "Decision trees",
},
{
name: "Naive Bayes",
},
{
name: "K nearest neighbor",
},
{
name: "Probabilistic neural network",
},
{
name: "Support vector machine",
},
],
},
{
name: "Consensus",
children: [
{
name: "Models diversity",
children: [
{
name: "Different initializations",
},
{
name: "Different parameter choices",
},
{
name: "Different architectures",
},
{
name: "Different modeling methods",
},
{
name: "Different training sets",
},
{
name: "Different feature sets",
},
],
},
{
name: "Methods",
children: [
{
name: "Classifier selection",
},
{
name: "Classifier fusion",
},
],
},
{
name: "Common",
children: [
{
name: "Bagging",
},
{
name: "Boosting",
},
{
name: "AdaBoost",
},
],
},
],
},
{
name: "Regression",
children: [
{
name: "Multiple linear regression",
},
{
name: "Partial least squares",
},
{
name: "Multi-layer feedforward neural network",
},
{
name: "General regression neural network",
},
{
name: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-tree/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-tree/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-tree/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 自定义复杂树图样式
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
F6.registerNode(
"tree-node",
{
drawShape: function drawShape(cfg, group) {
const rect = group.addShape("rect", {
attrs: {
fill: "#fff",
stroke: "#666",
x: 0,
y: 0,
width: 1,
height: 1,
},
name: "rect-shape",
});
const content = cfg.name.replace(/(.{19})/g, "$1\n");
const text = group.addShape("text", {
attrs: {
text: content,
x: 0,
y: 0,
textAlign: "left",
textBaseline: "middle",
fill: "#666",
},
name: "text-shape",
});
const bbox = text.getBBox();
const hasChildren = cfg.children && cfg.children.length > 0;
rect.attr({
x: -bbox.width / 2 - 4,
y: -bbox.height / 2 - 6,
width: bbox.width + (hasChildren ? 26 : 12),
height: bbox.height + 12,
});
text.attr({
x: -bbox.width / 2,
y: 0,
});
if (hasChildren) {
group.addShape("marker", {
attrs: {
x: bbox.width / 2 + 12,
y: 0,
r: 6,
symbol: cfg.collapsed ? F6.Marker.expand : F6.Marker.collapse,
stroke: "#666",
lineWidth: 2,
},
name: "collapse-icon",
});
}
return rect;
},
update: (cfg, item) => {
const group = item.getContainer();
const icon = group.find((e) => e.get("name") === "collapse-icon");
icon.attr(
"symbol",
cfg.collapsed ? F6.Marker.expand : F6.Marker.collapse,
);
},
},
"single-node",
);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
this.graph.updateItem(item, {
collapsed,
});
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
type: "tree-node",
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
style: {
stroke: "#A3B1BF",
},
},
layout: {
type: "compactBox",
direction: "LR",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 20;
},
getHGap: function getHGap() {
return 80;
},
},
});
F6.Util.traverseTree(data_, function (item) {
item.id = item.name;
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/custom-tree/index.json
================================================
{
"defaultTitle": "复杂树样式",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/file-system/data.js
================================================
export default {
id: "1",
name: "src",
children: [
{
id: "1-1",
name: "behavior",
children: [],
},
{
id: "1-3",
name: "graph",
children: [
{
id: "1-3-1",
name: "controller",
children: [],
},
],
},
{
id: "1-5",
name: "item",
children: [],
},
{
id: "1-6",
name: "shape",
children: [
{
id: "1-6-2",
name: "extend",
children: [],
},
],
},
{
id: "1-7",
name: "util",
children: [],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/file-system/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/file-system/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/file-system/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 缩进树-文件系统
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// registerNode
F6.registerNode("file-node", {
draw: function draw(cfg, group) {
const keyShape = group.addShape("rect", {
attrs: {
x: 10,
y: -12,
fill: "#fff",
stroke: null,
},
});
let isLeaf = false;
if (cfg.collapsed) {
group.addShape("marker", {
attrs: {
symbol: "triangle",
x: 4,
y: -2,
r: 4,
fill: "#666",
},
name: "marker-shape",
});
} else if (cfg.children && cfg.children.length > 0) {
group.addShape("marker", {
attrs: {
symbol: "triangle-down",
x: 4,
y: -2,
r: 4,
fill: "#666",
},
name: "marker-shape",
});
} else {
isLeaf = true;
}
const shape = group.addShape("text", {
attrs: {
x: 15,
y: 4,
text: cfg.name,
fill: "#666",
fontSize: 16,
textAlign: "left",
fontFamily:
typeof window !== "undefined"
? window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family") || "Arial, sans-serif"
: "Arial, sans-serif",
},
name: "text-shape",
});
const bbox = shape.getBBox();
let backRectW = bbox.width;
let backRectX = keyShape.attr("x");
if (!isLeaf) {
backRectW += 8;
backRectX -= 15;
}
keyShape.attr({
width: backRectW,
height: bbox.height + 4,
x: backRectX,
});
return keyShape;
},
});
// registerEdge
F6.registerEdge(
"step-line",
{
getControlPoints: function getControlPoints(cfg) {
const { startPoint } = cfg;
const { endPoint } = cfg;
return [
startPoint,
{
x: startPoint.x,
y: endPoint.y,
},
endPoint,
];
},
},
"polyline",
);
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
animate: false,
onChange: function onChange(item, collapsed) {
const model = item.getModel();
model.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultEdge: {
style: {
stroke: "#A3B1BF",
},
},
layout: {
type: "indented",
isHorizontal: true,
direction: "LR",
indent: 30,
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
// position的取值（由于ESlint禁止嵌套的三元表达，所以单独提取出来写）
let position_value = null;
if (node.children && node.children.length > 0) {
position_value = "left";
} else if (node.x > centerX) position_value = "right";
else position_value = "left";
return {
label: node.id,
labelCfg: {
offset: 5,
position: position_value,
},
};
});
this.graph.node((node) => {
return {
type: "file-node",
label: node.name,
};
});
this.graph.edge(() => {
return {
type: "step-line",
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/file-system/index.json
================================================
{
"defaultTitle": "文件系统",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/intend-align-top/data.js
================================================
export default {
id: "A",
children: [
{
id: "A1",
children: [{ id: "A11" }, { id: "A12" }, { id: "A13" }, { id: "A14" }],
},
{
id: "A2",
children: [
{
id: "A21",
children: [{ id: "A211" }, { id: "A212" }],
},
{
id: "A22",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/intend-align-top/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/intend-align-top/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/intend-align-top/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 缩进树-顶部对齐
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
F6.registerNode("card-node", {
draw: function drawShape(cfg, group) {
const r = 2;
const color = "#5B8FF9";
const w = cfg.size[0];
const h = cfg.size[1];
const shape = group.addShape("rect", {
attrs: {
x: -w / 2,
y: -h / 2,
width: w, // 200,
height: h, // 60
stroke: color,
radius: r,
fill: "#fff",
},
name: "main-box",
draggable: true,
});
group.addShape("rect", {
attrs: {
x: -w / 2,
y: -h / 2,
width: w, // 200,
height: h / 2, // 60
fill: color,
radius: [r, r, 0, 0],
},
name: "title-box",
draggable: true,
});
// title text
group.addShape("text", {
attrs: {
textBaseline: "top",
x: -w / 2 + 8,
y: -h / 2 + 2,
lineHeight: 20,
text: cfg.id,
fill: "#fff",
},
name: "title",
});
cfg.children &&
group.addShape("marker", {
attrs: {
x: w / 2,
y: 0,
r: 6,
cursor: "pointer",
symbol: F6.Marker.collapse,
stroke: "#666",
lineWidth: 1,
fill: "#fff",
},
name: "collapse-icon",
});
group.addShape("text", {
attrs: {
textBaseline: "top",
x: -w / 2 + 8,
y: -h / 2 + 24,
lineHeight: 20,
text: "description",
fill: "rgba(0,0,0, 1)",
},
name: `description`,
});
return shape;
},
setState(name, value, item) {
if (name === "collapsed") {
const marker = item
.get("group")
.find((ele) => ele.get("name") === "collapse-icon");
const icon = value ? F6.Marker.expand : F6.Marker.collapse;
marker.attr("symbol", icon);
}
},
});
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: ["drag-canvas"],
},
defaultNode: {
type: "card-node",
size: [100, 40],
},
defaultEdge: {
type: "cubic-horizontal",
style: {
endArrow: true,
},
},
layout: {
type: "indented",
direction: "LR",
dropCap: false,
indent: 200,
getHeight: () => {
return 60;
},
},
});
this.graph.on("node:tap", (e) => {
if (e.target.get("name") === "collapse-icon") {
e.item.getModel().collapsed = !e.item.getModel().collapsed;
this.graph.setItemState(
e.item,
"collapsed",
e.item.getModel().collapsed,
);
this.graph.layout();
}
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/intend-align-top/index.json
================================================
{
"defaultTitle": "顶部对齐",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/intended/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/intended/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/intended/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/intended/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 缩进树-子节点两侧分布
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: ["drag-canvas"],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "indented",
direction: "H",
indent: 80,
getHeight: () => {
return 10;
},
getWidth: () => {
return 10;
},
getSide: (d) => {
if (d.id === "Regression" || d.id === "Classification") return "left";
return "right";
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
let pos = "";
if (node.children && node.children.length > 0) {
pos = "left";
} else if (node.x > centerX) pos = "right";
else pos = "left";
return {
label: node.id,
labelCfg: {
position: pos,
offset: 5,
},
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/intended/index.json
================================================
{
"defaultTitle": "子节点两侧分布",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/left-mind-map/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/left-mind-map/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/left-mind-map/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/left-mind-map/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 脑图-子节点右侧分布
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "mindmap",
direction: "H",
getHeight: () => {
return 16;
},
getWidth: () => {
return 16;
},
getVGap: () => {
return 10;
},
getHGap: () => {
return 100;
},
getSide: () => {
return "left";
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
let pos = "";
if (node.children && node.children.length > 0) {
pos = "right";
} else if (node.x > centerX) pos = "right";
else pos = "left";
return {
label: node.id,
labelCfg: {
position: pos,
offset: 5,
},
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/left-mind-map/index.json
================================================
{
"defaultTitle": "子节点左侧分布",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/mind-map/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/mind-map/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/mind-map/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/mind-map/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 脑图-自节点自动两侧分布
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const model = item.getModel();
model.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "mindmap",
direction: "H",
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 10;
},
getHGap: function getHGap() {
return 50;
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
// position的取值（由于ESlint禁止嵌套的三元表达，所以单独提取出来写）
let position_value = null;
if (node.children && node.children.length > 0) {
position_value = "left";
} else if (node.x > centerX) position_value = "right";
else position_value = "left";
return {
label: node.id,
labelCfg: {
offset: 5,
position: position_value,
},
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/mind-map/index.json
================================================
{
"defaultTitle": "子节点自动两侧分布",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-compact-box/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-compact-box/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-compact-box/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-compact-box/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 紧凑辐射树
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
},
layout: {
type: "compactBox",
direction: "RL",
getId: function getId(d) {
return d.id;
},
getHeight: () => {
return 26;
},
getWidth: () => {
return 26;
},
getVGap: () => {
return 20;
},
getHGap: () => {
return 30;
},
radial: true,
},
});
this.graph.node(function (node) {
return {
label: node.id,
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-compact-box/index.json
================================================
{
"defaultTitle": "紧凑辐射树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-dendrogram/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-dendrogram/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-dendrogram/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-dendrogram/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data from "./data";
/**
* 生态辐射树
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const model = item.getModel();
model.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
},
layout: {
type: "dendrogram",
direction: "LR",
nodeSep: 20,
rankSep: 100,
radial: true,
},
});
this.graph.node(function (node) {
return {
label: node.id,
};
});
this.graph.data(data);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/radial-dendrogram/index.json
================================================
{
"defaultTitle": "生态辐射树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/right-mind-map/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/right-mind-map/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/right-mind-map/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/right-mind-map/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 脑图-子节点右侧分布
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-horizontal",
},
layout: {
type: "mindmap",
direction: "H",
getHeight: () => {
return 16;
},
getWidth: () => {
return 16;
},
getVGap: () => {
return 10;
},
getHGap: () => {
return 100;
},
getSide: () => {
return "right";
},
},
});
let centerX = 0;
this.graph.node(function (node) {
if (node.id === "Modeling Methods") {
centerX = node.x;
}
let pos = "";
if (node.children && node.children.length > 0) {
pos = "right";
} else if (node.x > centerX) pos = "right";
else pos = "left";
return {
label: node.id,
labelCfg: {
position: pos,
offset: 5,
},
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/right-mind-map/index.json
================================================
{
"defaultTitle": "子节点右侧分布",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-compact-box/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-compact-box/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-compact-box/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-compact-box/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data.js";
/**
* 至上而下的紧凑树
*/
Page({
canvas: null,
ctx: null, // 延迟获取的2d context
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化canvas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
linkCenter: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.getModel();
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-vertical",
},
layout: {
type: "compactBox",
direction: "TB",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 80;
},
getHGap: function getHGap() {
return 20;
},
},
});
this.graph.node(function (node) {
let position = "right";
let rotate = 0;
if (!node.children) {
position = "bottom";
rotate = Math.PI / 2;
}
return {
label: node.id,
labelCfg: {
position,
offset: 5,
style: {
rotate,
textAlign: "start",
},
},
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-compact-box/index.json
================================================
{
"defaultTitle": "至上而下的紧凑树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-dendrogram/data.js
================================================
export default {
id: "Modeling Methods",
children: [
{
id: "Classification",
children: [
{
id: "Logistic regression",
},
{
id: "Linear discriminant analysis",
},
{
id: "Rules",
},
{
id: "Decision trees",
},
{
id: "Naive Bayes",
},
{
id: "K nearest neighbor",
},
{
id: "Probabilistic neural network",
},
{
id: "Support vector machine",
},
],
},
{
id: "Consensus",
children: [
{
id: "Models diversity",
children: [
{
id: "Different initializations",
},
{
id: "Different parameter choices",
},
{
id: "Different architectures",
},
{
id: "Different modeling methods",
},
{
id: "Different training sets",
},
{
id: "Different feature sets",
},
],
},
{
id: "Methods",
children: [
{
id: "Classifier selection",
},
{
id: "Classifier fusion",
},
],
},
{
id: "Common",
children: [
{
id: "Bagging",
},
{
id: "Boosting",
},
{
id: "AdaBoost",
},
],
},
],
},
{
id: "Regression",
children: [
{
id: "Multiple linear regression",
},
{
id: "Partial least squares",
},
{
id: "Multi-layer feedforward neural network",
},
{
id: "General regression neural network",
},
{
id: "Support vector regression",
},
],
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-dendrogram/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-dendrogram/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-dendrogram/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 至上而下的生态树
*/
Page({
canvas: null,
ctx: null, // 延迟获取的2d context
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
pixelRatio,
fitView: true,
linkCenter: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 26,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
defaultEdge: {
type: "cubic-vertical",
},
layout: {
type: "dendrogram",
direction: "TB", // H / V / LR / RL / TB / BT
nodeSep: 40,
rankSep: 100,
},
});
this.graph.node(function (node) {
let position = "right";
let rotate = 0;
if (!node.children) {
position = "bottom";
rotate = Math.PI / 2;
}
return {
label: node.id,
labelCfg: {
position,
offset: 5,
style: {
rotate,
textAlign: "start",
},
},
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/tb-dendrogram/index.json
================================================
{
"defaultTitle": "至上而下的生态树",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tree-edge-label/data.js
================================================
export default {
isRoot: true,
id: "Root",
style: {
fill: "red",
},
children: [
{
id: "SubTreeNode1",
raw: {},
children: [
{
id: "SubTreeNode1.1",
},
{
id: "SubTreeNode1.2",
children: [
{
id: "SubTreeNode1.2.1",
},
{
id: "SubTreeNode1.2.2",
},
{
id: "SubTreeNode1.2.3",
},
],
},
],
},
{
id: "SubTreeNode2",
children: [
{
id: "SubTreeNode2.1",
},
],
},
{
id: "SubTreeNode3",
children: [
{
id: "SubTreeNode3.1",
},
{
id: "SubTreeNode3.2",
},
{
id: "SubTreeNode3.3",
},
],
},
{
id: "SubTreeNode4",
},
{
id: "SubTreeNode5",
},
{
id: "SubTreeNode6",
},
{
id: "SubTreeNode7",
},
{
id: "SubTreeNode8",
},
{
id: "SubTreeNode9",
},
{
id: "SubTreeNode10",
},
{
id: "SubTreeNode11",
},
],
};
================================================
FILE: packages/examples-alipay/pages/tree-graph/tree-edge-label/index.acss
================================================
page {
background-color: #f7f7f7;
border: 1px solid rgba(0,0,0,0);
box-sizing: border-box;
}
.page-section-demo {
padding: 32rpx;
}
================================================
FILE: packages/examples-alipay/pages/tree-graph/tree-edge-label/index.axml
================================================
================================================
FILE: packages/examples-alipay/pages/tree-graph/tree-edge-label/index.js
================================================
import F6 from "@antv/f6";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
import { wrapContext } from "../../../common/utils/context";
import data_ from "./data";
/**
* 树图边上的标签
*/
Page({
canvas: null,
ctx: null,
renderer: "", // mini、mini-native等，F6需要，标记环境
isCanvasInit: false, // canvas是否准备好了
graph: null,
data: {
width: 375,
height: 600,
pixelRatio: 2,
forceMini: false,
},
onLoad() {
// 注册自定义树，节点等
F6.registerGraph("TreeGraph", TreeGraph);
// 同步获取window的宽高
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio,
});
},
/**
* 初始化cnavas回调，缓存获得的context
* @param {*} ctx 绘图context
* @param {*} rect 宽高信息
* @param {*} canvas canvas对象，在render为mini时为null
* @param {*} renderer 使用canvas 1.0还是canvas 2.0，mini | mini-native
*/
handleInit(ctx, rect, canvas, renderer) {
this.isCanvasInit = true;
this.ctx = wrapContext(ctx);
this.renderer = renderer;
this.canvas = canvas;
this.updateChart();
},
/**
* canvas派发的事件，转派给graph实例
*/
handleTouch(e) {
this.graph && this.graph.emitEvent(e);
},
updateChart() {
const { width, height, pixelRatio } = this.data;
// 创建F6实例
this.graph = new F6.TreeGraph({
container: this.canvas,
context: this.ctx,
renderer: this.renderer,
width,
height,
linkCenter: true,
pixelRatio,
fitView: true,
modes: {
default: [
{
type: "collapse-expand",
onChange: function onChange(item, collapsed) {
const data = item.get("model");
data.collapsed = collapsed;
return true;
},
},
"drag-canvas",
"zoom-canvas",
],
},
defaultNode: {
size: 30,
},
layout: {
type: "compactBox",
direction: "LR",
getId: function getId(d) {
return d.id;
},
getHeight: function getHeight() {
return 16;
},
getWidth: function getWidth() {
return 16;
},
getVGap: function getVGap() {
return 10;
},
getHGap: function getHGap() {
return 100;
},
},
});
// 点
this.graph.node(function (node) {
return {
size: 16,
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
style: {
fill: "#C6E5FF",
stroke: "#5B8FF9",
},
label: node.id,
labelCfg: {
position:
node.children && node.children.length > 0 ? "left" : "right",
offset: 5,
},
};
});
// 边
let i = 0;
this.graph.edge(function () {
i++;
return {
type: "cubic-horizontal",
color: "#A3B1BF",
label: i,
};
});
this.graph.data(data_);
this.graph.render();
this.graph.fitView();
},
onUnload() {
this.graph && this.graph.destroy();
},
});
================================================
FILE: packages/examples-alipay/pages/tree-graph/tree-edge-label/index.json
================================================
{
"defaultTitle": "树边上的标签",
"usingComponents": {
"f6-canvas": "@antv/f6-alipay/es/container/container"
}
}
================================================
FILE: packages/examples-uniapp/.hbuilderx/launch.json
================================================
{
// launch.json 配置了启动调试时相关设置，configurations下节点名称可为 app-plus/h5/mp-weixin/mp-baidu/mp-alipay/mp-qq/mp-toutiao/mp-360/
// launchtype项可配置值为local或remote, local代表前端连本地云函数，remote代表前端连云端云函数
"version": "0.0",
"configurations": [
{
"default": {
"launchtype": "local"
},
"h5": {
"launchtype": "local"
},
"mp-weixin": {
"launchtype": "local"
},
"type": "uniCloud"
}
]
}
================================================
FILE: packages/examples-uniapp/App.vue
================================================
================================================
FILE: packages/examples-uniapp/components/canvas/canvas.vue
================================================
================================================
FILE: packages/examples-uniapp/f6/extends/graph/treeGraph.js
================================================
!(function (t, n) {
"object" == typeof exports && "object" == typeof module
? (module.exports = n())
: "function" == typeof define && define.amd
? define([], n)
: "object" == typeof exports
? (exports.TreeGraph = n())
: (t.TreeGraph = n());
})(this, function () {
return (function (t) {
var n = {};
function r(e) {
if (n[e]) return n[e].exports;
var i = (n[e] = { i: e, l: !1, exports: {} });
return t[e].call(i.exports, i, i.exports, r), (i.l = !0), i.exports;
}
return (
(r.m = t),
(r.c = n),
(r.d = function (t, n, e) {
r.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: e });
}),
(r.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(r.t = function (t, n) {
if ((1 & n && (t = r(t)), 8 & n)) return t;
if (4 & n && "object" == typeof t && t && t.__esModule) return t;
var e = Object.create(null);
if (
(r.r(e),
Object.defineProperty(e, "default", { enumerable: !0, value: t }),
2 & n && "string" != typeof t)
)
for (var i in t)
r.d(
e,
i,
function (n) {
return t[n];
}.bind(null, i),
);
return e;
}),
(r.n = function (t) {
var n =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return r.d(n, "a", n), n;
}),
(r.o = function (t, n) {
return Object.prototype.hasOwnProperty.call(t, n);
}),
(r.p = ""),
r((r.s = 196))
);
})({
0: function (t, n, r) {
"use strict";
r.r(n),
r.d(n, "contains", function () {
return i;
}),
r.d(n, "includes", function () {
return i;
}),
r.d(n, "difference", function () {
return o;
}),
r.d(n, "find", function () {
return O;
}),
r.d(n, "findIndex", function () {
return j;
}),
r.d(n, "firstValue", function () {
return x;
}),
r.d(n, "flatten", function () {
return w;
}),
r.d(n, "flattenDeep", function () {
return A;
}),
r.d(n, "getRange", function () {
return E;
}),
r.d(n, "pull", function () {
return T;
}),
r.d(n, "pullAt", function () {
return N;
}),
r.d(n, "reduce", function () {
return k;
}),
r.d(n, "remove", function () {
return I;
}),
r.d(n, "sortBy", function () {
return F;
}),
r.d(n, "union", function () {
return H;
}),
r.d(n, "uniq", function () {
return D;
}),
r.d(n, "valuesOfKey", function () {
return R;
}),
r.d(n, "head", function () {
return z;
}),
r.d(n, "last", function () {
return V;
}),
r.d(n, "startsWith", function () {
return q;
}),
r.d(n, "endsWith", function () {
return U;
}),
r.d(n, "filter", function () {
return u;
}),
r.d(n, "every", function () {
return W;
}),
r.d(n, "some", function () {
return G;
}),
r.d(n, "group", function () {
return $;
}),
r.d(n, "groupBy", function () {
return K;
}),
r.d(n, "groupToMap", function () {
return X;
}),
r.d(n, "getWrapBehavior", function () {
return J;
}),
r.d(n, "wrapBehavior", function () {
return Q;
}),
r.d(n, "number2color", function () {
return tt;
}),
r.d(n, "parseRadius", function () {
return nt;
}),
r.d(n, "clamp", function () {
return rt;
}),
r.d(n, "fixedBase", function () {
return et;
}),
r.d(n, "isDecimal", function () {
return ut;
}),
r.d(n, "isEven", function () {
return ot;
}),
r.d(n, "isInteger", function () {
return at;
}),
r.d(n, "isNegative", function () {
return ct;
}),
r.d(n, "isNumberEqual", function () {
return ft;
}),
r.d(n, "isOdd", function () {
return st;
}),
r.d(n, "isPositive", function () {
return lt;
}),
r.d(n, "max", function () {
return S;
}),
r.d(n, "maxBy", function () {
return dt;
}),
r.d(n, "min", function () {
return P;
}),
r.d(n, "minBy", function () {
return ht;
}),
r.d(n, "mod", function () {
return pt;
}),
r.d(n, "toDegree", function () {
return yt;
}),
r.d(n, "toInteger", function () {
return gt;
}),
r.d(n, "toRadian", function () {
return mt;
}),
r.d(n, "forIn", function () {
return Ot;
}),
r.d(n, "has", function () {
return jt;
}),
r.d(n, "hasKey", function () {
return xt;
}),
r.d(n, "hasValue", function () {
return At;
}),
r.d(n, "keys", function () {
return v;
}),
r.d(n, "isMatch", function () {
return y;
}),
r.d(n, "values", function () {
return wt;
}),
r.d(n, "lowerCase", function () {
return Pt;
}),
r.d(n, "lowerFirst", function () {
return Et;
}),
r.d(n, "substitute", function () {
return _t;
}),
r.d(n, "upperCase", function () {
return Ct;
}),
r.d(n, "upperFirst", function () {
return Mt;
}),
r.d(n, "getType", function () {
return Bt;
}),
r.d(n, "isArguments", function () {
return Nt;
}),
r.d(n, "isArray", function () {
return l;
}),
r.d(n, "isArrayLike", function () {
return e;
}),
r.d(n, "isBoolean", function () {
return kt;
}),
r.d(n, "isDate", function () {
return It;
}),
r.d(n, "isError", function () {
return Lt;
}),
r.d(n, "isFunction", function () {
return f;
}),
r.d(n, "isFinite", function () {
return Ft;
}),
r.d(n, "isNil", function () {
return s;
}),
r.d(n, "isNull", function () {
return Dt;
}),
r.d(n, "isNumber", function () {
return it;
}),
r.d(n, "isObject", function () {
return h;
}),
r.d(n, "isObjectLike", function () {
return b;
}),
r.d(n, "isPlainObject", function () {
return m;
}),
r.d(n, "isPrototype", function () {
return Rt;
}),
r.d(n, "isRegExp", function () {
return zt;
}),
r.d(n, "isString", function () {
return L;
}),
r.d(n, "isType", function () {
return c;
}),
r.d(n, "isUndefined", function () {
return Vt;
}),
r.d(n, "isElement", function () {
return qt;
}),
r.d(n, "requestAnimationFrame", function () {
return Ut;
}),
r.d(n, "clearAnimationFrame", function () {
return Wt;
}),
r.d(n, "augment", function () {
return Kt;
}),
r.d(n, "clone", function () {
return $t;
}),
r.d(n, "debounce", function () {
return Jt;
}),
r.d(n, "memoize", function () {
return Qt;
}),
r.d(n, "deepMix", function () {
return tn;
}),
r.d(n, "each", function () {
return p;
}),
r.d(n, "extend", function () {
return nn;
}),
r.d(n, "indexOf", function () {
return rn;
}),
r.d(n, "isEmpty", function () {
return un;
}),
r.d(n, "isEqual", function () {
return on;
}),
r.d(n, "isEqualWith", function () {
return an;
}),
r.d(n, "map", function () {
return cn;
}),
r.d(n, "mapValues", function () {
return sn;
}),
r.d(n, "mix", function () {
return Yt;
}),
r.d(n, "assign", function () {
return Yt;
}),
r.d(n, "get", function () {
return ln;
}),
r.d(n, "set", function () {
return dn;
}),
r.d(n, "pick", function () {
return pn;
}),
r.d(n, "omit", function () {
return vn;
}),
r.d(n, "throttle", function () {
return yn;
}),
r.d(n, "toArray", function () {
return gn;
}),
r.d(n, "toString", function () {
return St;
}),
r.d(n, "uniqueId", function () {
return mn;
}),
r.d(n, "noop", function () {
return On;
}),
r.d(n, "identity", function () {
return jn;
}),
r.d(n, "size", function () {
return xn;
}),
r.d(n, "measureTextWidth", function () {
return Sn;
}),
r.d(n, "getEllipsisText", function () {
return Pn;
}),
r.d(n, "Cache", function () {
return En;
});
var e = function (t) {
return null !== t && "function" != typeof t && isFinite(t.length);
},
i = function (t, n) {
return !!e(t) && t.indexOf(n) > -1;
},
u = function (t, n) {
if (!e(t)) return t;
for (var r = [], i = 0; i < t.length; i++) {
var u = t[i];
n(u, i) && r.push(u);
}
return r;
},
o = function (t, n) {
return (
void 0 === n && (n = []),
u(t, function (t) {
return !i(n, t);
})
);
},
a = {}.toString,
c = function (t, n) {
return a.call(t) === "[object " + n + "]";
},
f = function (t) {
return c(t, "Function");
},
s = function (t) {
return null == t;
},
l = function (t) {
return Array.isArray ? Array.isArray(t) : c(t, "Array");
};
function d(t) {
return (d =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var h = function (t) {
var n = d(t);
return (null !== t && "object" === n) || "function" === n;
};
var p = function (t, n) {
if (t)
if (l(t))
for (var r = 0, e = t.length; r < e && !1 !== n(t[r], r); r++);
else if (h(t))
for (var i in t)
if (t.hasOwnProperty(i) && !1 === n(t[i], i)) break;
},
v = Object.keys
? function (t) {
return Object.keys(t);
}
: function (t) {
var n = [];
return (
p(t, function (r, e) {
(f(t) && "prototype" === e) || n.push(e);
}),
n
);
};
var y = function (t, n) {
var r = v(n),
e = r.length;
if (s(t)) return !e;
for (var i = 0; i < e; i += 1) {
var u = r[i];
if (n[u] !== t[u] || !(u in t)) return !1;
}
return !0;
};
function g(t) {
return (g =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var b = function (t) {
return "object" === g(t) && null !== t;
},
m = function (t) {
if (!b(t) || !c(t, "Object")) return !1;
if (null === Object.getPrototypeOf(t)) return !0;
for (var n = t; null !== Object.getPrototypeOf(n); )
n = Object.getPrototypeOf(n);
return Object.getPrototypeOf(t) === n;
};
var O = function (t, n) {
if (!l(t)) return null;
var r;
if (
(f(n) && (r = n),
m(n) &&
(r = function (t) {
return y(t, n);
}),
r)
)
for (var e = 0; e < t.length; e += 1) if (r(t[e])) return t[e];
return null;
};
var j = function (t, n, r) {
void 0 === r && (r = 0);
for (var e = r; e < t.length; e++) if (n(t[e], e)) return e;
return -1;
},
x = function (t, n) {
for (var r = null, e = 0; e < t.length; e++) {
var i = t[e][n];
if (!s(i)) {
r = l(i) ? i[0] : i;
break;
}
}
return r;
},
w = function (t) {
if (!l(t)) return [];
for (var n = [], r = 0; r < t.length; r++) n = n.concat(t[r]);
return n;
},
A = function t(n, r) {
if ((void 0 === r && (r = []), l(n)))
for (var e = 0; e < n.length; e += 1) t(n[e], r);
else r.push(n);
return r;
},
S = function (t) {
if (l(t))
return t.reduce(function (t, n) {
return Math.max(t, n);
}, t[0]);
},
P = function (t) {
if (l(t))
return t.reduce(function (t, n) {
return Math.min(t, n);
}, t[0]);
},
E = function (t) {
var n = t.filter(function (t) {
return !isNaN(t);
});
if (!n.length) return { min: 0, max: 0 };
if (l(t[0])) {
for (var r = [], e = 0; e < t.length; e++) r = r.concat(t[e]);
n = r;
}
var i = S(n);
return { min: P(n), max: i };
},
_ = Array.prototype,
C = _.splice,
M = _.indexOf,
T = function (t) {
for (var n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
for (var e = 0; e < n.length; e++)
for (var i = n[e], u = -1; (u = M.call(t, i)) > -1; )
C.call(t, u, 1);
return t;
},
B = Array.prototype.splice,
N = function (t, n) {
if (!e(t)) return [];
for (var r = t ? n.length : 0, i = r - 1; r--; ) {
var u = void 0,
o = n[r];
(r !== i && o === u) || ((u = o), B.call(t, o, 1));
}
return t;
},
k = function (t, n, r) {
if (!l(t) && !m(t)) return t;
var e = r;
return (
p(t, function (t, r) {
e = n(e, t, r);
}),
e
);
},
I = function (t, n) {
var r = [];
if (!e(t)) return r;
for (var i = -1, u = [], o = t.length; ++i < o; ) {
var a = t[i];
n(a, i, t) && (r.push(a), u.push(i));
}
return N(t, u), r;
},
L = function (t) {
return c(t, "String");
};
var F = function (t, n) {
var r;
if (f(n))
r = function (t, r) {
return n(t) - n(r);
};
else {
var e = [];
L(n) ? e.push(n) : l(n) && (e = n),
(r = function (t, n) {
for (var r = 0; r < e.length; r += 1) {
var i = e[r];
if (t[i] > n[i]) return 1;
if (t[i] < n[i]) return -1;
}
return 0;
});
}
return t.sort(r), t;
};
function D(t, n) {
void 0 === n && (n = new Map());
var r = [];
if (Array.isArray(t))
for (var e = 0, i = t.length; e < i; e++) {
var u = t[e];
n.has(u) || (r.push(u), n.set(u, !0));
}
return r;
}
var H = function () {
for (var t = [], n = 0; n < arguments.length; n++)
t[n] = arguments[n];
return D([].concat.apply([], t));
},
R = function (t, n) {
for (var r = [], e = {}, i = 0; i < t.length; i++) {
var u = t[i][n];
if (!s(u)) {
l(u) || (u = [u]);
for (var o = 0; o < u.length; o++) {
var a = u[o];
e[a] || (r.push(a), (e[a] = !0));
}
}
}
return r;
};
function z(t) {
if (e(t)) return t[0];
}
function V(t) {
if (e(t)) {
return t[t.length - 1];
}
}
var q = function (t, n) {
return !(!l(t) && !L(t)) && t[0] === n;
};
var U = function (t, n) {
return !(!l(t) && !L(t)) && t[t.length - 1] === n;
},
W = function (t, n) {
for (var r = 0; r < t.length; r++) if (!n(t[r], r)) return !1;
return !0;
},
G = function (t, n) {
for (var r = 0; r < t.length; r++) if (n(t[r], r)) return !0;
return !1;
},
Y = Object.prototype.hasOwnProperty;
var K = function (t, n) {
if (!n || !l(t)) return {};
for (
var r,
e = {},
i = f(n)
? n
: function (t) {
return t[n];
},
u = 0;
u < t.length;
u++
) {
var o = t[u];
(r = i(o)), Y.call(e, r) ? e[r].push(o) : (e[r] = [o]);
}
return e;
};
function X(t, n) {
if (!n) return { 0: t };
if (!f(n)) {
var r = l(n) ? n : n.replace(/\s+/g, "").split("*");
n = function (t) {
for (var n = "_", e = 0, i = r.length; e < i; e++)
n += t[r[e]] && t[r[e]].toString();
return n;
};
}
return K(t, n);
}
var $ = function (t, n) {
if (!n) return [t];
var r = X(t, n),
e = [];
for (var i in r) e.push(r[i]);
return e;
};
var J = function (t, n) {
return t["_wrap_" + n];
};
var Q = function (t, n) {
if (t["_wrap_" + n]) return t["_wrap_" + n];
var r = function (r) {
t[n](r);
};
return (t["_wrap_" + n] = r), r;
},
Z = {};
var tt = function (t) {
var n = Z[t];
if (!n) {
for (var r = t.toString(16), e = r.length; e < 6; e++) r = "0" + r;
(n = "#" + r), (Z[t] = n);
}
return n;
};
var nt = function (t) {
var n = 0,
r = 0,
e = 0,
i = 0;
return (
l(t)
? 1 === t.length
? (n = r = e = i = t[0])
: 2 === t.length
? ((n = e = t[0]), (r = i = t[1]))
: 3 === t.length
? ((n = t[0]), (r = i = t[1]), (e = t[2]))
: ((n = t[0]), (r = t[1]), (e = t[2]), (i = t[3]))
: (n = r = e = i = t),
{ r1: n, r2: r, r3: e, r4: i }
);
},
rt = function (t, n, r) {
return t < n ? n : t > r ? r : t;
},
et = function (t, n) {
var r = n.toString(),
e = r.indexOf(".");
if (-1 === e) return Math.round(t);
var i = r.substr(e + 1).length;
return i > 20 && (i = 20), parseFloat(t.toFixed(i));
},
it = function (t) {
return c(t, "Number");
},
ut = function (t) {
return it(t) && t % 1 != 0;
},
ot = function (t) {
return it(t) && t % 2 == 0;
},
at = Number.isInteger
? Number.isInteger
: function (t) {
return it(t) && t % 1 == 0;
},
ct = function (t) {
return it(t) && t < 0;
};
function ft(t, n, r) {
return void 0 === r && (r = 1e-5), Math.abs(t - n) < r;
}
var st = function (t) {
return it(t) && t % 2 != 0;
},
lt = function (t) {
return it(t) && t > 0;
},
dt = function (t, n) {
if (l(t)) {
for (var r, e = -1 / 0, i = 0; i < t.length; i++) {
var u = t[i],
o = f(n) ? n(u) : u[n];
o > e && ((r = u), (e = o));
}
return r;
}
},
ht = function (t, n) {
if (l(t)) {
for (var r, e = 1 / 0, i = 0; i < t.length; i++) {
var u = t[i],
o = f(n) ? n(u) : u[n];
o < e && ((r = u), (e = o));
}
return r;
}
},
pt = function (t, n) {
return ((t % n) + n) % n;
},
vt = 180 / Math.PI,
yt = function (t) {
return vt * t;
},
gt = parseInt,
bt = Math.PI / 180,
mt = function (t) {
return bt * t;
},
Ot = p,
jt = function (t, n) {
return t.hasOwnProperty(n);
},
xt = jt,
wt = Object.values
? function (t) {
return Object.values(t);
}
: function (t) {
var n = [];
return (
p(t, function (r, e) {
(f(t) && "prototype" === e) || n.push(r);
}),
n
);
},
At = function (t, n) {
return i(wt(t), n);
},
St = function (t) {
return s(t) ? "" : t.toString();
},
Pt = function (t) {
return St(t).toLowerCase();
},
Et = function (t) {
var n = St(t);
return n.charAt(0).toLowerCase() + n.substring(1);
};
var _t = function (t, n) {
return t && n
? t.replace(/\\?\{([^{}]+)\}/g, function (t, r) {
return "\\" === t.charAt(0)
? t.slice(1)
: void 0 === n[r]
? ""
: n[r];
})
: t;
},
Ct = function (t) {
return St(t).toUpperCase();
},
Mt = function (t) {
var n = St(t);
return n.charAt(0).toUpperCase() + n.substring(1);
},
Tt = {}.toString,
Bt = function (t) {
return Tt.call(t)
.replace(/^\[object /, "")
.replace(/]$/, "");
},
Nt = function (t) {
return c(t, "Arguments");
},
kt = function (t) {
return c(t, "Boolean");
},
It = function (t) {
return c(t, "Date");
},
Lt = function (t) {
return c(t, "Error");
},
Ft = function (t) {
return it(t) && isFinite(t);
},
Dt = function (t) {
return null === t;
},
Ht = Object.prototype,
Rt = function (t) {
var n = t && t.constructor;
return t === (("function" == typeof n && n.prototype) || Ht);
},
zt = function (t) {
return c(t, "RegExp");
},
Vt = function (t) {
return void 0 === t;
},
qt = function (t) {
return t instanceof Element || t instanceof HTMLDocument;
};
function Ut(t) {
return (
window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
window.msRequestAnimationFrame ||
function (t) {
return setTimeout(t, 16);
}
)(t);
}
function Wt(t) {
(
window.cancelAnimationFrame ||
window.webkitCancelAnimationFrame ||
window.mozCancelAnimationFrame ||
window.msCancelAnimationFrame ||
clearTimeout
)(t);
}
function Gt(t, n) {
for (var r in n)
n.hasOwnProperty(r) &&
"constructor" !== r &&
void 0 !== n[r] &&
(t[r] = n[r]);
}
function Yt(t, n, r, e) {
return n && Gt(t, n), r && Gt(t, r), e && Gt(t, e), t;
}
var Kt = function () {
for (var t = [], n = 0; n < arguments.length; n++) t[n] = arguments[n];
for (var r = t[0], e = 1; e < t.length; e++) {
var i = t[e];
f(i) && (i = i.prototype), Yt(r.prototype, i);
}
};
function Xt(t) {
return (Xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var $t = function t(n) {
if ("object" !== Xt(n) || null === n) return n;
var r;
if (l(n)) {
r = [];
for (var e = 0, i = n.length; e < i; e++)
"object" === Xt(n[e]) && null != n[e]
? (r[e] = t(n[e]))
: (r[e] = n[e]);
} else
for (var u in ((r = {}), n))
"object" === Xt(n[u]) && null != n[u]
? (r[u] = t(n[u]))
: (r[u] = n[u]);
return r;
};
var Jt = function (t, n, r) {
var e;
return function () {
var i = this,
u = arguments,
o = function () {
(e = null), r || t.apply(i, u);
},
a = r && !e;
clearTimeout(e), (e = setTimeout(o, n)), a && t.apply(i, u);
};
},
Qt = function (t, n) {
if (!f(t)) throw new TypeError("Expected a function");
var r = function r() {
for (var e = [], i = 0; i < arguments.length; i++)
e[i] = arguments[i];
var u = n ? n.apply(this, e) : e[0],
o = r.cache;
if (o.has(u)) return o.get(u);
var a = t.apply(this, e);
return o.set(u, a), a;
};
return (r.cache = new Map()), r;
};
function Zt(t, n, r, e) {
for (var i in ((r = r || 0), (e = e || 5), n))
if (n.hasOwnProperty(i)) {
var u = n[i];
null !== u && m(u)
? (m(t[i]) || (t[i] = {}),
r < e ? Zt(t[i], u, r + 1, e) : (t[i] = n[i]))
: l(u)
? ((t[i] = []), (t[i] = t[i].concat(u)))
: void 0 !== u && (t[i] = u);
}
}
var tn = function (t) {
for (var n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
for (var e = 0; e < n.length; e += 1) Zt(t, n[e]);
return t;
},
nn = function (t, n, r, e) {
f(n) || ((r = n), (n = t), (t = function () {}));
var i = Object.create
? function (t, n) {
return Object.create(t, { constructor: { value: n } });
}
: function (t, n) {
function r() {}
r.prototype = t;
var e = new r();
return (e.constructor = n), e;
},
u = i(n.prototype, t);
return (
(t.prototype = Yt(u, t.prototype)),
(t.superclass = i(n.prototype, n)),
Yt(u, r),
Yt(t, e),
t
);
},
rn = function (t, n) {
if (!e(t)) return -1;
var r = Array.prototype.indexOf;
if (r) return r.call(t, n);
for (var i = -1, u = 0; u < t.length; u++)
if (t[u] === n) {
i = u;
break;
}
return i;
},
en = Object.prototype.hasOwnProperty;
var un = function (t) {
if (s(t)) return !0;
if (e(t)) return !t.length;
var n = Bt(t);
if ("Map" === n || "Set" === n) return !t.size;
if (Rt(t)) return !Object.keys(t).length;
for (var r in t) if (en.call(t, r)) return !1;
return !0;
},
on = function t(n, r) {
if (n === r) return !0;
if (!n || !r) return !1;
if (L(n) || L(r)) return !1;
if (e(n) || e(r)) {
if (n.length !== r.length) return !1;
for (var i = !0, u = 0; u < n.length && (i = t(n[u], r[u])); u++);
return i;
}
if (b(n) || b(r)) {
var o = Object.keys(n),
a = Object.keys(r);
if (o.length !== a.length) return !1;
for (i = !0, u = 0; u < o.length && (i = t(n[o[u]], r[o[u]])); u++);
return i;
}
return !1;
},
an = function (t, n, r) {
return f(r) ? !!r(t, n) : on(t, n);
},
cn = function (t, n) {
if (!e(t)) return t;
for (var r = [], i = 0; i < t.length; i++) {
var u = t[i];
r.push(n(u, i));
}
return r;
},
fn = function (t) {
return t;
},
sn = function (t, n) {
void 0 === n && (n = fn);
var r = {};
return (
h(t) &&
!s(t) &&
Object.keys(t).forEach(function (e) {
r[e] = n(t[e], e);
}),
r
);
},
ln = function (t, n, r) {
for (var e = 0, i = L(n) ? n.split(".") : n; t && e < i.length; )
t = t[i[e++]];
return void 0 === t || e < i.length ? r : t;
},
dn = function (t, n, r) {
var e = t,
i = L(n) ? n.split(".") : n;
return (
i.forEach(function (t, n) {
n < i.length - 1
? (h(e[t]) || (e[t] = it(i[n + 1]) ? [] : {}), (e = e[t]))
: (e[t] = r);
}),
t
);
},
hn = Object.prototype.hasOwnProperty,
pn = function (t, n) {
if (null === t || !m(t)) return {};
var r = {};
return (
p(n, function (n) {
hn.call(t, n) && (r[n] = t[n]);
}),
r
);
},
vn = function (t, n) {
return k(
t,
function (t, r, e) {
return n.includes(e) || (t[e] = r), t;
},
{},
);
},
yn = function (t, n, r) {
var e,
i,
u,
o,
a = 0;
r || (r = {});
var c = function () {
(a = !1 === r.leading ? 0 : Date.now()),
(e = null),
(o = t.apply(i, u)),
e || (i = u = null);
},
f = function () {
var f = Date.now();
a || !1 !== r.leading || (a = f);
var s = n - (f - a);
return (
(i = this),
(u = arguments),
s <= 0 || s > n
? (e && (clearTimeout(e), (e = null)),
(a = f),
(o = t.apply(i, u)),
e || (i = u = null))
: e || !1 === r.trailing || (e = setTimeout(c, s)),
o
);
};
return (
(f.cancel = function () {
clearTimeout(e), (a = 0), (e = i = u = null);
}),
f
);
},
gn = function (t) {
return e(t) ? Array.prototype.slice.call(t) : [];
},
bn = {},
mn = function (t) {
return bn[(t = t || "g")] ? (bn[t] += 1) : (bn[t] = 1), t + bn[t];
},
On = function () {},
jn = function (t) {
return t;
};
function xn(t) {
return s(t) ? 0 : e(t) ? t.length : Object.keys(t).length;
}
var wn,
An = r(1),
Sn = Qt(
function (t, n) {
void 0 === n && (n = {});
var r = n.fontSize,
e = n.fontFamily,
i = n.fontWeight,
u = n.fontStyle,
o = n.fontVariant;
return (
wn || (wn = document.createElement("canvas").getContext("2d")),
(wn.font = [u, o, i, r + "px", e].join(" ")),
wn.measureText(L(t) ? t : "").width
);
},
function (t, n) {
return void 0 === n && (n = {}), Object(An.g)([t], wt(n)).join("");
},
),
Pn = function (t, n, r, e) {
void 0 === e && (e = "...");
var i,
u,
o = Sn(e, r),
a = L(t) ? t : St(t),
c = n,
f = [];
if (Sn(t, r) <= n) return t;
for (; (i = a.substr(0, 16)), !((u = Sn(i, r)) + o > c && u > c); )
if ((f.push(i), (c -= u), !(a = a.substr(16)))) return f.join("");
for (; (i = a.substr(0, 1)), !((u = Sn(i, r)) + o > c); )
if ((f.push(i), (c -= u), !(a = a.substr(1)))) return f.join("");
return "" + f.join("") + e;
},
En = (function () {
function t() {
this.map = {};
}
return (
(t.prototype.has = function (t) {
return void 0 !== this.map[t];
}),
(t.prototype.get = function (t, n) {
var r = this.map[t];
return void 0 === r ? n : r;
}),
(t.prototype.set = function (t, n) {
this.map[t] = n;
}),
(t.prototype.clear = function () {
this.map = {};
}),
(t.prototype.delete = function (t) {
delete this.map[t];
}),
(t.prototype.size = function () {
return Object.keys(this.map).length;
}),
t
);
})();
},
1: function (t, n, r) {
"use strict";
r.d(n, "c", function () {
return i;
}),
r.d(n, "a", function () {
return u;
}),
r.d(n, "e", function () {
return o;
}),
r.d(n, "b", function () {
return a;
}),
r.d(n, "d", function () {
return c;
}),
r.d(n, "g", function () {
return f;
}),
r.d(n, "f", function () {
return s;
});
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var e = function (t, n) {
return (e =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, n) {
t.__proto__ = n;
}) ||
function (t, n) {
for (var r in n)
Object.prototype.hasOwnProperty.call(n, r) && (t[r] = n[r]);
})(t, n);
};
function i(t, n) {
if ("function" != typeof n && null !== n)
throw new TypeError(
"Class extends value " +
String(n) +
" is not a constructor or null",
);
function r() {
this.constructor = t;
}
e(t, n),
(t.prototype =
null === n
? Object.create(n)
: ((r.prototype = n.prototype), new r()));
}
var u = function () {
return (u =
Object.assign ||
function (t) {
for (var n, r = 1, e = arguments.length; r < e; r++)
for (var i in (n = arguments[r]))
Object.prototype.hasOwnProperty.call(n, i) && (t[i] = n[i]);
return t;
}).apply(this, arguments);
};
function o(t, n) {
var r = {};
for (var e in t)
Object.prototype.hasOwnProperty.call(t, e) &&
n.indexOf(e) < 0 &&
(r[e] = t[e]);
if (null != t && "function" == typeof Object.getOwnPropertySymbols) {
var i = 0;
for (e = Object.getOwnPropertySymbols(t); i < e.length; i++)
n.indexOf(e[i]) < 0 &&
Object.prototype.propertyIsEnumerable.call(t, e[i]) &&
(r[e[i]] = t[e[i]]);
}
return r;
}
function a(t, n, r, e) {
return new (r || (r = Promise))(function (i, u) {
function o(t) {
try {
c(e.next(t));
} catch (t) {
u(t);
}
}
function a(t) {
try {
c(e.throw(t));
} catch (t) {
u(t);
}
}
function c(t) {
var n;
t.done
? i(t.value)
: ((n = t.value),
n instanceof r
? n
: new r(function (t) {
t(n);
})).then(o, a);
}
c((e = e.apply(t, n || [])).next());
});
}
function c(t, n) {
var r,
e,
i,
u,
o = {
label: 0,
sent: function () {
if (1 & i[0]) throw i[1];
return i[1];
},
trys: [],
ops: [],
};
return (
(u = { next: a(0), throw: a(1), return: a(2) }),
"function" == typeof Symbol &&
(u[Symbol.iterator] = function () {
return this;
}),
u
);
function a(u) {
return function (a) {
return (function (u) {
if (r) throw new TypeError("Generator is already executing.");
for (; o; )
try {
if (
((r = 1),
e &&
(i =
2 & u[0]
? e.return
: u[0]
? e.throw || ((i = e.return) && i.call(e), 0)
: e.next) &&
!(i = i.call(e, u[1])).done)
)
return i;
switch (((e = 0), i && (u = [2 & u[0], i.value]), u[0])) {
case 0:
case 1:
i = u;
break;
case 4:
return o.label++, { value: u[1], done: !1 };
case 5:
o.label++, (e = u[1]), (u = [0]);
continue;
case 7:
(u = o.ops.pop()), o.trys.pop();
continue;
default:
if (
!((i = o.trys),
(i = i.length > 0 && i[i.length - 1]) ||
(6 !== u[0] && 2 !== u[0]))
) {
o = 0;
continue;
}
if (3 === u[0] && (!i || (u[1] > i[0] && u[1] < i[3]))) {
o.label = u[1];
break;
}
if (6 === u[0] && o.label < i[1]) {
(o.label = i[1]), (i = u);
break;
}
if (i && o.label < i[2]) {
(o.label = i[2]), o.ops.push(u);
break;
}
i[2] && o.ops.pop(), o.trys.pop();
continue;
}
u = n.call(t, o);
} catch (t) {
(u = [6, t]), (e = 0);
} finally {
r = i = 0;
}
if (5 & u[0]) throw u[1];
return { value: u[0] ? u[1] : void 0, done: !0 };
})([u, a]);
};
}
}
Object.create;
function f() {
for (var t = 0, n = 0, r = arguments.length; n < r; n++)
t += arguments[n].length;
var e = Array(t),
i = 0;
for (n = 0; n < r; n++)
for (var u = arguments[n], o = 0, a = u.length; o < a; o++, i++)
e[i] = u[o];
return e;
}
function s(t, n, r) {
if (r || 2 === arguments.length)
for (var e, i = 0, u = n.length; i < u; i++)
(!e && i in n) ||
(e || (e = Array.prototype.slice.call(n, 0, i)), (e[i] = n[i]));
return t.concat(e || Array.prototype.slice.call(n));
}
Object.create;
},
196: function (t, n, r) {
"use strict";
r.r(n);
var e = r(1),
i = r(99),
u = r.n(i),
o = r(0);
n.default = function (t) {
var n = t.Graph,
r = t.Util,
i = r.radialLayout,
a = r.traverseTree;
return (function (t) {
function n(n) {
var r = t.call(this, n) || this;
return (
(r.layoutAnimating = !1),
r.set("removeList", []),
r.set("layoutMethod", r.getLayout()),
r
);
}
return (
Object(e.c)(n, t),
(n.prototype.getLayout = function () {
var t = this.get("layout");
return t
? "function" == typeof t
? t
: (t.type || (t.type = "dendrogram"),
t.direction || (t.direction = "TB"),
t.radial
? function (n) {
var r = u.a[t.type](n, t);
return i(r), r;
}
: function (n) {
return u.a[t.type](n, t);
})
: null;
}),
(n.indexOfChild = function (t, n) {
var r = -1;
return (
Object(o.each)(t, function (t, e) {
if (n === t.id) return (r = e), !1;
}),
r
);
}),
(n.prototype.getDefaultCfg = function () {
var n = t.prototype.getDefaultCfg.call(this);
return (n.animate = !0), n;
}),
(n.prototype.innerAddChild = function (t, n, r) {
var e = this,
i = t.data;
i && ((i.x = t.x), (i.y = t.y), (i.depth = t.depth));
var u = e.addItem("node", i, !1);
if (n) {
if ((u.set("parent", n), r)) {
var a = n.get("originAttrs");
if (a) u.set("originAttrs", a);
else {
var c = n.getModel();
u.set("originAttrs", { x: c.x, y: c.y });
}
}
var f = n.get("children");
f ? f.push(u) : n.set("children", [u]),
e.addItem(
"edge",
{
source: n,
target: u,
id: n.get("id") + ":" + u.get("id"),
},
!1,
);
}
return (
Object(o.each)(t.children || [], function (t) {
e.innerAddChild(t, u, r);
}),
e.emit("afteraddchild", { item: u, parent: n }),
u
);
}),
(n.prototype.innerUpdateChild = function (t, r, e) {
var i = this,
u = i.findById(t.id);
if (u) {
Object(o.each)(t.children || [], function (t) {
i.innerUpdateChild(t, u, e);
});
var a,
c,
f = u.get("children");
if (f)
if (f.length > 0)
for (var s = f.length - 1; s >= 0; s--) {
var l = f[s].getModel();
-1 === n.indexOfChild(t.children || [], l.id) &&
(i.innerRemoveChild(l.id, { x: t.x, y: t.y }, e),
f.splice(s, 1));
}
u.get("originAttrs") &&
((a = u.get("originAttrs").x), (c = u.get("originAttrs").y));
var d = u.getModel();
e && u.set("originAttrs", { x: d.x, y: d.y }),
u.set("model", t.data),
(a === t.x && c === t.y) ||
u.updatePosition({ x: t.x, y: t.y });
} else i.innerAddChild(t, r, e);
}),
(n.prototype.innerRemoveChild = function (t, n, r) {
var e = this,
i = e.findById(t);
if (i)
if (
(Object(o.each)(i.get("children"), function (t) {
e.innerRemoveChild(t.getModel().id, n, r);
}),
r)
) {
var u = i.getModel();
i.set("to", n),
i.set("originAttrs", { x: u.x, y: u.y }),
e.get("removeList").push(i);
} else e.removeItem(i);
}),
(n.prototype.changeData = function (t) {
var n = this;
this.getNodes().map(function (t) {
return n.clearItemStates(t);
}),
this.getEdges().map(function (t) {
return n.clearItemStates(t);
}),
t ? (n.data(t), n.render()) : n.layout(this.get("fitView"));
}),
(n.prototype.changeLayout = function (t) {
console.warn(
"Please call updateLayout instead of changeLayout. changeLayout will be discarded soon",
);
this.updateLayout(t);
}),
(n.prototype.updateLayout = function (t) {
t
? (this.set("layout", t),
this.set("layoutMethod", this.getLayout()),
this.layout())
: console.warn("layout cannot be null");
}),
(n.prototype.refreshLayout = function (t) {
console.warn(
"Please call layout instead of refreshLayout. refreshLayout will be discarded soon",
);
this.layout(t);
}),
(n.prototype.layout = function (t) {
var n = this.get("data"),
r = this.get("layoutMethod")(n, this.get("layout")),
e = this.get("animate");
(this.emit("beforerefreshlayout", { data: n, layoutData: r }),
this.emit("beforelayout"),
this.innerUpdateChild(r, void 0, e),
t) && this.get("viewController").fitView();
e ? this.layoutAnimate(r) : (this.refresh(), this.paint()),
this.emit("afterrefreshlayout", { data: n, layoutData: r }),
this.emit("afterlayout");
}),
(n.prototype.addChild = function (t, n) {
this.emit("beforeaddchild", { model: t, parent: n }),
Object(o.isString)(n) || (n = n.get("id"));
var r = this.findDataById(n);
r &&
(r.children || (r.children = []),
r.children.push(t),
this.changeData());
}),
(n.prototype.updateChildren = function (t, n) {
n && this.findById(n)
? ((this.findDataById(n).children = t), this.changeData())
: console.warn(
"Update children failed! There is no node with id '" +
n +
"'",
);
}),
(n.prototype.updateChild = function (t, r) {
if (r && this.findById(r)) {
var e = this.findDataById(r),
i = this.findById(t.id);
if ((e.children || (e.children = []), i)) {
var u = n.indexOfChild(e.children, t.id);
e.children[u] = t;
} else e.children.push(t);
this.changeData();
} else this.changeData(t);
}),
(n.prototype.removeChild = function (t) {
var r = this.findById(t);
if (r) {
var e = r.get("parent");
if (e && !e.destroyed) {
var i = this.findDataById(e.get("id")),
u = (i && i.children) || [],
o = r.getModel(),
a = n.indexOfChild(u, o.id);
u.splice(a, 1);
}
this.changeData();
}
}),
(n.prototype.findDataById = function (t, n) {
var r = this;
if ((n || (n = r.get("data")), t === n.id)) return n;
var e = null;
return (
Object(o.each)(n.children || [], function (n) {
return n.id === t
? ((e = n), !1)
: !(e = r.findDataById(t, n)) && void 0;
}),
e
);
}),
(n.prototype.layoutAnimate = function (t, n) {
var r = this,
e = this.get("animateCfg");
r.emit("beforeanimate", { data: t }),
r.getEdges().forEach(function (t) {
var n = t.get("model");
n.sourceAnchor ||
(n.sourceAnchor = t.get("sourceAnchorIndex"));
}),
this.get("canvas").animate(
function (e) {
a(t, function (i) {
var u = r.findById(i.id);
if (u) {
var o = u.get("originAttrs"),
a = u.get("model");
if (
(o ||
((o = { x: a.x, y: a.y }), u.set("originAttrs", o)),
n)
) {
var c = n(u, e, o, t);
u.set("model", Object.assign(a, c));
} else
(a.x = o.x + (i.x - o.x) * e),
(a.y = o.y + (i.y - o.y) * e);
}
return !0;
}),
Object(o.each)(r.get("removeList"), function (t) {
var n = t.getModel(),
r = t.get("originAttrs"),
i = t.get("to");
(n.x = r.x + (i.x - r.x) * e),
(n.y = r.y + (i.y - r.y) * e);
}),
r.refreshPositions();
},
{
duration: e.duration,
easing: e.ease,
callback: function () {
Object(o.each)(r.getNodes(), function (t) {
t.set("originAttrs", null);
}),
Object(o.each)(r.get("removeList"), function (t) {
r.removeItem(t);
}),
r.set("removeList", []),
e.callback && e.callback(),
r.emit("afteranimate", { data: t });
},
delay: e.delay,
},
);
}),
(n.prototype.stopLayoutAnimate = function () {
this.get("canvas").stopAnimate(),
this.emit("layoutanimateend", { data: this.get("data") }),
(this.layoutAnimating = !1);
}),
(n.prototype.isLayoutAnimating = function () {
return this.layoutAnimating;
}),
(n.prototype.render = function () {
if (!this.get("data"))
throw new Error("data must be defined first");
this.clear(),
this.emit("beforerender"),
this.layout(this.get("fitView")),
this.emit("afterrender");
}),
(n.prototype.save = function () {
return this.get("data");
}),
n
);
})(n);
};
},
45: function (t, n) {
t.exports = function (t) {
return (
t.webpackPolyfill ||
((t.deprecate = function () {}),
(t.paths = []),
t.children || (t.children = []),
Object.defineProperty(t, "loaded", {
enumerable: !0,
get: function () {
return t.l;
},
}),
Object.defineProperty(t, "id", {
enumerable: !0,
get: function () {
return t.i;
},
}),
(t.webpackPolyfill = 1)),
t
);
};
},
99: function (t, n, r) {
(function (t) {
var r, e, i, u;
function o(t) {
return (o =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
"undefined" != typeof self && self,
(u = function () {
return (function (t) {
var n = {};
function r(e) {
if (n[e]) return n[e].exports;
var i = (n[e] = { i: e, l: !1, exports: {} });
return (
t[e].call(i.exports, i, i.exports, r), (i.l = !0), i.exports
);
}
return (
(r.m = t),
(r.c = n),
(r.d = function (t, n, e) {
r.o(t, n) ||
Object.defineProperty(t, n, {
configurable: !1,
enumerable: !0,
get: e,
});
}),
(r.n = function (t) {
var n =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return r.d(n, "a", n), n;
}),
(r.o = function (t, n) {
return Object.prototype.hasOwnProperty.call(t, n);
}),
(r.p = ""),
r((r.s = 31))
);
})([
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Array.isArray
? Array.isArray(t)
: Object(e.a)(t, "Array");
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return (
null !== t && "function" != typeof t && isFinite(t.length)
);
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(13);
n.a = function (t, n) {
if (t)
if (Object(e.a)(t))
for (
var r = 0, u = t.length;
r < u && !1 !== n(t[r], r);
r++
);
else if (Object(i.a)(t))
for (var o in t)
if (t.hasOwnProperty(o) && !1 === n(t[o], o)) break;
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Function");
};
},
function (t, n, r) {
"use strict";
var e = {}.toString;
n.a = function (t, n) {
return e.call(t) === "[object " + n + "]";
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Number");
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return null == t;
};
},
function (t, n, r) {
var e = r(33).mix;
t.exports = { assign: e };
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "String");
};
},
function (t, n, r) {
"use strict";
var e = r(15),
i = r(4);
n.a = function (t) {
if (!Object(e.a)(t) || !Object(i.a)(t, "Object")) return !1;
if (null === Object.getPrototypeOf(t)) return !0;
for (var n = t; null !== Object.getPrototypeOf(n); )
n = Object.getPrototypeOf(n);
return Object.getPrototypeOf(t) === n;
};
},
function (t, n, r) {
"use strict";
var e = r(6);
n.a = function (t) {
return Object(e.a)(t) ? "" : t.toString();
};
},
function (t, n, r) {
var e = r(18),
i = (function () {
function t(t, n) {
void 0 === n && (n = {}),
(this.options = n),
(this.rootNode = e(t, n));
}
return (
(t.prototype.execute = function () {
throw new Error("please override this method");
}),
t
);
})();
t.exports = i;
},
function (t, n, r) {
"use strict";
var e = r(1);
n.a = function (t, n) {
return !!Object(e.a)(t) && t.indexOf(n) > -1;
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
var n = o(t);
return (null !== t && "object" === n) || "function" === n;
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(1);
n.a = function (t, n) {
if (!Object(i.a)(t)) return t;
var r = [];
return (
Object(e.a)(t, function (t, e) {
n(t, e) && r.push(t);
}),
r
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return "object" === o(t) && null !== t;
};
},
function (t, n, r) {
"use strict";
function e(t, n) {
for (var r in n)
n.hasOwnProperty(r) &&
"constructor" !== r &&
void 0 !== n[r] &&
(t[r] = n[r]);
}
n.a = function (t, n, r, i) {
return n && e(t, n), r && e(t, r), i && e(t, i), t;
};
},
function (t, n, r) {
var e = r(30),
i = ["LR", "RL", "TB", "BT", "H", "V"],
u = ["LR", "RL", "H"],
o = i[0];
t.exports = function (t, n, r) {
var a = n.direction || o;
if (
((n.isHorizontal = (function (t) {
return u.indexOf(t) > -1;
})(a)),
a && -1 === i.indexOf(a))
)
throw new TypeError("Invalid direction: " + a);
if (a === i[0]) r(t, n);
else if (a === i[1]) r(t, n), t.right2left();
else if (a === i[2]) r(t, n);
else if (a === i[3]) r(t, n), t.bottom2top();
else if (a === i[4] || a === i[5]) {
var c = e(t, n),
f = c.left,
s = c.right;
r(f, n),
r(s, n),
n.isHorizontal ? f.right2left() : f.bottom2top(),
s.translate(f.x - s.x, f.y - s.y),
(t.x = f.x),
(t.y = s.y);
var l = t.getBoundingBox();
n.isHorizontal
? l.top < 0 && t.translate(0, -l.top)
: l.left < 0 && t.translate(-l.left, 0);
}
var d = n.fixedRoot;
return (
void 0 === d && (d = !0),
d &&
t.translate(
-(t.x + t.width / 2 + t.hgap),
-(t.y + t.height / 2 + t.vgap),
),
t
);
};
},
function (t, n, r) {
var e = r(7),
i = {
getId: function (t) {
return t.id || t.name;
},
getPreH: function (t) {
return t.preH || 0;
},
getPreV: function (t) {
return t.preV || 0;
},
getHGap: function (t) {
return t.hgap || 18;
},
getVGap: function (t) {
return t.vgap || 18;
},
getChildren: function (t) {
return t.children;
},
getHeight: function (t) {
return t.height || 36;
},
getWidth: function (t) {
var n = t.label || " ";
return t.width || 18 * n.split("").length;
},
};
function u(t, n) {
var r = this;
if (((r.vgap = r.hgap = 0), t instanceof u)) return t;
r.data = t;
var e = n.getHGap(t),
i = n.getVGap(t);
return (
(r.preH = n.getPreH(t)),
(r.preV = n.getPreV(t)),
(r.width = n.getWidth(t)),
(r.height = n.getHeight(t)),
(r.width += r.preH),
(r.height += r.preV),
(r.id = n.getId(t)),
(r.x = r.y = 0),
(r.depth = 0),
r.children || (r.children = []),
r.addGap(e, i),
r
);
}
e.assign(u.prototype, {
isRoot: function () {
return 0 === this.depth;
},
isLeaf: function () {
return 0 === this.children.length;
},
addGap: function (t, n) {
(this.hgap += t),
(this.vgap += n),
(this.width += 2 * t),
(this.height += 2 * n);
},
eachNode: function (t) {
for (var n, r = [this]; (n = r.shift()); )
t(n), (r = n.children.concat(r));
},
DFTraverse: function (t) {
this.eachNode(t);
},
BFTraverse: function (t) {
for (var n, r = [this]; (n = r.shift()); )
t(n), (r = r.concat(n.children));
},
getBoundingBox: function () {
var t = {
left: Number.MAX_VALUE,
top: Number.MAX_VALUE,
width: 0,
height: 0,
};
return (
this.eachNode(function (n) {
(t.left = Math.min(t.left, n.x)),
(t.top = Math.min(t.top, n.y)),
(t.width = Math.max(t.width, n.x + n.width)),
(t.height = Math.max(t.height, n.y + n.height));
}),
t
);
},
translate: function (t, n) {
void 0 === t && (t = 0),
void 0 === n && (n = 0),
this.eachNode(function (r) {
(r.x += t),
(r.y += n),
(r.x += r.preH),
(r.y += r.preV);
});
},
right2left: function () {
var t = this.getBoundingBox();
this.eachNode(function (n) {
n.x = n.x - 2 * (n.x - t.left) - n.width;
}),
this.translate(t.width, 0);
},
bottom2top: function () {
var t = this.getBoundingBox();
this.eachNode(function (n) {
n.y = n.y - 2 * (n.y - t.top) - n.height;
}),
this.translate(0, t.height);
},
}),
(t.exports = function (t, n, r) {
void 0 === n && (n = {});
var o,
a = new u(t, (n = e.assign({}, i, n))),
c = [a];
if (!r && !t.collapsed)
for (; (o = c.shift()); )
if (!o.data.collapsed) {
var f = n.getChildren(o.data),
s = f ? f.length : 0;
if (((o.children = new Array(s)), f && s))
for (var l = 0; l < s; l++) {
var d = new u(f[l], n);
(o.children[l] = d),
c.push(d),
(d.parent = o),
(d.depth = o.depth + 1);
}
}
return a;
});
},
function (t, n, r) {
"use strict";
var e = r(6),
i = r(20);
n.a = function (t, n) {
var r = Object(i.a)(n),
u = r.length;
if (Object(e.a)(t)) return !u;
for (var o = 0; o < u; o += 1) {
var a = r[o];
if (n[a] !== t[a] || !(a in t)) return !1;
}
return !0;
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(3),
u = Object.keys
? function (t) {
return Object.keys(t);
}
: function (t) {
var n = [];
return (
Object(e.a)(t, function (r, e) {
(Object(i.a)(t) && "prototype" === e) || n.push(e);
}),
n
);
};
n.a = u;
},
function (t, n, r) {
"use strict";
var e = r(1),
i = Array.prototype.splice;
n.a = function (t, n) {
if (!Object(e.a)(t)) return [];
for (var r = t ? n.length : 0, u = r - 1; r--; ) {
var o = void 0,
a = n[r];
(r !== u && a === o) || ((o = a), i.call(t, a, 1));
}
return t;
};
},
function (t, n, r) {
"use strict";
var e = r(12),
i = r(2);
n.a = function (t) {
var n = [];
return (
Object(i.a)(t, function (t) {
Object(e.a)(n, t) || n.push(t);
}),
n
);
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(3),
u = r(24);
n.a = function (t, n) {
if (!n) return { 0: t };
if (!Object(i.a)(n)) {
var r = Object(e.a)(n)
? n
: n.replace(/\s+/g, "").split("*");
n = function (t) {
for (var n = "_", e = 0, i = r.length; e < i; e++)
n += t[r[e]] && t[r[e]].toString();
return n;
};
}
return Object(u.a)(t, n);
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(0),
u = r(3),
o = Object.prototype.hasOwnProperty;
n.a = function (t, n) {
if (!n || !Object(i.a)(t)) return {};
var r,
a = {},
c = Object(u.a)(n)
? n
: function (t) {
return t[n];
};
return (
Object(e.a)(t, function (t) {
(r = c(t)), o.call(a, r) ? a[r].push(t) : (a[r] = [t]);
}),
a
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
return t.hasOwnProperty(n);
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(3),
u = Object.values
? function (t) {
return Object.values(t);
}
: function (t) {
var n = [];
return (
Object(e.a)(t, function (r, e) {
(Object(i.a)(t) && "prototype" === e) || n.push(r);
}),
n
);
};
n.a = u;
},
function (t, n, r) {
"use strict";
var e = {}.toString;
n.a = function (t) {
return e
.call(t)
.replace(/^\[object /, "")
.replace(/]$/, "");
};
},
function (t, n, r) {
"use strict";
var e = Object.prototype;
n.a = function (t) {
var n = t && t.constructor;
return t === (("function" == typeof n && n.prototype) || e);
};
},
function (t, n, r) {
"use strict";
var e = r(15),
i = r(1),
u = r(8);
n.a = function t(n, r) {
if (n === r) return !0;
if (!n || !r) return !1;
if (Object(u.a)(n) || Object(u.a)(r)) return !1;
if (Object(i.a)(n) || Object(i.a)(r)) {
if (n.length !== r.length) return !1;
for (
var o = !0, a = 0;
a < n.length && (o = t(n[a], r[a]));
a++
);
return o;
}
if (Object(e.a)(n) || Object(e.a)(r)) {
var c = Object.keys(n),
f = Object.keys(r);
if (c.length !== f.length) return !1;
for (
o = !0, a = 0;
a < c.length && (o = t(n[c[a]], r[c[a]]));
a++
);
return o;
}
return !1;
};
},
function (t, n, r) {
var e = r(18);
t.exports = function (t, n) {
for (
var r = e(t.data, n, !0),
i = e(t.data, n, !0),
u = t.children.length,
o = Math.round(u / 2),
a =
n.getSide ||
function (t, n) {
return n < o ? "right" : "left";
},
c = 0;
c < u;
c++
) {
var f = t.children[c];
"right" === a(f, c)
? i.children.push(f)
: r.children.push(f);
}
return (
r.eachNode(function (t) {
t.isRoot() || (t.side = "left");
}),
i.eachNode(function (t) {
t.isRoot() || (t.side = "right");
}),
{ left: r, right: i }
);
};
},
function (t, n, r) {
var e = {
compactBox: r(32),
dendrogram: r(114),
indented: r(116),
mindmap: r(118),
};
t.exports = e;
},
function (t, n, r) {
var e = r(11),
i = r(113),
u = r(17),
o = r(7),
a = (function (t) {
var n, r;
function e() {
return t.apply(this, arguments) || this;
}
return (
(r = t),
((n = e).prototype = Object.create(r.prototype)),
(n.prototype.constructor = n),
(n.__proto__ = r),
(e.prototype.execute = function () {
return u(this.rootNode, this.options, i);
}),
e
);
})(e),
c = {};
t.exports = function (t, n) {
return (n = o.assign({}, c, n)), new a(t, n).execute();
};
},
function (t, n, r) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 });
var e = r(12);
r.d(n, "contains", function () {
return e.a;
}),
r.d(n, "includes", function () {
return e.a;
});
var i = r(34);
r.d(n, "difference", function () {
return i.a;
});
var u = r(35);
r.d(n, "find", function () {
return u.a;
});
var o = r(36);
r.d(n, "findIndex", function () {
return o.a;
});
var a = r(37);
r.d(n, "firstValue", function () {
return a.a;
});
var c = r(38);
r.d(n, "flatten", function () {
return c.a;
});
var f = r(39);
r.d(n, "flattenDeep", function () {
return f.a;
});
var s = r(40);
r.d(n, "getRange", function () {
return s.a;
});
var l = r(41);
r.d(n, "pull", function () {
return l.a;
});
var d = r(21);
r.d(n, "pullAt", function () {
return d.a;
});
var h = r(42);
r.d(n, "reduce", function () {
return h.a;
});
var p = r(43);
r.d(n, "remove", function () {
return p.a;
});
var v = r(44);
r.d(n, "sortBy", function () {
return v.a;
});
var y = r(45);
r.d(n, "union", function () {
return y.a;
});
var g = r(22);
r.d(n, "uniq", function () {
return g.a;
});
var b = r(46);
r.d(n, "valuesOfKey", function () {
return b.a;
});
var m = r(47);
r.d(n, "head", function () {
return m.a;
});
var O = r(48);
r.d(n, "last", function () {
return O.a;
});
var j = r(49);
r.d(n, "startsWith", function () {
return j.a;
});
var x = r(50);
r.d(n, "endsWith", function () {
return x.a;
});
var w = r(14);
r.d(n, "filter", function () {
return w.a;
});
var A = r(51);
r.d(n, "every", function () {
return A.a;
});
var S = r(52);
r.d(n, "some", function () {
return S.a;
});
var P = r(53);
r.d(n, "group", function () {
return P.a;
});
var E = r(24);
r.d(n, "groupBy", function () {
return E.a;
});
var _ = r(23);
r.d(n, "groupToMap", function () {
return _.a;
});
var C = r(54);
r.d(n, "getWrapBehavior", function () {
return C.a;
});
var M = r(55);
r.d(n, "wrapBehavior", function () {
return M.a;
});
var T = r(56);
r.d(n, "number2color", function () {
return T.a;
});
var B = r(57);
r.d(n, "parseRadius", function () {
return B.a;
});
var N = r(58);
r.d(n, "clamp", function () {
return N.a;
});
var k = r(59);
r.d(n, "fixedBase", function () {
return k.a;
});
var I = r(60);
r.d(n, "isDecimal", function () {
return I.a;
});
var L = r(61);
r.d(n, "isEven", function () {
return L.a;
});
var F = r(62);
r.d(n, "isInteger", function () {
return F.a;
});
var D = r(63);
r.d(n, "isNegative", function () {
return D.a;
});
var H = r(64);
r.d(n, "isNumberEqual", function () {
return H.a;
});
var R = r(65);
r.d(n, "isOdd", function () {
return R.a;
});
var z = r(66);
r.d(n, "isPositive", function () {
return z.a;
});
var V = r(67);
r.d(n, "maxBy", function () {
return V.a;
});
var q = r(68);
r.d(n, "minBy", function () {
return q.a;
});
var U = r(69);
r.d(n, "mod", function () {
return U.a;
});
var W = r(70);
r.d(n, "toDegree", function () {
return W.a;
});
var G = r(71);
r.d(n, "toInteger", function () {
return G.a;
});
var Y = r(72);
r.d(n, "toRadian", function () {
return Y.a;
});
var K = r(73);
r.d(n, "forIn", function () {
return K.a;
});
var X = r(25);
r.d(n, "has", function () {
return X.a;
});
var $ = r(74);
r.d(n, "hasKey", function () {
return $.a;
});
var J = r(75);
r.d(n, "hasValue", function () {
return J.a;
});
var Q = r(20);
r.d(n, "keys", function () {
return Q.a;
});
var Z = r(19);
r.d(n, "isMatch", function () {
return Z.a;
});
var tt = r(26);
r.d(n, "values", function () {
return tt.a;
});
var nt = r(76);
r.d(n, "lowerCase", function () {
return nt.a;
});
var rt = r(77);
r.d(n, "lowerFirst", function () {
return rt.a;
});
var et = r(78);
r.d(n, "substitute", function () {
return et.a;
});
var it = r(79);
r.d(n, "upperCase", function () {
return it.a;
});
var ut = r(80);
r.d(n, "upperFirst", function () {
return ut.a;
});
var ot = r(27);
r.d(n, "getType", function () {
return ot.a;
});
var at = r(81);
r.d(n, "isArguments", function () {
return at.a;
});
var ct = r(0);
r.d(n, "isArray", function () {
return ct.a;
});
var ft = r(1);
r.d(n, "isArrayLike", function () {
return ft.a;
});
var st = r(82);
r.d(n, "isBoolean", function () {
return st.a;
});
var lt = r(83);
r.d(n, "isDate", function () {
return lt.a;
});
var dt = r(84);
r.d(n, "isError", function () {
return dt.a;
});
var ht = r(3);
r.d(n, "isFunction", function () {
return ht.a;
});
var pt = r(85);
r.d(n, "isFinite", function () {
return pt.a;
});
var vt = r(6);
r.d(n, "isNil", function () {
return vt.a;
});
var yt = r(86);
r.d(n, "isNull", function () {
return yt.a;
});
var gt = r(5);
r.d(n, "isNumber", function () {
return gt.a;
});
var bt = r(13);
r.d(n, "isObject", function () {
return bt.a;
});
var mt = r(15);
r.d(n, "isObjectLike", function () {
return mt.a;
});
var Ot = r(9);
r.d(n, "isPlainObject", function () {
return Ot.a;
});
var jt = r(28);
r.d(n, "isPrototype", function () {
return jt.a;
});
var xt = r(87);
r.d(n, "isRegExp", function () {
return xt.a;
});
var wt = r(8);
r.d(n, "isString", function () {
return wt.a;
});
var At = r(4);
r.d(n, "isType", function () {
return At.a;
});
var St = r(88);
r.d(n, "isUndefined", function () {
return St.a;
});
var Pt = r(89);
r.d(n, "isElement", function () {
return Pt.a;
});
var Et = r(90);
r.d(n, "requestAnimationFrame", function () {
return Et.a;
});
var _t = r(91);
r.d(n, "clearAnimationFrame", function () {
return _t.a;
});
var Ct = r(92);
r.d(n, "augment", function () {
return Ct.a;
});
var Mt = r(93);
r.d(n, "clone", function () {
return Mt.a;
});
var Tt = r(94);
r.d(n, "debounce", function () {
return Tt.a;
});
var Bt = r(95);
r.d(n, "memoize", function () {
return Bt.a;
});
var Nt = r(96);
r.d(n, "deepMix", function () {
return Nt.a;
});
var kt = r(2);
r.d(n, "each", function () {
return kt.a;
});
var It = r(97);
r.d(n, "extend", function () {
return It.a;
});
var Lt = r(98);
r.d(n, "indexOf", function () {
return Lt.a;
});
var Ft = r(99);
r.d(n, "isEmpty", function () {
return Ft.a;
});
var Dt = r(29);
r.d(n, "isEqual", function () {
return Dt.a;
});
var Ht = r(100);
r.d(n, "isEqualWith", function () {
return Ht.a;
});
var Rt = r(101);
r.d(n, "map", function () {
return Rt.a;
});
var zt = r(102);
r.d(n, "mapValues", function () {
return zt.a;
});
var Vt = r(16);
r.d(n, "mix", function () {
return Vt.a;
}),
r.d(n, "assign", function () {
return Vt.a;
});
var qt = r(103);
r.d(n, "get", function () {
return qt.a;
});
var Ut = r(104);
r.d(n, "set", function () {
return Ut.a;
});
var Wt = r(105);
r.d(n, "pick", function () {
return Wt.a;
});
var Gt = r(106);
r.d(n, "throttle", function () {
return Gt.a;
});
var Yt = r(107);
r.d(n, "toArray", function () {
return Yt.a;
});
var Kt = r(10);
r.d(n, "toString", function () {
return Kt.a;
});
var Xt = r(108);
r.d(n, "uniqueId", function () {
return Xt.a;
});
var $t = r(109);
r.d(n, "noop", function () {
return $t.a;
});
var Jt = r(110);
r.d(n, "identity", function () {
return Jt.a;
});
var Qt = r(111);
r.d(n, "size", function () {
return Qt.a;
});
var Zt = r(112);
r.d(n, "Cache", function () {
return Zt.a;
});
},
function (t, n, r) {
"use strict";
var e = r(14),
i = r(12);
n.a = function (t, n) {
return (
void 0 === n && (n = []),
Object(e.a)(t, function (t) {
return !Object(i.a)(n, t);
})
);
};
},
function (t, n, r) {
"use strict";
var e = r(3),
i = r(19),
u = r(0),
o = r(9);
n.a = function (t, n) {
if (!Object(u.a)(t)) return null;
var r;
if (
(Object(e.a)(n) && (r = n),
Object(o.a)(n) &&
(r = function (t) {
return Object(i.a)(t, n);
}),
r)
)
for (var a = 0; a < t.length; a += 1)
if (r(t[a])) return t[a];
return null;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n, r) {
void 0 === r && (r = 0);
for (var e = r; e < t.length; e++) if (n(t[e], e)) return e;
return -1;
};
},
function (t, n, r) {
"use strict";
var e = r(6),
i = r(0);
n.a = function (t, n) {
for (var r = null, u = 0; u < t.length; u++) {
var o = t[u][n];
if (!Object(e.a)(o)) {
r = Object(i.a)(o) ? o[0] : o;
break;
}
}
return r;
};
},
function (t, n, r) {
"use strict";
var e = r(0);
n.a = function (t) {
if (!Object(e.a)(t)) return [];
for (var n = [], r = 0; r < t.length; r++) n = n.concat(t[r]);
return n;
};
},
function (t, n, r) {
"use strict";
var e = r(0);
n.a = function t(n, r) {
if ((void 0 === r && (r = []), Object(e.a)(n)))
for (var i = 0; i < n.length; i += 1) t(n[i], r);
else r.push(n);
return r;
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(14);
n.a = function (t) {
if (
!(t = Object(i.a)(t, function (t) {
return !isNaN(t);
})).length
)
return { min: 0, max: 0 };
if (Object(e.a)(t[0])) {
for (var n = [], r = 0; r < t.length; r++)
n = n.concat(t[r]);
t = n;
}
var u = Math.max.apply(null, t);
return { min: Math.min.apply(null, t), max: u };
};
},
function (t, n, r) {
"use strict";
var e = Array.prototype,
i = e.splice,
u = e.indexOf;
n.a = function (t) {
for (var n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
for (var e = 0; e < n.length; e++)
for (var o = n[e], a = -1; (a = u.call(t, o)) > -1; )
i.call(t, a, 1);
return t;
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(0),
u = r(9);
n.a = function (t, n, r) {
if (!Object(i.a)(t) && !Object(u.a)(t)) return t;
var o = r;
return (
Object(e.a)(t, function (t, r) {
o = n(o, t, r);
}),
o
);
};
},
function (t, n, r) {
"use strict";
var e = r(1),
i = r(21);
n.a = function (t, n) {
var r = [];
if (!Object(e.a)(t)) return r;
for (var u = -1, o = [], a = t.length; ++u < a; ) {
var c = t[u];
n(c, u, t) && (r.push(c), o.push(u));
}
return Object(i.a)(t, o), r;
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(8),
u = r(3);
n.a = function (t, n) {
var r;
if (Object(u.a)(n))
r = function (t, r) {
return n(t) - n(r);
};
else {
var o = [];
Object(i.a)(n) ? o.push(n) : Object(e.a)(n) && (o = n),
(r = function (t, n) {
for (var r = 0; r < o.length; r += 1) {
var e = o[r];
if (t[e] > n[e]) return 1;
if (t[e] < n[e]) return -1;
}
return 0;
});
}
return t.sort(r), t;
};
},
function (t, n, r) {
"use strict";
var e = r(22);
n.a = function () {
for (var t = [], n = 0; n < arguments.length; n++)
t[n] = arguments[n];
return Object(e.a)([].concat.apply([], t));
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(0),
u = r(6);
n.a = function (t, n) {
var r = [],
o = {};
return (
t.forEach(function (t) {
var a = t[n];
Object(u.a)(a) ||
(Object(i.a)(a) || (a = [a]),
Object(e.a)(a, function (t) {
o[t] || (r.push(t), (o[t] = !0));
}));
}),
r
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
if (Object(e.a)(t)) return t[0];
};
var e = r(1);
},
function (t, n, r) {
"use strict";
n.a = function (t) {
if (Object(e.a)(t)) return t[t.length - 1];
};
var e = r(1);
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(8);
n.a = function (t, n) {
return !(!Object(e.a)(t) && !Object(i.a)(t)) && t[0] === n;
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(8);
n.a = function (t, n) {
return (
!(!Object(e.a)(t) && !Object(i.a)(t)) &&
t[t.length - 1] === n
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
for (var r = 0; r < t.length; r++) if (!n(t[r], r)) return !1;
return !0;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
for (var r = 0; r < t.length; r++) if (n(t[r], r)) return !0;
return !1;
};
},
function (t, n, r) {
"use strict";
var e = r(23);
n.a = function (t, n) {
if (!n) return [t];
var r = Object(e.a)(t, n),
i = [];
for (var u in r) i.push(r[u]);
return i;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
return t["_wrap_" + n];
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
if (t["_wrap_" + n]) return t["_wrap_" + n];
var r = function (r) {
t[n](r);
};
return (t["_wrap_" + n] = r), r;
};
},
function (t, n, r) {
"use strict";
var e = {};
n.a = function (t) {
var n = e[t];
if (!n) {
for (var r = t.toString(16), i = r.length; i < 6; i++)
r = "0" + r;
(n = "#" + r), (e[t] = n);
}
return n;
};
},
function (t, n, r) {
"use strict";
var e = r(0);
n.a = function (t) {
var n = 0,
r = 0,
i = 0,
u = 0;
return (
Object(e.a)(t)
? 1 === t.length
? (n = r = i = u = t[0])
: 2 === t.length
? ((n = i = t[0]), (r = u = t[1]))
: 3 === t.length
? ((n = t[0]), (r = u = t[1]), (i = t[2]))
: ((n = t[0]), (r = t[1]), (i = t[2]), (u = t[3]))
: (n = r = i = u = t),
{ r1: n, r2: r, r3: i, r4: u }
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n, r) {
return t < n ? n : t > r ? r : t;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
var r = n.toString(),
e = r.indexOf(".");
if (-1 === e) return Math.round(t);
var i = r.substr(e + 1).length;
return i > 20 && (i = 20), parseFloat(t.toFixed(i));
};
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && t % 1 != 0;
};
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && t % 2 == 0;
};
},
function (t, n, r) {
"use strict";
var e = r(5),
i = Number.isInteger
? Number.isInteger
: function (t) {
return Object(e.a)(t) && t % 1 == 0;
};
n.a = i;
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && t < 0;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n, r) {
return void 0 === r && (r = 1e-5), Math.abs(t - n) < r;
};
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && t % 2 != 0;
};
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && t > 0;
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(0),
u = r(3);
n.a = function (t, n) {
if (Object(i.a)(t)) {
var r,
o,
a = t[0];
return (
(r = Object(u.a)(n) ? n(t[0]) : t[0][n]),
Object(e.a)(t, function (t) {
(o = Object(u.a)(n) ? n(t) : t[n]) > r &&
((a = t), (r = o));
}),
a
);
}
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(0),
u = r(3);
n.a = function (t, n) {
if (Object(i.a)(t)) {
var r,
o,
a = t[0];
return (
(r = Object(u.a)(n) ? n(t[0]) : t[0][n]),
Object(e.a)(t, function (t) {
(o = Object(u.a)(n) ? n(t) : t[n]) < r &&
((a = t), (r = o));
}),
a
);
}
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
return ((t % n) + n) % n;
};
},
function (t, n, r) {
"use strict";
var e = 180 / Math.PI;
n.a = function (t) {
return e * t;
};
},
function (t, n, r) {
"use strict";
n.a = parseInt;
},
function (t, n, r) {
"use strict";
var e = Math.PI / 180;
n.a = function (t) {
return e * t;
};
},
function (t, n, r) {
"use strict";
var e = r(2);
n.a = e.a;
},
function (t, n, r) {
"use strict";
var e = r(25);
n.a = e.a;
},
function (t, n, r) {
"use strict";
var e = r(12),
i = r(26);
n.a = function (t, n) {
return Object(e.a)(Object(i.a)(t), n);
};
},
function (t, n, r) {
"use strict";
var e = r(10);
n.a = function (t) {
return Object(e.a)(t).toLowerCase();
};
},
function (t, n, r) {
"use strict";
var e = r(10);
n.a = function (t) {
var n = Object(e.a)(t);
return n.charAt(0).toLowerCase() + n.substring(1);
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n) {
return t && n
? t.replace(/\\?\{([^{}]+)\}/g, function (t, r) {
return "\\" === t.charAt(0)
? t.slice(1)
: void 0 === n[r]
? ""
: n[r];
})
: t;
};
},
function (t, n, r) {
"use strict";
var e = r(10);
n.a = function (t) {
return Object(e.a)(t).toUpperCase();
};
},
function (t, n, r) {
"use strict";
var e = r(10);
n.a = function (t) {
var n = Object(e.a)(t);
return n.charAt(0).toUpperCase() + n.substring(1);
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Arguments");
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Boolean");
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Date");
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "Error");
};
},
function (t, n, r) {
"use strict";
var e = r(5);
n.a = function (t) {
return Object(e.a)(t) && isFinite(t);
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return null === t;
};
},
function (t, n, r) {
"use strict";
var e = r(4);
n.a = function (t) {
return Object(e.a)(t, "RegExp");
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return void 0 === t;
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return t instanceof Element || t instanceof HTMLDocument;
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return (
window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
window.msRequestAnimationFrame ||
function (t) {
return setTimeout(t, 16);
}
)(t);
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
(
window.cancelAnimationFrame ||
window.webkitCancelAnimationFrame ||
window.mozCancelAnimationFrame ||
window.msCancelAnimationFrame ||
clearTimeout
)(t);
};
},
function (t, n, r) {
"use strict";
var e = r(16),
i = r(3);
n.a = function () {
for (var t = [], n = 0; n < arguments.length; n++)
t[n] = arguments[n];
for (var r = t[0], u = 1; u < t.length; u++) {
var o = t[u];
Object(i.a)(o) && (o = o.prototype),
Object(e.a)(r.prototype, o);
}
};
},
function (t, n, r) {
"use strict";
var e = r(0);
n.a = function t(n) {
if ("object" !== o(n) || null === n) return n;
var r;
if (Object(e.a)(n)) {
r = [];
for (var i = 0, u = n.length; i < u; i++)
"object" === o(n[i]) && null != n[i]
? (r[i] = t(n[i]))
: (r[i] = n[i]);
} else
for (var a in ((r = {}), n))
"object" === o(n[a]) && null != n[a]
? (r[a] = t(n[a]))
: (r[a] = n[a]);
return r;
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n, r) {
var e;
return function () {
var i = this,
u = arguments,
o = function () {
(e = null), r || t.apply(i, u);
},
a = r && !e;
clearTimeout(e), (e = setTimeout(o, n)), a && t.apply(i, u);
};
};
},
function (t, n, r) {
"use strict";
var e = r(3);
n.a = function (t, n) {
if (!Object(e.a)(t))
throw new TypeError("Expected a function");
var r = function r() {
for (var e = [], i = 0; i < arguments.length; i++)
e[i] = arguments[i];
var u = n ? n.apply(this, e) : e[0],
o = r.cache;
if (o.has(u)) return o.get(u);
var a = t.apply(this, e);
return o.set(u, a), a;
};
return (r.cache = new Map()), r;
};
},
function (t, n, r) {
"use strict";
var e = r(0),
i = r(9);
function u(t, n, r, o) {
for (var a in ((r = r || 0), (o = o || 5), n))
if (n.hasOwnProperty(a)) {
var c = n[a];
null !== c && Object(i.a)(c)
? (Object(i.a)(t[a]) || (t[a] = {}),
r < o ? u(t[a], c, r + 1, o) : (t[a] = n[a]))
: Object(e.a)(c)
? ((t[a] = []), (t[a] = t[a].concat(c)))
: void 0 !== c && (t[a] = c);
}
}
n.a = function (t) {
for (var n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
for (var e = 0; e < n.length; e += 1) u(t, n[e]);
return t;
};
},
function (t, n, r) {
"use strict";
var e = r(16),
i = r(3);
n.a = function (t, n, r, u) {
Object(i.a)(n) || ((r = n), (n = t), (t = function () {}));
var o = Object.create
? function (t, n) {
return Object.create(t, {
constructor: { value: n },
});
}
: function (t, n) {
function r() {}
r.prototype = t;
var e = new r();
return (e.constructor = n), e;
},
a = o(n.prototype, t);
return (
(t.prototype = Object(e.a)(a, t.prototype)),
(t.superclass = o(n.prototype, n)),
Object(e.a)(a, r),
Object(e.a)(t, u),
t
);
};
},
function (t, n, r) {
"use strict";
var e = r(1);
n.a = function (t, n) {
if (!Object(e.a)(t)) return -1;
var r = Array.prototype.indexOf;
if (r) return r.call(t, n);
for (var i = -1, u = 0; u < t.length; u++)
if (t[u] === n) {
i = u;
break;
}
return i;
};
},
function (t, n, r) {
"use strict";
var e = r(6),
i = r(1),
u = r(27),
o = r(28),
a = Object.prototype.hasOwnProperty;
n.a = function (t) {
if (Object(e.a)(t)) return !0;
if (Object(i.a)(t)) return !t.length;
var n = Object(u.a)(t);
if ("Map" === n || "Set" === n) return !t.size;
if (Object(o.a)(t)) return !Object.keys(t).length;
for (var r in t) if (a.call(t, r)) return !1;
return !0;
};
},
function (t, n, r) {
"use strict";
var e = r(3),
i = r(29);
n.a = function (t, n, r) {
return Object(e.a)(r) ? !!r(t, n) : Object(i.a)(t, n);
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(1);
n.a = function (t, n) {
if (!Object(i.a)(t)) return t;
var r = [];
return (
Object(e.a)(t, function (t, e) {
r.push(n(t, e));
}),
r
);
};
},
function (t, n, r) {
"use strict";
var e = r(6),
i = r(13),
u = function (t) {
return t;
};
n.a = function (t, n) {
void 0 === n && (n = u);
var r = {};
return (
Object(i.a)(t) &&
!Object(e.a)(t) &&
Object.keys(t).forEach(function (e) {
r[e] = n(t[e], e);
}),
r
);
};
},
function (t, n, r) {
"use strict";
var e = r(8);
n.a = function (t, n, r) {
for (
var i = 0, u = Object(e.a)(n) ? n.split(".") : n;
t && i < u.length;
)
t = t[u[i++]];
return void 0 === t || i < u.length ? r : t;
};
},
function (t, n, r) {
"use strict";
var e = r(13),
i = r(8),
u = r(5);
n.a = function (t, n, r) {
var o = t,
a = Object(i.a)(n) ? n.split(".") : n;
return (
a.forEach(function (t, n) {
n < a.length - 1
? (Object(e.a)(o[t]) ||
(o[t] = Object(u.a)(a[n + 1]) ? [] : {}),
(o = o[t]))
: (o[t] = r);
}),
t
);
};
},
function (t, n, r) {
"use strict";
var e = r(2),
i = r(9),
u = Object.prototype.hasOwnProperty;
n.a = function (t, n) {
if (null === t || !Object(i.a)(t)) return {};
var r = {};
return (
Object(e.a)(n, function (n) {
u.call(t, n) && (r[n] = t[n]);
}),
r
);
};
},
function (t, n, r) {
"use strict";
n.a = function (t, n, r) {
var e,
i,
u,
o,
a = 0;
r || (r = {});
var c = function () {
(a = !1 === r.leading ? 0 : Date.now()),
(e = null),
(o = t.apply(i, u)),
e || (i = u = null);
},
f = function () {
var f = Date.now();
a || !1 !== r.leading || (a = f);
var s = n - (f - a);
return (
(i = this),
(u = arguments),
s <= 0 || s > n
? (e && (clearTimeout(e), (e = null)),
(a = f),
(o = t.apply(i, u)),
e || (i = u = null))
: e || !1 === r.trailing || (e = setTimeout(c, s)),
o
);
};
return (
(f.cancel = function () {
clearTimeout(e), (a = 0), (e = i = u = null);
}),
f
);
};
},
function (t, n, r) {
"use strict";
var e = r(1);
n.a = function (t) {
return Object(e.a)(t) ? Array.prototype.slice.call(t) : [];
};
},
function (t, n, r) {
"use strict";
var e = {};
n.a = function (t) {
return e[(t = t || "g")] ? (e[t] += 1) : (e[t] = 1), t + e[t];
};
},
function (t, n, r) {
"use strict";
n.a = function () {};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return t;
};
},
function (t, n, r) {
"use strict";
n.a = function (t) {
return Object(e.a)(t)
? 0
: Object(i.a)(t)
? t.length
: Object.keys(t).length;
};
var e = r(6),
i = r(1);
},
function (t, n, r) {
"use strict";
var e = (function () {
function t() {
this.map = {};
}
return (
(t.prototype.has = function (t) {
return void 0 !== this.map[t];
}),
(t.prototype.get = function (t, n) {
var r = this.map[t];
return void 0 === r ? n : r;
}),
(t.prototype.set = function (t, n) {
this.map[t] = n;
}),
(t.prototype.clear = function () {
this.map = {};
}),
(t.prototype.delete = function (t) {
delete this.map[t];
}),
(t.prototype.size = function () {
return Object.keys(this.map).length;
}),
t
);
})();
n.a = e;
},
function (t, n) {
function r(t, n, r, e) {
void 0 === e && (e = []);
var i = this;
(i.w = t || 0),
(i.h = n || 0),
(i.y = r || 0),
(i.x = 0),
(i.c = e || []),
(i.cs = e.length),
(i.prelim = 0),
(i.mod = 0),
(i.shift = 0),
(i.change = 0),
(i.tl = null),
(i.tr = null),
(i.el = null),
(i.er = null),
(i.msel = 0),
(i.mser = 0);
}
function e(t, n) {
var r = (function t(n, r) {
var e = r ? n.y : n.x;
return (
n.children.forEach(function (n) {
e = Math.min(t(n, r), e);
}),
e
);
})(t, n);
!(function t(n, r, e) {
e ? (n.y += r) : (n.x += r),
n.children.forEach(function (n) {
t(n, r, e);
});
})(t, -r, n);
}
(r.fromNode = function (t, n) {
if (!t) return null;
var e = [];
return (
t.children.forEach(function (t) {
e.push(r.fromNode(t, n));
}),
n
? new r(t.height, t.width, t.x, e)
: new r(t.width, t.height, t.y, e)
);
}),
(t.exports = function (t, n) {
void 0 === n && (n = {});
var i = n.isHorizontal;
function u(t) {
0 === t.cs
? ((t.el = t), (t.er = t), (t.msel = t.mser = 0))
: ((t.el = t.c[0].el),
(t.msel = t.c[0].msel),
(t.er = t.c[t.cs - 1].er),
(t.mser = t.c[t.cs - 1].mser));
}
function o(t, n, r) {
for (
var e = t.c[n - 1], i = e.mod, u = t.c[n], o = u.mod;
null !== e && null !== u;
) {
s(e) > r.low && (r = r.nxt);
var l = i + e.prelim + e.w - (o + u.prelim);
l > 0 && ((o += l), a(t, n, r.index, l));
var d = s(e),
h = s(u);
d <= h && null !== (e = f(e)) && (i += e.mod),
d >= h && null !== (u = c(u)) && (o += u.mod);
}
!e && u
? (function (t, n, r, e) {
var i = t.c[0].el;
i.tl = r;
var u = e - r.mod - t.c[0].msel;
(i.mod += u),
(i.prelim -= u),
(t.c[0].el = t.c[n].el),
(t.c[0].msel = t.c[n].msel);
})(t, n, u, o)
: e &&
!u &&
(function (t, n, r, e) {
var i = t.c[n].er;
i.tr = r;
var u = e - r.mod - t.c[n].mser;
(i.mod += u),
(i.prelim -= u),
(t.c[n].er = t.c[n - 1].er),
(t.c[n].mser = t.c[n - 1].mser);
})(t, n, e, i);
}
function a(t, n, r, e) {
(t.c[n].mod += e),
(t.c[n].msel += e),
(t.c[n].mser += e),
(function (t, n, r, e) {
if (r !== n - 1) {
var i = n - r;
(t.c[r + 1].shift += e / i),
(t.c[n].shift -= e / i),
(t.c[n].change -= e - e / i);
}
})(t, n, r, e);
}
function c(t) {
return 0 === t.cs ? t.tl : t.c[0];
}
function f(t) {
return 0 === t.cs ? t.tr : t.c[t.cs - 1];
}
function s(t) {
return t.y + t.h;
}
function l(t, n, r) {
for (; null !== r && t >= r.low; ) r = r.nxt;
return { low: t, index: n, nxt: r };
}
!(function t(n, r, e) {
void 0 === e && (e = 0),
r
? ((n.x = e), (e += n.width))
: ((n.y = e), (e += n.height)),
n.children.forEach(function (n) {
t(n, r, e);
});
})(t, i);
var d = r.fromNode(t, i);
return (
(function t(n) {
if (0 !== n.cs) {
t(n.c[0]);
for (
var r = l(s(n.c[0].el), 0, null), e = 1;
e < n.cs;
++e
) {
t(n.c[e]);
var i = s(n.c[e].er);
o(n, e, r), (r = l(i, e, r));
}
!(function (t) {
t.prelim =
(t.c[0].prelim +
t.c[0].mod +
t.c[t.cs - 1].mod +
t.c[t.cs - 1].prelim +
t.c[t.cs - 1].w) /
2 -
t.w / 2;
})(n),
u(n);
} else u(n);
})(d),
(function t(n, r) {
(r += n.mod),
(n.x = n.prelim + r),
(function (t) {
for (var n = 0, r = 0, e = 0; e < t.cs; e++)
(n += t.c[e].shift),
(r += n + t.c[e].change),
(t.c[e].mod += r);
})(n);
for (var e = 0; e < n.cs; e++) t(n.c[e], r);
})(d, 0),
(function t(n, r, e) {
e ? (r.y = n.x) : (r.x = n.x),
n.c.forEach(function (n, i) {
t(n, r.children[i], e);
});
})(d, t, i),
e(t, i),
t
);
});
},
function (t, n, r) {
var e = r(11),
i = r(115),
u = r(17),
o = r(7),
a = (function (t) {
var n, r;
function e() {
return t.apply(this, arguments) || this;
}
return (
(r = t),
((n = e).prototype = Object.create(r.prototype)),
(n.prototype.constructor = n),
(n.__proto__ = r),
(e.prototype.execute = function () {
return (
(this.rootNode.width = 0),
u(this.rootNode, this.options, i)
);
}),
e
);
})(e),
c = {};
t.exports = function (t, n) {
return (n = o.assign({}, c, n)), new a(t, n).execute();
};
},
function (t, n, r) {
var e = r(7);
function i(t, n) {
void 0 === t && (t = 0), void 0 === n && (n = []);
var r = this;
(r.x = r.y = 0),
(r.leftChild = r.rightChild = null),
(r.height = 0),
(r.children = n);
}
var u = {
isHorizontal: !0,
nodeSep: 20,
nodeSize: 20,
rankSep: 200,
subTreeSep: 10,
};
t.exports = function (t, n) {
void 0 === n && (n = {}), (n = e.assign({}, u, n));
var r,
o = 0,
a = (function t(n) {
if (!n) return null;
(n.width = 0), n.depth && n.depth > o && (o = n.depth);
var r = n.children,
e = r.length,
u = new i(n.height, []);
return (
r.forEach(function (n, r) {
var i = t(n);
u.children.push(i),
0 === r && (u.leftChild = i),
r === e - 1 && (u.rightChild = i);
}),
(u.originNode = n),
(u.isLeaf = n.isLeaf()),
u
);
})(t);
return (
(function t(n) {
if (n.isLeaf || 0 === n.children.length)
n.drawingDepth = o;
else {
var r = n.children.map(function (n) {
return t(n);
}),
e = Math.min.apply(null, r);
n.drawingDepth = e - 1;
}
return n.drawingDepth;
})(a),
(function t(e) {
(e.x = e.drawingDepth * n.rankSep),
e.isLeaf
? ((e.y = 0),
r &&
((e.y = r.y + r.height + n.nodeSep),
e.originNode.parent !== r.originNode.parent &&
(e.y += n.subTreeSep)),
(r = e))
: (e.children.forEach(function (n) {
t(n);
}),
(e.y = (e.leftChild.y + e.rightChild.y) / 2));
})(a),
(function t(n, r, e) {
e
? ((r.x = n.x), (r.y = n.y))
: ((r.x = n.y), (r.y = n.x)),
n.children.forEach(function (n, i) {
t(n, r.children[i], e);
});
})(a, t, n.isHorizontal),
t
);
};
},
function (t, n, r) {
var e = r(11),
i = r(117),
u = r(30),
o = r(7),
a = ["LR", "RL", "H"],
c = a[0],
f = (function (t) {
var n, r;
function e() {
return t.apply(this, arguments) || this;
}
return (
(r = t),
((n = e).prototype = Object.create(r.prototype)),
(n.prototype.constructor = n),
(n.__proto__ = r),
(e.prototype.execute = function () {
var t = this.options,
n = this.rootNode;
t.isHorizontal = !0;
var r = t.indent,
e = void 0 === r ? 20 : r,
o = t.dropCap,
f = void 0 === o || o,
s = t.direction || c;
if (s && -1 === a.indexOf(s))
throw new TypeError("Invalid direction: " + s);
if (s === a[0]) i(n, e, f);
else if (s === a[1]) i(n, e, f), n.right2left();
else if (s === a[2]) {
var l = u(n, t),
d = l.left,
h = l.right;
i(d, e, f), d.right2left(), i(h, e, f);
var p = d.getBoundingBox();
h.translate(p.width, 0), (n.x = h.x - n.width / 2);
}
return n;
}),
e
);
})(e),
s = {};
t.exports = function (t, n) {
return (n = o.assign({}, s, n)), new f(t, n).execute();
};
},
function (t, n) {
t.exports = function (t, n, r) {
var e = null;
t.eachNode(function (t) {
!(function (t, n, r, e) {
var i = "function" == typeof r ? r(t) : r * t.depth;
if (!e)
try {
if (t.id === t.parent.children[0].id)
return (t.x += i), void (t.y = n ? n.y : 0);
} catch (t) {}
(t.x += i), (t.y = n ? n.y + n.height : 0);
})(t, e, n, r),
(e = t);
});
};
},
function (t, n, r) {
var e = r(11),
i = r(119),
u = r(17),
o = r(7),
a = (function (t) {
var n, r;
function e() {
return t.apply(this, arguments) || this;
}
return (
(r = t),
((n = e).prototype = Object.create(r.prototype)),
(n.prototype.constructor = n),
(n.__proto__ = r),
(e.prototype.execute = function () {
return u(this.rootNode, this.options, i);
}),
e
);
})(e),
c = {};
t.exports = function (t, n) {
return (n = o.assign({}, c, n)), new a(t, n).execute();
};
},
function (t, n, r) {
var e = r(7),
i = {
getSubTreeSep: function () {
return 0;
},
};
t.exports = function (t, n) {
void 0 === n && (n = {}),
(n = e.assign({}, i, n)),
(t.parent = { x: 0, width: 0, height: 0, y: 0 }),
t.BFTraverse(function (t) {
t.x = t.parent.x + t.parent.width;
}),
(t.parent = null),
(function t(n, r) {
var e = 0;
return (
n.children.length
? n.children.forEach(function (n) {
e += t(n, r);
})
: (e = n.height),
(n._subTreeSep = r.getSubTreeSep(n.data)),
(n.totalHeight =
Math.max(n.height, e) + 2 * n._subTreeSep),
n.totalHeight
);
})(t, n),
(t.startY = 0),
(t.y = t.totalHeight / 2 - t.height / 2),
t.eachNode(function (t) {
var n = t.children,
r = n.length;
if (r) {
var e = n[0];
if (((e.startY = t.startY + t._subTreeSep), 1 === r))
e.y = t.y + t.height / 2 - e.height / 2;
else {
e.y = e.startY + e.totalHeight / 2 - e.height / 2;
for (var i = 1; i < r; i++) {
var u = n[i];
(u.startY = n[i - 1].startY + n[i - 1].totalHeight),
(u.y =
u.startY + u.totalHeight / 2 - u.height / 2);
}
}
}
}),
(function t(n) {
var r = n.children,
e = r.length;
if (e) {
r.forEach(function (n) {
t(n);
});
var i = r[0],
u = r[e - 1],
o = u.y - i.y + u.height,
a = 0;
if (
(r.forEach(function (t) {
a += t.totalHeight;
}),
o > n.height)
)
n.y = i.y + o / 2 - n.height / 2;
else if (1 !== r.length || n.height > a) {
var c = n.y + (n.height - o) / 2 - i.y;
r.forEach(function (t) {
t.translate(0, c);
});
} else
n.y =
(i.y + i.height / 2 + u.y + u.height / 2) / 2 -
n.height / 2;
}
})(t);
};
},
]);
}),
"object" === o(n) && "object" === o(t)
? (t.exports = u())
: ((e = []),
void 0 ===
(i = "function" == typeof (r = u) ? r.apply(n, e) : r) ||
(t.exports = i));
}).call(this, r(45)(t));
},
}).default;
});
//# sourceMappingURL=treeGraph.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/circularLayout.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.CircularLayout = e())
: (t.CircularLayout = e());
})(this, function () {
return (function (t) {
var e = {};
function r(n) {
if (e[n]) return e[n].exports;
var o = (e[n] = { i: n, l: !1, exports: {} });
return t[n].call(o.exports, o, o.exports, r), (o.l = !0), o.exports;
}
return (
(r.m = t),
(r.c = e),
(r.d = function (t, e, n) {
r.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
}),
(r.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(r.t = function (t, e) {
if ((1 & e && (t = r(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var n = Object.create(null);
if (
(r.r(n),
Object.defineProperty(n, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var o in t)
r.d(
n,
o,
function (e) {
return t[e];
}.bind(null, o),
);
return n;
}),
(r.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return r.d(e, "a", e), e;
}),
(r.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(r.p = ""),
r((r.s = 197))
);
})({
10: function (t, e, r) {
"use strict";
var n =
(this && this.__createBinding) ||
(Object.create
? function (t, e, r, n) {
void 0 === n && (n = r),
Object.defineProperty(t, n, {
enumerable: !0,
get: function () {
return e[r];
},
});
}
: function (t, e, r, n) {
void 0 === n && (n = r), (t[n] = e[r]);
}),
o =
(this && this.__exportStar) ||
function (t, e) {
for (var r in t)
"default" === r ||
Object.prototype.hasOwnProperty.call(e, r) ||
n(e, t, r);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
o(r(11), e),
o(r(12), e),
o(r(13), e),
o(r(14), e),
o(r(15), e),
o(r(16), e);
},
11: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.camelize = e.isString = void 0);
e.isString = function (t) {
return "string" == typeof t;
};
var n,
o,
i = /-(\w)/g;
e.camelize =
((n = function (t) {
return t.replace(i, function (t, e) {
return e ? e.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (t) {
return o[t] || (o[t] = n(t));
});
},
12: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isArray = void 0),
(e.isArray = Array.isArray);
},
13: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.toNumber = e.isNaN = e.isNumber = void 0);
e.isNumber = function (t) {
return "number" == typeof t;
};
e.isNaN = function (t) {
return Number.isNaN(Number(t));
};
e.toNumber = function (t) {
var r = parseFloat(t);
return e.isNaN(r) ? t : r;
};
},
14: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.traverseTreeUp =
e.scaleMatrix =
e.getAdjMatrix =
e.floydWarshall =
e.getDegree =
void 0);
e.getDegree = function (t, e, r) {
for (var n = [], o = 0; o < t; o++) n[o] = 0;
return r
? (r.forEach(function (t) {
t.source && (n[e[t.source]] += 1),
t.target && (n[e[t.target]] += 1);
}),
n)
: n;
};
e.floydWarshall = function (t) {
for (var e = [], r = t.length, n = 0; n < r; n += 1) {
e[n] = [];
for (var o = 0; o < r; o += 1)
n === o
? (e[n][o] = 0)
: 0 !== t[n][o] && t[n][o]
? (e[n][o] = t[n][o])
: (e[n][o] = 1 / 0);
}
for (var i = 0; i < r; i += 1)
for (n = 0; n < r; n += 1)
for (o = 0; o < r; o += 1)
e[n][o] > e[n][i] + e[i][o] && (e[n][o] = e[n][i] + e[i][o]);
return e;
};
e.getAdjMatrix = function (t, e) {
var r = t.nodes,
n = t.edges,
o = [],
i = {};
if (!r) throw new Error("invalid nodes data!");
return (
r &&
r.forEach(function (t, e) {
i[t.id] = e;
o.push([]);
}),
n &&
n.forEach(function (t) {
var r = t.source,
n = t.target,
u = i[r],
s = i[n];
(o[u][s] = 1), e || (o[s][u] = 1);
}),
o
);
};
e.scaleMatrix = function (t, e) {
var r = [];
return (
t.forEach(function (t) {
var n = [];
t.forEach(function (t) {
n.push(t * e);
}),
r.push(n);
}),
r
);
};
e.traverseTreeUp = function (t, e) {
"function" == typeof e &&
(function t(e, r) {
if (e && e.children)
for (var n = e.children.length - 1; n >= 0; n--)
if (!t(e.children[n], r)) return;
return !!r(e);
})(t, e);
};
},
15: function (t, e, r) {
"use strict";
function n(t) {
return (n =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (t) {
for (var e, r = 1, n = arguments.length; r < n; r++)
for (var o in (e = arguments[r]))
Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clone = e.isObject = void 0);
e.isObject = function (t) {
return null !== t && "object" === n(t);
};
e.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var r = [];
return (
t.forEach(function (t) {
r.push(t);
}),
r.map(function (t) {
return e.clone(t);
})
);
}
if ("object" === n(t) && t !== {}) {
var i = o({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = e.clone(i[t]);
}),
i
);
}
return t;
};
},
158: function (t, e, r) {
"use strict";
var n,
o =
(this && this.__extends) ||
((n = function (t, e) {
return (n =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var r in e)
Object.prototype.hasOwnProperty.call(e, r) && (t[r] = e[r]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function r() {
this.constructor = t;
}
n(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((r.prototype = e.prototype), new r()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.CircularLayout = void 0);
var i = r(9),
u = r(10);
function s(t, e) {
var r = t.degree,
n = e.degree;
return r < n ? -1 : r > n ? 1 : 0;
}
var c = (function (t) {
function e(e) {
var r = t.call(this) || this;
return (
(r.radius = null),
(r.startRadius = null),
(r.endRadius = null),
(r.startAngle = 0),
(r.endAngle = 2 * Math.PI),
(r.clockwise = !0),
(r.divisions = 1),
(r.ordering = null),
(r.angleRatio = 1),
(r.nodes = []),
(r.edges = []),
(r.nodeMap = {}),
(r.degrees = []),
(r.width = 300),
(r.height = 300),
r.updateCfg(e),
r
);
}
return (
o(e, t),
(e.prototype.getDefaultCfg = function () {
return {
radius: null,
startRadius: null,
endRadius: null,
startAngle: 0,
endAngle: 2 * Math.PI,
clockwise: !0,
divisions: 1,
ordering: null,
angleRatio: 1,
};
}),
(e.prototype.execute = function () {
var t = this.nodes,
e = this.edges,
r = t.length;
if (0 !== r) {
this.width ||
"undefined" == typeof window ||
(this.width = window.innerWidth),
this.height ||
"undefined" == typeof window ||
(this.height = window.innerHeight),
this.center ||
(this.center = [this.width / 2, this.height / 2]);
var n = this.center;
if (1 === r)
return (
(t[0].x = n[0]),
(t[0].y = n[1]),
void (this.onLayoutEnd && this.onLayoutEnd())
);
var o = this.radius,
i = this.startRadius,
s = this.endRadius,
c = this.divisions,
a = this.startAngle,
f = this.endAngle,
d = (f - a) / r,
l = {};
t.forEach(function (t, e) {
l[t.id] = e;
}),
(this.nodeMap = l);
var h = u.getDegree(t.length, l, e);
(this.degrees = h),
o || i || s
? !i && s
? (i = s)
: i && !s && (s = i)
: (o =
this.height > this.width
? this.width / 2
: this.height / 2);
var p = d * this.angleRatio,
y = this.ordering,
g = [];
g =
"topology" === y
? this.topologyOrdering()
: "topology-directed" === y
? this.topologyOrdering(!0)
: "degree" === y
? this.degreeOrdering()
: t;
for (
var v = this.clockwise, b = Math.ceil(r / c), _ = 0;
_ < r;
++_
) {
var O = o;
O ||
null === i ||
null === s ||
(O = i + (_ * (s - i)) / (r - 1)),
O || (O = 10 + (100 * _) / (r - 1));
var j =
a + (_ % b) * p + ((2 * Math.PI) / c) * Math.floor(_ / b);
v ||
(j =
f - (_ % b) * p - ((2 * Math.PI) / c) * Math.floor(_ / b)),
(g[_].x = n[0] + Math.cos(j) * O),
(g[_].y = n[1] + Math.sin(j) * O),
(g[_].weight = h[_]);
}
return (
this.onLayoutEnd && this.onLayoutEnd(),
{ nodes: g, edges: this.edges }
);
}
this.onLayoutEnd && this.onLayoutEnd();
}),
(e.prototype.topologyOrdering = function (t) {
void 0 === t && (t = !1);
var e = this.degrees,
r = this.edges,
n = this.nodes,
o = u.clone(n),
i = this.nodeMap,
s = [o[0]],
c = [n[0]],
a = [],
f = n.length;
(a[0] = !0),
(function (t, e, r, n) {
t.forEach(function (e, r) {
(t[r].children = []), (t[r].parent = []);
}),
n
? e.forEach(function (e) {
var n = 0;
e.source && (n = r[e.source]);
var o = 0;
e.target && (o = r[e.target]);
var i = t[n].children,
u = t[o].parent;
i.push(t[o].id), u.push(t[n].id);
})
: e.forEach(function (e) {
var n = 0;
e.source && (n = r[e.source]);
var o = 0;
e.target && (o = r[e.target]);
var i = t[n].children,
u = t[o].children;
i.push(t[o].id), u.push(t[n].id);
});
})(o, r, i, t);
var d = 0;
return (
o.forEach(function (t, u) {
if (0 !== u)
if (
(u !== f - 1 &&
e[u] === e[u + 1] &&
!(function (t, e, r) {
for (var n = r.length, o = 0; o < n; o++)
if (
(t.id === r[o].source && e.id === r[o].target) ||
(e.id === r[o].source && t.id === r[o].target)
)
return !0;
return !1;
})(s[d], t, r)) ||
a[u]
) {
for (
var l = s[d].children, h = !1, p = 0;
p < l.length;
p++
) {
var y = i[l[p]];
if (e[y] === e[u] && !a[y]) {
s.push(o[y]),
c.push(n[i[o[y].id]]),
(a[y] = !0),
(h = !0);
break;
}
}
for (
var g = 0;
!h &&
(a[g] ||
(s.push(o[g]),
c.push(n[i[o[g].id]]),
(a[g] = !0),
(h = !0)),
++g !== f);
);
} else s.push(t), c.push(n[i[t.id]]), (a[u] = !0), d++;
}),
c
);
}),
(e.prototype.degreeOrdering = function () {
var t = this.nodes,
e = [],
r = this.degrees;
return (
t.forEach(function (t, n) {
(t.degree = r[n]), e.push(t);
}),
e.sort(s),
e
);
}),
(e.prototype.getType = function () {
return "circular";
}),
e
);
})(i.Base);
e.CircularLayout = c;
},
16: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isFunction = void 0);
e.isFunction = function (t) {
return "function" == typeof t;
};
},
197: function (t, e, r) {
"use strict";
r.r(e);
var n = r(158);
e.default = n.CircularLayout;
},
9: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var n = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = n;
},
}).default;
});
//# sourceMappingURL=circularLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/comboForceLayout.js
================================================
!(function (e, t) {
"object" == typeof exports && "object" == typeof module
? (module.exports = t())
: "function" == typeof define && define.amd
? define([], t)
: "object" == typeof exports
? (exports.ComboForceLayout = t())
: (e.ComboForceLayout = t());
})(this, function () {
return (function (e) {
var t = {};
function o(r) {
if (t[r]) return t[r].exports;
var n = (t[r] = { i: r, l: !1, exports: {} });
return e[r].call(n.exports, n, n.exports, o), (n.l = !0), n.exports;
}
return (
(o.m = e),
(o.c = t),
(o.d = function (e, t, r) {
o.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: r });
}),
(o.r = function (e) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(e, "__esModule", { value: !0 });
}),
(o.t = function (e, t) {
if ((1 & t && (e = o(e)), 8 & t)) return e;
if (4 & t && "object" == typeof e && e && e.__esModule) return e;
var r = Object.create(null);
if (
(o.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: e }),
2 & t && "string" != typeof e)
)
for (var n in e)
o.d(
r,
n,
function (t) {
return e[t];
}.bind(null, n),
);
return r;
}),
(o.n = function (e) {
var t =
e && e.__esModule
? function () {
return e.default;
}
: function () {
return e;
};
return o.d(t, "a", t), t;
}),
(o.o = function (e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}),
(o.p = ""),
o((o.s = 198))
);
})({
10: function (e, t, o) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (e, t, o, r) {
void 0 === r && (r = o),
Object.defineProperty(e, r, {
enumerable: !0,
get: function () {
return t[o];
},
});
}
: function (e, t, o, r) {
void 0 === r && (r = o), (e[r] = t[o]);
}),
n =
(this && this.__exportStar) ||
function (e, t) {
for (var o in e)
"default" === o ||
Object.prototype.hasOwnProperty.call(t, o) ||
r(t, e, o);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
n(o(11), t),
n(o(12), t),
n(o(13), t),
n(o(14), t),
n(o(15), t),
n(o(16), t);
},
11: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.camelize = t.isString = void 0);
t.isString = function (e) {
return "string" == typeof e;
};
var r,
n,
i = /-(\w)/g;
t.camelize =
((r = function (e) {
return e.replace(i, function (e, t) {
return t ? t.toUpperCase() : "";
});
}),
(n = Object.create(null)),
function (e) {
return n[e] || (n[e] = r(e));
});
},
12: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isArray = void 0),
(t.isArray = Array.isArray);
},
13: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.toNumber = t.isNaN = t.isNumber = void 0);
t.isNumber = function (e) {
return "number" == typeof e;
};
t.isNaN = function (e) {
return Number.isNaN(Number(e));
};
t.toNumber = function (e) {
var o = parseFloat(e);
return t.isNaN(o) ? e : o;
};
},
14: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.traverseTreeUp =
t.scaleMatrix =
t.getAdjMatrix =
t.floydWarshall =
t.getDegree =
void 0);
t.getDegree = function (e, t, o) {
for (var r = [], n = 0; n < e; n++) r[n] = 0;
return o
? (o.forEach(function (e) {
e.source && (r[t[e.source]] += 1),
e.target && (r[t[e.target]] += 1);
}),
r)
: r;
};
t.floydWarshall = function (e) {
for (var t = [], o = e.length, r = 0; r < o; r += 1) {
t[r] = [];
for (var n = 0; n < o; n += 1)
r === n
? (t[r][n] = 0)
: 0 !== e[r][n] && e[r][n]
? (t[r][n] = e[r][n])
: (t[r][n] = 1 / 0);
}
for (var i = 0; i < o; i += 1)
for (r = 0; r < o; r += 1)
for (n = 0; n < o; n += 1)
t[r][n] > t[r][i] + t[i][n] && (t[r][n] = t[r][i] + t[i][n]);
return t;
};
t.getAdjMatrix = function (e, t) {
var o = e.nodes,
r = e.edges,
n = [],
i = {};
if (!o) throw new Error("invalid nodes data!");
return (
o &&
o.forEach(function (e, t) {
i[e.id] = t;
n.push([]);
}),
r &&
r.forEach(function (e) {
var o = e.source,
r = e.target,
c = i[o],
a = i[r];
(n[c][a] = 1), t || (n[a][c] = 1);
}),
n
);
};
t.scaleMatrix = function (e, t) {
var o = [];
return (
e.forEach(function (e) {
var r = [];
e.forEach(function (e) {
r.push(e * t);
}),
o.push(r);
}),
o
);
};
t.traverseTreeUp = function (e, t) {
"function" == typeof t &&
(function e(t, o) {
if (t && t.children)
for (var r = t.children.length - 1; r >= 0; r--)
if (!e(t.children[r], o)) return;
return !!o(t);
})(e, t);
};
},
15: function (e, t, o) {
"use strict";
function r(e) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (e) {
return typeof e;
}
: function (e) {
return e &&
"function" == typeof Symbol &&
e.constructor === Symbol &&
e !== Symbol.prototype
? "symbol"
: typeof e;
})(e);
}
var n =
(this && this.__assign) ||
function () {
return (n =
Object.assign ||
function (e) {
for (var t, o = 1, r = arguments.length; o < r; o++)
for (var n in (t = arguments[o]))
Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
return e;
}).apply(this, arguments);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.clone = t.isObject = void 0);
t.isObject = function (e) {
return null !== e && "object" === r(e);
};
t.clone = function (e) {
if (null === e) return e;
if (e instanceof Date) return new Date(e.getTime());
if (e instanceof Array) {
var o = [];
return (
e.forEach(function (e) {
o.push(e);
}),
o.map(function (e) {
return t.clone(e);
})
);
}
if ("object" === r(e) && e !== {}) {
var i = n({}, e);
return (
Object.keys(i).forEach(function (e) {
i[e] = t.clone(i[e]);
}),
i
);
}
return e;
};
},
159: function (e, t, o) {
"use strict";
var r,
n =
(this && this.__extends) ||
((r = function (e, t) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (e, t) {
e.__proto__ = t;
}) ||
function (e, t) {
for (var o in t)
Object.prototype.hasOwnProperty.call(t, o) && (e[o] = t[o]);
})(e, t);
}),
function (e, t) {
if ("function" != typeof t && null !== t)
throw new TypeError(
"Class extends value " +
String(t) +
" is not a constructor or null",
);
function o() {
this.constructor = e;
}
r(e, t),
(e.prototype =
null === t
? Object.create(t)
: ((o.prototype = t.prototype), new o()));
});
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.ComboForceLayout = void 0);
var i = o(9),
c = o(10),
a = (function (e) {
function t(t) {
var o = e.call(this) || this;
return (
(o.center = [0, 0]),
(o.maxIteration = 100),
(o.gravity = 10),
(o.comboGravity = 10),
(o.linkDistance = 10),
(o.alpha = 1),
(o.alphaMin = 0.001),
(o.alphaDecay = 1 - Math.pow(o.alphaMin, 1 / 300)),
(o.alphaTarget = 0),
(o.velocityDecay = 0.6),
(o.edgeStrength = 0.6),
(o.nodeStrength = 30),
(o.preventOverlap = !1),
(o.preventNodeOverlap = !1),
(o.preventComboOverlap = !1),
(o.collideStrength = void 0),
(o.nodeCollideStrength = 0.5),
(o.comboCollideStrength = 0.5),
(o.comboSpacing = 20),
(o.comboPadding = 10),
(o.optimizeRangeFactor = 1),
(o.onTick = function () {}),
(o.onLayoutEnd = function () {}),
(o.depthAttractiveForceScale = 1),
(o.depthRepulsiveForceScale = 2),
(o.nodes = []),
(o.edges = []),
(o.combos = []),
(o.comboTrees = []),
(o.width = 300),
(o.height = 300),
(o.bias = []),
(o.nodeMap = {}),
(o.oriComboMap = {}),
(o.indexMap = {}),
(o.comboMap = {}),
(o.previousLayouted = !1),
o.updateCfg(t),
o
);
}
return (
n(t, e),
(t.prototype.getDefaultCfg = function () {
return {
maxIteration: 100,
center: [0, 0],
gravity: 10,
speed: 1,
comboGravity: 30,
preventOverlap: !1,
preventComboOverlap: !0,
preventNodeOverlap: !0,
nodeSpacing: void 0,
collideStrength: void 0,
nodeCollideStrength: 0.5,
comboCollideStrength: 0.5,
comboSpacing: 20,
comboPadding: 10,
edgeStrength: 0.6,
nodeStrength: 30,
linkDistance: 10,
};
}),
(t.prototype.execute = function () {
var e = this.nodes,
t = this.center;
if (
((this.comboTree = {
id: "comboTreeRoot",
depth: -1,
children: this.comboTrees,
}),
e && 0 !== e.length)
) {
if (1 === e.length)
return (
(e[0].x = t[0]),
(e[0].y = t[1]),
void (this.onLayoutEnd && this.onLayoutEnd())
);
this.initVals(),
this.run(),
this.onLayoutEnd && this.onLayoutEnd();
} else this.onLayoutEnd && this.onLayoutEnd();
}),
(t.prototype.run = function () {
var e = this,
t = e.nodes,
o = e.previousLayouted ? e.maxIteration / 5 : e.maxIteration;
e.width ||
"undefined" == typeof window ||
(e.width = window.innerWidth),
e.height ||
"undefined" == typeof window ||
(e.height = window.innerHeight);
var r = e.center,
n = e.velocityDecay,
i = e.comboMap;
e.previousLayouted || e.initPos(i);
for (
var a = function (o) {
var r = [];
t.forEach(function (e, t) {
r[t] = { x: 0, y: 0 };
}),
e.applyCalculate(r),
e.applyComboCenterForce(r),
t.forEach(function (e, t) {
c.isNumber(e.x) &&
c.isNumber(e.y) &&
((e.x += r[t].x * n), (e.y += r[t].y * n));
}),
(e.alpha += (e.alphaTarget - e.alpha) * e.alphaDecay),
e.onTick();
},
u = 0;
u < o;
u++
)
a();
var s = [0, 0];
t.forEach(function (e) {
c.isNumber(e.x) &&
c.isNumber(e.y) &&
((s[0] += e.x), (s[1] += e.y));
}),
(s[0] /= t.length),
(s[1] /= t.length);
var d = [r[0] - s[0], r[1] - s[1]];
t.forEach(function (e, t) {
c.isNumber(e.x) &&
c.isNumber(e.y) &&
((e.x += d[0]), (e.y += d[1]));
}),
e.combos.forEach(function (e) {
var t = i[e.id];
t && t.empty && ((e.x = t.cx || e.x), (e.y = t.cy || e.y));
}),
(e.previousLayouted = !0);
}),
(t.prototype.initVals = function () {
var e = this.edges,
t = this.nodes,
o = this.combos,
r = {},
n = {},
i = {};
t.forEach(function (e, t) {
(n[e.id] = e), (i[e.id] = t);
}),
(this.nodeMap = n),
(this.indexMap = i);
var a = {};
o.forEach(function (e) {
a[e.id] = e;
}),
(this.oriComboMap = a),
(this.comboMap = this.getComboMap());
var u = this.preventOverlap;
(this.preventComboOverlap = this.preventComboOverlap || u),
(this.preventNodeOverlap = this.preventNodeOverlap || u);
var s = this.collideStrength;
s &&
((this.comboCollideStrength = s),
(this.nodeCollideStrength = s)),
(this.comboCollideStrength = this.comboCollideStrength
? this.comboCollideStrength
: 0),
(this.nodeCollideStrength = this.nodeCollideStrength
? this.nodeCollideStrength
: 0);
for (var d = 0; d < e.length; ++d)
r[e[d].source] ? r[e[d].source]++ : (r[e[d].source] = 1),
r[e[d].target] ? r[e[d].target]++ : (r[e[d].target] = 1);
var f = [];
for (d = 0; d < e.length; ++d)
f[d] = r[e[d].source] / (r[e[d].source] + r[e[d].target]);
this.bias = f;
var p,
h,
l = this.nodeSize,
y = this.nodeSpacing;
if (
((h = c.isNumber(y)
? function () {
return y;
}
: c.isFunction(y)
? y
: function () {
return 0;
}),
(this.nodeSpacing = h),
l)
)
if (c.isFunction(l))
p = function (e) {
return l(e);
};
else if (c.isArray(l)) {
var v = (l[0] > l[1] ? l[0] : l[1]) / 2;
p = function (e) {
return v;
};
} else {
var m = l / 2;
p = function (e) {
return m;
};
}
else
p = function (e) {
return e.size
? c.isArray(e.size)
? (e.size[0] > e.size[1] ? e.size[0] : e.size[1]) / 2
: e.size / 2
: 10;
};
this.nodeSize = p;
var b,
g = this.comboSpacing;
(b = c.isNumber(g)
? function () {
return g;
}
: c.isFunction(g)
? g
: function () {
return 0;
}),
(this.comboSpacing = b);
var x,
S = this.comboPadding;
(x = c.isNumber(S)
? function () {
return S;
}
: c.isArray(S)
? function () {
return Math.max.apply(null, S);
}
: c.isFunction(S)
? S
: function () {
return 0;
}),
(this.comboPadding = x);
var M,
O = this.linkDistance;
O || (O = 10),
(M = c.isNumber(O)
? function (e) {
return O;
}
: O),
(this.linkDistance = M);
var C,
N = this.edgeStrength;
N || (N = 1),
(C = c.isNumber(N)
? function (e) {
return N;
}
: N),
(this.edgeStrength = C);
var E,
_ = this.nodeStrength;
_ || (_ = 30),
(E = c.isNumber(_)
? function (e) {
return _;
}
: _),
(this.nodeStrength = E);
}),
(t.prototype.initPos = function (e) {
this.nodes.forEach(function (t, o) {
var r = t.comboId,
n = e[r];
r && n
? ((t.x = n.cx + 100 / (o + 1)), (t.y = n.cy + 100 / (o + 1)))
: ((t.x = 100 / (o + 1)), (t.y = 100 / (o + 1)));
});
}),
(t.prototype.getComboMap = function () {
var e = this,
t = e.nodeMap,
o = e.indexMap,
r = e.comboTrees,
n = e.oriComboMap,
i = {};
return (
(r || []).forEach(function (r) {
var a = [];
c.traverseTreeUp(r, function (r) {
if ("node" === r.itemType) return !0;
if (!n[r.id]) return !0;
if (void 0 === i[r.id]) {
var u = {
id: r.id,
name: r.id,
cx: 0,
cy: 0,
count: 0,
depth: e.oriComboMap[r.id].depth,
children: [],
};
i[r.id] = u;
}
var s = r.children;
s &&
s.forEach(function (e) {
if (!i[e.id] && !t[e.id]) return !0;
a.push(e);
});
var d = i[r.id];
if (((d.cx = 0), (d.cy = 0), 0 === a.length)) {
d.empty = !0;
var f = n[r.id],
p = Object.keys(t).length,
h = r.id + "-visual-child-" + p,
l = {
id: h,
x: f.x,
y: f.y,
depth: d.depth + 1,
itemType: "node",
};
e.nodes.push(l),
(t[h] = l),
(o[h] = p),
(d.cx = f.x),
(d.cy = f.y),
a.push(l);
}
return (
a.forEach(function (e) {
if ((d.count++, "node" !== e.itemType)) {
var o = i[e.id];
return (
c.isNumber(o.cx) && (d.cx += o.cx),
void (c.isNumber(o.cy) && (d.cy += o.cy))
);
}
var r = t[e.id];
r &&
(c.isNumber(r.x) && (d.cx += r.x),
c.isNumber(r.y) && (d.cy += r.y));
}),
(d.cx /= d.count),
(d.cy /= d.count),
(d.children = a),
!0
);
});
}),
i
);
}),
(t.prototype.applyComboCenterForce = function (e) {
var t = this.gravity,
o = this.comboGravity || t,
r = this.alpha,
n = this.comboTrees,
i = this.indexMap,
a = this.nodeMap,
u = this.comboMap;
(n || []).forEach(function (t) {
c.traverseTreeUp(t, function (t) {
if ("node" === t.itemType) return !0;
if (!u[t.id]) return !0;
var n = u[t.id],
s = ((n.depth + 1) / 10) * 0.5,
d = n.cx,
f = n.cy;
return (
(n.cx = 0),
(n.cy = 0),
n.children.forEach(function (t) {
if ("node" !== t.itemType) {
var p = u[t.id];
return (
p && c.isNumber(p.cx) && (n.cx += p.cx),
void (p && c.isNumber(p.cy) && (n.cy += p.cy))
);
}
var h = a[t.id],
l = h.x - d || 0.005,
y = h.y - f || 0.005,
v = Math.sqrt(l * l + y * y),
m = i[h.id],
b = ((o * r) / v) * s;
(e[m].x -= l * b),
(e[m].y -= y * b),
c.isNumber(h.x) && (n.cx += h.x),
c.isNumber(h.y) && (n.cy += h.y);
}),
(n.cx /= n.count),
(n.cy /= n.count),
!0
);
});
});
}),
(t.prototype.applyCalculate = function (e) {
var t = this.comboMap,
o = this.nodes,
r = {};
o.forEach(function (e, t) {
o.forEach(function (o, n) {
if (!(t < n)) {
var i = e.x - o.x || 0.005,
c = e.y - o.y || 0.005,
a = i * i + c * c,
u = Math.sqrt(a);
a < 1 && (a = u),
(r[e.id + "-" + o.id] = { vx: i, vy: c, vl2: a, vl: u }),
(r[o.id + "-" + e.id] = {
vl2: a,
vl: u,
vx: -i,
vy: -c,
});
}
});
}),
this.updateComboSizes(t),
this.calRepulsive(e, r),
this.calAttractive(e, r),
this.preventComboOverlap && this.comboNonOverlapping(e, t);
}),
(t.prototype.updateComboSizes = function (e) {
var t = this,
o = t.comboTrees,
r = t.nodeMap,
n = t.nodeSize,
i = t.comboSpacing,
a = t.comboPadding;
(o || []).forEach(function (o) {
var u = [];
c.traverseTreeUp(o, function (o) {
if ("node" === o.itemType) return !0;
var s = e[o.id];
if (!s) return !1;
var d = o.children;
d &&
d.forEach(function (t) {
(e[t.id] || r[t.id]) && u.push(t);
}),
(s.minX = 1 / 0),
(s.minY = 1 / 0),
(s.maxX = -1 / 0),
(s.maxY = -1 / 0),
u.forEach(function (e) {
if ("node" !== e.itemType) return !0;
var t = r[e.id];
if (!t) return !0;
var o = n(t),
i = t.x - o,
c = t.y - o,
a = t.x + o,
u = t.y + o;
s.minX > i && (s.minX = i),
s.minY > c && (s.minY = c),
s.maxX < a && (s.maxX = a),
s.maxY < u && (s.maxY = u);
});
var f = t.oriComboMap[o.id].size || 10;
c.isArray(f) && (f = f[0]);
var p = Math.max(s.maxX - s.minX, s.maxY - s.minY, f);
return (s.r = p / 2 + i(s) / 2 + a(s)), !0;
});
});
}),
(t.prototype.comboNonOverlapping = function (e, t) {
var o = this.comboTree,
r = this.comboCollideStrength,
n = this.indexMap,
i = this.nodeMap;
c.traverseTreeUp(o, function (o) {
if (!t[o.id] && !i[o.id] && "comboTreeRoot" !== o.id) return !1;
var c = o.children;
return (
c &&
c.length > 1 &&
c.forEach(function (o, a) {
if ("node" === o.itemType) return !1;
var u = t[o.id];
u &&
c.forEach(function (c, s) {
if (a <= s) return !1;
if ("node" === c.itemType) return !1;
var d = t[c.id];
if (!d) return !1;
var f = u.cx - d.cx || 0.005,
p = u.cy - d.cy || 0.005,
h = f * f + p * p,
l = u.r,
y = d.r,
v = l + y,
m = y * y,
b = l * l;
if (h < v * v) {
var g = o.children;
if (!g || 0 === g.length) return !1;
var x = c.children;
if (!x || 0 === x.length) return !1;
var S = Math.sqrt(h),
M = ((v - S) / S) * r,
O = f * M,
C = p * M,
N = m / (b + m),
E = 1 - N;
g.forEach(function (t) {
if ("node" !== t.itemType) return !1;
if (i[t.id]) {
var o = n[t.id];
x.forEach(function (t) {
if ("node" !== t.itemType) return !1;
if (!i[t.id]) return !1;
var r = n[t.id];
(e[o].x += O * N),
(e[o].y += C * N),
(e[r].x -= O * E),
(e[r].y -= C * E);
});
}
});
}
});
}),
!0
);
});
}),
(t.prototype.calRepulsive = function (e, t) {
var o = this,
r = o.nodes,
n = o.width * o.optimizeRangeFactor,
i = o.nodeStrength,
c = o.alpha,
a = o.nodeCollideStrength,
u = o.preventNodeOverlap,
s = o.nodeSize,
d = o.nodeSpacing,
f = o.depthRepulsiveForceScale,
p = o.center;
r.forEach(function (h, l) {
if (h.x && h.y) {
if (p) {
var y = o.gravity,
v = h.x - p[0] || 0.005,
m = h.y - p[1] || 0.005,
b = Math.sqrt(v * v + m * m);
(e[l].x -= (v * y * c) / b), (e[l].y -= (m * y * c) / b);
}
r.forEach(function (o, r) {
if (l !== r && o.x && o.y) {
var p = t[h.id + "-" + o.id],
y = p.vl2,
v = p.vl;
if (!(v > n)) {
var m = t[h.id + "-" + o.id],
b = m.vx,
g = m.vy,
x =
Math.log(Math.abs(o.depth - h.depth) / 10) + 1 || 1;
(x = x < 1 ? 1 : x),
o.comboId !== h.comboId && (x += 1);
var S = x ? Math.pow(f, x) : 1,
M = ((i(o) * c) / y) * S;
if (
((e[l].x += b * M), (e[l].y += g * M), l < r && u)
) {
var O = s(h) + d(h),
C = s(o) + d(o),
N = O + C;
if (y < N * N) {
var E = ((N - v) / v) * a,
_ = C * C,
j = _ / (O * O + _),
T = b * E,
w = g * E;
(e[l].x += T * j),
(e[l].y += w * j),
(j = 1 - j),
(e[r].x -= T * j),
(e[r].y -= w * j);
}
}
}
}
});
}
});
}),
(t.prototype.calAttractive = function (e, t) {
var o = this,
r = o.edges,
n = o.linkDistance,
i = o.alpha,
a = o.edgeStrength,
u = o.bias,
s = o.depthAttractiveForceScale;
r.forEach(function (r, d) {
if (r.source && r.target && r.source !== r.target) {
var f = o.indexMap[r.source],
p = o.indexMap[r.target],
h = o.nodeMap[r.source],
l = o.nodeMap[r.target];
if (h && l) {
var y = Math.log(Math.abs(h.depth - l.depth) / 10);
h.comboId === l.comboId && (y /= 2);
var v = y ? Math.pow(s, y) : 1;
if (
(h.comboId !== l.comboId && 1 === v
? (v = s / 2)
: h.comboId === l.comboId && (v = 2),
c.isNumber(l.x) &&
c.isNumber(h.x) &&
c.isNumber(l.y) &&
c.isNumber(h.y))
) {
var m = t[r.target + "-" + r.source],
b = m.vl,
g = m.vx,
x = m.vy,
S = ((b - n(r)) / b) * i * a(r) * v,
M = g * S,
O = x * S,
C = u[d];
(e[p].x -= M * C),
(e[p].y -= O * C),
(e[f].x += M * (1 - C)),
(e[f].y += O * (1 - C));
}
}
}
});
}),
(t.prototype.getType = function () {
return "comboForce";
}),
t
);
})(i.Base);
t.ComboForceLayout = a;
},
16: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isFunction = void 0);
t.isFunction = function (e) {
return "function" == typeof e;
};
},
198: function (e, t, o) {
"use strict";
o.r(t);
var r = o(159);
t.default = r.ComboForceLayout;
},
9: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }), (t.Base = void 0);
var r = (function () {
function e() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(e.prototype.layout = function (e) {
return this.init(e), this.execute(!0);
}),
(e.prototype.init = function (e) {
(this.nodes = e.nodes || []),
(this.edges = e.edges || []),
(this.combos = e.combos || []);
}),
(e.prototype.execute = function (e) {}),
(e.prototype.executeWithWorker = function () {}),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.updateCfg = function (e) {
e && Object.assign(this, e);
}),
(e.prototype.getType = function () {
return "base";
}),
(e.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
e
);
})();
t.Base = r;
},
}).default;
});
//# sourceMappingURL=comboForceLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/concentricLayout.js
================================================
!(function (e, t) {
"object" == typeof exports && "object" == typeof module
? (module.exports = t())
: "function" == typeof define && define.amd
? define([], t)
: "object" == typeof exports
? (exports.ConcentricLayout = t())
: (e.ConcentricLayout = t());
})(this, function () {
return (function (e) {
var t = {};
function n(r) {
if (t[r]) return t[r].exports;
var o = (t[r] = { i: r, l: !1, exports: {} });
return e[r].call(o.exports, o, o.exports, n), (o.l = !0), o.exports;
}
return (
(n.m = e),
(n.c = t),
(n.d = function (e, t, r) {
n.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: r });
}),
(n.r = function (e) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(e, "__esModule", { value: !0 });
}),
(n.t = function (e, t) {
if ((1 & t && (e = n(e)), 8 & t)) return e;
if (4 & t && "object" == typeof e && e && e.__esModule) return e;
var r = Object.create(null);
if (
(n.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: e }),
2 & t && "string" != typeof e)
)
for (var o in e)
n.d(
r,
o,
function (t) {
return e[t];
}.bind(null, o),
);
return r;
}),
(n.n = function (e) {
var t =
e && e.__esModule
? function () {
return e.default;
}
: function () {
return e;
};
return n.d(t, "a", t), t;
}),
(n.o = function (e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}),
(n.p = ""),
n((n.s = 199))
);
})({
10: function (e, t, n) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (e, t, n, r) {
void 0 === r && (r = n),
Object.defineProperty(e, r, {
enumerable: !0,
get: function () {
return t[n];
},
});
}
: function (e, t, n, r) {
void 0 === r && (r = n), (e[r] = t[n]);
}),
o =
(this && this.__exportStar) ||
function (e, t) {
for (var n in e)
"default" === n ||
Object.prototype.hasOwnProperty.call(t, n) ||
r(t, e, n);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
o(n(11), t),
o(n(12), t),
o(n(13), t),
o(n(14), t),
o(n(15), t),
o(n(16), t);
},
11: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.camelize = t.isString = void 0);
t.isString = function (e) {
return "string" == typeof e;
};
var r,
o,
i = /-(\w)/g;
t.camelize =
((r = function (e) {
return e.replace(i, function (e, t) {
return t ? t.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (e) {
return o[e] || (o[e] = r(e));
});
},
12: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isArray = void 0),
(t.isArray = Array.isArray);
},
13: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.toNumber = t.isNaN = t.isNumber = void 0);
t.isNumber = function (e) {
return "number" == typeof e;
};
t.isNaN = function (e) {
return Number.isNaN(Number(e));
};
t.toNumber = function (e) {
var n = parseFloat(e);
return t.isNaN(n) ? e : n;
};
},
14: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.traverseTreeUp =
t.scaleMatrix =
t.getAdjMatrix =
t.floydWarshall =
t.getDegree =
void 0);
t.getDegree = function (e, t, n) {
for (var r = [], o = 0; o < e; o++) r[o] = 0;
return n
? (n.forEach(function (e) {
e.source && (r[t[e.source]] += 1),
e.target && (r[t[e.target]] += 1);
}),
r)
: r;
};
t.floydWarshall = function (e) {
for (var t = [], n = e.length, r = 0; r < n; r += 1) {
t[r] = [];
for (var o = 0; o < n; o += 1)
r === o
? (t[r][o] = 0)
: 0 !== e[r][o] && e[r][o]
? (t[r][o] = e[r][o])
: (t[r][o] = 1 / 0);
}
for (var i = 0; i < n; i += 1)
for (r = 0; r < n; r += 1)
for (o = 0; o < n; o += 1)
t[r][o] > t[r][i] + t[i][o] && (t[r][o] = t[r][i] + t[i][o]);
return t;
};
t.getAdjMatrix = function (e, t) {
var n = e.nodes,
r = e.edges,
o = [],
i = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (e, t) {
i[e.id] = t;
o.push([]);
}),
r &&
r.forEach(function (e) {
var n = e.source,
r = e.target,
u = i[n],
c = i[r];
(o[u][c] = 1), t || (o[c][u] = 1);
}),
o
);
};
t.scaleMatrix = function (e, t) {
var n = [];
return (
e.forEach(function (e) {
var r = [];
e.forEach(function (e) {
r.push(e * t);
}),
n.push(r);
}),
n
);
};
t.traverseTreeUp = function (e, t) {
"function" == typeof t &&
(function e(t, n) {
if (t && t.children)
for (var r = t.children.length - 1; r >= 0; r--)
if (!e(t.children[r], n)) return;
return !!n(t);
})(e, t);
};
},
15: function (e, t, n) {
"use strict";
function r(e) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (e) {
return typeof e;
}
: function (e) {
return e &&
"function" == typeof Symbol &&
e.constructor === Symbol &&
e !== Symbol.prototype
? "symbol"
: typeof e;
})(e);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (e) {
for (var t, n = 1, r = arguments.length; n < r; n++)
for (var o in (t = arguments[n]))
Object.prototype.hasOwnProperty.call(t, o) && (e[o] = t[o]);
return e;
}).apply(this, arguments);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.clone = t.isObject = void 0);
t.isObject = function (e) {
return null !== e && "object" === r(e);
};
t.clone = function (e) {
if (null === e) return e;
if (e instanceof Date) return new Date(e.getTime());
if (e instanceof Array) {
var n = [];
return (
e.forEach(function (e) {
n.push(e);
}),
n.map(function (e) {
return t.clone(e);
})
);
}
if ("object" === r(e) && e !== {}) {
var i = o({}, e);
return (
Object.keys(i).forEach(function (e) {
i[e] = t.clone(i[e]);
}),
i
);
}
return e;
};
},
16: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isFunction = void 0);
t.isFunction = function (e) {
return "function" == typeof e;
};
},
160: function (e, t, n) {
"use strict";
var r,
o =
(this && this.__extends) ||
((r = function (e, t) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (e, t) {
e.__proto__ = t;
}) ||
function (e, t) {
for (var n in t)
Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
})(e, t);
}),
function (e, t) {
if ("function" != typeof t && null !== t)
throw new TypeError(
"Class extends value " +
String(t) +
" is not a constructor or null",
);
function n() {
this.constructor = e;
}
r(e, t),
(e.prototype =
null === t
? Object.create(t)
: ((n.prototype = t.prototype), new n()));
});
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.ConcentricLayout = void 0);
var i = n(10),
u = (function (e) {
function t(t) {
var n = e.call(this) || this;
return (
(n.nodeSize = 30),
(n.minNodeSpacing = 10),
(n.preventOverlap = !1),
(n.equidistant = !1),
(n.startAngle = 1.5 * Math.PI),
(n.clockwise = !0),
(n.sortBy = "degree"),
(n.nodes = []),
(n.edges = []),
(n.width = 300),
(n.height = 300),
(n.onLayoutEnd = function () {}),
n.updateCfg(t),
n
);
}
return (
o(t, e),
(t.prototype.getDefaultCfg = function () {
return {
nodeSize: 30,
minNodeSpacing: 10,
preventOverlap: !1,
sweep: void 0,
equidistant: !1,
startAngle: 1.5 * Math.PI,
clockwise: !0,
maxLevelDiff: void 0,
sortBy: "degree",
};
}),
(t.prototype.execute = function () {
var e = this,
t = e.nodes,
n = e.edges,
r = t.length;
if (0 !== r) {
e.width ||
"undefined" == typeof window ||
(e.width = window.innerWidth),
e.height ||
"undefined" == typeof window ||
(e.height = window.innerHeight),
e.center || (e.center = [e.width / 2, e.height / 2]);
var o = e.center;
if (1 === r)
return (
(t[0].x = o[0]),
(t[0].y = o[1]),
void (e.onLayoutEnd && e.onLayoutEnd())
);
var u,
c = [];
(u = i.isArray(e.nodeSize)
? Math.max(e.nodeSize[0], e.nodeSize[1])
: e.nodeSize),
t.forEach(function (e) {
c.push(e);
var t = u;
i.isArray(e.size)
? (t = Math.max(e.size[0], e.size[1]))
: i.isNumber(e.size) && (t = e.size),
(u = Math.max(u, t));
}),
(e.clockwise =
void 0 !== e.counterclockwise
? !e.counterclockwise
: e.clockwise);
var a = {},
s = {};
if (
(c.forEach(function (e, t) {
(a[e.id] = e), (s[e.id] = t);
}),
!(
("degree" !== e.sortBy &&
i.isString(e.sortBy) &&
void 0 !== c[0][e.sortBy]) ||
((e.sortBy = "degree"), i.isNumber(t[0].degree))
))
) {
var f = i.getDegree(t.length, s, n);
c.forEach(function (e, t) {
e.degree = f[t];
});
}
c.sort(function (t, n) {
return n[e.sortBy] - t[e.sortBy];
}),
(e.maxValueNode = c[0]),
(e.maxLevelDiff =
e.maxLevelDiff || e.maxValueNode[e.sortBy] / 4);
var d = [[]],
l = d[0];
c.forEach(function (t) {
if (l.length > 0) {
var n = Math.abs(l[0][e.sortBy] - t[e.sortBy]);
e.maxLevelDiff &&
n >= e.maxLevelDiff &&
((l = []), d.push(l));
}
l.push(t);
});
var p = u + e.minNodeSpacing;
if (!e.preventOverlap) {
var h = d.length > 0 && d[0].length > 1,
y =
(Math.min(e.width, e.height) / 2 - p) /
(d.length + (h ? 1 : 0));
p = Math.min(p, y);
}
var v = 0;
if (
(d.forEach(function (t) {
var n = e.sweep;
void 0 === n &&
(n = 2 * Math.PI - (2 * Math.PI) / t.length);
var r = (t.dTheta = n / Math.max(1, t.length - 1));
if (t.length > 1 && e.preventOverlap) {
var o = Math.cos(r) - Math.cos(0),
i = Math.sin(r) - Math.sin(0),
u = Math.sqrt((p * p) / (o * o + i * i));
v = Math.max(u, v);
}
(t.r = v), (v += p);
}),
e.equidistant)
) {
for (var g = 0, b = 0, m = 0; m < d.length; m++) {
var _ = d[m].r - b;
g = Math.max(g, _);
}
(b = 0),
d.forEach(function (e, t) {
0 === t && (b = e.r), (e.r = b), (b += g);
});
}
return (
d.forEach(function (t) {
var n = t.dTheta,
r = t.r;
t.forEach(function (t, i) {
var u = e.startAngle + (e.clockwise ? 1 : -1) * n * i;
(t.x = o[0] + r * Math.cos(u)),
(t.y = o[1] + r * Math.sin(u));
});
}),
e.onLayoutEnd && e.onLayoutEnd(),
{ nodes: t, edges: n }
);
}
e.onLayoutEnd && e.onLayoutEnd();
}),
(t.prototype.getType = function () {
return "concentric";
}),
t
);
})(n(9).Base);
t.ConcentricLayout = u;
},
199: function (e, t, n) {
"use strict";
n.r(t);
var r = n(160);
t.default = r.ConcentricLayout;
},
9: function (e, t, n) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }), (t.Base = void 0);
var r = (function () {
function e() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(e.prototype.layout = function (e) {
return this.init(e), this.execute(!0);
}),
(e.prototype.init = function (e) {
(this.nodes = e.nodes || []),
(this.edges = e.edges || []),
(this.combos = e.combos || []);
}),
(e.prototype.execute = function (e) {}),
(e.prototype.executeWithWorker = function () {}),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.updateCfg = function (e) {
e && Object.assign(this, e);
}),
(e.prototype.getType = function () {
return "base";
}),
(e.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
e
);
})();
t.Base = r;
},
}).default;
});
//# sourceMappingURL=concentricLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/dagreLayout.js
================================================
!(function (t, n) {
"object" == typeof exports && "object" == typeof module
? (module.exports = n())
: "function" == typeof define && define.amd
? define([], n)
: "object" == typeof exports
? (exports.DagreLayout = n())
: (t.DagreLayout = n());
})(this, function () {
return (function (t) {
var n = {};
function e(r) {
if (n[r]) return n[r].exports;
var o = (n[r] = { i: r, l: !1, exports: {} });
return t[r].call(o.exports, o, o.exports, e), (o.l = !0), o.exports;
}
return (
(e.m = t),
(e.c = n),
(e.d = function (t, n, r) {
e.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: r });
}),
(e.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(e.t = function (t, n) {
if ((1 & n && (t = e(t)), 8 & n)) return t;
if (4 & n && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(e.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & n && "string" != typeof t)
)
for (var o in t)
e.d(
r,
o,
function (n) {
return t[n];
}.bind(null, o),
);
return r;
}),
(e.n = function (t) {
var n =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return e.d(n, "a", n), n;
}),
(e.o = function (t, n) {
return Object.prototype.hasOwnProperty.call(t, n);
}),
(e.p = ""),
e((e.s = 200))
);
})([
,
,
,
,
,
,
,
,
function (t, n, e) {
var r;
try {
r = {
cloneDeep: e(316),
constant: e(89),
defaults: e(317),
each: e(121),
filter: e(124),
find: e(318),
flatten: e(151),
forEach: e(122),
forIn: e(325),
has: e(135),
isUndefined: e(136),
last: e(326),
map: e(137),
mapValues: e(327),
max: e(328),
merge: e(330),
min: e(336),
minBy: e(337),
now: e(338),
pick: e(339),
range: e(344),
reduce: e(139),
sortBy: e(347),
uniqueId: e(352),
values: e(144),
zipObject: e(353),
};
} catch (t) {}
r || (r = window._), (t.exports = r);
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }), (n.Base = void 0);
var r = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
n.Base = r;
},
function (t, n, e) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, n, e, r) {
void 0 === r && (r = e),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return n[e];
},
});
}
: function (t, n, e, r) {
void 0 === r && (r = e), (t[r] = n[e]);
}),
o =
(this && this.__exportStar) ||
function (t, n) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(n, e) ||
r(n, t, e);
};
Object.defineProperty(n, "__esModule", { value: !0 }),
o(e(11), n),
o(e(12), n),
o(e(13), n),
o(e(14), n),
o(e(15), n),
o(e(16), n);
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.camelize = n.isString = void 0);
n.isString = function (t) {
return "string" == typeof t;
};
var r,
o,
i = /-(\w)/g;
n.camelize =
((r = function (t) {
return t.replace(i, function (t, n) {
return n ? n.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (t) {
return o[t] || (o[t] = r(t));
});
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.isArray = void 0),
(n.isArray = Array.isArray);
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.toNumber = n.isNaN = n.isNumber = void 0);
n.isNumber = function (t) {
return "number" == typeof t;
};
n.isNaN = function (t) {
return Number.isNaN(Number(t));
};
n.toNumber = function (t) {
var e = parseFloat(t);
return n.isNaN(e) ? t : e;
};
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.traverseTreeUp =
n.scaleMatrix =
n.getAdjMatrix =
n.floydWarshall =
n.getDegree =
void 0);
n.getDegree = function (t, n, e) {
for (var r = [], o = 0; o < t; o++) r[o] = 0;
return e
? (e.forEach(function (t) {
t.source && (r[n[t.source]] += 1),
t.target && (r[n[t.target]] += 1);
}),
r)
: r;
};
n.floydWarshall = function (t) {
for (var n = [], e = t.length, r = 0; r < e; r += 1) {
n[r] = [];
for (var o = 0; o < e; o += 1)
r === o
? (n[r][o] = 0)
: 0 !== t[r][o] && t[r][o]
? (n[r][o] = t[r][o])
: (n[r][o] = 1 / 0);
}
for (var i = 0; i < e; i += 1)
for (r = 0; r < e; r += 1)
for (o = 0; o < e; o += 1)
n[r][o] > n[r][i] + n[i][o] && (n[r][o] = n[r][i] + n[i][o]);
return n;
};
n.getAdjMatrix = function (t, n) {
var e = t.nodes,
r = t.edges,
o = [],
i = {};
if (!e) throw new Error("invalid nodes data!");
return (
e &&
e.forEach(function (t, n) {
i[t.id] = n;
o.push([]);
}),
r &&
r.forEach(function (t) {
var e = t.source,
r = t.target,
u = i[e],
c = i[r];
(o[u][c] = 1), n || (o[c][u] = 1);
}),
o
);
};
n.scaleMatrix = function (t, n) {
var e = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * n);
}),
e.push(r);
}),
e
);
};
n.traverseTreeUp = function (t, n) {
"function" == typeof n &&
(function t(n, e) {
if (n && n.children)
for (var r = n.children.length - 1; r >= 0; r--)
if (!t(n.children[r], e)) return;
return !!e(n);
})(t, n);
};
},
function (t, n, e) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (t) {
for (var n, e = 1, r = arguments.length; e < r; e++)
for (var o in (n = arguments[e]))
Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.clone = n.isObject = void 0);
n.isObject = function (t) {
return null !== t && "object" === r(t);
};
n.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var e = [];
return (
t.forEach(function (t) {
e.push(t);
}),
e.map(function (t) {
return n.clone(t);
})
);
}
if ("object" === r(t) && t !== {}) {
var i = o({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = n.clone(i[t]);
}),
i
);
}
return t;
};
},
function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.isFunction = void 0);
n.isFunction = function (t) {
return "function" == typeof t;
};
},
function (t, n) {
var e = Array.isArray;
t.exports = e;
},
,
function (t, n, e) {
"use strict";
var r = e(8),
o = e(23).Graph;
function i(t, n, e, o) {
var i;
do {
i = r.uniqueId(o);
} while (t.hasNode(i));
return (e.dummy = n), t.setNode(i, e), i;
}
function u(t) {
return r.max(
r.map(t.nodes(), function (n) {
var e = t.node(n).rank;
if (!r.isUndefined(e)) return e;
}),
);
}
t.exports = {
addDummyNode: i,
simplify: function (t) {
var n = new o().setGraph(t.graph());
return (
r.forEach(t.nodes(), function (e) {
n.setNode(e, t.node(e));
}),
r.forEach(t.edges(), function (e) {
var r = n.edge(e.v, e.w) || { weight: 0, minlen: 1 },
o = t.edge(e);
n.setEdge(e.v, e.w, {
weight: r.weight + o.weight,
minlen: Math.max(r.minlen, o.minlen),
});
}),
n
);
},
asNonCompoundGraph: function (t) {
var n = new o({ multigraph: t.isMultigraph() }).setGraph(t.graph());
return (
r.forEach(t.nodes(), function (e) {
t.children(e).length || n.setNode(e, t.node(e));
}),
r.forEach(t.edges(), function (e) {
n.setEdge(e, t.edge(e));
}),
n
);
},
successorWeights: function (t) {
var n = r.map(t.nodes(), function (n) {
var e = {};
return (
r.forEach(t.outEdges(n), function (n) {
e[n.w] = (e[n.w] || 0) + t.edge(n).weight;
}),
e
);
});
return r.zipObject(t.nodes(), n);
},
predecessorWeights: function (t) {
var n = r.map(t.nodes(), function (n) {
var e = {};
return (
r.forEach(t.inEdges(n), function (n) {
e[n.v] = (e[n.v] || 0) + t.edge(n).weight;
}),
e
);
});
return r.zipObject(t.nodes(), n);
},
intersectRect: function (t, n) {
var e,
r,
o = t.x,
i = t.y,
u = n.x - o,
c = n.y - i,
a = t.width / 2,
f = t.height / 2;
if (!u && !c)
throw new Error(
"Not possible to find intersection inside of the rectangle",
);
Math.abs(c) * a > Math.abs(u) * f
? (c < 0 && (f = -f), (e = (f * u) / c), (r = f))
: (u < 0 && (a = -a), (e = a), (r = (a * c) / u));
return { x: o + e, y: i + r };
},
buildLayerMatrix: function (t) {
var n = r.map(r.range(u(t) + 1), function () {
return [];
});
return (
r.forEach(t.nodes(), function (e) {
var o = t.node(e),
i = o.rank;
r.isUndefined(i) || (n[i][o.order] = e);
}),
n
);
},
normalizeRanks: function (t) {
var n = r.min(
r.map(t.nodes(), function (n) {
return t.node(n).rank;
}),
);
r.forEach(t.nodes(), function (e) {
var o = t.node(e);
r.has(o, "rank") && (o.rank -= n);
});
},
removeEmptyRanks: function (t) {
var n = r.min(
r.map(t.nodes(), function (n) {
return t.node(n).rank;
}),
),
e = [];
r.forEach(t.nodes(), function (r) {
var o = t.node(r).rank - n;
e[o] || (e[o] = []), e[o].push(r);
});
var o = 0,
i = t.graph().nodeRankFactor;
r.forEach(e, function (n, e) {
r.isUndefined(n) && e % i != 0
? --o
: o &&
r.forEach(n, function (n) {
t.node(n).rank += o;
});
});
},
addBorderNode: function (t, n, e, r) {
var o = { width: 0, height: 0 };
arguments.length >= 4 && ((o.rank = e), (o.order = r));
return i(t, "border", o, n);
},
maxRank: u,
partition: function (t, n) {
var e = { lhs: [], rhs: [] };
return (
r.forEach(t, function (t) {
n(t) ? e.lhs.push(t) : e.rhs.push(t);
}),
e
);
},
time: function (t, n) {
var e = r.now();
try {
return n();
} finally {
console.log(t + " time: " + (r.now() - e) + "ms");
}
},
notime: function (t, n) {
return n();
},
};
},
function (t, n, e) {
var r;
try {
r = {
clone: e(204),
constant: e(89),
each: e(121),
filter: e(124),
has: e(135),
isArray: e(17),
isEmpty: e(280),
isFunction: e(46),
isUndefined: e(136),
keys: e(31),
map: e(137),
reduce: e(139),
size: e(283),
transform: e(289),
union: e(290),
values: e(144),
};
} catch (t) {}
r || (r = window._), (t.exports = r);
},
function (t, n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
t.exports = function (t) {
var n = e(t);
return null != t && ("object" == n || "function" == n);
};
},
,
function (t, n, e) {
var r;
try {
r = e(202);
} catch (t) {}
r || (r = window.graphlib), (t.exports = r);
},
function (t, n, e) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(104),
i =
"object" == ("undefined" == typeof self ? "undefined" : r(self)) &&
self &&
self.Object === Object &&
self,
u = o || i || Function("return this")();
t.exports = u;
},
function (t, n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
t.exports = function (t) {
return null != t && "object" == e(t);
};
},
,
,
function (t, n, e) {
var r = e(46),
o = e(83);
t.exports = function (t) {
return null != t && o(t.length) && !r(t);
};
},
function (t, n, e) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(260),
i = e(270),
u = e(36),
c = e(17),
a = e(277);
t.exports = function (t) {
return "function" == typeof t
? t
: null == t
? u
: "object" == r(t)
? c(t)
? i(t[0], t[1])
: o(t)
: a(t);
};
},
,
function (t, n, e) {
var r = e(107),
o = e(85),
i = e(28);
t.exports = function (t) {
return i(t) ? r(t) : o(t);
};
},
,
function (t, n, e) {
var r = e(215),
o = e(220);
t.exports = function (t, n) {
var e = o(t, n);
return r(e) ? e : void 0;
};
},
function (t, n, e) {
var r = e(38),
o = e(216),
i = e(217),
u = r ? r.toStringTag : void 0;
t.exports = function (t) {
return null == t
? void 0 === t
? "[object Undefined]"
: "[object Null]"
: u && u in Object(t)
? o(t)
: i(t);
};
},
function (t, n, e) {
var r = e(107),
o = e(240),
i = e(28);
t.exports = function (t) {
return i(t) ? r(t, !0) : o(t);
};
},
function (t, n) {
t.exports = function (t) {
return t;
};
},
function (t, n) {
t.exports = function (t, n) {
return t === n || (t != t && n != n);
};
},
function (t, n, e) {
var r = e(24).Symbol;
t.exports = r;
},
function (t, n, e) {
(function (t) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(24),
i = e(236),
u = "object" == r(n) && n && !n.nodeType && n,
c = u && "object" == r(t) && t && !t.nodeType && t,
a = c && c.exports === u ? o.Buffer : void 0,
f = (a ? a.isBuffer : void 0) || i;
t.exports = f;
}).call(this, e(45)(t));
},
function (t, n, e) {
var r = e(245),
o = e(80),
i = e(246),
u = e(116),
c = e(247),
a = e(34),
f = e(105),
s = f(r),
p = f(o),
d = f(i),
h = f(u),
l = f(c),
v = a;
((r && "[object DataView]" != v(new r(new ArrayBuffer(1)))) ||
(o && "[object Map]" != v(new o())) ||
(i && "[object Promise]" != v(i.resolve())) ||
(u && "[object Set]" != v(new u())) ||
(c && "[object WeakMap]" != v(new c()))) &&
(v = function (t) {
var n = a(t),
e = "[object Object]" == n ? t.constructor : void 0,
r = e ? f(e) : "";
if (r)
switch (r) {
case s:
return "[object DataView]";
case p:
return "[object Map]";
case d:
return "[object Promise]";
case h:
return "[object Set]";
case l:
return "[object WeakMap]";
}
return n;
}),
(t.exports = v);
},
function (t, n, e) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(34),
i = e(25);
t.exports = function (t) {
return "symbol" == r(t) || (i(t) && "[object Symbol]" == o(t));
};
},
,
,
,
function (t, n) {
t.exports = function (t) {
return (
t.webpackPolyfill ||
((t.deprecate = function () {}),
(t.paths = []),
t.children || (t.children = []),
Object.defineProperty(t, "loaded", {
enumerable: !0,
get: function () {
return t.l;
},
}),
Object.defineProperty(t, "id", {
enumerable: !0,
get: function () {
return t.i;
},
}),
(t.webpackPolyfill = 1)),
t
);
};
},
function (t, n, e) {
var r = e(34),
o = e(21);
t.exports = function (t) {
if (!o(t)) return !1;
var n = r(t);
return (
"[object Function]" == n ||
"[object GeneratorFunction]" == n ||
"[object AsyncFunction]" == n ||
"[object Proxy]" == n
);
};
},
function (t, n, e) {
var r = e(59),
o = e(60);
t.exports = function (t, n, e, i) {
var u = !e;
e || (e = {});
for (var c = -1, a = n.length; ++c < a; ) {
var f = n[c],
s = i ? i(e[f], t[f], f, e, t) : void 0;
void 0 === s && (s = t[f]), u ? o(e, f, s) : r(e, f, s);
}
return e;
};
},
function (t, n, e) {
var r = e(235),
o = e(25),
i = Object.prototype,
u = i.hasOwnProperty,
c = i.propertyIsEnumerable,
a = r(
(function () {
return arguments;
})(),
)
? r
: function (t) {
return o(t) && u.call(t, "callee") && !c.call(t, "callee");
};
t.exports = a;
},
function (t, n, e) {
var r = e(237),
o = e(62),
i = e(84),
u = i && i.isTypedArray,
c = u ? o(u) : r;
t.exports = c;
},
function (t, n, e) {
var r = e(41);
t.exports = function (t) {
if ("string" == typeof t || r(t)) return t;
var n = t + "";
return "0" == n && 1 / t == -1 / 0 ? "-0" : n;
};
},
,
,
,
function (t, n, e) {
var r = e(55),
o = e(210),
i = e(211),
u = e(212),
c = e(213),
a = e(214);
function f(t) {
var n = (this.__data__ = new r(t));
this.size = n.size;
}
(f.prototype.clear = o),
(f.prototype.delete = i),
(f.prototype.get = u),
(f.prototype.has = c),
(f.prototype.set = a),
(t.exports = f);
},
function (t, n, e) {
var r = e(205),
o = e(206),
i = e(207),
u = e(208),
c = e(209);
function a(t) {
var n = -1,
e = null == t ? 0 : t.length;
for (this.clear(); ++n < e; ) {
var r = t[n];
this.set(r[0], r[1]);
}
}
(a.prototype.clear = r),
(a.prototype.delete = o),
(a.prototype.get = i),
(a.prototype.has = u),
(a.prototype.set = c),
(t.exports = a);
},
function (t, n, e) {
var r = e(37);
t.exports = function (t, n) {
for (var e = t.length; e--; ) if (r(t[e][0], n)) return e;
return -1;
};
},
function (t, n, e) {
var r = e(33)(Object, "create");
t.exports = r;
},
function (t, n, e) {
var r = e(229);
t.exports = function (t, n) {
var e = t.__data__;
return r(n) ? e["string" == typeof n ? "string" : "hash"] : e.map;
};
},
function (t, n, e) {
var r = e(60),
o = e(37),
i = Object.prototype.hasOwnProperty;
t.exports = function (t, n, e) {
var u = t[n];
(i.call(t, n) && o(u, e) && (void 0 !== e || n in t)) || r(t, n, e);
};
},
function (t, n, e) {
var r = e(106);
t.exports = function (t, n, e) {
"__proto__" == n && r
? r(t, n, {
configurable: !0,
enumerable: !0,
value: e,
writable: !0,
})
: (t[n] = e);
};
},
function (t, n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var r = /^(?:0|[1-9]\d*)$/;
t.exports = function (t, n) {
var o = e(t);
return (
!!(n = null == n ? 9007199254740991 : n) &&
("number" == o || ("symbol" != o && r.test(t))) &&
t > -1 &&
t % 1 == 0 &&
t < n
);
};
},
function (t, n) {
t.exports = function (t) {
return function (n) {
return t(n);
};
};
},
function (t, n) {
var e = Object.prototype;
t.exports = function (t) {
var n = t && t.constructor;
return t === (("function" == typeof n && n.prototype) || e);
};
},
function (t, n, e) {
var r = e(108)(Object.getPrototypeOf, Object);
t.exports = r;
},
function (t, n, e) {
var r = e(90),
o = e(258)(r);
t.exports = o;
},
function (t, n, e) {
var r = e(67),
o = e(50);
t.exports = function (t, n) {
for (var e = 0, i = (n = r(n, t)).length; null != t && e < i; )
t = t[o(n[e++])];
return e && e == i ? t : void 0;
};
},
function (t, n, e) {
var r = e(17),
o = e(93),
i = e(272),
u = e(131);
t.exports = function (t, n) {
return r(t) ? t : o(t, n) ? [t] : i(u(t));
};
},
function (t, n) {
t.exports = function (t, n) {
for (var e = -1, r = null == t ? 0 : t.length, o = Array(r); ++e < r; )
o[e] = n(t[e], e, t);
return o;
};
},
function (t, n, e) {
var r = e(36),
o = e(140),
i = e(141);
t.exports = function (t, n) {
return i(o(t, n, r), t + "");
};
},
function (t, n, e) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(37),
i = e(28),
u = e(61),
c = e(21);
t.exports = function (t, n, e) {
if (!c(e)) return !1;
var a = r(n);
return (
!!("number" == a
? i(e) && u(n, e.length)
: "string" == a && n in e) && o(e[n], t)
);
};
},
function (t, n, e) {
"use strict";
var r = e(8);
t.exports = {
longestPath: function (t) {
var n = {};
r.forEach(t.sources(), function e(o) {
var i = t.node(o);
if (r.has(n, o)) return i.rank;
n[o] = !0;
var u = r.min(
r.map(t.outEdges(o), function (n) {
return e(n.w) - t.edge(n).minlen;
}),
);
return (
(u !== Number.POSITIVE_INFINITY && null != u) || (u = 0),
(i.rank = u)
);
});
},
slack: function (t, n) {
return t.node(n.w).rank - t.node(n.v).rank - t.edge(n).minlen;
},
};
},
,
,
,
,
,
function (t, n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var r;
r = (function () {
return this;
})();
try {
r = r || new Function("return this")();
} catch (t) {
"object" === ("undefined" == typeof window ? "undefined" : e(window)) &&
(r = window);
}
t.exports = r;
},
,
function (t, n, e) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(20);
t.exports = i;
function i(t) {
(this._isDirected = !o.has(t, "directed") || t.directed),
(this._isMultigraph = !!o.has(t, "multigraph") && t.multigraph),
(this._isCompound = !!o.has(t, "compound") && t.compound),
(this._label = void 0),
(this._defaultNodeLabelFn = o.constant(void 0)),
(this._defaultEdgeLabelFn = o.constant(void 0)),
(this._nodes = {}),
this._isCompound &&
((this._parent = {}),
(this._children = {}),
(this._children["\0"] = {})),
(this._in = {}),
(this._preds = {}),
(this._out = {}),
(this._sucs = {}),
(this._edgeObjs = {}),
(this._edgeLabels = {});
}
function u(t, n) {
t[n] ? t[n]++ : (t[n] = 1);
}
function c(t, n) {
--t[n] || delete t[n];
}
function a(t, n, e, r) {
var i = "" + n,
u = "" + e;
if (!t && i > u) {
var c = i;
(i = u), (u = c);
}
return i + "" + u + "" + (o.isUndefined(r) ? "\0" : r);
}
function f(t, n, e, r) {
var o = "" + n,
i = "" + e;
if (!t && o > i) {
var u = o;
(o = i), (i = u);
}
var c = { v: o, w: i };
return r && (c.name = r), c;
}
function s(t, n) {
return a(t, n.v, n.w, n.name);
}
(i.prototype._nodeCount = 0),
(i.prototype._edgeCount = 0),
(i.prototype.isDirected = function () {
return this._isDirected;
}),
(i.prototype.isMultigraph = function () {
return this._isMultigraph;
}),
(i.prototype.isCompound = function () {
return this._isCompound;
}),
(i.prototype.setGraph = function (t) {
return (this._label = t), this;
}),
(i.prototype.graph = function () {
return this._label;
}),
(i.prototype.setDefaultNodeLabel = function (t) {
return (
o.isFunction(t) || (t = o.constant(t)),
(this._defaultNodeLabelFn = t),
this
);
}),
(i.prototype.nodeCount = function () {
return this._nodeCount;
}),
(i.prototype.nodes = function () {
return o.keys(this._nodes);
}),
(i.prototype.sources = function () {
var t = this;
return o.filter(this.nodes(), function (n) {
return o.isEmpty(t._in[n]);
});
}),
(i.prototype.sinks = function () {
var t = this;
return o.filter(this.nodes(), function (n) {
return o.isEmpty(t._out[n]);
});
}),
(i.prototype.setNodes = function (t, n) {
var e = arguments,
r = this;
return (
o.each(t, function (t) {
e.length > 1 ? r.setNode(t, n) : r.setNode(t);
}),
this
);
}),
(i.prototype.setNode = function (t, n) {
return o.has(this._nodes, t)
? (arguments.length > 1 && (this._nodes[t] = n), this)
: ((this._nodes[t] =
arguments.length > 1 ? n : this._defaultNodeLabelFn(t)),
this._isCompound &&
((this._parent[t] = "\0"),
(this._children[t] = {}),
(this._children["\0"][t] = !0)),
(this._in[t] = {}),
(this._preds[t] = {}),
(this._out[t] = {}),
(this._sucs[t] = {}),
++this._nodeCount,
this);
}),
(i.prototype.node = function (t) {
return this._nodes[t];
}),
(i.prototype.hasNode = function (t) {
return o.has(this._nodes, t);
}),
(i.prototype.removeNode = function (t) {
var n = this;
if (o.has(this._nodes, t)) {
var e = function (t) {
n.removeEdge(n._edgeObjs[t]);
};
delete this._nodes[t],
this._isCompound &&
(this._removeFromParentsChildList(t),
delete this._parent[t],
o.each(this.children(t), function (t) {
n.setParent(t);
}),
delete this._children[t]),
o.each(o.keys(this._in[t]), e),
delete this._in[t],
delete this._preds[t],
o.each(o.keys(this._out[t]), e),
delete this._out[t],
delete this._sucs[t],
--this._nodeCount;
}
return this;
}),
(i.prototype.setParent = function (t, n) {
if (!this._isCompound)
throw new Error("Cannot set parent in a non-compound graph");
if (o.isUndefined(n)) n = "\0";
else {
for (var e = (n += ""); !o.isUndefined(e); e = this.parent(e))
if (e === t)
throw new Error(
"Setting " +
n +
" as parent of " +
t +
" would create a cycle",
);
this.setNode(n);
}
return (
this.setNode(t),
this._removeFromParentsChildList(t),
(this._parent[t] = n),
(this._children[n][t] = !0),
this
);
}),
(i.prototype._removeFromParentsChildList = function (t) {
delete this._children[this._parent[t]][t];
}),
(i.prototype.parent = function (t) {
if (this._isCompound) {
var n = this._parent[t];
if ("\0" !== n) return n;
}
}),
(i.prototype.children = function (t) {
if ((o.isUndefined(t) && (t = "\0"), this._isCompound)) {
var n = this._children[t];
if (n) return o.keys(n);
} else {
if ("\0" === t) return this.nodes();
if (this.hasNode(t)) return [];
}
}),
(i.prototype.predecessors = function (t) {
var n = this._preds[t];
if (n) return o.keys(n);
}),
(i.prototype.successors = function (t) {
var n = this._sucs[t];
if (n) return o.keys(n);
}),
(i.prototype.neighbors = function (t) {
var n = this.predecessors(t);
if (n) return o.union(n, this.successors(t));
}),
(i.prototype.isLeaf = function (t) {
return (
0 ===
(this.isDirected() ? this.successors(t) : this.neighbors(t)).length
);
}),
(i.prototype.filterNodes = function (t) {
var n = new this.constructor({
directed: this._isDirected,
multigraph: this._isMultigraph,
compound: this._isCompound,
});
n.setGraph(this.graph());
var e = this;
o.each(this._nodes, function (e, r) {
t(r) && n.setNode(r, e);
}),
o.each(this._edgeObjs, function (t) {
n.hasNode(t.v) && n.hasNode(t.w) && n.setEdge(t, e.edge(t));
});
var r = {};
return (
this._isCompound &&
o.each(n.nodes(), function (t) {
n.setParent(
t,
(function t(o) {
var i = e.parent(o);
return void 0 === i || n.hasNode(i)
? ((r[o] = i), i)
: i in r
? r[i]
: t(i);
})(t),
);
}),
n
);
}),
(i.prototype.setDefaultEdgeLabel = function (t) {
return (
o.isFunction(t) || (t = o.constant(t)),
(this._defaultEdgeLabelFn = t),
this
);
}),
(i.prototype.edgeCount = function () {
return this._edgeCount;
}),
(i.prototype.edges = function () {
return o.values(this._edgeObjs);
}),
(i.prototype.setPath = function (t, n) {
var e = this,
r = arguments;
return (
o.reduce(t, function (t, o) {
return r.length > 1 ? e.setEdge(t, o, n) : e.setEdge(t, o), o;
}),
this
);
}),
(i.prototype.setEdge = function () {
var t,
n,
e,
i,
c = !1,
s = arguments[0];
"object" === r(s) && null !== s && "v" in s
? ((t = s.v),
(n = s.w),
(e = s.name),
2 === arguments.length && ((i = arguments[1]), (c = !0)))
: ((t = s),
(n = arguments[1]),
(e = arguments[3]),
arguments.length > 2 && ((i = arguments[2]), (c = !0))),
(t = "" + t),
(n = "" + n),
o.isUndefined(e) || (e = "" + e);
var p = a(this._isDirected, t, n, e);
if (o.has(this._edgeLabels, p))
return c && (this._edgeLabels[p] = i), this;
if (!o.isUndefined(e) && !this._isMultigraph)
throw new Error(
"Cannot set a named edge when isMultigraph = false",
);
this.setNode(t),
this.setNode(n),
(this._edgeLabels[p] = c ? i : this._defaultEdgeLabelFn(t, n, e));
var d = f(this._isDirected, t, n, e);
return (
(t = d.v),
(n = d.w),
Object.freeze(d),
(this._edgeObjs[p] = d),
u(this._preds[n], t),
u(this._sucs[t], n),
(this._in[n][p] = d),
(this._out[t][p] = d),
this._edgeCount++,
this
);
}),
(i.prototype.edge = function (t, n, e) {
var r =
1 === arguments.length
? s(this._isDirected, arguments[0])
: a(this._isDirected, t, n, e);
return this._edgeLabels[r];
}),
(i.prototype.hasEdge = function (t, n, e) {
var r =
1 === arguments.length
? s(this._isDirected, arguments[0])
: a(this._isDirected, t, n, e);
return o.has(this._edgeLabels, r);
}),
(i.prototype.removeEdge = function (t, n, e) {
var r =
1 === arguments.length
? s(this._isDirected, arguments[0])
: a(this._isDirected, t, n, e),
o = this._edgeObjs[r];
return (
o &&
((t = o.v),
(n = o.w),
delete this._edgeLabels[r],
delete this._edgeObjs[r],
c(this._preds[n], t),
c(this._sucs[t], n),
delete this._in[n][r],
delete this._out[t][r],
this._edgeCount--),
this
);
}),
(i.prototype.inEdges = function (t, n) {
var e = this._in[t];
if (e) {
var r = o.values(e);
return n
? o.filter(r, function (t) {
return t.v === n;
})
: r;
}
}),
(i.prototype.outEdges = function (t, n) {
var e = this._out[t];
if (e) {
var r = o.values(e);
return n
? o.filter(r, function (t) {
return t.w === n;
})
: r;
}
}),
(i.prototype.nodeEdges = function (t, n) {
var e = this.inEdges(t, n);
if (e) return e.concat(this.outEdges(t, n));
});
},
function (t, n, e) {
var r = e(33)(e(24), "Map");
t.exports = r;
},
function (t, n, e) {
var r = e(221),
o = e(228),
i = e(230),
u = e(231),
c = e(232);
function a(t) {
var n = -1,
e = null == t ? 0 : t.length;
for (this.clear(); ++n < e; ) {
var r = t[n];
this.set(r[0], r[1]);
}
}
(a.prototype.clear = r),
(a.prototype.delete = o),
(a.prototype.get = i),
(a.prototype.has = u),
(a.prototype.set = c),
(t.exports = a);
},
function (t, n) {
t.exports = function (t, n) {
for (
var e = -1, r = null == t ? 0 : t.length;
++e < r && !1 !== n(t[e], e, t);
);
return t;
};
},
function (t, n) {
t.exports = function (t) {
return (
"number" == typeof t && t > -1 && t % 1 == 0 && t <= 9007199254740991
);
};
},
function (t, n, e) {
(function (t) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(104),
i = "object" == r(n) && n && !n.nodeType && n,
u = i && "object" == r(t) && t && !t.nodeType && t,
c = u && u.exports === i && o.process,
a = (function () {
try {
var t = u && u.require && u.require("util").types;
return t || (c && c.binding && c.binding("util"));
} catch (t) {}
})();
t.exports = a;
}).call(this, e(45)(t));
},
function (t, n, e) {
var r = e(63),
o = e(238),
i = Object.prototype.hasOwnProperty;
t.exports = function (t) {
if (!r(t)) return o(t);
var n = [];
for (var e in Object(t))
i.call(t, e) && "constructor" != e && n.push(e);
return n;
};
},
function (t, n, e) {
var r = e(111),
o = e(112),
i = Object.prototype.propertyIsEnumerable,
u = Object.getOwnPropertySymbols,
c = u
? function (t) {
return null == t
? []
: ((t = Object(t)),
r(u(t), function (n) {
return i.call(t, n);
}));
}
: o;
t.exports = c;
},
function (t, n) {
t.exports = function (t, n) {
for (var e = -1, r = n.length, o = t.length; ++e < r; ) t[o + e] = n[e];
return t;
};
},
function (t, n, e) {
var r = e(117);
t.exports = function (t) {
var n = new t.constructor(t.byteLength);
return new r(n).set(new r(t)), n;
};
},
function (t, n) {
t.exports = function (t) {
return function () {
return t;
};
};
},
function (t, n, e) {
var r = e(91),
o = e(31);
t.exports = function (t, n) {
return t && r(t, n, o);
};
},
function (t, n, e) {
var r = e(257)();
t.exports = r;
},
function (t, n) {
t.exports = function (t) {
var n = -1,
e = Array(t.size);
return (
t.forEach(function (t) {
e[++n] = t;
}),
e
);
};
},
function (t, n, e) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(17),
i = e(41),
u = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
c = /^\w*$/;
t.exports = function (t, n) {
if (o(t)) return !1;
var e = r(t);
return (
!(
"number" != e &&
"symbol" != e &&
"boolean" != e &&
null != t &&
!i(t)
) ||
c.test(t) ||
!u.test(t) ||
(null != n && t in Object(n))
);
};
},
function (t, n, e) {
var r = e(87),
o = e(291);
t.exports = function t(n, e, i, u, c) {
var a = -1,
f = n.length;
for (i || (i = o), c || (c = []); ++a < f; ) {
var s = n[a];
e > 0 && i(s)
? e > 1
? t(s, e - 1, i, u, c)
: r(c, s)
: u || (c[c.length] = s);
}
return c;
};
},
function (t, n, e) {
var r = e(41);
t.exports = function (t, n, e) {
for (var o = -1, i = t.length; ++o < i; ) {
var u = t[o],
c = n(u);
if (null != c && (void 0 === a ? c == c && !r(c) : e(c, a)))
var a = c,
f = u;
}
return f;
};
},
,
,
,
,
,
,
,
function (t, n, e) {
var r = e(54),
o = e(82),
i = e(59),
u = e(233),
c = e(239),
a = e(109),
f = e(110),
s = e(242),
p = e(243),
d = e(114),
h = e(244),
l = e(40),
v = e(248),
y = e(249),
g = e(119),
b = e(17),
m = e(39),
x = e(253),
_ = e(21),
w = e(255),
E = e(31),
j = e(35),
k = {};
(k["[object Arguments]"] =
k["[object Array]"] =
k["[object ArrayBuffer]"] =
k["[object DataView]"] =
k["[object Boolean]"] =
k["[object Date]"] =
k["[object Float32Array]"] =
k["[object Float64Array]"] =
k["[object Int8Array]"] =
k["[object Int16Array]"] =
k["[object Int32Array]"] =
k["[object Map]"] =
k["[object Number]"] =
k["[object Object]"] =
k["[object RegExp]"] =
k["[object Set]"] =
k["[object String]"] =
k["[object Symbol]"] =
k["[object Uint8Array]"] =
k["[object Uint8ClampedArray]"] =
k["[object Uint16Array]"] =
k["[object Uint32Array]"] =
!0),
(k["[object Error]"] =
k["[object Function]"] =
k["[object WeakMap]"] =
!1),
(t.exports = function t(n, e, S, O, N, I) {
var P,
M = 1 & e,
C = 2 & e,
A = 4 & e;
if ((S && (P = N ? S(n, O, N, I) : S(n)), void 0 !== P)) return P;
if (!_(n)) return n;
var L = b(n);
if (L) {
if (((P = v(n)), !M)) return f(n, P);
} else {
var T = l(n),
z = "[object Function]" == T || "[object GeneratorFunction]" == T;
if (m(n)) return a(n, M);
if (
"[object Object]" == T ||
"[object Arguments]" == T ||
(z && !N)
) {
if (((P = C || z ? {} : g(n)), !M))
return C ? p(n, c(P, n)) : s(n, u(P, n));
} else {
if (!k[T]) return N ? n : {};
P = y(n, T, M);
}
}
I || (I = new r());
var F = I.get(n);
if (F) return F;
I.set(n, P),
w(n)
? n.forEach(function (r) {
P.add(t(r, e, S, r, n, I));
})
: x(n) &&
n.forEach(function (r, o) {
P.set(o, t(r, e, S, o, n, I));
});
var D = L ? void 0 : (A ? (C ? h : d) : C ? j : E)(n);
return (
o(D || n, function (r, o) {
D && (r = n[(o = r)]), i(P, o, t(r, e, S, o, n, I));
}),
P
);
});
},
function (t, n, e) {
(function (n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var r =
"object" == (void 0 === n ? "undefined" : e(n)) &&
n &&
n.Object === Object &&
n;
t.exports = r;
}).call(this, e(77));
},
function (t, n) {
var e = Function.prototype.toString;
t.exports = function (t) {
if (null != t) {
try {
return e.call(t);
} catch (t) {}
try {
return t + "";
} catch (t) {}
}
return "";
};
},
function (t, n, e) {
var r = e(33),
o = (function () {
try {
var t = r(Object, "defineProperty");
return t({}, "", {}), t;
} catch (t) {}
})();
t.exports = o;
},
function (t, n, e) {
var r = e(234),
o = e(48),
i = e(17),
u = e(39),
c = e(61),
a = e(49),
f = Object.prototype.hasOwnProperty;
t.exports = function (t, n) {
var e = i(t),
s = !e && o(t),
p = !e && !s && u(t),
d = !e && !s && !p && a(t),
h = e || s || p || d,
l = h ? r(t.length, String) : [],
v = l.length;
for (var y in t)
(!n && !f.call(t, y)) ||
(h &&
("length" == y ||
(p && ("offset" == y || "parent" == y)) ||
(d &&
("buffer" == y || "byteLength" == y || "byteOffset" == y)) ||
c(y, v))) ||
l.push(y);
return l;
};
},
function (t, n) {
t.exports = function (t, n) {
return function (e) {
return t(n(e));
};
};
},
function (t, n, e) {
(function (t) {
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o = e(24),
i = "object" == r(n) && n && !n.nodeType && n,
u = i && "object" == r(t) && t && !t.nodeType && t,
c = u && u.exports === i ? o.Buffer : void 0,
a = c ? c.allocUnsafe : void 0;
t.exports = function (t, n) {
if (n) return t.slice();
var e = t.length,
r = a ? a(e) : new t.constructor(e);
return t.copy(r), r;
};
}).call(this, e(45)(t));
},
function (t, n) {
t.exports = function (t, n) {
var e = -1,
r = t.length;
for (n || (n = Array(r)); ++e < r; ) n[e] = t[e];
return n;
};
},
function (t, n) {
t.exports = function (t, n) {
for (
var e = -1, r = null == t ? 0 : t.length, o = 0, i = [];
++e < r;
) {
var u = t[e];
n(u, e, t) && (i[o++] = u);
}
return i;
};
},
function (t, n) {
t.exports = function () {
return [];
};
},
function (t, n, e) {
var r = e(87),
o = e(64),
i = e(86),
u = e(112),
c = Object.getOwnPropertySymbols
? function (t) {
for (var n = []; t; ) r(n, i(t)), (t = o(t));
return n;
}
: u;
t.exports = c;
},
function (t, n, e) {
var r = e(115),
o = e(86),
i = e(31);
t.exports = function (t) {
return r(t, i, o);
};
},
function (t, n, e) {
var r = e(87),
o = e(17);
t.exports = function (t, n, e) {
var i = n(t);
return o(t) ? i : r(i, e(t));
};
},
function (t, n, e) {
var r = e(33)(e(24), "Set");
t.exports = r;
},
function (t, n, e) {
var r = e(24).Uint8Array;
t.exports = r;
},
function (t, n, e) {
var r = e(88);
t.exports = function (t, n) {
var e = n ? r(t.buffer) : t.buffer;
return new t.constructor(e, t.byteOffset, t.length);
};
},
function (t, n, e) {
var r = e(120),
o = e(64),
i = e(63);
t.exports = function (t) {
return "function" != typeof t.constructor || i(t) ? {} : r(o(t));
};
},
function (t, n, e) {
var r = e(21),
o = Object.create,
i = (function () {
function t() {}
return function (n) {
if (!r(n)) return {};
if (o) return o(n);
t.prototype = n;
var e = new t();
return (t.prototype = void 0), e;
};
})();
t.exports = i;
},
function (t, n, e) {
t.exports = e(122);
},
function (t, n, e) {
var r = e(82),
o = e(65),
i = e(123),
u = e(17);
t.exports = function (t, n) {
return (u(t) ? r : o)(t, i(n));
};
},
function (t, n, e) {
var r = e(36);
t.exports = function (t) {
return "function" == typeof t ? t : r;
};
},
function (t, n, e) {
var r = e(111),
o = e(259),
i = e(29),
u = e(17);
t.exports = function (t, n) {
return (u(t) ? r : o)(t, i(n, 3));
};
},
function (t, n, e) {
var r = e(262),
o = e(25);
t.exports = function t(n, e, i, u, c) {
return (
n === e ||
(null == n || null == e || (!o(n) && !o(e))
? n != n && e != e
: r(n, e, i, u, t, c))
);
};
},
function (t, n, e) {
var r = e(127),
o = e(265),
i = e(128);
t.exports = function (t, n, e, u, c, a) {
var f = 1 & e,
s = t.length,
p = n.length;
if (s != p && !(f && p > s)) return !1;
var d = a.get(t),
h = a.get(n);
if (d && h) return d == n && h == t;
var l = -1,
v = !0,
y = 2 & e ? new r() : void 0;
for (a.set(t, n), a.set(n, t); ++l < s; ) {
var g = t[l],
b = n[l];
if (u) var m = f ? u(b, g, l, n, t, a) : u(g, b, l, t, n, a);
if (void 0 !== m) {
if (m) continue;
v = !1;
break;
}
if (y) {
if (
!o(n, function (t, n) {
if (!i(y, n) && (g === t || c(g, t, e, u, a))) return y.push(n);
})
) {
v = !1;
break;
}
} else if (g !== b && !c(g, b, e, u, a)) {
v = !1;
break;
}
}
return a.delete(t), a.delete(n), v;
};
},
function (t, n, e) {
var r = e(81),
o = e(263),
i = e(264);
function u(t) {
var n = -1,
e = null == t ? 0 : t.length;
for (this.__data__ = new r(); ++n < e; ) this.add(t[n]);
}
(u.prototype.add = u.prototype.push = o),
(u.prototype.has = i),
(t.exports = u);
},
function (t, n) {
t.exports = function (t, n) {
return t.has(n);
};
},
function (t, n, e) {
var r = e(21);
t.exports = function (t) {
return t == t && !r(t);
};
},
function (t, n) {
t.exports = function (t, n) {
return function (e) {
return null != e && e[t] === n && (void 0 !== n || t in Object(e));
};
};
},
function (t, n, e) {
var r = e(275);
t.exports = function (t) {
return null == t ? "" : r(t);
};
},
function (t, n, e) {
var r = e(276),
o = e(133);
t.exports = function (t, n) {
return null != t && o(t, n, r);
};
},
function (t, n, e) {
var r = e(67),
o = e(48),
i = e(17),
u = e(61),
c = e(83),
a = e(50);
t.exports = function (t, n, e) {
for (var f = -1, s = (n = r(n, t)).length, p = !1; ++f < s; ) {
var d = a(n[f]);
if (!(p = null != t && e(t, d))) break;
t = t[d];
}
return p || ++f != s
? p
: !!(s = null == t ? 0 : t.length) &&
c(s) &&
u(d, s) &&
(i(t) || o(t));
};
},
function (t, n) {
t.exports = function (t) {
return function (n) {
return null == n ? void 0 : n[t];
};
};
},
function (t, n, e) {
var r = e(279),
o = e(133);
t.exports = function (t, n) {
return null != t && o(t, n, r);
};
},
function (t, n) {
t.exports = function (t) {
return void 0 === t;
};
},
function (t, n, e) {
var r = e(68),
o = e(29),
i = e(138),
u = e(17);
t.exports = function (t, n) {
return (u(t) ? r : i)(t, o(n, 3));
};
},
function (t, n, e) {
var r = e(65),
o = e(28);
t.exports = function (t, n) {
var e = -1,
i = o(t) ? Array(t.length) : [];
return (
r(t, function (t, r, o) {
i[++e] = n(t, r, o);
}),
i
);
};
},
function (t, n, e) {
var r = e(281),
o = e(65),
i = e(29),
u = e(282),
c = e(17);
t.exports = function (t, n, e) {
var a = c(t) ? r : u,
f = arguments.length < 3;
return a(t, i(n, 4), e, f, o);
};
},
function (t, n, e) {
var r = e(292),
o = Math.max;
t.exports = function (t, n, e) {
return (
(n = o(void 0 === n ? t.length - 1 : n, 0)),
function () {
for (
var i = arguments, u = -1, c = o(i.length - n, 0), a = Array(c);
++u < c;
)
a[u] = i[n + u];
u = -1;
for (var f = Array(n + 1); ++u < n; ) f[u] = i[u];
return (f[n] = e(a)), r(t, this, f);
}
);
};
},
function (t, n, e) {
var r = e(293),
o = e(294)(r);
t.exports = o;
},
function (t, n) {
t.exports = function (t, n, e, r) {
for (var o = t.length, i = e + (r ? 1 : -1); r ? i-- : ++i < o; )
if (n(t[i], i, t)) return i;
return -1;
};
},
function (t, n, e) {
var r = e(28),
o = e(25);
t.exports = function (t) {
return o(t) && r(t);
};
},
function (t, n, e) {
var r = e(303),
o = e(31);
t.exports = function (t) {
return null == t ? [] : r(t, o(t));
};
},
function (t, n, e) {
var r = e(20),
o = e(146);
t.exports = function (t, n, e, r) {
return (function (t, n, e, r) {
var i,
u,
c = {},
a = new o(),
f = function (t) {
var n = t.v !== i ? t.v : t.w,
r = c[n],
o = e(t),
f = u.distance + o;
if (o < 0)
throw new Error(
"dijkstra does not allow negative edge weights. Bad edge: " +
t +
" Weight: " +
o,
);
f < r.distance &&
((r.distance = f), (r.predecessor = i), a.decrease(n, f));
};
t.nodes().forEach(function (t) {
var e = t === n ? 0 : Number.POSITIVE_INFINITY;
(c[t] = { distance: e }), a.add(t, e);
});
for (
;
a.size() > 0 &&
((i = a.removeMin()),
(u = c[i]).distance !== Number.POSITIVE_INFINITY);
)
r(i).forEach(f);
return c;
})(
t,
String(n),
e || i,
r ||
function (n) {
return t.outEdges(n);
},
);
};
var i = r.constant(1);
},
function (t, n, e) {
var r = e(20);
function o() {
(this._arr = []), (this._keyIndices = {});
}
(t.exports = o),
(o.prototype.size = function () {
return this._arr.length;
}),
(o.prototype.keys = function () {
return this._arr.map(function (t) {
return t.key;
});
}),
(o.prototype.has = function (t) {
return r.has(this._keyIndices, t);
}),
(o.prototype.priority = function (t) {
var n = this._keyIndices[t];
if (void 0 !== n) return this._arr[n].priority;
}),
(o.prototype.min = function () {
if (0 === this.size()) throw new Error("Queue underflow");
return this._arr[0].key;
}),
(o.prototype.add = function (t, n) {
var e = this._keyIndices;
if (((t = String(t)), !r.has(e, t))) {
var o = this._arr,
i = o.length;
return (
(e[t] = i), o.push({ key: t, priority: n }), this._decrease(i), !0
);
}
return !1;
}),
(o.prototype.removeMin = function () {
this._swap(0, this._arr.length - 1);
var t = this._arr.pop();
return delete this._keyIndices[t.key], this._heapify(0), t.key;
}),
(o.prototype.decrease = function (t, n) {
var e = this._keyIndices[t];
if (n > this._arr[e].priority)
throw new Error(
"New priority is greater than current priority. Key: " +
t +
" Old: " +
this._arr[e].priority +
" New: " +
n,
);
(this._arr[e].priority = n), this._decrease(e);
}),
(o.prototype._heapify = function (t) {
var n = this._arr,
e = 2 * t,
r = e + 1,
o = t;
e < n.length &&
((o = n[e].priority < n[o].priority ? e : o),
r < n.length && (o = n[r].priority < n[o].priority ? r : o),
o !== t && (this._swap(t, o), this._heapify(o)));
}),
(o.prototype._decrease = function (t) {
for (
var n, e = this._arr, r = e[t].priority;
0 !== t && !(e[(n = t >> 1)].priority < r);
)
this._swap(t, n), (t = n);
}),
(o.prototype._swap = function (t, n) {
var e = this._arr,
r = this._keyIndices,
o = e[t],
i = e[n];
(e[t] = i), (e[n] = o), (r[i.key] = t), (r[o.key] = n);
});
},
function (t, n, e) {
var r = e(20);
t.exports = function (t) {
var n = 0,
e = [],
o = {},
i = [];
return (
t.nodes().forEach(function (u) {
r.has(o, u) ||
(function u(c) {
var a = (o[c] = { onStack: !0, lowlink: n, index: n++ });
if (
(e.push(c),
t.successors(c).forEach(function (t) {
r.has(o, t)
? o[t].onStack &&
(a.lowlink = Math.min(a.lowlink, o[t].index))
: (u(t), (a.lowlink = Math.min(a.lowlink, o[t].lowlink)));
}),
a.lowlink === a.index)
) {
var f,
s = [];
do {
(f = e.pop()), (o[f].onStack = !1), s.push(f);
} while (c !== f);
i.push(s);
}
})(u);
}),
i
);
};
},
function (t, n, e) {
var r = e(20);
function o(t) {
var n = {},
e = {},
o = [];
if (
(r.each(t.sinks(), function u(c) {
if (r.has(e, c)) throw new i();
r.has(n, c) ||
((e[c] = !0),
(n[c] = !0),
r.each(t.predecessors(c), u),
delete e[c],
o.push(c));
}),
r.size(n) !== t.nodeCount())
)
throw new i();
return o;
}
function i() {}
(t.exports = o), (o.CycleException = i), (i.prototype = new Error());
},
function (t, n, e) {
var r = e(20);
t.exports = function (t, n, e) {
r.isArray(n) || (n = [n]);
var o = (t.isDirected() ? t.successors : t.neighbors).bind(t),
i = [],
u = {};
return (
r.each(n, function (n) {
if (!t.hasNode(n))
throw new Error("Graph does not have node: " + n);
!(function t(n, e, o, i, u, c) {
r.has(i, e) ||
((i[e] = !0),
o || c.push(e),
r.each(u(e), function (e) {
t(n, e, o, i, u, c);
}),
o && c.push(e));
})(t, n, "post" === e, u, o, i);
}),
i
);
};
},
function (t, n, e) {
var r = e(322);
t.exports = function (t) {
return t
? (t = r(t)) === 1 / 0 || t === -1 / 0
? 17976931348623157e292 * (t < 0 ? -1 : 1)
: t == t
? t
: 0
: 0 === t
? t
: 0;
};
},
function (t, n, e) {
var r = e(94);
t.exports = function (t) {
return (null == t ? 0 : t.length) ? r(t, 1) : [];
};
},
function (t, n, e) {
var r = e(60),
o = e(37);
t.exports = function (t, n, e) {
((void 0 !== e && !o(t[n], e)) || (void 0 === e && !(n in t))) &&
r(t, n, e);
};
},
function (t, n) {
t.exports = function (t, n) {
if (
("constructor" !== n || "function" != typeof t[n]) &&
"__proto__" != n
)
return t[n];
};
},
function (t, n) {
t.exports = function (t, n) {
return t < n;
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(23).Graph,
i = e(71).slack;
function u(t, n) {
return (
r.forEach(t.nodes(), function e(o) {
r.forEach(n.nodeEdges(o), function (r) {
var u = r.v,
c = o === u ? r.w : u;
t.hasNode(c) ||
i(n, r) ||
(t.setNode(c, {}), t.setEdge(o, c, {}), e(c));
});
}),
t.nodeCount()
);
}
function c(t, n) {
return r.minBy(n.edges(), function (e) {
if (t.hasNode(e.v) !== t.hasNode(e.w)) return i(n, e);
});
}
function a(t, n, e) {
r.forEach(t.nodes(), function (t) {
n.node(t).rank += e;
});
}
t.exports = function (t) {
var n,
e,
r = new o({ directed: !1 }),
f = t.nodes()[0],
s = t.nodeCount();
r.setNode(f, {});
for (; u(r, t) < s; )
(n = c(r, t)), (e = r.hasNode(n.v) ? i(t, n) : -i(t, n)), a(r, t, e);
return r;
};
},
,
,
,
,
,
function (t, n, e) {
"use strict";
var r,
o =
(this && this.__extends) ||
((r = function (t, n) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, n) {
t.__proto__ = n;
}) ||
function (t, n) {
for (var e in n)
Object.prototype.hasOwnProperty.call(n, e) && (t[e] = n[e]);
})(t, n);
}),
function (t, n) {
if ("function" != typeof n && null !== n)
throw new TypeError(
"Class extends value " +
String(n) +
" is not a constructor or null",
);
function e() {
this.constructor = t;
}
r(t, n),
(t.prototype =
null === n
? Object.create(n)
: ((e.prototype = n.prototype), new e()));
}),
i =
(this && this.__importDefault) ||
function (t) {
return t && t.__esModule ? t : { default: t };
};
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.DagreLayout = void 0);
var u = i(e(201)),
c = e(10),
a = (function (t) {
function n(n) {
var e = t.call(this) || this;
return (
(e.rankdir = "TB"),
(e.nodesep = 50),
(e.ranksep = 50),
(e.controlPoints = !1),
(e.sortByCombo = !1),
(e.nodes = []),
(e.edges = []),
(e.onLayoutEnd = function () {}),
e.updateCfg(n),
e
);
}
return (
o(n, t),
(n.prototype.getDefaultCfg = function () {
return {
rankdir: "TB",
align: void 0,
nodeSize: void 0,
nodesepFunc: void 0,
ranksepFunc: void 0,
nodesep: 50,
ranksep: 50,
controlPoints: !1,
};
}),
(n.prototype.execute = function () {
var t = this,
n = this,
e = n.nodes,
r = n.nodeSize,
o = n.rankdir,
i = n.combos;
if (e) {
var a,
s = n.edges || [],
p = new u.default.graphlib.Graph({
multigraph: !0,
compound: !0,
});
a = r
? c.isArray(r)
? function () {
return r;
}
: function () {
return [r, r];
}
: function (t) {
return t.size
? c.isArray(t.size)
? t.size
: [t.size, t.size]
: [40, 40];
};
var d = f(n.nodesepFunc, n.nodesep, 50),
h = f(n.ranksepFunc, n.ranksep, 50);
("LR" !== o && "RL" !== o) ||
((d = f(n.ranksepFunc, n.ranksep, 50)),
(h = f(n.nodesepFunc, n.nodesep, 50))),
p.setDefaultEdgeLabel(function () {
return {};
}),
p.setGraph(n);
var l,
v = {};
return (
e.forEach(function (n) {
var e = a(n),
r = h(n),
o = d(n),
i = e[0] + 2 * o,
u = e[1] + 2 * r;
p.setNode(n.id, { width: i, height: u }),
t.sortByCombo &&
n.comboId &&
(v[n.comboId] ||
((v[n.comboId] = !0), p.setNode(n.comboId, {})),
p.setParent(n.id, n.comboId));
}),
this.sortByCombo &&
i &&
i.forEach(function (t) {
t.parentId &&
(v[t.parentId] ||
((v[t.parentId] = !0), p.setNode(t.parentId, {})),
p.setParent(t.id, t.parentId));
}),
s.forEach(function (t) {
p.setEdge(t.source, t.target, { weight: t.weight || 1 });
}),
u.default.layout(p),
p.nodes().forEach(function (t) {
l = p.node(t);
var n = e.findIndex(function (n) {
return n.id === t;
});
e[n] && ((e[n].x = l.x), (e[n].y = l.y));
}),
p.edges().forEach(function (t) {
l = p.edge(t);
var e = s.findIndex(function (n) {
return n.source === t.v && n.target === t.w;
});
n.controlPoints &&
"loop" !== s[e].type &&
(s[e].controlPoints = l.points.slice(
1,
l.points.length - 1,
));
}),
n.onLayoutEnd && n.onLayoutEnd(),
{ nodes: e, edges: s }
);
}
}),
(n.prototype.getType = function () {
return "dagre";
}),
n
);
})(e(9).Base);
function f(t, n, e) {
return (
t ||
(c.isNumber(n)
? function () {
return n;
}
: function () {
return e;
})
);
}
n.DagreLayout = a;
},
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
,
function (t, n, e) {
"use strict";
e.r(n);
var r = e(161);
n.default = r.DagreLayout;
},
function (t, n, e) {
t.exports = {
graphlib: e(23),
layout: e(315),
debug: e(376),
util: { time: e(19).time, notime: e(19).notime },
version: e(377),
};
},
function (t, n, e) {
var r = e(203);
t.exports = {
Graph: r.Graph,
json: e(305),
alg: e(306),
version: r.version,
};
},
function (t, n, e) {
t.exports = { Graph: e(79), version: e(304) };
},
function (t, n, e) {
var r = e(103);
t.exports = function (t) {
return r(t, 4);
};
},
function (t, n) {
t.exports = function () {
(this.__data__ = []), (this.size = 0);
};
},
function (t, n, e) {
var r = e(56),
o = Array.prototype.splice;
t.exports = function (t) {
var n = this.__data__,
e = r(n, t);
return (
!(e < 0) &&
(e == n.length - 1 ? n.pop() : o.call(n, e, 1), --this.size, !0)
);
};
},
function (t, n, e) {
var r = e(56);
t.exports = function (t) {
var n = this.__data__,
e = r(n, t);
return e < 0 ? void 0 : n[e][1];
};
},
function (t, n, e) {
var r = e(56);
t.exports = function (t) {
return r(this.__data__, t) > -1;
};
},
function (t, n, e) {
var r = e(56);
t.exports = function (t, n) {
var e = this.__data__,
o = r(e, t);
return o < 0 ? (++this.size, e.push([t, n])) : (e[o][1] = n), this;
};
},
function (t, n, e) {
var r = e(55);
t.exports = function () {
(this.__data__ = new r()), (this.size = 0);
};
},
function (t, n) {
t.exports = function (t) {
var n = this.__data__,
e = n.delete(t);
return (this.size = n.size), e;
};
},
function (t, n) {
t.exports = function (t) {
return this.__data__.get(t);
};
},
function (t, n) {
t.exports = function (t) {
return this.__data__.has(t);
};
},
function (t, n, e) {
var r = e(55),
o = e(80),
i = e(81);
t.exports = function (t, n) {
var e = this.__data__;
if (e instanceof r) {
var u = e.__data__;
if (!o || u.length < 199)
return u.push([t, n]), (this.size = ++e.size), this;
e = this.__data__ = new i(u);
}
return e.set(t, n), (this.size = e.size), this;
};
},
function (t, n, e) {
var r = e(46),
o = e(218),
i = e(21),
u = e(105),
c = /^\[object .+?Constructor\]$/,
a = Function.prototype,
f = Object.prototype,
s = a.toString,
p = f.hasOwnProperty,
d = RegExp(
"^" +
s
.call(p)
.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&")
.replace(
/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,
"$1.*?",
) +
"$",
);
t.exports = function (t) {
return !(!i(t) || o(t)) && (r(t) ? d : c).test(u(t));
};
},
function (t, n, e) {
var r = e(38),
o = Object.prototype,
i = o.hasOwnProperty,
u = o.toString,
c = r ? r.toStringTag : void 0;
t.exports = function (t) {
var n = i.call(t, c),
e = t[c];
try {
t[c] = void 0;
var r = !0;
} catch (t) {}
var o = u.call(t);
return r && (n ? (t[c] = e) : delete t[c]), o;
};
},
function (t, n) {
var e = Object.prototype.toString;
t.exports = function (t) {
return e.call(t);
};
},
function (t, n, e) {
var r,
o = e(219),
i = (r = /[^.]+$/.exec((o && o.keys && o.keys.IE_PROTO) || ""))
? "Symbol(src)_1." + r
: "";
t.exports = function (t) {
return !!i && i in t;
};
},
function (t, n, e) {
var r = e(24)["__core-js_shared__"];
t.exports = r;
},
function (t, n) {
t.exports = function (t, n) {
return null == t ? void 0 : t[n];
};
},
function (t, n, e) {
var r = e(222),
o = e(55),
i = e(80);
t.exports = function () {
(this.size = 0),
(this.__data__ = {
hash: new r(),
map: new (i || o)(),
string: new r(),
});
};
},
function (t, n, e) {
var r = e(223),
o = e(224),
i = e(225),
u = e(226),
c = e(227);
function a(t) {
var n = -1,
e = null == t ? 0 : t.length;
for (this.clear(); ++n < e; ) {
var r = t[n];
this.set(r[0], r[1]);
}
}
(a.prototype.clear = r),
(a.prototype.delete = o),
(a.prototype.get = i),
(a.prototype.has = u),
(a.prototype.set = c),
(t.exports = a);
},
function (t, n, e) {
var r = e(57);
t.exports = function () {
(this.__data__ = r ? r(null) : {}), (this.size = 0);
};
},
function (t, n) {
t.exports = function (t) {
var n = this.has(t) && delete this.__data__[t];
return (this.size -= n ? 1 : 0), n;
};
},
function (t, n, e) {
var r = e(57),
o = Object.prototype.hasOwnProperty;
t.exports = function (t) {
var n = this.__data__;
if (r) {
var e = n[t];
return "__lodash_hash_undefined__" === e ? void 0 : e;
}
return o.call(n, t) ? n[t] : void 0;
};
},
function (t, n, e) {
var r = e(57),
o = Object.prototype.hasOwnProperty;
t.exports = function (t) {
var n = this.__data__;
return r ? void 0 !== n[t] : o.call(n, t);
};
},
function (t, n, e) {
var r = e(57);
t.exports = function (t, n) {
var e = this.__data__;
return (
(this.size += this.has(t) ? 0 : 1),
(e[t] = r && void 0 === n ? "__lodash_hash_undefined__" : n),
this
);
};
},
function (t, n, e) {
var r = e(58);
t.exports = function (t) {
var n = r(this, t).delete(t);
return (this.size -= n ? 1 : 0), n;
};
},
function (t, n) {
function e(t) {
return (e =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
t.exports = function (t) {
var n = e(t);
return "string" == n || "number" == n || "symbol" == n || "boolean" == n
? "__proto__" !== t
: null === t;
};
},
function (t, n, e) {
var r = e(58);
t.exports = function (t) {
return r(this, t).get(t);
};
},
function (t, n, e) {
var r = e(58);
t.exports = function (t) {
return r(this, t).has(t);
};
},
function (t, n, e) {
var r = e(58);
t.exports = function (t, n) {
var e = r(this, t),
o = e.size;
return e.set(t, n), (this.size += e.size == o ? 0 : 1), this;
};
},
function (t, n, e) {
var r = e(47),
o = e(31);
t.exports = function (t, n) {
return t && r(n, o(n), t);
};
},
function (t, n) {
t.exports = function (t, n) {
for (var e = -1, r = Array(t); ++e < t; ) r[e] = n(e);
return r;
};
},
function (t, n, e) {
var r = e(34),
o = e(25);
t.exports = function (t) {
return o(t) && "[object Arguments]" == r(t);
};
},
function (t, n) {
t.exports = function () {
return !1;
};
},
function (t, n, e) {
var r = e(34),
o = e(83),
i = e(25),
u = {};
(u["[object Float32Array]"] =
u["[object Float64Array]"] =
u["[object Int8Array]"] =
u["[object Int16Array]"] =
u["[object Int32Array]"] =
u["[object Uint8Array]"] =
u["[object Uint8ClampedArray]"] =
u["[object Uint16Array]"] =
u["[object Uint32Array]"] =
!0),
(u["[object Arguments]"] =
u["[object Array]"] =
u["[object ArrayBuffer]"] =
u["[object Boolean]"] =
u["[object DataView]"] =
u["[object Date]"] =
u["[object Error]"] =
u["[object Function]"] =
u["[object Map]"] =
u["[object Number]"] =
u["[object Object]"] =
u["[object RegExp]"] =
u["[object Set]"] =
u["[object String]"] =
u["[object WeakMap]"] =
!1),
(t.exports = function (t) {
return i(t) && o(t.length) && !!u[r(t)];
});
},
function (t, n, e) {
var r = e(108)(Object.keys, Object);
t.exports = r;
},
function (t, n, e) {
var r = e(47),
o = e(35);
t.exports = function (t, n) {
return t && r(n, o(n), t);
};
},
function (t, n, e) {
var r = e(21),
o = e(63),
i = e(241),
u = Object.prototype.hasOwnProperty;
t.exports = function (t) {
if (!r(t)) return i(t);
var n = o(t),
e = [];
for (var c in t)
("constructor" != c || (!n && u.call(t, c))) && e.push(c);
return e;
};
},
function (t, n) {
t.exports = function (t) {
var n = [];
if (null != t) for (var e in Object(t)) n.push(e);
return n;
};
},
function (t, n, e) {
var r = e(47),
o = e(86);
t.exports = function (t, n) {
return r(t, o(t), n);
};
},
function (t, n, e) {
var r = e(47),
o = e(113);
t.exports = function (t, n) {
return r(t, o(t), n);
};
},
function (t, n, e) {
var r = e(115),
o = e(113),
i = e(35);
t.exports = function (t) {
return r(t, i, o);
};
},
function (t, n, e) {
var r = e(33)(e(24), "DataView");
t.exports = r;
},
function (t, n, e) {
var r = e(33)(e(24), "Promise");
t.exports = r;
},
function (t, n, e) {
var r = e(33)(e(24), "WeakMap");
t.exports = r;
},
function (t, n) {
var e = Object.prototype.hasOwnProperty;
t.exports = function (t) {
var n = t.length,
r = new t.constructor(n);
return (
n &&
"string" == typeof t[0] &&
e.call(t, "index") &&
((r.index = t.index), (r.input = t.input)),
r
);
};
},
function (t, n, e) {
var r = e(88),
o = e(250),
i = e(251),
u = e(252),
c = e(118);
t.exports = function (t, n, e) {
var a = t.constructor;
switch (n) {
case "[object ArrayBuffer]":
return r(t);
case "[object Boolean]":
case "[object Date]":
return new a(+t);
case "[object DataView]":
return o(t, e);
case "[object Float32Array]":
case "[object Float64Array]":
case "[object Int8Array]":
case "[object Int16Array]":
case "[object Int32Array]":
case "[object Uint8Array]":
case "[object Uint8ClampedArray]":
case "[object Uint16Array]":
case "[object Uint32Array]":
return c(t, e);
case "[object Map]":
return new a();
case "[object Number]":
case "[object String]":
return new a(t);
case "[object RegExp]":
return i(t);
case "[object Set]":
return new a();
case "[object Symbol]":
return u(t);
}
};
},
function (t, n, e) {
var r = e(88);
t.exports = function (t, n) {
var e = n ? r(t.buffer) : t.buffer;
return new t.constructor(e, t.byteOffset, t.byteLength);
};
},
function (t, n) {
var e = /\w*$/;
t.exports = function (t) {
var n = new t.constructor(t.source, e.exec(t));
return (n.lastIndex = t.lastIndex), n;
};
},
function (t, n, e) {
var r = e(38),
o = r ? r.prototype : void 0,
i = o ? o.valueOf : void 0;
t.exports = function (t) {
return i ? Object(i.call(t)) : {};
};
},
function (t, n, e) {
var r = e(254),
o = e(62),
i = e(84),
u = i && i.isMap,
c = u ? o(u) : r;
t.exports = c;
},
function (t, n, e) {
var r = e(40),
o = e(25);
t.exports = function (t) {
return o(t) && "[object Map]" == r(t);
};
},
function (t, n, e) {
var r = e(256),
o = e(62),
i = e(84),
u = i && i.isSet,
c = u ? o(u) : r;
t.exports = c;
},
function (t, n, e) {
var r = e(40),
o = e(25);
t.exports = function (t) {
return o(t) && "[object Set]" == r(t);
};
},
function (t, n) {
t.exports = function (t) {
return function (n, e, r) {
for (var o = -1, i = Object(n), u = r(n), c = u.length; c--; ) {
var a = u[t ? c : ++o];
if (!1 === e(i[a], a, i)) break;
}
return n;
};
};
},
function (t, n, e) {
var r = e(28);
t.exports = function (t, n) {
return function (e, o) {
if (null == e) return e;
if (!r(e)) return t(e, o);
for (
var i = e.length, u = n ? i : -1, c = Object(e);
(n ? u-- : ++u < i) && !1 !== o(c[u], u, c);
);
return e;
};
};
},
function (t, n, e) {
var r = e(65);
t.exports = function (t, n) {
var e = [];
return (
r(t, function (t, r, o) {
n(t, r, o) && e.push(t);
}),
e
);
};
},
function (t, n, e) {
var r = e(261),
o = e(269),
i = e(130);
t.exports = function (t) {
var n = o(t);
return 1 == n.length && n[0][2]
? i(n[0][0], n[0][1])
: function (e) {
return e === t || r(e, t, n);
};
};
},
function (t, n, e) {
var r = e(54),
o = e(125);
t.exports = function (t, n, e, i) {
var u = e.length,
c = u,
a = !i;
if (null == t) return !c;
for (t = Object(t); u--; ) {
var f = e[u];
if (a && f[2] ? f[1] !== t[f[0]] : !(f[0] in t)) return !1;
}
for (; ++u < c; ) {
var s = (f = e[u])[0],
p = t[s],
d = f[1];
if (a && f[2]) {
if (void 0 === p && !(s in t)) return !1;
} else {
var h = new r();
if (i) var l = i(p, d, s, t, n, h);
if (!(void 0 === l ? o(d, p, 3, i, h) : l)) return !1;
}
}
return !0;
};
},
function (t, n, e) {
var r = e(54),
o = e(126),
i = e(266),
u = e(268),
c = e(40),
a = e(17),
f = e(39),
s = e(49),
p = "[object Object]",
d = Object.prototype.hasOwnProperty;
t.exports = function (t, n, e, h, l, v) {
var y = a(t),
g = a(n),
b = y ? "[object Array]" : c(t),
m = g ? "[object Array]" : c(n),
x = (b = "[object Arguments]" == b ? p : b) == p,
_ = (m = "[object Arguments]" == m ? p : m) == p,
w = b == m;
if (w && f(t)) {
if (!f(n)) return !1;
(y = !0), (x = !1);
}
if (w && !x)
return (
v || (v = new r()),
y || s(t) ? o(t, n, e, h, l, v) : i(t, n, b, e, h, l, v)
);
if (!(1 & e)) {
var E = x && d.call(t, "__wrapped__"),
j = _ && d.call(n, "__wrapped__");
if (E || j) {
var k = E ? t.value() : t,
S = j ? n.value() : n;
return v || (v = new r()), l(k, S, e, h, v);
}
}
return !!w && (v || (v = new r()), u(t, n, e, h, l, v));
};
},
function (t, n) {
t.exports = function (t) {
return this.__data__.set(t, "__lodash_hash_undefined__"), this;
};
},
function (t, n) {
t.exports = function (t) {
return this.__data__.has(t);
};
},
function (t, n) {
t.exports = function (t, n) {
for (var e = -1, r = null == t ? 0 : t.length; ++e < r; )
if (n(t[e], e, t)) return !0;
return !1;
};
},
function (t, n, e) {
var r = e(38),
o = e(117),
i = e(37),
u = e(126),
c = e(267),
a = e(92),
f = r ? r.prototype : void 0,
s = f ? f.valueOf : void 0;
t.exports = function (t, n, e, r, f, p, d) {
switch (e) {
case "[object DataView]":
if (t.byteLength != n.byteLength || t.byteOffset != n.byteOffset)
return !1;
(t = t.buffer), (n = n.buffer);
case "[object ArrayBuffer]":
return !(t.byteLength != n.byteLength || !p(new o(t), new o(n)));
case "[object Boolean]":
case "[object Date]":
case "[object Number]":
return i(+t, +n);
case "[object Error]":
return t.name == n.name && t.message == n.message;
case "[object RegExp]":
case "[object String]":
return t == n + "";
case "[object Map]":
var h = c;
case "[object Set]":
var l = 1 & r;
if ((h || (h = a), t.size != n.size && !l)) return !1;
var v = d.get(t);
if (v) return v == n;
(r |= 2), d.set(t, n);
var y = u(h(t), h(n), r, f, p, d);
return d.delete(t), y;
case "[object Symbol]":
if (s) return s.call(t) == s.call(n);
}
return !1;
};
},
function (t, n) {
t.exports = function (t) {
var n = -1,
e = Array(t.size);
return (
t.forEach(function (t, r) {
e[++n] = [r, t];
}),
e
);
};
},
function (t, n, e) {
var r = e(114),
o = Object.prototype.hasOwnProperty;
t.exports = function (t, n, e, i, u, c) {
var a = 1 & e,
f = r(t),
s = f.length;
if (s != r(n).length && !a) return !1;
for (var p = s; p--; ) {
var d = f[p];
if (!(a ? d in n : o.call(n, d))) return !1;
}
var h = c.get(t),
l = c.get(n);
if (h && l) return h == n && l == t;
var v = !0;
c.set(t, n), c.set(n, t);
for (var y = a; ++p < s; ) {
var g = t[(d = f[p])],
b = n[d];
if (i) var m = a ? i(b, g, d, n, t, c) : i(g, b, d, t, n, c);
if (!(void 0 === m ? g === b || u(g, b, e, i, c) : m)) {
v = !1;
break;
}
y || (y = "constructor" == d);
}
if (v && !y) {
var x = t.constructor,
_ = n.constructor;
x == _ ||
!("constructor" in t) ||
!("constructor" in n) ||
("function" == typeof x &&
x instanceof x &&
"function" == typeof _ &&
_ instanceof _) ||
(v = !1);
}
return c.delete(t), c.delete(n), v;
};
},
function (t, n, e) {
var r = e(129),
o = e(31);
t.exports = function (t) {
for (var n = o(t), e = n.length; e--; ) {
var i = n[e],
u = t[i];
n[e] = [i, u, r(u)];
}
return n;
};
},
function (t, n, e) {
var r = e(125),
o = e(271),
i = e(132),
u = e(93),
c = e(129),
a = e(130),
f = e(50);
t.exports = function (t, n) {
return u(t) && c(n)
? a(f(t), n)
: function (e) {
var u = o(e, t);
return void 0 === u && u === n ? i(e, t) : r(n, u, 3);
};
};
},
function (t, n, e) {
var r = e(66);
t.exports = function (t, n, e) {
var o = null == t ? void 0 : r(t, n);
return void 0 === o ? e : o;
};
},
function (t, n, e) {
var r = e(273),
o =
/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,
i = /\\(\\)?/g,
u = r(function (t) {
var n = [];
return (
46 === t.charCodeAt(0) && n.push(""),
t.replace(o, function (t, e, r, o) {
n.push(r ? o.replace(i, "$1") : e || t);
}),
n
);
});
t.exports = u;
},
function (t, n, e) {
var r = e(274);
t.exports = function (t) {
var n = r(t, function (t) {
return 500 === e.size && e.clear(), t;
}),
e = n.cache;
return n;
};
},
function (t, n, e) {
var r = e(81);
function o(t, n) {
if ("function" != typeof t || (null != n && "function" != typeof n))
throw new TypeError("Expected a function");
var e = function e() {
var r = arguments,
o = n ? n.apply(this, r) : r[0],
i = e.cache;
if (i.has(o)) return i.get(o);
var u = t.apply(this, r);
return (e.cache = i.set(o, u) || i), u;
};
return (e.cache = new (o.Cache || r)()), e;
}
(o.Cache = r), (t.exports = o);
},
function (t, n, e) {
var r = e(38),
o = e(68),
i = e(17),
u = e(41),
c = r ? r.prototype : void 0,
a = c ? c.toString : void 0;
t.exports = function t(n) {
if ("string" == typeof n) return n;
if (i(n)) return o(n, t) + "";
if (u(n)) return a ? a.call(n) : "";
var e = n + "";
return "0" == e && 1 / n == -1 / 0 ? "-0" : e;
};
},
function (t, n) {
t.exports = function (t, n) {
return null != t && n in Object(t);
};
},
function (t, n, e) {
var r = e(134),
o = e(278),
i = e(93),
u = e(50);
t.exports = function (t) {
return i(t) ? r(u(t)) : o(t);
};
},
function (t, n, e) {
var r = e(66);
t.exports = function (t) {
return function (n) {
return r(n, t);
};
};
},
function (t, n) {
var e = Object.prototype.hasOwnProperty;
t.exports = function (t, n) {
return null != t && e.call(t, n);
};
},
function (t, n, e) {
var r = e(85),
o = e(40),
i = e(48),
u = e(17),
c = e(28),
a = e(39),
f = e(63),
s = e(49),
p = Object.prototype.hasOwnProperty;
t.exports = function (t) {
if (null == t) return !0;
if (
c(t) &&
(u(t) ||
"string" == typeof t ||
"function" == typeof t.splice ||
a(t) ||
s(t) ||
i(t))
)
return !t.length;
var n = o(t);
if ("[object Map]" == n || "[object Set]" == n) return !t.size;
if (f(t)) return !r(t).length;
for (var e in t) if (p.call(t, e)) return !1;
return !0;
};
},
function (t, n) {
t.exports = function (t, n, e, r) {
var o = -1,
i = null == t ? 0 : t.length;
for (r && i && (e = t[++o]); ++o < i; ) e = n(e, t[o], o, t);
return e;
};
},
function (t, n) {
t.exports = function (t, n, e, r, o) {
return (
o(t, function (t, o, i) {
e = r ? ((r = !1), t) : n(e, t, o, i);
}),
e
);
};
},
function (t, n, e) {
var r = e(85),
o = e(40),
i = e(28),
u = e(284),
c = e(285);
t.exports = function (t) {
if (null == t) return 0;
if (i(t)) return u(t) ? c(t) : t.length;
var n = o(t);
return "[object Map]" == n || "[object Set]" == n
? t.size
: r(t).length;
};
},
function (t, n, e) {
var r = e(34),
o = e(17),
i = e(25);
t.exports = function (t) {
return (
"string" == typeof t || (!o(t) && i(t) && "[object String]" == r(t))
);
};
},
function (t, n, e) {
var r = e(286),
o = e(287),
i = e(288);
t.exports = function (t) {
return o(t) ? i(t) : r(t);
};
},
function (t, n, e) {
var r = e(134)("length");
t.exports = r;
},
function (t, n) {
var e = RegExp(
"[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]",
);
t.exports = function (t) {
return e.test(t);
};
},
function (t, n) {
var e = "[\\ud800-\\udfff]",
r = "[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]",
o = "\\ud83c[\\udffb-\\udfff]",
i = "[^\\ud800-\\udfff]",
u = "(?:\\ud83c[\\udde6-\\uddff]){2}",
c = "[\\ud800-\\udbff][\\udc00-\\udfff]",
a = "(?:" + r + "|" + o + ")" + "?",
f =
"[\\ufe0e\\ufe0f]?" +
a +
("(?:\\u200d(?:" +
[i, u, c].join("|") +
")[\\ufe0e\\ufe0f]?" +
a +
")*"),
s = "(?:" + [i + r + "?", r, u, c, e].join("|") + ")",
p = RegExp(o + "(?=" + o + ")|" + s + f, "g");
t.exports = function (t) {
for (var n = (p.lastIndex = 0); p.test(t); ) ++n;
return n;
};
},
function (t, n, e) {
var r = e(82),
o = e(120),
i = e(90),
u = e(29),
c = e(64),
a = e(17),
f = e(39),
s = e(46),
p = e(21),
d = e(49);
t.exports = function (t, n, e) {
var h = a(t),
l = h || f(t) || d(t);
if (((n = u(n, 4)), null == e)) {
var v = t && t.constructor;
e = l ? (h ? new v() : []) : p(t) && s(v) ? o(c(t)) : {};
}
return (
(l ? r : i)(t, function (t, r, o) {
return n(e, t, r, o);
}),
e
);
};
},
function (t, n, e) {
var r = e(94),
o = e(69),
i = e(295),
u = e(143),
c = o(function (t) {
return i(r(t, 1, u, !0));
});
t.exports = c;
},
function (t, n, e) {
var r = e(38),
o = e(48),
i = e(17),
u = r ? r.isConcatSpreadable : void 0;
t.exports = function (t) {
return i(t) || o(t) || !!(u && t && t[u]);
};
},
function (t, n) {
t.exports = function (t, n, e) {
switch (e.length) {
case 0:
return t.call(n);
case 1:
return t.call(n, e[0]);
case 2:
return t.call(n, e[0], e[1]);
case 3:
return t.call(n, e[0], e[1], e[2]);
}
return t.apply(n, e);
};
},
function (t, n, e) {
var r = e(89),
o = e(106),
i = e(36),
u = o
? function (t, n) {
return o(t, "toString", {
configurable: !0,
enumerable: !1,
value: r(n),
writable: !0,
});
}
: i;
t.exports = u;
},
function (t, n) {
var e = Date.now;
t.exports = function (t) {
var n = 0,
r = 0;
return function () {
var o = e(),
i = 16 - (o - r);
if (((r = o), i > 0)) {
if (++n >= 800) return arguments[0];
} else n = 0;
return t.apply(void 0, arguments);
};
};
},
function (t, n, e) {
var r = e(127),
o = e(296),
i = e(300),
u = e(128),
c = e(301),
a = e(92);
t.exports = function (t, n, e) {
var f = -1,
s = o,
p = t.length,
d = !0,
h = [],
l = h;
if (e) (d = !1), (s = i);
else if (p >= 200) {
var v = n ? null : c(t);
if (v) return a(v);
(d = !1), (s = u), (l = new r());
} else l = n ? [] : h;
t: for (; ++f < p; ) {
var y = t[f],
g = n ? n(y) : y;
if (((y = e || 0 !== y ? y : 0), d && g == g)) {
for (var b = l.length; b--; ) if (l[b] === g) continue t;
n && l.push(g), h.push(y);
} else s(l, g, e) || (l !== h && l.push(g), h.push(y));
}
return h;
};
},
function (t, n, e) {
var r = e(297);
t.exports = function (t, n) {
return !!(null == t ? 0 : t.length) && r(t, n, 0) > -1;
};
},
function (t, n, e) {
var r = e(142),
o = e(298),
i = e(299);
t.exports = function (t, n, e) {
return n == n ? i(t, n, e) : r(t, o, e);
};
},
function (t, n) {
t.exports = function (t) {
return t != t;
};
},
function (t, n) {
t.exports = function (t, n, e) {
for (var r = e - 1, o = t.length; ++r < o; ) if (t[r] === n) return r;
return -1;
};
},
function (t, n) {
t.exports = function (t, n, e) {
for (var r = -1, o = null == t ? 0 : t.length; ++r < o; )
if (e(n, t[r])) return !0;
return !1;
};
},
function (t, n, e) {
var r = e(116),
o = e(302),
i = e(92),
u =
r && 1 / i(new r([, -0]))[1] == 1 / 0
? function (t) {
return new r(t);
}
: o;
t.exports = u;
},
function (t, n) {
t.exports = function () {};
},
function (t, n, e) {
var r = e(68);
t.exports = function (t, n) {
return r(n, function (n) {
return t[n];
});
};
},
function (t, n) {
t.exports = "2.1.8";
},
function (t, n, e) {
var r = e(20),
o = e(79);
function i(t) {
return r.map(t.nodes(), function (n) {
var e = t.node(n),
o = t.parent(n),
i = { v: n };
return (
r.isUndefined(e) || (i.value = e),
r.isUndefined(o) || (i.parent = o),
i
);
});
}
function u(t) {
return r.map(t.edges(), function (n) {
var e = t.edge(n),
o = { v: n.v, w: n.w };
return (
r.isUndefined(n.name) || (o.name = n.name),
r.isUndefined(e) || (o.value = e),
o
);
});
}
t.exports = {
write: function (t) {
var n = {
options: {
directed: t.isDirected(),
multigraph: t.isMultigraph(),
compound: t.isCompound(),
},
nodes: i(t),
edges: u(t),
};
r.isUndefined(t.graph()) || (n.value = r.clone(t.graph()));
return n;
},
read: function (t) {
var n = new o(t.options).setGraph(t.value);
return (
r.each(t.nodes, function (t) {
n.setNode(t.v, t.value), t.parent && n.setParent(t.v, t.parent);
}),
r.each(t.edges, function (t) {
n.setEdge({ v: t.v, w: t.w, name: t.name }, t.value);
}),
n
);
},
};
},
function (t, n, e) {
t.exports = {
components: e(307),
dijkstra: e(145),
dijkstraAll: e(308),
findCycles: e(309),
floydWarshall: e(310),
isAcyclic: e(311),
postorder: e(312),
preorder: e(313),
prim: e(314),
tarjan: e(147),
topsort: e(148),
};
},
function (t, n, e) {
var r = e(20);
t.exports = function (t) {
var n,
e = {},
o = [];
function i(o) {
r.has(e, o) ||
((e[o] = !0),
n.push(o),
r.each(t.successors(o), i),
r.each(t.predecessors(o), i));
}
return (
r.each(t.nodes(), function (t) {
(n = []), i(t), n.length && o.push(n);
}),
o
);
};
},
function (t, n, e) {
var r = e(145),
o = e(20);
t.exports = function (t, n, e) {
return o.transform(
t.nodes(),
function (o, i) {
o[i] = r(t, i, n, e);
},
{},
);
};
},
function (t, n, e) {
var r = e(20),
o = e(147);
t.exports = function (t) {
return r.filter(o(t), function (n) {
return n.length > 1 || (1 === n.length && t.hasEdge(n[0], n[0]));
});
};
},
function (t, n, e) {
var r = e(20);
t.exports = function (t, n, e) {
return (function (t, n, e) {
var r = {},
o = t.nodes();
return (
o.forEach(function (t) {
(r[t] = {}),
(r[t][t] = { distance: 0 }),
o.forEach(function (n) {
t !== n && (r[t][n] = { distance: Number.POSITIVE_INFINITY });
}),
e(t).forEach(function (e) {
var o = e.v === t ? e.w : e.v,
i = n(e);
r[t][o] = { distance: i, predecessor: t };
});
}),
o.forEach(function (t) {
var n = r[t];
o.forEach(function (e) {
var i = r[e];
o.forEach(function (e) {
var r = i[t],
o = n[e],
u = i[e],
c = r.distance + o.distance;
c < u.distance &&
((u.distance = c), (u.predecessor = o.predecessor));
});
});
}),
r
);
})(
t,
n || o,
e ||
function (n) {
return t.outEdges(n);
},
);
};
var o = r.constant(1);
},
function (t, n, e) {
var r = e(148);
t.exports = function (t) {
try {
r(t);
} catch (t) {
if (t instanceof r.CycleException) return !1;
throw t;
}
return !0;
};
},
function (t, n, e) {
var r = e(149);
t.exports = function (t, n) {
return r(t, n, "post");
};
},
function (t, n, e) {
var r = e(149);
t.exports = function (t, n) {
return r(t, n, "pre");
};
},
function (t, n, e) {
var r = e(20),
o = e(79),
i = e(146);
t.exports = function (t, n) {
var e,
u = new o(),
c = {},
a = new i();
function f(t) {
var r = t.v === e ? t.w : t.v,
o = a.priority(r);
if (void 0 !== o) {
var i = n(t);
i < o && ((c[r] = e), a.decrease(r, i));
}
}
if (0 === t.nodeCount()) return u;
r.each(t.nodes(), function (t) {
a.add(t, Number.POSITIVE_INFINITY), u.setNode(t);
}),
a.decrease(t.nodes()[0], 0);
var s = !1;
for (; a.size() > 0; ) {
if (((e = a.removeMin()), r.has(c, e))) u.setEdge(e, c[e]);
else {
if (s) throw new Error("Input graph is not connected: " + t);
s = !0;
}
t.nodeEdges(e).forEach(f);
}
return u;
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(355),
i = e(358),
u = e(359),
c = e(19).normalizeRanks,
a = e(361),
f = e(19).removeEmptyRanks,
s = e(362),
p = e(363),
d = e(364),
h = e(365),
l = e(374),
v = e(19),
y = e(23).Graph;
t.exports = function (t, n) {
var e = n && n.debugTiming ? v.time : v.notime;
e("layout", function () {
var n = e(" buildLayoutGraph", function () {
return (function (t) {
var n = new y({ multigraph: !0, compound: !0 }),
e = S(t.graph());
return (
n.setGraph(r.merge({}, b, k(e, g), r.pick(e, m))),
r.forEach(t.nodes(), function (e) {
var o = S(t.node(e));
n.setNode(e, r.defaults(k(o, x), _)),
n.setParent(e, t.parent(e));
}),
r.forEach(t.edges(), function (e) {
var o = S(t.edge(e));
n.setEdge(e, r.merge({}, E, k(o, w), r.pick(o, j)));
}),
n
);
})(t);
});
e(" runLayout", function () {
!(function (t, n) {
n(" makeSpaceForEdgeLabels", function () {
!(function (t) {
var n = t.graph();
(n.ranksep /= 2),
r.forEach(t.edges(), function (e) {
var r = t.edge(e);
(r.minlen *= 2),
"c" !== r.labelpos.toLowerCase() &&
("TB" === n.rankdir || "BT" === n.rankdir
? (r.width += r.labeloffset)
: (r.height += r.labeloffset));
});
})(t);
}),
n(" removeSelfEdges", function () {
!(function (t) {
r.forEach(t.edges(), function (n) {
if (n.v === n.w) {
var e = t.node(n.v);
e.selfEdges || (e.selfEdges = []),
e.selfEdges.push({ e: n, label: t.edge(n) }),
t.removeEdge(n);
}
});
})(t);
}),
n(" acyclic", function () {
o.run(t);
}),
n(" nestingGraph.run", function () {
s.run(t);
}),
n(" rank", function () {
u(v.asNonCompoundGraph(t));
}),
n(" injectEdgeLabelProxies", function () {
!(function (t) {
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
if (e.width && e.height) {
var r = t.node(n.v),
o = {
rank: (t.node(n.w).rank - r.rank) / 2 + r.rank,
e: n,
};
v.addDummyNode(t, "edge-proxy", o, "_ep");
}
});
})(t);
}),
n(" removeEmptyRanks", function () {
f(t);
}),
n(" nestingGraph.cleanup", function () {
s.cleanup(t);
}),
n(" normalizeRanks", function () {
c(t);
}),
n(" assignRankMinMax", function () {
!(function (t) {
var n = 0;
r.forEach(t.nodes(), function (e) {
var o = t.node(e);
o.borderTop &&
((o.minRank = t.node(o.borderTop).rank),
(o.maxRank = t.node(o.borderBottom).rank),
(n = r.max(n, o.maxRank)));
}),
(t.graph().maxRank = n);
})(t);
}),
n(" removeEdgeLabelProxies", function () {
!(function (t) {
r.forEach(t.nodes(), function (n) {
var e = t.node(n);
"edge-proxy" === e.dummy &&
((t.edge(e.e).labelRank = e.rank), t.removeNode(n));
});
})(t);
}),
n(" normalize.run", function () {
i.run(t);
}),
n(" parentDummyChains", function () {
a(t);
}),
n(" addBorderSegments", function () {
p(t);
}),
n(" order", function () {
h(t);
}),
n(" insertSelfEdges", function () {
!(function (t) {
var n = v.buildLayerMatrix(t);
r.forEach(n, function (n) {
var e = 0;
r.forEach(n, function (n, o) {
var i = t.node(n);
(i.order = o + e),
r.forEach(i.selfEdges, function (n) {
v.addDummyNode(
t,
"selfedge",
{
width: n.label.width,
height: n.label.height,
rank: i.rank,
order: o + ++e,
e: n.e,
label: n.label,
},
"_se",
);
}),
delete i.selfEdges;
});
});
})(t);
}),
n(" adjustCoordinateSystem", function () {
d.adjust(t);
}),
n(" position", function () {
l(t);
}),
n(" positionSelfEdges", function () {
!(function (t) {
r.forEach(t.nodes(), function (n) {
var e = t.node(n);
if ("selfedge" === e.dummy) {
var r = t.node(e.e.v),
o = r.x + r.width / 2,
i = r.y,
u = e.x - o,
c = r.height / 2;
t.setEdge(e.e, e.label),
t.removeNode(n),
(e.label.points = [
{ x: o + (2 * u) / 3, y: i - c },
{ x: o + (5 * u) / 6, y: i - c },
{ x: o + u, y: i },
{ x: o + (5 * u) / 6, y: i + c },
{ x: o + (2 * u) / 3, y: i + c },
]),
(e.label.x = e.x),
(e.label.y = e.y);
}
});
})(t);
}),
n(" removeBorderNodes", function () {
!(function (t) {
r.forEach(t.nodes(), function (n) {
if (t.children(n).length) {
var e = t.node(n),
o = t.node(e.borderTop),
i = t.node(e.borderBottom),
u = t.node(r.last(e.borderLeft)),
c = t.node(r.last(e.borderRight));
(e.width = Math.abs(c.x - u.x)),
(e.height = Math.abs(i.y - o.y)),
(e.x = u.x + e.width / 2),
(e.y = o.y + e.height / 2);
}
}),
r.forEach(t.nodes(), function (n) {
"border" === t.node(n).dummy && t.removeNode(n);
});
})(t);
}),
n(" normalize.undo", function () {
i.undo(t);
}),
n(" fixupEdgeLabelCoords", function () {
!(function (t) {
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
if (r.has(e, "x"))
switch (
(("l" !== e.labelpos && "r" !== e.labelpos) ||
(e.width -= e.labeloffset),
e.labelpos)
) {
case "l":
e.x -= e.width / 2 + e.labeloffset;
break;
case "r":
e.x += e.width / 2 + e.labeloffset;
}
});
})(t);
}),
n(" undoCoordinateSystem", function () {
d.undo(t);
}),
n(" translateGraph", function () {
!(function (t) {
var n = Number.POSITIVE_INFINITY,
e = 0,
o = Number.POSITIVE_INFINITY,
i = 0,
u = t.graph(),
c = u.marginx || 0,
a = u.marginy || 0;
function f(t) {
var r = t.x,
u = t.y,
c = t.width,
a = t.height;
(n = Math.min(n, r - c / 2)),
(e = Math.max(e, r + c / 2)),
(o = Math.min(o, u - a / 2)),
(i = Math.max(i, u + a / 2));
}
r.forEach(t.nodes(), function (n) {
f(t.node(n));
}),
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
r.has(e, "x") && f(e);
}),
(n -= c),
(o -= a),
r.forEach(t.nodes(), function (e) {
var r = t.node(e);
(r.x -= n), (r.y -= o);
}),
r.forEach(t.edges(), function (e) {
var i = t.edge(e);
r.forEach(i.points, function (t) {
(t.x -= n), (t.y -= o);
}),
r.has(i, "x") && (i.x -= n),
r.has(i, "y") && (i.y -= o);
}),
(u.width = e - n + c),
(u.height = i - o + a);
})(t);
}),
n(" assignNodeIntersects", function () {
!(function (t) {
r.forEach(t.edges(), function (n) {
var e,
r,
o = t.edge(n),
i = t.node(n.v),
u = t.node(n.w);
o.points
? ((e = o.points[0]),
(r = o.points[o.points.length - 1]))
: ((o.points = []), (e = u), (r = i)),
o.points.unshift(v.intersectRect(i, e)),
o.points.push(v.intersectRect(u, r));
});
})(t);
}),
n(" reversePoints", function () {
!(function (t) {
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
e.reversed && e.points.reverse();
});
})(t);
}),
n(" acyclic.undo", function () {
o.undo(t);
});
})(n, e);
}),
e(" updateInputGraph", function () {
!(function (t, n) {
r.forEach(t.nodes(), function (e) {
var r = t.node(e),
o = n.node(e);
r &&
((r.x = o.x),
(r.y = o.y),
n.children(e).length &&
((r.width = o.width), (r.height = o.height)));
}),
r.forEach(t.edges(), function (e) {
var o = t.edge(e),
i = n.edge(e);
(o.points = i.points),
r.has(i, "x") && ((o.x = i.x), (o.y = i.y));
}),
(t.graph().width = n.graph().width),
(t.graph().height = n.graph().height);
})(t, n);
});
});
};
var g = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"],
b = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" },
m = ["acyclicer", "ranker", "rankdir", "align"],
x = ["width", "height"],
_ = { width: 0, height: 0 },
w = ["minlen", "weight", "width", "height", "labeloffset"],
E = {
minlen: 1,
weight: 1,
width: 0,
height: 0,
labeloffset: 10,
labelpos: "r",
},
j = ["labelpos"];
function k(t, n) {
return r.mapValues(r.pick(t, n), Number);
}
function S(t) {
var n = {};
return (
r.forEach(t, function (t, e) {
n[e.toLowerCase()] = t;
}),
n
);
}
},
function (t, n, e) {
var r = e(103);
t.exports = function (t) {
return r(t, 5);
};
},
function (t, n, e) {
var r = e(69),
o = e(37),
i = e(70),
u = e(35),
c = Object.prototype,
a = c.hasOwnProperty,
f = r(function (t, n) {
t = Object(t);
var e = -1,
r = n.length,
f = r > 2 ? n[2] : void 0;
for (f && i(n[0], n[1], f) && (r = 1); ++e < r; )
for (var s = n[e], p = u(s), d = -1, h = p.length; ++d < h; ) {
var l = p[d],
v = t[l];
(void 0 === v || (o(v, c[l]) && !a.call(t, l))) && (t[l] = s[l]);
}
return t;
});
t.exports = f;
},
function (t, n, e) {
var r = e(319)(e(320));
t.exports = r;
},
function (t, n, e) {
var r = e(29),
o = e(28),
i = e(31);
t.exports = function (t) {
return function (n, e, u) {
var c = Object(n);
if (!o(n)) {
var a = r(e, 3);
(n = i(n)),
(e = function (t) {
return a(c[t], t, c);
});
}
var f = t(n, e, u);
return f > -1 ? c[a ? n[f] : f] : void 0;
};
};
},
function (t, n, e) {
var r = e(142),
o = e(29),
i = e(321),
u = Math.max;
t.exports = function (t, n, e) {
var c = null == t ? 0 : t.length;
if (!c) return -1;
var a = null == e ? 0 : i(e);
return a < 0 && (a = u(c + a, 0)), r(t, o(n, 3), a);
};
},
function (t, n, e) {
var r = e(150);
t.exports = function (t) {
var n = r(t),
e = n % 1;
return n == n ? (e ? n - e : n) : 0;
};
},
function (t, n, e) {
var r = e(323),
o = e(21),
i = e(41),
u = /^[-+]0x[0-9a-f]+$/i,
c = /^0b[01]+$/i,
a = /^0o[0-7]+$/i,
f = parseInt;
t.exports = function (t) {
if ("number" == typeof t) return t;
if (i(t)) return NaN;
if (o(t)) {
var n = "function" == typeof t.valueOf ? t.valueOf() : t;
t = o(n) ? n + "" : n;
}
if ("string" != typeof t) return 0 === t ? t : +t;
t = r(t);
var e = c.test(t);
return e || a.test(t) ? f(t.slice(2), e ? 2 : 8) : u.test(t) ? NaN : +t;
};
},
function (t, n, e) {
var r = e(324),
o = /^\s+/;
t.exports = function (t) {
return t ? t.slice(0, r(t) + 1).replace(o, "") : t;
};
},
function (t, n) {
var e = /\s/;
t.exports = function (t) {
for (var n = t.length; n-- && e.test(t.charAt(n)); );
return n;
};
},
function (t, n, e) {
var r = e(91),
o = e(123),
i = e(35);
t.exports = function (t, n) {
return null == t ? t : r(t, o(n), i);
};
},
function (t, n) {
t.exports = function (t) {
var n = null == t ? 0 : t.length;
return n ? t[n - 1] : void 0;
};
},
function (t, n, e) {
var r = e(60),
o = e(90),
i = e(29);
t.exports = function (t, n) {
var e = {};
return (
(n = i(n, 3)),
o(t, function (t, o, i) {
r(e, o, n(t, o, i));
}),
e
);
};
},
function (t, n, e) {
var r = e(95),
o = e(329),
i = e(36);
t.exports = function (t) {
return t && t.length ? r(t, i, o) : void 0;
};
},
function (t, n) {
t.exports = function (t, n) {
return t > n;
};
},
function (t, n, e) {
var r = e(331),
o = e(335)(function (t, n, e) {
r(t, n, e);
});
t.exports = o;
},
function (t, n, e) {
var r = e(54),
o = e(152),
i = e(91),
u = e(332),
c = e(21),
a = e(35),
f = e(153);
t.exports = function t(n, e, s, p, d) {
n !== e &&
i(
e,
function (i, a) {
if ((d || (d = new r()), c(i))) u(n, e, a, s, t, p, d);
else {
var h = p ? p(f(n, a), i, a + "", n, e, d) : void 0;
void 0 === h && (h = i), o(n, a, h);
}
},
a,
);
};
},
function (t, n, e) {
var r = e(152),
o = e(109),
i = e(118),
u = e(110),
c = e(119),
a = e(48),
f = e(17),
s = e(143),
p = e(39),
d = e(46),
h = e(21),
l = e(333),
v = e(49),
y = e(153),
g = e(334);
t.exports = function (t, n, e, b, m, x, _) {
var w = y(t, e),
E = y(n, e),
j = _.get(E);
if (j) r(t, e, j);
else {
var k = x ? x(w, E, e + "", t, n, _) : void 0,
S = void 0 === k;
if (S) {
var O = f(E),
N = !O && p(E),
I = !O && !N && v(E);
(k = E),
O || N || I
? f(w)
? (k = w)
: s(w)
? (k = u(w))
: N
? ((S = !1), (k = o(E, !0)))
: I
? ((S = !1), (k = i(E, !0)))
: (k = [])
: l(E) || a(E)
? ((k = w), a(w) ? (k = g(w)) : (h(w) && !d(w)) || (k = c(E)))
: (S = !1);
}
S && (_.set(E, k), m(k, E, b, x, _), _.delete(E)), r(t, e, k);
}
};
},
function (t, n, e) {
var r = e(34),
o = e(64),
i = e(25),
u = Function.prototype,
c = Object.prototype,
a = u.toString,
f = c.hasOwnProperty,
s = a.call(Object);
t.exports = function (t) {
if (!i(t) || "[object Object]" != r(t)) return !1;
var n = o(t);
if (null === n) return !0;
var e = f.call(n, "constructor") && n.constructor;
return "function" == typeof e && e instanceof e && a.call(e) == s;
};
},
function (t, n, e) {
var r = e(47),
o = e(35);
t.exports = function (t) {
return r(t, o(t));
};
},
function (t, n, e) {
var r = e(69),
o = e(70);
t.exports = function (t) {
return r(function (n, e) {
var r = -1,
i = e.length,
u = i > 1 ? e[i - 1] : void 0,
c = i > 2 ? e[2] : void 0;
for (
u = t.length > 3 && "function" == typeof u ? (i--, u) : void 0,
c && o(e[0], e[1], c) && ((u = i < 3 ? void 0 : u), (i = 1)),
n = Object(n);
++r < i;
) {
var a = e[r];
a && t(n, a, r, u);
}
return n;
});
};
},
function (t, n, e) {
var r = e(95),
o = e(154),
i = e(36);
t.exports = function (t) {
return t && t.length ? r(t, i, o) : void 0;
};
},
function (t, n, e) {
var r = e(95),
o = e(29),
i = e(154);
t.exports = function (t, n) {
return t && t.length ? r(t, o(n, 2), i) : void 0;
};
},
function (t, n, e) {
var r = e(24);
t.exports = function () {
return r.Date.now();
};
},
function (t, n, e) {
var r = e(340),
o = e(343)(function (t, n) {
return null == t ? {} : r(t, n);
});
t.exports = o;
},
function (t, n, e) {
var r = e(341),
o = e(132);
t.exports = function (t, n) {
return r(t, n, function (n, e) {
return o(t, e);
});
};
},
function (t, n, e) {
var r = e(66),
o = e(342),
i = e(67);
t.exports = function (t, n, e) {
for (var u = -1, c = n.length, a = {}; ++u < c; ) {
var f = n[u],
s = r(t, f);
e(s, f) && o(a, i(f, t), s);
}
return a;
};
},
function (t, n, e) {
var r = e(59),
o = e(67),
i = e(61),
u = e(21),
c = e(50);
t.exports = function (t, n, e, a) {
if (!u(t)) return t;
for (
var f = -1, s = (n = o(n, t)).length, p = s - 1, d = t;
null != d && ++f < s;
) {
var h = c(n[f]),
l = e;
if ("__proto__" === h || "constructor" === h || "prototype" === h)
return t;
if (f != p) {
var v = d[h];
void 0 === (l = a ? a(v, h, d) : void 0) &&
(l = u(v) ? v : i(n[f + 1]) ? [] : {});
}
r(d, h, l), (d = d[h]);
}
return t;
};
},
function (t, n, e) {
var r = e(151),
o = e(140),
i = e(141);
t.exports = function (t) {
return i(o(t, void 0, r), t + "");
};
},
function (t, n, e) {
var r = e(345)();
t.exports = r;
},
function (t, n, e) {
var r = e(346),
o = e(70),
i = e(150);
t.exports = function (t) {
return function (n, e, u) {
return (
u && "number" != typeof u && o(n, e, u) && (e = u = void 0),
(n = i(n)),
void 0 === e ? ((e = n), (n = 0)) : (e = i(e)),
(u = void 0 === u ? (n < e ? 1 : -1) : i(u)),
r(n, e, u, t)
);
};
};
},
function (t, n) {
var e = Math.ceil,
r = Math.max;
t.exports = function (t, n, o, i) {
for (var u = -1, c = r(e((n - t) / (o || 1)), 0), a = Array(c); c--; )
(a[i ? c : ++u] = t), (t += o);
return a;
};
},
function (t, n, e) {
var r = e(94),
o = e(348),
i = e(69),
u = e(70),
c = i(function (t, n) {
if (null == t) return [];
var e = n.length;
return (
e > 1 && u(t, n[0], n[1])
? (n = [])
: e > 2 && u(n[0], n[1], n[2]) && (n = [n[0]]),
o(t, r(n, 1), [])
);
});
t.exports = c;
},
function (t, n, e) {
var r = e(68),
o = e(66),
i = e(29),
u = e(138),
c = e(349),
a = e(62),
f = e(350),
s = e(36),
p = e(17);
t.exports = function (t, n, e) {
n = n.length
? r(n, function (t) {
return p(t)
? function (n) {
return o(n, 1 === t.length ? t[0] : t);
}
: t;
})
: [s];
var d = -1;
n = r(n, a(i));
var h = u(t, function (t, e, o) {
return {
criteria: r(n, function (n) {
return n(t);
}),
index: ++d,
value: t,
};
});
return c(h, function (t, n) {
return f(t, n, e);
});
};
},
function (t, n) {
t.exports = function (t, n) {
var e = t.length;
for (t.sort(n); e--; ) t[e] = t[e].value;
return t;
};
},
function (t, n, e) {
var r = e(351);
t.exports = function (t, n, e) {
for (
var o = -1,
i = t.criteria,
u = n.criteria,
c = i.length,
a = e.length;
++o < c;
) {
var f = r(i[o], u[o]);
if (f) return o >= a ? f : f * ("desc" == e[o] ? -1 : 1);
}
return t.index - n.index;
};
},
function (t, n, e) {
var r = e(41);
t.exports = function (t, n) {
if (t !== n) {
var e = void 0 !== t,
o = null === t,
i = t == t,
u = r(t),
c = void 0 !== n,
a = null === n,
f = n == n,
s = r(n);
if (
(!a && !s && !u && t > n) ||
(u && c && f && !a && !s) ||
(o && c && f) ||
(!e && f) ||
!i
)
return 1;
if (
(!o && !u && !s && t < n) ||
(s && e && i && !o && !u) ||
(a && e && i) ||
(!c && i) ||
!f
)
return -1;
}
return 0;
};
},
function (t, n, e) {
var r = e(131),
o = 0;
t.exports = function (t) {
var n = ++o;
return r(t) + n;
};
},
function (t, n, e) {
var r = e(59),
o = e(354);
t.exports = function (t, n) {
return o(t || [], n || [], r);
};
},
function (t, n) {
t.exports = function (t, n, e) {
for (var r = -1, o = t.length, i = n.length, u = {}; ++r < o; ) {
var c = r < i ? n[r] : void 0;
e(u, t[r], c);
}
return u;
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(356);
t.exports = {
run: function (t) {
var n =
"greedy" === t.graph().acyclicer
? o(
t,
(function (t) {
return function (n) {
return t.edge(n).weight;
};
})(t),
)
: (function (t) {
var n = [],
e = {},
o = {};
function i(u) {
r.has(o, u) ||
((o[u] = !0),
(e[u] = !0),
r.forEach(t.outEdges(u), function (t) {
r.has(e, t.w) ? n.push(t) : i(t.w);
}),
delete e[u]);
}
return r.forEach(t.nodes(), i), n;
})(t);
r.forEach(n, function (n) {
var e = t.edge(n);
t.removeEdge(n),
(e.forwardName = n.name),
(e.reversed = !0),
t.setEdge(n.w, n.v, e, r.uniqueId("rev"));
});
},
undo: function (t) {
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
if (e.reversed) {
t.removeEdge(n);
var r = e.forwardName;
delete e.reversed,
delete e.forwardName,
t.setEdge(n.w, n.v, e, r);
}
});
},
};
},
function (t, n, e) {
var r = e(8),
o = e(23).Graph,
i = e(357);
t.exports = function (t, n) {
if (t.nodeCount() <= 1) return [];
var e = (function (t, n) {
var e = new o(),
u = 0,
c = 0;
r.forEach(t.nodes(), function (t) {
e.setNode(t, { v: t, in: 0, out: 0 });
}),
r.forEach(t.edges(), function (t) {
var r = e.edge(t.v, t.w) || 0,
o = n(t),
i = r + o;
e.setEdge(t.v, t.w, i),
(c = Math.max(c, (e.node(t.v).out += o))),
(u = Math.max(u, (e.node(t.w).in += o)));
});
var f = r.range(c + u + 3).map(function () {
return new i();
}),
s = u + 1;
return (
r.forEach(e.nodes(), function (t) {
a(f, s, e.node(t));
}),
{ graph: e, buckets: f, zeroIdx: s }
);
})(t, n || u),
f = (function (t, n, e) {
var r,
o = [],
i = n[n.length - 1],
u = n[0];
for (; t.nodeCount(); ) {
for (; (r = u.dequeue()); ) c(t, n, e, r);
for (; (r = i.dequeue()); ) c(t, n, e, r);
if (t.nodeCount())
for (var a = n.length - 2; a > 0; --a)
if ((r = n[a].dequeue())) {
o = o.concat(c(t, n, e, r, !0));
break;
}
}
return o;
})(e.graph, e.buckets, e.zeroIdx);
return r.flatten(
r.map(f, function (n) {
return t.outEdges(n.v, n.w);
}),
!0,
);
};
var u = r.constant(1);
function c(t, n, e, o, i) {
var u = i ? [] : void 0;
return (
r.forEach(t.inEdges(o.v), function (r) {
var o = t.edge(r),
c = t.node(r.v);
i && u.push({ v: r.v, w: r.w }), (c.out -= o), a(n, e, c);
}),
r.forEach(t.outEdges(o.v), function (r) {
var o = t.edge(r),
i = r.w,
u = t.node(i);
(u.in -= o), a(n, e, u);
}),
t.removeNode(o.v),
u
);
}
function a(t, n, e) {
e.out
? e.in
? t[e.out - e.in + n].enqueue(e)
: t[t.length - 1].enqueue(e)
: t[0].enqueue(e);
}
},
function (t, n) {
function e() {
var t = {};
(t._next = t._prev = t), (this._sentinel = t);
}
function r(t) {
(t._prev._next = t._next),
(t._next._prev = t._prev),
delete t._next,
delete t._prev;
}
function o(t, n) {
if ("_next" !== t && "_prev" !== t) return n;
}
(t.exports = e),
(e.prototype.dequeue = function () {
var t = this._sentinel,
n = t._prev;
if (n !== t) return r(n), n;
}),
(e.prototype.enqueue = function (t) {
var n = this._sentinel;
t._prev && t._next && r(t),
(t._next = n._next),
(n._next._prev = t),
(n._next = t),
(t._prev = n);
}),
(e.prototype.toString = function () {
for (var t = [], n = this._sentinel, e = n._prev; e !== n; )
t.push(JSON.stringify(e, o)), (e = e._prev);
return "[" + t.join(", ") + "]";
});
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(19);
t.exports = {
run: function (t) {
(t.graph().dummyChains = []),
r.forEach(t.edges(), function (n) {
!(function (t, n) {
var e,
r,
i,
u = n.v,
c = t.node(u).rank,
a = n.w,
f = t.node(a).rank,
s = n.name,
p = t.edge(n),
d = p.labelRank;
if (f === c + 1) return;
for (t.removeEdge(n), i = 0, ++c; c < f; ++i, ++c)
(p.points = []),
(r = {
width: 0,
height: 0,
edgeLabel: p,
edgeObj: n,
rank: c,
}),
(e = o.addDummyNode(t, "edge", r, "_d")),
c === d &&
((r.width = p.width),
(r.height = p.height),
(r.dummy = "edge-label"),
(r.labelpos = p.labelpos)),
t.setEdge(u, e, { weight: p.weight }, s),
0 === i && t.graph().dummyChains.push(e),
(u = e);
t.setEdge(u, a, { weight: p.weight }, s);
})(t, n);
});
},
undo: function (t) {
r.forEach(t.graph().dummyChains, function (n) {
var e,
r = t.node(n),
o = r.edgeLabel;
for (t.setEdge(r.edgeObj, o); r.dummy; )
(e = t.successors(n)[0]),
t.removeNode(n),
o.points.push({ x: r.x, y: r.y }),
"edge-label" === r.dummy &&
((o.x = r.x),
(o.y = r.y),
(o.width = r.width),
(o.height = r.height)),
(n = e),
(r = t.node(n));
});
},
};
},
function (t, n, e) {
"use strict";
var r = e(71).longestPath,
o = e(155),
i = e(360);
t.exports = function (t) {
switch (t.graph().ranker) {
case "network-simplex":
c(t);
break;
case "tight-tree":
!(function (t) {
r(t), o(t);
})(t);
break;
case "longest-path":
u(t);
break;
default:
c(t);
}
};
var u = r;
function c(t) {
i(t);
}
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(155),
i = e(71).slack,
u = e(71).longestPath,
c = e(23).alg.preorder,
a = e(23).alg.postorder,
f = e(19).simplify;
function s(t) {
(t = f(t)), u(t);
var n,
e = o(t);
for (h(e), p(e, t); (n = v(e)); ) g(e, t, n, y(e, t, n));
}
function p(t, n) {
var e = a(t, t.nodes());
(e = e.slice(0, e.length - 1)),
r.forEach(e, function (e) {
!(function (t, n, e) {
var r = t.node(e).parent;
t.edge(e, r).cutvalue = d(t, n, e);
})(t, n, e);
});
}
function d(t, n, e) {
var o = t.node(e).parent,
i = !0,
u = n.edge(e, o),
c = 0;
return (
u || ((i = !1), (u = n.edge(o, e))),
(c = u.weight),
r.forEach(n.nodeEdges(e), function (r) {
var u,
a,
f = r.v === e,
s = f ? r.w : r.v;
if (s !== o) {
var p = f === i,
d = n.edge(r).weight;
if (((c += p ? d : -d), (u = e), (a = s), t.hasEdge(u, a))) {
var h = t.edge(e, s).cutvalue;
c += p ? -h : h;
}
}
}),
c
);
}
function h(t, n) {
arguments.length < 2 && (n = t.nodes()[0]), l(t, {}, 1, n);
}
function l(t, n, e, o, i) {
var u = e,
c = t.node(o);
return (
(n[o] = !0),
r.forEach(t.neighbors(o), function (i) {
r.has(n, i) || (e = l(t, n, e, i, o));
}),
(c.low = u),
(c.lim = e++),
i ? (c.parent = i) : delete c.parent,
e
);
}
function v(t) {
return r.find(t.edges(), function (n) {
return t.edge(n).cutvalue < 0;
});
}
function y(t, n, e) {
var o = e.v,
u = e.w;
n.hasEdge(o, u) || ((o = e.w), (u = e.v));
var c = t.node(o),
a = t.node(u),
f = c,
s = !1;
c.lim > a.lim && ((f = a), (s = !0));
var p = r.filter(n.edges(), function (n) {
return s === b(t, t.node(n.v), f) && s !== b(t, t.node(n.w), f);
});
return r.minBy(p, function (t) {
return i(n, t);
});
}
function g(t, n, e, o) {
var i = e.v,
u = e.w;
t.removeEdge(i, u),
t.setEdge(o.v, o.w, {}),
h(t),
p(t, n),
(function (t, n) {
var e = r.find(t.nodes(), function (t) {
return !n.node(t).parent;
}),
o = c(t, e);
(o = o.slice(1)),
r.forEach(o, function (e) {
var r = t.node(e).parent,
o = n.edge(e, r),
i = !1;
o || ((o = n.edge(r, e)), (i = !0)),
(n.node(e).rank =
n.node(r).rank + (i ? o.minlen : -o.minlen));
});
})(t, n);
}
function b(t, n, e) {
return e.low <= n.lim && n.lim <= e.lim;
}
(t.exports = s),
(s.initLowLimValues = h),
(s.initCutValues = p),
(s.calcCutValue = d),
(s.leaveEdge = v),
(s.enterEdge = y),
(s.exchangeEdges = g);
},
function (t, n, e) {
var r = e(8);
t.exports = function (t) {
var n = (function (t) {
var n = {},
e = 0;
function o(i) {
var u = e;
r.forEach(t.children(i), o), (n[i] = { low: u, lim: e++ });
}
return r.forEach(t.children(), o), n;
})(t);
r.forEach(t.graph().dummyChains, function (e) {
for (
var r = t.node(e),
o = r.edgeObj,
i = (function (t, n, e, r) {
var o,
i,
u = [],
c = [],
a = Math.min(n[e].low, n[r].low),
f = Math.max(n[e].lim, n[r].lim);
o = e;
do {
(o = t.parent(o)), u.push(o);
} while (o && (n[o].low > a || f > n[o].lim));
(i = o), (o = r);
for (; (o = t.parent(o)) !== i; ) c.push(o);
return { path: u.concat(c.reverse()), lca: i };
})(t, n, o.v, o.w),
u = i.path,
c = i.lca,
a = 0,
f = u[a],
s = !0;
e !== o.w;
) {
if (((r = t.node(e)), s)) {
for (; (f = u[a]) !== c && t.node(f).maxRank < r.rank; ) a++;
f === c && (s = !1);
}
if (!s) {
for (
;
a < u.length - 1 && t.node((f = u[a + 1])).minRank <= r.rank;
)
a++;
f = u[a];
}
t.setParent(e, f), (e = t.successors(e)[0]);
}
});
};
},
function (t, n, e) {
var r = e(8),
o = e(19);
t.exports = {
run: function (t) {
var n = o.addDummyNode(t, "root", {}, "_root"),
e = (function (t) {
var n = {};
return (
r.forEach(t.children(), function (e) {
!(function e(o, i) {
var u = t.children(o);
u &&
u.length &&
r.forEach(u, function (t) {
e(t, i + 1);
});
n[o] = i;
})(e, 1);
}),
n
);
})(t),
i = r.max(r.values(e)) - 1,
u = 2 * i + 1;
(t.graph().nestingRoot = n),
r.forEach(t.edges(), function (n) {
t.edge(n).minlen *= u;
});
var c =
(function (t) {
return r.reduce(
t.edges(),
function (n, e) {
return n + t.edge(e).weight;
},
0,
);
})(t) + 1;
r.forEach(t.children(), function (a) {
!(function t(n, e, i, u, c, a, f) {
var s = n.children(f);
if (!s.length)
return void (
f !== e && n.setEdge(e, f, { weight: 0, minlen: i })
);
var p = o.addBorderNode(n, "_bt"),
d = o.addBorderNode(n, "_bb"),
h = n.node(f);
n.setParent(p, f),
(h.borderTop = p),
n.setParent(d, f),
(h.borderBottom = d),
r.forEach(s, function (r) {
t(n, e, i, u, c, a, r);
var o = n.node(r),
s = o.borderTop ? o.borderTop : r,
h = o.borderBottom ? o.borderBottom : r,
l = o.borderTop ? u : 2 * u,
v = s !== h ? 1 : c - a[f] + 1;
n.setEdge(p, s, { weight: l, minlen: v, nestingEdge: !0 }),
n.setEdge(h, d, { weight: l, minlen: v, nestingEdge: !0 });
}),
n.parent(f) || n.setEdge(e, p, { weight: 0, minlen: c + a[f] });
})(t, n, u, c, i, e, a);
}),
(t.graph().nodeRankFactor = u);
},
cleanup: function (t) {
var n = t.graph();
t.removeNode(n.nestingRoot),
delete n.nestingRoot,
r.forEach(t.edges(), function (n) {
t.edge(n).nestingEdge && t.removeEdge(n);
});
},
};
},
function (t, n, e) {
var r = e(8),
o = e(19);
function i(t, n, e, r, i, u) {
var c = { width: 0, height: 0, rank: u, borderType: n },
a = i[n][u - 1],
f = o.addDummyNode(t, "border", c, e);
(i[n][u] = f), t.setParent(f, r), a && t.setEdge(a, f, { weight: 1 });
}
t.exports = function (t) {
r.forEach(t.children(), function n(e) {
var o = t.children(e),
u = t.node(e);
if ((o.length && r.forEach(o, n), r.has(u, "minRank"))) {
(u.borderLeft = []), (u.borderRight = []);
for (var c = u.minRank, a = u.maxRank + 1; c < a; ++c)
i(t, "borderLeft", "_bl", e, u, c),
i(t, "borderRight", "_br", e, u, c);
}
});
};
},
function (t, n, e) {
"use strict";
var r = e(8);
function o(t) {
r.forEach(t.nodes(), function (n) {
i(t.node(n));
}),
r.forEach(t.edges(), function (n) {
i(t.edge(n));
});
}
function i(t) {
var n = t.width;
(t.width = t.height), (t.height = n);
}
function u(t) {
t.y = -t.y;
}
function c(t) {
var n = t.x;
(t.x = t.y), (t.y = n);
}
t.exports = {
adjust: function (t) {
var n = t.graph().rankdir.toLowerCase();
("lr" !== n && "rl" !== n) || o(t);
},
undo: function (t) {
var n = t.graph().rankdir.toLowerCase();
("bt" !== n && "rl" !== n) ||
(function (t) {
r.forEach(t.nodes(), function (n) {
u(t.node(n));
}),
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
r.forEach(e.points, u), r.has(e, "y") && u(e);
});
})(t);
("lr" !== n && "rl" !== n) ||
(!(function (t) {
r.forEach(t.nodes(), function (n) {
c(t.node(n));
}),
r.forEach(t.edges(), function (n) {
var e = t.edge(n);
r.forEach(e.points, c), r.has(e, "x") && c(e);
});
})(t),
o(t));
},
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(366),
i = e(367),
u = e(368),
c = e(372),
a = e(373),
f = e(23).Graph,
s = e(19);
function p(t, n, e) {
return r.map(n, function (n) {
return c(t, n, e);
});
}
function d(t, n) {
var e = new f();
r.forEach(t, function (t) {
var o = t.graph().root,
i = u(t, o, e, n);
r.forEach(i.vs, function (n, e) {
t.node(n).order = e;
}),
a(t, e, i.vs);
});
}
function h(t, n) {
r.forEach(n, function (n) {
r.forEach(n, function (n, e) {
t.node(n).order = e;
});
});
}
t.exports = function (t) {
var n = s.maxRank(t),
e = p(t, r.range(1, n + 1), "inEdges"),
u = p(t, r.range(n - 1, -1, -1), "outEdges"),
c = o(t);
h(t, c);
for (
var a, f = Number.POSITIVE_INFINITY, l = 0, v = 0;
v < 4;
++l, ++v
) {
d(l % 2 ? e : u, l % 4 >= 2), (c = s.buildLayerMatrix(t));
var y = i(t, c);
y < f && ((v = 0), (a = r.cloneDeep(c)), (f = y));
}
h(t, a);
};
},
function (t, n, e) {
"use strict";
var r = e(8);
t.exports = function (t) {
var n = {},
e = r.filter(t.nodes(), function (n) {
return !t.children(n).length;
}),
o = r.max(
r.map(e, function (n) {
return t.node(n).rank;
}),
),
i = r.map(r.range(o + 1), function () {
return [];
});
var u = r.sortBy(e, function (n) {
return t.node(n).rank;
});
return (
r.forEach(u, function e(o) {
if (r.has(n, o)) return;
n[o] = !0;
var u = t.node(o);
i[u.rank].push(o), r.forEach(t.successors(o), e);
}),
i
);
};
},
function (t, n, e) {
"use strict";
var r = e(8);
function o(t, n, e) {
for (
var o = r.zipObject(
e,
r.map(e, function (t, n) {
return n;
}),
),
i = r.flatten(
r.map(n, function (n) {
return r.sortBy(
r.map(t.outEdges(n), function (n) {
return { pos: o[n.w], weight: t.edge(n).weight };
}),
"pos",
);
}),
!0,
),
u = 1;
u < e.length;
)
u <<= 1;
var c = 2 * u - 1;
u -= 1;
var a = r.map(new Array(c), function () {
return 0;
}),
f = 0;
return (
r.forEach(
i.forEach(function (t) {
var n = t.pos + u;
a[n] += t.weight;
for (var e = 0; n > 0; )
n % 2 && (e += a[n + 1]), (a[(n = (n - 1) >> 1)] += t.weight);
f += t.weight * e;
}),
),
f
);
}
t.exports = function (t, n) {
for (var e = 0, r = 1; r < n.length; ++r) e += o(t, n[r - 1], n[r]);
return e;
};
},
function (t, n, e) {
var r = e(8),
o = e(369),
i = e(370),
u = e(371);
t.exports = function t(n, e, c, a) {
var f = n.children(e),
s = n.node(e),
p = s ? s.borderLeft : void 0,
d = s ? s.borderRight : void 0,
h = {};
p &&
(f = r.filter(f, function (t) {
return t !== p && t !== d;
}));
var l = o(n, f);
r.forEach(l, function (e) {
if (n.children(e.v).length) {
var o = t(n, e.v, c, a);
(h[e.v] = o),
r.has(o, "barycenter") &&
((i = e),
(u = o),
r.isUndefined(i.barycenter)
? ((i.barycenter = u.barycenter), (i.weight = u.weight))
: ((i.barycenter =
(i.barycenter * i.weight + u.barycenter * u.weight) /
(i.weight + u.weight)),
(i.weight += u.weight)));
}
var i, u;
});
var v = i(l, c);
!(function (t, n) {
r.forEach(t, function (t) {
t.vs = r.flatten(
t.vs.map(function (t) {
return n[t] ? n[t].vs : t;
}),
!0,
);
});
})(v, h);
var y = u(v, a);
if (
p &&
((y.vs = r.flatten([p, y.vs, d], !0)), n.predecessors(p).length)
) {
var g = n.node(n.predecessors(p)[0]),
b = n.node(n.predecessors(d)[0]);
r.has(y, "barycenter") || ((y.barycenter = 0), (y.weight = 0)),
(y.barycenter =
(y.barycenter * y.weight + g.order + b.order) / (y.weight + 2)),
(y.weight += 2);
}
return y;
};
},
function (t, n, e) {
var r = e(8);
t.exports = function (t, n) {
return r.map(n, function (n) {
var e = t.inEdges(n);
if (e.length) {
var o = r.reduce(
e,
function (n, e) {
var r = t.edge(e),
o = t.node(e.v);
return {
sum: n.sum + r.weight * o.order,
weight: n.weight + r.weight,
};
},
{ sum: 0, weight: 0 },
);
return { v: n, barycenter: o.sum / o.weight, weight: o.weight };
}
return { v: n };
});
};
},
function (t, n, e) {
"use strict";
var r = e(8);
t.exports = function (t, n) {
var e = {};
return (
r.forEach(t, function (t, n) {
var o = (e[t.v] = {
indegree: 0,
in: [],
out: [],
vs: [t.v],
i: n,
});
r.isUndefined(t.barycenter) ||
((o.barycenter = t.barycenter), (o.weight = t.weight));
}),
r.forEach(n.edges(), function (t) {
var n = e[t.v],
o = e[t.w];
r.isUndefined(n) ||
r.isUndefined(o) ||
(o.indegree++, n.out.push(e[t.w]));
}),
(function (t) {
var n = [];
function e(t) {
return function (n) {
n.merged ||
((r.isUndefined(n.barycenter) ||
r.isUndefined(t.barycenter) ||
n.barycenter >= t.barycenter) &&
(function (t, n) {
var e = 0,
r = 0;
t.weight &&
((e += t.barycenter * t.weight), (r += t.weight));
n.weight &&
((e += n.barycenter * n.weight), (r += n.weight));
(t.vs = n.vs.concat(t.vs)),
(t.barycenter = e / r),
(t.weight = r),
(t.i = Math.min(n.i, t.i)),
(n.merged = !0);
})(t, n));
};
}
function o(n) {
return function (e) {
e.in.push(n), 0 == --e.indegree && t.push(e);
};
}
for (; t.length; ) {
var i = t.pop();
n.push(i),
r.forEach(i.in.reverse(), e(i)),
r.forEach(i.out, o(i));
}
return r.map(
r.filter(n, function (t) {
return !t.merged;
}),
function (t) {
return r.pick(t, ["vs", "i", "barycenter", "weight"]);
},
);
})(
r.filter(e, function (t) {
return !t.indegree;
}),
)
);
};
},
function (t, n, e) {
var r = e(8),
o = e(19);
function i(t, n, e) {
for (var o; n.length && (o = r.last(n)).i <= e; )
n.pop(), t.push(o.vs), e++;
return e;
}
t.exports = function (t, n) {
var e = o.partition(t, function (t) {
return r.has(t, "barycenter");
}),
u = e.lhs,
c = r.sortBy(e.rhs, function (t) {
return -t.i;
}),
a = [],
f = 0,
s = 0,
p = 0;
u.sort(
((d = !!n),
function (t, n) {
return t.barycenter < n.barycenter
? -1
: t.barycenter > n.barycenter
? 1
: d
? n.i - t.i
: t.i - n.i;
}),
),
(p = i(a, c, p)),
r.forEach(u, function (t) {
(p += t.vs.length),
a.push(t.vs),
(f += t.barycenter * t.weight),
(s += t.weight),
(p = i(a, c, p));
});
var d;
var h = { vs: r.flatten(a, !0) };
s && ((h.barycenter = f / s), (h.weight = s));
return h;
};
},
function (t, n, e) {
var r = e(8),
o = e(23).Graph;
t.exports = function (t, n, e) {
var i = (function (t) {
var n;
for (; t.hasNode((n = r.uniqueId("_root"))); );
return n;
})(t),
u = new o({ compound: !0 })
.setGraph({ root: i })
.setDefaultNodeLabel(function (n) {
return t.node(n);
});
return (
r.forEach(t.nodes(), function (o) {
var c = t.node(o),
a = t.parent(o);
(c.rank === n || (c.minRank <= n && n <= c.maxRank)) &&
(u.setNode(o),
u.setParent(o, a || i),
r.forEach(t[e](o), function (n) {
var e = n.v === o ? n.w : n.v,
i = u.edge(e, o),
c = r.isUndefined(i) ? 0 : i.weight;
u.setEdge(e, o, { weight: t.edge(n).weight + c });
}),
r.has(c, "minRank") &&
u.setNode(o, {
borderLeft: c.borderLeft[n],
borderRight: c.borderRight[n],
}));
}),
u
);
};
},
function (t, n, e) {
var r = e(8);
t.exports = function (t, n, e) {
var o,
i = {};
r.forEach(e, function (e) {
for (var r, u, c = t.parent(e); c; ) {
if (
((r = t.parent(c))
? ((u = i[r]), (i[r] = c))
: ((u = o), (o = c)),
u && u !== c)
)
return void n.setEdge(u, c);
c = r;
}
});
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(19),
i = e(375).positionX;
t.exports = function (t) {
(function (t) {
var n = o.buildLayerMatrix(t),
e = t.graph().ranksep,
i = 0;
r.forEach(n, function (n) {
var o = r.max(
r.map(n, function (n) {
return t.node(n).height;
}),
);
r.forEach(n, function (n) {
t.node(n).y = i + o / 2;
}),
(i += o + e);
});
})((t = o.asNonCompoundGraph(t))),
r.forEach(i(t), function (n, e) {
t.node(e).x = n;
});
};
},
function (t, n, e) {
"use strict";
var r = e(8),
o = e(23).Graph,
i = e(19);
function u(t, n) {
var e = {};
return (
r.reduce(n, function (n, o) {
var i = 0,
u = 0,
c = n.length,
f = r.last(o);
return (
r.forEach(o, function (n, s) {
var p = (function (t, n) {
if (t.node(n).dummy)
return r.find(t.predecessors(n), function (n) {
return t.node(n).dummy;
});
})(t, n),
d = p ? t.node(p).order : c;
(p || n === f) &&
(r.forEach(o.slice(u, s + 1), function (n) {
r.forEach(t.predecessors(n), function (r) {
var o = t.node(r),
u = o.order;
!(u < i || d < u) ||
(o.dummy && t.node(n).dummy) ||
a(e, r, n);
});
}),
(u = s + 1),
(i = d));
}),
o
);
}),
e
);
}
function c(t, n) {
var e = {};
function o(n, o, i, u, c) {
var f;
r.forEach(r.range(o, i), function (o) {
(f = n[o]),
t.node(f).dummy &&
r.forEach(t.predecessors(f), function (n) {
var r = t.node(n);
r.dummy && (r.order < u || r.order > c) && a(e, n, f);
});
});
}
return (
r.reduce(n, function (n, e) {
var i,
u = -1,
c = 0;
return (
r.forEach(e, function (r, a) {
if ("border" === t.node(r).dummy) {
var f = t.predecessors(r);
f.length &&
((i = t.node(f[0]).order),
o(e, c, a, u, i),
(c = a),
(u = i));
}
o(e, c, e.length, i, n.length);
}),
e
);
}),
e
);
}
function a(t, n, e) {
if (n > e) {
var r = n;
(n = e), (e = r);
}
var o = t[n];
o || (t[n] = o = {}), (o[e] = !0);
}
function f(t, n, e) {
if (n > e) {
var o = n;
(n = e), (e = o);
}
return r.has(t[n], e);
}
function s(t, n, e, o) {
var i = {},
u = {},
c = {};
return (
r.forEach(n, function (t) {
r.forEach(t, function (t, n) {
(i[t] = t), (u[t] = t), (c[t] = n);
});
}),
r.forEach(n, function (t) {
var n = -1;
r.forEach(t, function (t) {
var a = o(t);
if (a.length)
for (
var s =
((a = r.sortBy(a, function (t) {
return c[t];
})).length -
1) /
2,
p = Math.floor(s),
d = Math.ceil(s);
p <= d;
++p
) {
var h = a[p];
u[t] === t &&
n < c[h] &&
!f(e, t, h) &&
((u[h] = t), (u[t] = i[t] = i[h]), (n = c[h]));
}
});
}),
{ root: i, align: u }
);
}
function p(t, n, e, i, u) {
var c = {},
a = (function (t, n, e, i) {
var u = new o(),
c = t.graph(),
a = (function (t, n, e) {
return function (o, i, u) {
var c,
a = o.node(i),
f = o.node(u),
s = 0;
if (((s += a.width / 2), r.has(a, "labelpos")))
switch (a.labelpos.toLowerCase()) {
case "l":
c = -a.width / 2;
break;
case "r":
c = a.width / 2;
}
if (
(c && (s += e ? c : -c),
(c = 0),
(s += (a.dummy ? n : t) / 2),
(s += (f.dummy ? n : t) / 2),
(s += f.width / 2),
r.has(f, "labelpos"))
)
switch (f.labelpos.toLowerCase()) {
case "l":
c = f.width / 2;
break;
case "r":
c = -f.width / 2;
}
return c && (s += e ? c : -c), (c = 0), s;
};
})(c.nodesep, c.edgesep, i);
return (
r.forEach(n, function (n) {
var o;
r.forEach(n, function (n) {
var r = e[n];
if ((u.setNode(r), o)) {
var i = e[o],
c = u.edge(i, r);
u.setEdge(i, r, Math.max(a(t, n, o), c || 0));
}
o = n;
});
}),
u
);
})(t, n, e, u),
f = u ? "borderLeft" : "borderRight";
function s(t, n) {
for (var e = a.nodes(), r = e.pop(), o = {}; r; )
o[r] ? t(r) : ((o[r] = !0), e.push(r), (e = e.concat(n(r)))),
(r = e.pop());
}
return (
s(function (t) {
c[t] = a.inEdges(t).reduce(function (t, n) {
return Math.max(t, c[n.v] + a.edge(n));
}, 0);
}, a.predecessors.bind(a)),
s(function (n) {
var e = a.outEdges(n).reduce(function (t, n) {
return Math.min(t, c[n.w] - a.edge(n));
}, Number.POSITIVE_INFINITY),
r = t.node(n);
e !== Number.POSITIVE_INFINITY &&
r.borderType !== f &&
(c[n] = Math.max(c[n], e));
}, a.successors.bind(a)),
r.forEach(i, function (t) {
c[t] = c[e[t]];
}),
c
);
}
function d(t, n) {
return r.minBy(r.values(n), function (n) {
var e = Number.NEGATIVE_INFINITY,
o = Number.POSITIVE_INFINITY;
return (
r.forIn(n, function (n, r) {
var i =
(function (t, n) {
return t.node(n).width;
})(t, r) / 2;
(e = Math.max(n + i, e)), (o = Math.min(n - i, o));
}),
e - o
);
});
}
function h(t, n) {
var e = r.values(n),
o = r.min(e),
i = r.max(e);
r.forEach(["u", "d"], function (e) {
r.forEach(["l", "r"], function (u) {
var c,
a = e + u,
f = t[a];
if (f !== n) {
var s = r.values(f);
(c = "l" === u ? o - r.min(s) : i - r.max(s)) &&
(t[a] = r.mapValues(f, function (t) {
return t + c;
}));
}
});
});
}
function l(t, n) {
return r.mapValues(t.ul, function (e, o) {
if (n) return t[n.toLowerCase()][o];
var i = r.sortBy(r.map(t, o));
return (i[1] + i[2]) / 2;
});
}
t.exports = {
positionX: function (t) {
var n,
e = i.buildLayerMatrix(t),
o = r.merge(u(t, e), c(t, e)),
a = {};
r.forEach(["u", "d"], function (i) {
(n = "u" === i ? e : r.values(e).reverse()),
r.forEach(["l", "r"], function (e) {
"r" === e &&
(n = r.map(n, function (t) {
return r.values(t).reverse();
}));
var u = ("u" === i ? t.predecessors : t.successors).bind(t),
c = s(t, n, o, u),
f = p(t, n, c.root, c.align, "r" === e);
"r" === e &&
(f = r.mapValues(f, function (t) {
return -t;
})),
(a[i + e] = f);
});
});
var f = d(t, a);
return h(a, f), l(a, t.graph().align);
},
findType1Conflicts: u,
findType2Conflicts: c,
addConflict: a,
hasConflict: f,
verticalAlignment: s,
horizontalCompaction: p,
alignCoordinates: h,
findSmallestWidthAlignment: d,
balance: l,
};
},
function (t, n, e) {
var r = e(8),
o = e(19),
i = e(23).Graph;
t.exports = {
debugOrdering: function (t) {
var n = o.buildLayerMatrix(t),
e = new i({ compound: !0, multigraph: !0 }).setGraph({});
return (
r.forEach(t.nodes(), function (n) {
e.setNode(n, { label: n }),
e.setParent(n, "layer" + t.node(n).rank);
}),
r.forEach(t.edges(), function (t) {
e.setEdge(t.v, t.w, {}, t.name);
}),
r.forEach(n, function (t, n) {
var o = "layer" + n;
e.setNode(o, { rank: "same" }),
r.reduce(t, function (t, n) {
return e.setEdge(t, n, { style: "invis" }), n;
});
}),
e
);
},
};
},
function (t, n) {
t.exports = "0.8.5";
},
]).default;
});
//# sourceMappingURL=dagreLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/forceAtlas2Layout.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.ForceAtlas2Layout = e())
: (t.ForceAtlas2Layout = e());
})(this, function () {
return (function (t) {
var e = {};
function r(i) {
if (e[i]) return e[i].exports;
var n = (e[i] = { i: i, l: !1, exports: {} });
return t[i].call(n.exports, n, n.exports, r), (n.l = !0), n.exports;
}
return (
(r.m = t),
(r.c = e),
(r.d = function (t, e, i) {
r.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: i });
}),
(r.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(r.t = function (t, e) {
if ((1 & e && (t = r(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var i = Object.create(null);
if (
(r.r(i),
Object.defineProperty(i, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var n in t)
r.d(
i,
n,
function (e) {
return t[e];
}.bind(null, n),
);
return i;
}),
(r.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return r.d(e, "a", e), e;
}),
(r.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(r.p = ""),
r((r.s = 378))
);
})({
10: function (t, e, r) {
"use strict";
var i =
(this && this.__createBinding) ||
(Object.create
? function (t, e, r, i) {
void 0 === i && (i = r),
Object.defineProperty(t, i, {
enumerable: !0,
get: function () {
return e[r];
},
});
}
: function (t, e, r, i) {
void 0 === i && (i = r), (t[i] = e[r]);
}),
n =
(this && this.__exportStar) ||
function (t, e) {
for (var r in t)
"default" === r ||
Object.prototype.hasOwnProperty.call(e, r) ||
i(e, t, r);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
n(r(11), e),
n(r(12), e),
n(r(13), e),
n(r(14), e),
n(r(15), e),
n(r(16), e);
},
11: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.camelize = e.isString = void 0);
e.isString = function (t) {
return "string" == typeof t;
};
var i,
n,
o = /-(\w)/g;
e.camelize =
((i = function (t) {
return t.replace(o, function (t, e) {
return e ? e.toUpperCase() : "";
});
}),
(n = Object.create(null)),
function (t) {
return n[t] || (n[t] = i(t));
});
},
12: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isArray = void 0),
(e.isArray = Array.isArray);
},
13: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.toNumber = e.isNaN = e.isNumber = void 0);
e.isNumber = function (t) {
return "number" == typeof t;
};
e.isNaN = function (t) {
return Number.isNaN(Number(t));
};
e.toNumber = function (t) {
var r = parseFloat(t);
return e.isNaN(r) ? t : r;
};
},
14: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.traverseTreeUp =
e.scaleMatrix =
e.getAdjMatrix =
e.floydWarshall =
e.getDegree =
void 0);
e.getDegree = function (t, e, r) {
for (var i = [], n = 0; n < t; n++) i[n] = 0;
return r
? (r.forEach(function (t) {
t.source && (i[e[t.source]] += 1),
t.target && (i[e[t.target]] += 1);
}),
i)
: i;
};
e.floydWarshall = function (t) {
for (var e = [], r = t.length, i = 0; i < r; i += 1) {
e[i] = [];
for (var n = 0; n < r; n += 1)
i === n
? (e[i][n] = 0)
: 0 !== t[i][n] && t[i][n]
? (e[i][n] = t[i][n])
: (e[i][n] = 1 / 0);
}
for (var o = 0; o < r; o += 1)
for (i = 0; i < r; i += 1)
for (n = 0; n < r; n += 1)
e[i][n] > e[i][o] + e[o][n] && (e[i][n] = e[i][o] + e[o][n]);
return e;
};
e.getAdjMatrix = function (t, e) {
var r = t.nodes,
i = t.edges,
n = [],
o = {};
if (!r) throw new Error("invalid nodes data!");
return (
r &&
r.forEach(function (t, e) {
o[t.id] = e;
n.push([]);
}),
i &&
i.forEach(function (t) {
var r = t.source,
i = t.target,
s = o[r],
u = o[i];
(n[s][u] = 1), e || (n[u][s] = 1);
}),
n
);
};
e.scaleMatrix = function (t, e) {
var r = [];
return (
t.forEach(function (t) {
var i = [];
t.forEach(function (t) {
i.push(t * e);
}),
r.push(i);
}),
r
);
};
e.traverseTreeUp = function (t, e) {
"function" == typeof e &&
(function t(e, r) {
if (e && e.children)
for (var i = e.children.length - 1; i >= 0; i--)
if (!t(e.children[i], r)) return;
return !!r(e);
})(t, e);
};
},
15: function (t, e, r) {
"use strict";
function i(t) {
return (i =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var n =
(this && this.__assign) ||
function () {
return (n =
Object.assign ||
function (t) {
for (var e, r = 1, i = arguments.length; r < i; r++)
for (var n in (e = arguments[r]))
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clone = e.isObject = void 0);
e.isObject = function (t) {
return null !== t && "object" === i(t);
};
e.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var r = [];
return (
t.forEach(function (t) {
r.push(t);
}),
r.map(function (t) {
return e.clone(t);
})
);
}
if ("object" === i(t) && t !== {}) {
var o = n({}, t);
return (
Object.keys(o).forEach(function (t) {
o[t] = e.clone(o[t]);
}),
o
);
}
return t;
};
},
16: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isFunction = void 0);
e.isFunction = function (t) {
return "function" == typeof t;
};
},
162: function (t, e, r) {
"use strict";
var i,
n =
(this && this.__extends) ||
((i = function (t, e) {
return (i =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var r in e)
Object.prototype.hasOwnProperty.call(e, r) && (t[r] = e[r]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function r() {
this.constructor = t;
}
i(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((r.prototype = e.prototype), new r()));
}),
o =
(this && this.__importDefault) ||
function (t) {
return t && t.__esModule ? t : { default: t };
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.ForceAtlas2Layout = void 0);
var s = r(9),
u = r(10),
h = o(r(379)),
a = o(r(380)),
c = o(r(381)),
d = (function (t) {
function e(e) {
var r = t.call(this) || this;
return (
(r.center = [0, 0]),
(r.width = 300),
(r.height = 300),
(r.nodes = []),
(r.edges = []),
(r.kr = 5),
(r.kg = 1),
(r.mode = "normal"),
(r.preventOverlap = !1),
(r.dissuadeHubs = !1),
(r.barnesHut = !1),
(r.maxIteration = 0),
(r.ks = 0.1),
(r.ksmax = 10),
(r.tao = 0.1),
(r.onLayoutEnd = function () {}),
(r.prune = !1),
r.updateCfg(e),
r
);
}
return (
n(e, t),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.execute = function () {
var t = this.nodes,
e = this.maxIteration,
r = this.onLayoutEnd,
i = this.prune;
this.width ||
"undefined" == typeof window ||
(this.width = window.innerWidth),
this.height ||
"undefined" == typeof window ||
(this.height = window.innerHeight);
for (var n = [], o = t.length, s = 0; s < o; s += 1) {
var h = t[s],
a = 10,
c = 10;
u.isNumber(h.size) && ((a = h.size), (c = h.size)),
u.isArray(h.size) &&
(isNaN(h.size[0]) || (a = h.size[0]),
isNaN(h.size[1]) || (c = h.size[1])),
this.getWidth &&
!isNaN(this.getWidth(h)) &&
(c = this.getWidth(h)),
this.getHeight &&
!isNaN(this.getHeight(h)) &&
(a = this.getHeight(h));
var d = Math.max(a, c);
n.push(d);
}
!this.barnesHut && o > 250 && (this.barnesHut = !0),
!this.prune && o > 100 && (this.prune = !0),
0 !== this.maxIteration || this.prune
? 0 === this.maxIteration &&
i &&
((e = 100),
o <= 200 && o > 100 ? (e = 500) : o > 200 && (e = 950),
(this.maxIteration = e))
: ((e = 250),
o <= 200 && o > 100 ? (e = 1e3) : o > 200 && (e = 1200),
(this.maxIteration = e)),
this.kr ||
((this.kr = 50),
o > 100 && o <= 500
? (this.kr = 20)
: o > 500 && (this.kr = 1)),
this.kg ||
((this.kg = 20),
o > 100 && o <= 500
? (this.kg = 10)
: o > 500 && (this.kg = 1)),
(this.nodes = this.updateNodesByForces(n)),
r();
}),
(e.prototype.updateNodesByForces = function (t) {
for (
var e = this.nodes,
r = this.edges,
i = this.maxIteration,
n = r.filter(function (t) {
return t.source !== t.target;
}),
o = e.length,
s = n.length,
u = [],
h = {},
a = {},
c = [],
d = 0;
d < o;
d += 1
)
(h[e[d].id] = d),
(u[d] = 0),
(void 0 === e[d].x || isNaN(e[d].x)) &&
(e[d].x = 1e3 * Math.random()),
(void 0 === e[d].y || isNaN(e[d].y)) &&
(e[d].y = 1e3 * Math.random()),
c.push({ x: e[d].x, y: e[d].y });
for (d = 0; d < s; d += 1) {
for (
var f = void 0, p = void 0, l = 0, y = 0, g = 0;
g < o;
g += 1
)
e[g].id === n[d].source
? ((f = e[g]), (l = g))
: e[g].id === n[d].target && ((p = e[g]), (y = g)),
(a[d] = { sourceIdx: l, targetIdx: y });
f && (u[h[f.id]] += 1), p && (u[h[p.id]] += 1);
}
var v = i;
if (((e = this.iterate(v, h, a, s, u, t)), this.prune)) {
for (g = 0; g < s; g += 1)
u[a[g].sourceIdx] <= 1
? ((e[a[g].sourceIdx].x = e[a[g].targetIdx].x),
(e[a[g].sourceIdx].y = e[a[g].targetIdx].y))
: u[a[g].targetIdx] <= 1 &&
((e[a[g].targetIdx].x = e[a[g].sourceIdx].x),
(e[a[g].targetIdx].y = e[a[g].sourceIdx].y));
(this.prune = !1),
(this.barnesHut = !1),
(v = 100),
(e = this.iterate(v, h, a, s, u, t));
}
return e;
}),
(e.prototype.iterate = function (t, e, r, i, n, o) {
for (
var s = this.nodes,
u = this.kr,
a = this.preventOverlap,
c = this.barnesHut,
d = s.length,
f = 0,
p = t,
l = [],
y = [],
g = [],
v = 0;
v < d;
v += 1
)
if (((l[2 * v] = 0), (l[2 * v + 1] = 0), c)) {
var x = {
id: v,
rx: s[v].x,
ry: s[v].y,
mass: 1,
g: u,
degree: n[v],
};
g[v] = new h.default(x);
}
for (; p > 0; ) {
for (v = 0; v < d; v += 1)
(y[2 * v] = l[2 * v]),
(y[2 * v + 1] = l[2 * v + 1]),
(l[2 * v] = 0),
(l[2 * v + 1] = 0);
(l = this.getAttrForces(p, 50, i, e, r, n, o, l)),
(l =
c && ((a && p > 50) || !a)
? this.getOptRepGraForces(l, g, n)
: this.getRepGraForces(p, 50, l, 100, o, n));
var m = this.updatePos(l, y, f, n);
(s = m.nodes), (f = m.sg), p--, this.tick && this.tick();
}
return s;
}),
(e.prototype.getAttrForces = function (t, e, r, i, n, o, s, u) {
for (
var h = this.nodes,
a = this.preventOverlap,
c = this.dissuadeHubs,
d = this.mode,
f = this.prune,
p = 0;
p < r;
p += 1
) {
var l = h[n[p].sourceIdx],
y = n[p].sourceIdx,
g = h[n[p].targetIdx],
v = n[p].targetIdx;
if (!f || !(o[y] <= 1 || o[v] <= 1)) {
var x = [g.x - l.x, g.y - l.y],
m = Math.hypot(x[0], x[1]);
(m = m < 1e-4 ? 1e-4 : m),
(x[0] = x[0] / m),
(x[1] = x[1] / m),
a && t < e && (m = m - s[y] - s[v]);
var b = m,
_ = b;
"linlog" === d && (_ = b = Math.log(1 + m)),
c && ((b = m / o[y]), (_ = m / o[v])),
a && t < e && m <= 0
? ((b = 0), (_ = 0))
: a && t < e && m > 0 && ((b = m), (_ = m)),
(u[2 * i[l.id]] += b * x[0]),
(u[2 * i[g.id]] -= _ * x[0]),
(u[2 * i[l.id] + 1] += b * x[1]),
(u[2 * i[g.id] + 1] -= _ * x[1]);
}
}
return u;
}),
(e.prototype.getRepGraForces = function (t, e, r, i, n, o) {
for (
var s = this.nodes,
u = this.preventOverlap,
h = this.kr,
a = this.kg,
c = this.center,
d = this.prune,
f = s.length,
p = 0;
p < f;
p += 1
) {
for (var l = p + 1; l < f; l += 1)
if (!d || !(o[p] <= 1 || o[l] <= 1)) {
var y = [s[l].x - s[p].x, s[l].y - s[p].y],
g = Math.hypot(y[0], y[1]);
(g = g < 1e-4 ? 1e-4 : g),
(y[0] = y[0] / g),
(y[1] = y[1] / g),
u && t < e && (g = g - n[p] - n[l]);
var v = (h * (o[p] + 1) * (o[l] + 1)) / g;
u && t < e && g < 0
? (v = i * (o[p] + 1) * (o[l] + 1))
: u && t < e && 0 === g
? (v = 0)
: u &&
t < e &&
g > 0 &&
(v = (h * (o[p] + 1) * (o[l] + 1)) / g),
(r[2 * p] -= v * y[0]),
(r[2 * l] += v * y[0]),
(r[2 * p + 1] -= v * y[1]),
(r[2 * l + 1] += v * y[1]);
}
var x = [s[p].x - c[0], s[p].y - c[1]],
m = Math.hypot(x[0], x[1]);
(x[0] = x[0] / m), (x[1] = x[1] / m);
var b = a * (o[p] + 1);
(r[2 * p] -= b * x[0]), (r[2 * p + 1] -= b * x[1]);
}
return r;
}),
(e.prototype.getOptRepGraForces = function (t, e, r) {
for (
var i = this.nodes,
n = this.kg,
o = this.center,
s = this.prune,
u = i.length,
h = 9e10,
d = -9e10,
f = 9e10,
p = -9e10,
l = 0;
l < u;
l += 1
)
(s && r[l] <= 1) ||
(e[l].setPos(i[l].x, i[l].y),
i[l].x >= d && (d = i[l].x),
i[l].x <= h && (h = i[l].x),
i[l].y >= p && (p = i[l].y),
i[l].y <= f && (f = i[l].y));
var y = {
xmid: (d + h) / 2,
ymid: (p + f) / 2,
length: Math.max(d - h, p - f),
massCenter: o,
mass: u,
},
g = new a.default(y),
v = new c.default(g);
for (l = 0; l < u; l += 1)
(s && r[l] <= 1) || (e[l].in(g) && v.insert(e[l]));
for (l = 0; l < u; l += 1)
if (!(s && r[l] <= 1)) {
e[l].resetForce(),
v.updateForce(e[l]),
(t[2 * l] -= e[l].fx),
(t[2 * l + 1] -= e[l].fy);
var x = [i[l].x - o[0], i[l].y - o[1]],
m = Math.hypot(x[0], x[1]);
(m = m < 1e-4 ? 1e-4 : m),
(x[0] = x[0] / m),
(x[1] = x[1] / m);
var b = n * (r[l] + 1);
(t[2 * l] -= b * x[0]), (t[2 * l + 1] -= b * x[1]);
}
return t;
}),
(e.prototype.updatePos = function (t, e, r, i) {
for (
var n = this.nodes,
o = this.ks,
s = this.tao,
u = this.prune,
h = this.ksmax,
a = n.length,
c = [],
d = [],
f = 0,
p = 0,
l = 0;
l < a;
l += 1
)
if (!(u && i[l] <= 1)) {
var y = [t[2 * l] - e[2 * l], t[2 * l + 1] - e[2 * l + 1]],
g = Math.hypot(y[0], y[1]),
v = [t[2 * l] + e[2 * l], t[2 * l + 1] + e[2 * l + 1]],
x = Math.hypot(v[0], v[1]);
(c[l] = g),
(d[l] = x / 2),
(f += (i[l] + 1) * c[l]),
(p += (i[l] + 1) * d[l]);
}
var m = r;
(r = (s * p) / f), 0 !== m && (r = r > 1.5 * m ? 1.5 * m : r);
for (l = 0; l < a; l += 1)
if (!(u && i[l] <= 1)) {
var b = (o * r) / (1 + r * Math.sqrt(c[l])),
_ = Math.hypot(t[2 * l], t[2 * l + 1]),
N = h / (_ = _ < 1e-4 ? 1e-4 : _),
O = (b = b > N ? N : b) * t[2 * l],
j = b * t[2 * l + 1];
(n[l].x += O), (n[l].y += j);
}
return { nodes: n, sg: r };
}),
e
);
})(s.Base);
e.ForceAtlas2Layout = d;
},
378: function (t, e, r) {
"use strict";
r.r(e);
var i = r(162);
e.default = i.ForceAtlas2Layout;
},
379: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 });
var i = (function () {
function t(t) {
(this.id = t.id || 0),
(this.rx = t.rx),
(this.ry = t.ry),
(this.fx = 0),
(this.fy = 0),
(this.mass = t.mass),
(this.degree = t.degree),
(this.g = t.g || 0);
}
return (
(t.prototype.distanceTo = function (t) {
var e = this.rx - t.rx,
r = this.ry - t.ry;
return Math.hypot(e, r);
}),
(t.prototype.setPos = function (t, e) {
(this.rx = t), (this.ry = e);
}),
(t.prototype.resetForce = function () {
(this.fx = 0), (this.fy = 0);
}),
(t.prototype.addForce = function (t) {
var e = t.rx - this.rx,
r = t.ry - this.ry,
i = Math.hypot(e, r);
i = i < 1e-4 ? 1e-4 : i;
var n = (this.g * (this.degree + 1) * (t.degree + 1)) / i;
(this.fx += (n * e) / i), (this.fy += (n * r) / i);
}),
(t.prototype.in = function (t) {
return t.contains(this.rx, this.ry);
}),
(t.prototype.add = function (e) {
var r = this.mass + e.mass;
return new t({
rx: (this.rx * this.mass + e.rx * e.mass) / r,
ry: (this.ry * this.mass + e.ry * e.mass) / r,
mass: r,
degree: this.degree + e.degree,
});
}),
t
);
})();
e.default = i;
},
380: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 });
var i = (function () {
function t(t) {
(this.xmid = t.xmid),
(this.ymid = t.ymid),
(this.length = t.length),
(this.massCenter = t.massCenter || [0, 0]),
(this.mass = t.mass || 1);
}
return (
(t.prototype.getLength = function () {
return this.length;
}),
(t.prototype.contains = function (t, e) {
var r = this.length / 2;
return (
t <= this.xmid + r &&
t >= this.xmid - r &&
e <= this.ymid + r &&
e >= this.ymid - r
);
}),
(t.prototype.NW = function () {
return new t({
xmid: this.xmid - this.length / 4,
ymid: this.ymid + this.length / 4,
length: this.length / 2,
});
}),
(t.prototype.NE = function () {
return new t({
xmid: this.xmid + this.length / 4,
ymid: this.ymid + this.length / 4,
length: this.length / 2,
});
}),
(t.prototype.SW = function () {
return new t({
xmid: this.xmid - this.length / 4,
ymid: this.ymid - this.length / 4,
length: this.length / 2,
});
}),
(t.prototype.SE = function () {
return new t({
xmid: this.xmid + this.length / 4,
ymid: this.ymid - this.length / 4,
length: this.length / 2,
});
}),
t
);
})();
e.default = i;
},
381: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 });
var i = (function () {
function t(t) {
(this.body = null),
(this.quad = null),
(this.NW = null),
(this.NE = null),
(this.SW = null),
(this.SE = null),
(this.theta = 0.5),
null != t && (this.quad = t);
}
return (
(t.prototype.insert = function (e) {
null != this.body
? this._isExternal()
? (this.quad &&
((this.NW = new t(this.quad.NW())),
(this.NE = new t(this.quad.NE())),
(this.SW = new t(this.quad.SW())),
(this.SE = new t(this.quad.SE()))),
this._putBody(this.body),
this._putBody(e),
(this.body = this.body.add(e)))
: ((this.body = this.body.add(e)), this._putBody(e))
: (this.body = e);
}),
(t.prototype._putBody = function (t) {
this.quad &&
(t.in(this.quad.NW()) && this.NW
? this.NW.insert(t)
: t.in(this.quad.NE()) && this.NE
? this.NE.insert(t)
: t.in(this.quad.SW()) && this.SW
? this.SW.insert(t)
: t.in(this.quad.SE()) && this.SE && this.SE.insert(t));
}),
(t.prototype._isExternal = function () {
return (
null == this.NW &&
null == this.NE &&
null == this.SW &&
null == this.SE
);
}),
(t.prototype.updateForce = function (t) {
null != this.body &&
t !== this.body &&
(this._isExternal() ||
(this.quad ? this.quad.getLength() : 0) /
this.body.distanceTo(t) <
this.theta
? t.addForce(this.body)
: (this.NW && this.NW.updateForce(t),
this.NE && this.NE.updateForce(t),
this.SW && this.SW.updateForce(t),
this.SE && this.SE.updateForce(t)));
}),
t
);
})();
e.default = i;
},
9: function (t, e, r) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var i = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = i;
},
}).default;
});
//# sourceMappingURL=forceAtlas2Layout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/forceLayout.js
================================================
!(function (t, n) {
"object" == typeof exports && "object" == typeof module
? (module.exports = n())
: "function" == typeof define && define.amd
? define([], n)
: "object" == typeof exports
? (exports.ForceLayout = n())
: (t.ForceLayout = n());
})(this, function () {
return (function (t) {
var n = {};
function e(r) {
if (n[r]) return n[r].exports;
var o = (n[r] = { i: r, l: !1, exports: {} });
return t[r].call(o.exports, o, o.exports, e), (o.l = !0), o.exports;
}
return (
(e.m = t),
(e.c = n),
(e.d = function (t, n, r) {
e.o(t, n) || Object.defineProperty(t, n, { enumerable: !0, get: r });
}),
(e.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(e.t = function (t, n) {
if ((1 & n && (t = e(t)), 8 & n)) return t;
if (4 & n && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(e.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & n && "string" != typeof t)
)
for (var o in t)
e.d(
r,
o,
function (n) {
return t[n];
}.bind(null, o),
);
return r;
}),
(e.n = function (t) {
var n =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return e.d(n, "a", n), n;
}),
(e.o = function (t, n) {
return Object.prototype.hasOwnProperty.call(t, n);
}),
(e.p = ""),
e((e.s = 382))
);
})({
10: function (t, n, e) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, n, e, r) {
void 0 === r && (r = e),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return n[e];
},
});
}
: function (t, n, e, r) {
void 0 === r && (r = e), (t[r] = n[e]);
}),
o =
(this && this.__exportStar) ||
function (t, n) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(n, e) ||
r(n, t, e);
};
Object.defineProperty(n, "__esModule", { value: !0 }),
o(e(11), n),
o(e(12), n),
o(e(13), n),
o(e(14), n),
o(e(15), n),
o(e(16), n);
},
11: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.camelize = n.isString = void 0);
n.isString = function (t) {
return "string" == typeof t;
};
var r,
o,
i = /-(\w)/g;
n.camelize =
((r = function (t) {
return t.replace(i, function (t, n) {
return n ? n.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (t) {
return o[t] || (o[t] = r(t));
});
},
12: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.isArray = void 0),
(n.isArray = Array.isArray);
},
13: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.toNumber = n.isNaN = n.isNumber = void 0);
n.isNumber = function (t) {
return "number" == typeof t;
};
n.isNaN = function (t) {
return Number.isNaN(Number(t));
};
n.toNumber = function (t) {
var e = parseFloat(t);
return n.isNaN(e) ? t : e;
};
},
14: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.traverseTreeUp =
n.scaleMatrix =
n.getAdjMatrix =
n.floydWarshall =
n.getDegree =
void 0);
n.getDegree = function (t, n, e) {
for (var r = [], o = 0; o < t; o++) r[o] = 0;
return e
? (e.forEach(function (t) {
t.source && (r[n[t.source]] += 1),
t.target && (r[n[t.target]] += 1);
}),
r)
: r;
};
n.floydWarshall = function (t) {
for (var n = [], e = t.length, r = 0; r < e; r += 1) {
n[r] = [];
for (var o = 0; o < e; o += 1)
r === o
? (n[r][o] = 0)
: 0 !== t[r][o] && t[r][o]
? (n[r][o] = t[r][o])
: (n[r][o] = 1 / 0);
}
for (var i = 0; i < e; i += 1)
for (r = 0; r < e; r += 1)
for (o = 0; o < e; o += 1)
n[r][o] > n[r][i] + n[i][o] && (n[r][o] = n[r][i] + n[i][o]);
return n;
};
n.getAdjMatrix = function (t, n) {
var e = t.nodes,
r = t.edges,
o = [],
i = {};
if (!e) throw new Error("invalid nodes data!");
return (
e &&
e.forEach(function (t, n) {
i[t.id] = n;
o.push([]);
}),
r &&
r.forEach(function (t) {
var e = t.source,
r = t.target,
u = i[e],
c = i[r];
(o[u][c] = 1), n || (o[c][u] = 1);
}),
o
);
};
n.scaleMatrix = function (t, n) {
var e = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * n);
}),
e.push(r);
}),
e
);
};
n.traverseTreeUp = function (t, n) {
"function" == typeof n &&
(function t(n, e) {
if (n && n.children)
for (var r = n.children.length - 1; r >= 0; r--)
if (!t(n.children[r], e)) return;
return !!e(n);
})(t, n);
};
},
15: function (t, n, e) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (t) {
for (var n, e = 1, r = arguments.length; e < r; e++)
for (var o in (n = arguments[e]))
Object.prototype.hasOwnProperty.call(n, o) && (t[o] = n[o]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.clone = n.isObject = void 0);
n.isObject = function (t) {
return null !== t && "object" === r(t);
};
n.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var e = [];
return (
t.forEach(function (t) {
e.push(t);
}),
e.map(function (t) {
return n.clone(t);
})
);
}
if ("object" === r(t) && t !== {}) {
var i = o({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = n.clone(i[t]);
}),
i
);
}
return t;
};
},
156: function (t, n, e) {
"use strict";
e.r(n),
e.d(n, "forceCenter", function () {
return r;
}),
e.d(n, "forceCollide", function () {
return v;
}),
e.d(n, "forceLink", function () {
return b;
}),
e.d(n, "forceManyBody", function () {
return V;
}),
e.d(n, "forceRadial", function () {
return Z;
}),
e.d(n, "forceSimulation", function () {
return Q;
}),
e.d(n, "forceX", function () {
return $;
}),
e.d(n, "forceY", function () {
return tt;
});
var r = function (t, n) {
var e,
r = 1;
function o() {
var o,
i,
u = e.length,
c = 0,
f = 0;
for (o = 0; o < u; ++o) (c += (i = e[o]).x), (f += i.y);
for (c = (c / u - t) * r, f = (f / u - n) * r, o = 0; o < u; ++o)
((i = e[o]).x -= c), (i.y -= f);
}
return (
null == t && (t = 0),
null == n && (n = 0),
(o.initialize = function (t) {
e = t;
}),
(o.x = function (n) {
return arguments.length ? ((t = +n), o) : t;
}),
(o.y = function (t) {
return arguments.length ? ((n = +t), o) : n;
}),
(o.strength = function (t) {
return arguments.length ? ((r = +t), o) : r;
}),
o
);
};
function o(t, n, e, r) {
if (isNaN(n) || isNaN(e)) return t;
var o,
i,
u,
c,
f,
a,
l,
s,
h,
d = t._root,
y = { data: r },
p = t._x0,
v = t._y0,
g = t._x1,
_ = t._y1;
if (!d) return (t._root = y), t;
for (; d.length; )
if (
((a = n >= (i = (p + g) / 2)) ? (p = i) : (g = i),
(l = e >= (u = (v + _) / 2)) ? (v = u) : (_ = u),
(o = d),
!(d = d[(s = (l << 1) | a)]))
)
return (o[s] = y), t;
if (
((c = +t._x.call(null, d.data)),
(f = +t._y.call(null, d.data)),
n === c && e === f)
)
return (y.next = d), o ? (o[s] = y) : (t._root = y), t;
do {
(o = o ? (o[s] = new Array(4)) : (t._root = new Array(4))),
(a = n >= (i = (p + g) / 2)) ? (p = i) : (g = i),
(l = e >= (u = (v + _) / 2)) ? (v = u) : (_ = u);
} while ((s = (l << 1) | a) == (h = ((f >= u) << 1) | (c >= i)));
return (o[h] = d), (o[s] = y), t;
}
var i = function (t, n, e, r, o) {
(this.node = t),
(this.x0 = n),
(this.y0 = e),
(this.x1 = r),
(this.y1 = o);
};
function u(t) {
return t[0];
}
function c(t) {
return t[1];
}
function f(t, n, e) {
var r = new a(null == n ? u : n, null == e ? c : e, NaN, NaN, NaN, NaN);
return null == t ? r : r.addAll(t);
}
function a(t, n, e, r, o, i) {
(this._x = t),
(this._y = n),
(this._x0 = e),
(this._y0 = r),
(this._x1 = o),
(this._y1 = i),
(this._root = void 0);
}
function l(t) {
for (var n = { data: t.data }, e = n; (t = t.next); )
e = e.next = { data: t.data };
return n;
}
var s = (f.prototype = a.prototype);
(s.copy = function () {
var t,
n,
e = new a(this._x, this._y, this._x0, this._y0, this._x1, this._y1),
r = this._root;
if (!r) return e;
if (!r.length) return (e._root = l(r)), e;
for (
t = [{ source: r, target: (e._root = new Array(4)) }];
(r = t.pop());
)
for (var o = 0; o < 4; ++o)
(n = r.source[o]) &&
(n.length
? t.push({ source: n, target: (r.target[o] = new Array(4)) })
: (r.target[o] = l(n)));
return e;
}),
(s.add = function (t) {
var n = +this._x.call(null, t),
e = +this._y.call(null, t);
return o(this.cover(n, e), n, e, t);
}),
(s.addAll = function (t) {
var n,
e,
r,
i,
u = t.length,
c = new Array(u),
f = new Array(u),
a = 1 / 0,
l = 1 / 0,
s = -1 / 0,
h = -1 / 0;
for (e = 0; e < u; ++e)
isNaN((r = +this._x.call(null, (n = t[e])))) ||
isNaN((i = +this._y.call(null, n))) ||
((c[e] = r),
(f[e] = i),
r < a && (a = r),
r > s && (s = r),
i < l && (l = i),
i > h && (h = i));
if (a > s || l > h) return this;
for (this.cover(a, l).cover(s, h), e = 0; e < u; ++e)
o(this, c[e], f[e], t[e]);
return this;
}),
(s.cover = function (t, n) {
if (isNaN((t = +t)) || isNaN((n = +n))) return this;
var e = this._x0,
r = this._y0,
o = this._x1,
i = this._y1;
if (isNaN(e))
(o = (e = Math.floor(t)) + 1), (i = (r = Math.floor(n)) + 1);
else {
for (
var u, c, f = o - e || 1, a = this._root;
e > t || t >= o || r > n || n >= i;
)
switch (
((c = ((n < r) << 1) | (t < e)),
((u = new Array(4))[c] = a),
(a = u),
(f *= 2),
c)
) {
case 0:
(o = e + f), (i = r + f);
break;
case 1:
(e = o - f), (i = r + f);
break;
case 2:
(o = e + f), (r = i - f);
break;
case 3:
(e = o - f), (r = i - f);
}
this._root && this._root.length && (this._root = a);
}
return (
(this._x0 = e), (this._y0 = r), (this._x1 = o), (this._y1 = i), this
);
}),
(s.data = function () {
var t = [];
return (
this.visit(function (n) {
if (!n.length)
do {
t.push(n.data);
} while ((n = n.next));
}),
t
);
}),
(s.extent = function (t) {
return arguments.length
? this.cover(+t[0][0], +t[0][1]).cover(+t[1][0], +t[1][1])
: isNaN(this._x0)
? void 0
: [
[this._x0, this._y0],
[this._x1, this._y1],
];
}),
(s.find = function (t, n, e) {
var r,
o,
u,
c,
f,
a,
l,
s = this._x0,
h = this._y0,
d = this._x1,
y = this._y1,
p = [],
v = this._root;
for (
v && p.push(new i(v, s, h, d, y)),
null == e
? (e = 1 / 0)
: ((s = t - e),
(h = n - e),
(d = t + e),
(y = n + e),
(e *= e));
(a = p.pop());
)
if (
!(
!(v = a.node) ||
(o = a.x0) > d ||
(u = a.y0) > y ||
(c = a.x1) < s ||
(f = a.y1) < h
)
)
if (v.length) {
var g = (o + c) / 2,
_ = (u + f) / 2;
p.push(
new i(v[3], g, _, c, f),
new i(v[2], o, _, g, f),
new i(v[1], g, u, c, _),
new i(v[0], o, u, g, _),
),
(l = ((n >= _) << 1) | (t >= g)) &&
((a = p[p.length - 1]),
(p[p.length - 1] = p[p.length - 1 - l]),
(p[p.length - 1 - l] = a));
} else {
var x = t - +this._x.call(null, v.data),
b = n - +this._y.call(null, v.data),
w = x * x + b * b;
if (w < e) {
var m = Math.sqrt((e = w));
(s = t - m),
(h = n - m),
(d = t + m),
(y = n + m),
(r = v.data);
}
}
return r;
}),
(s.remove = function (t) {
if (
isNaN((i = +this._x.call(null, t))) ||
isNaN((u = +this._y.call(null, t)))
)
return this;
var n,
e,
r,
o,
i,
u,
c,
f,
a,
l,
s,
h,
d = this._root,
y = this._x0,
p = this._y0,
v = this._x1,
g = this._y1;
if (!d) return this;
if (d.length)
for (;;) {
if (
((a = i >= (c = (y + v) / 2)) ? (y = c) : (v = c),
(l = u >= (f = (p + g) / 2)) ? (p = f) : (g = f),
(n = d),
!(d = d[(s = (l << 1) | a)]))
)
return this;
if (!d.length) break;
(n[(s + 1) & 3] || n[(s + 2) & 3] || n[(s + 3) & 3]) &&
((e = n), (h = s));
}
for (; d.data !== t; ) if (((r = d), !(d = d.next))) return this;
return (
(o = d.next) && delete d.next,
r
? (o ? (r.next = o) : delete r.next, this)
: n
? (o ? (n[s] = o) : delete n[s],
(d = n[0] || n[1] || n[2] || n[3]) &&
d === (n[3] || n[2] || n[1] || n[0]) &&
!d.length &&
(e ? (e[h] = d) : (this._root = d)),
this)
: ((this._root = o), this)
);
}),
(s.removeAll = function (t) {
for (var n = 0, e = t.length; n < e; ++n) this.remove(t[n]);
return this;
}),
(s.root = function () {
return this._root;
}),
(s.size = function () {
var t = 0;
return (
this.visit(function (n) {
if (!n.length)
do {
++t;
} while ((n = n.next));
}),
t
);
}),
(s.visit = function (t) {
var n,
e,
r,
o,
u,
c,
f = [],
a = this._root;
for (
a && f.push(new i(a, this._x0, this._y0, this._x1, this._y1));
(n = f.pop());
)
if (
!t(
(a = n.node),
(r = n.x0),
(o = n.y0),
(u = n.x1),
(c = n.y1),
) &&
a.length
) {
var l = (r + u) / 2,
s = (o + c) / 2;
(e = a[3]) && f.push(new i(e, l, s, u, c)),
(e = a[2]) && f.push(new i(e, r, s, l, c)),
(e = a[1]) && f.push(new i(e, l, o, u, s)),
(e = a[0]) && f.push(new i(e, r, o, l, s));
}
return this;
}),
(s.visitAfter = function (t) {
var n,
e = [],
r = [];
for (
this._root &&
e.push(new i(this._root, this._x0, this._y0, this._x1, this._y1));
(n = e.pop());
) {
var o = n.node;
if (o.length) {
var u,
c = n.x0,
f = n.y0,
a = n.x1,
l = n.y1,
s = (c + a) / 2,
h = (f + l) / 2;
(u = o[0]) && e.push(new i(u, c, f, s, h)),
(u = o[1]) && e.push(new i(u, s, f, a, h)),
(u = o[2]) && e.push(new i(u, c, h, s, l)),
(u = o[3]) && e.push(new i(u, s, h, a, l));
}
r.push(n);
}
for (; (n = r.pop()); ) t(n.node, n.x0, n.y0, n.x1, n.y1);
return this;
}),
(s.x = function (t) {
return arguments.length ? ((this._x = t), this) : this._x;
}),
(s.y = function (t) {
return arguments.length ? ((this._y = t), this) : this._y;
});
var h = function (t) {
return function () {
return t;
};
},
d = function (t) {
return 1e-6 * (t() - 0.5);
};
function y(t) {
return t.x + t.vx;
}
function p(t) {
return t.y + t.vy;
}
var v = function (t) {
var n,
e,
r,
o = 1,
i = 1;
function u() {
for (var t, u, a, l, s, h, v, g = n.length, _ = 0; _ < i; ++_)
for (u = f(n, y, p).visitAfter(c), t = 0; t < g; ++t)
(a = n[t]),
(h = e[a.index]),
(v = h * h),
(l = a.x + a.vx),
(s = a.y + a.vy),
u.visit(x);
function x(t, n, e, i, u) {
var c = t.data,
f = t.r,
y = h + f;
if (!c) return n > l + y || i < l - y || e > s + y || u < s - y;
if (c.index > a.index) {
var p = l - c.x - c.vx,
g = s - c.y - c.vy,
_ = p * p + g * g;
_ < y * y &&
(0 === p && (_ += (p = d(r)) * p),
0 === g && (_ += (g = d(r)) * g),
(_ = ((y - (_ = Math.sqrt(_))) / _) * o),
(a.vx += (p *= _) * (y = (f *= f) / (v + f))),
(a.vy += (g *= _) * y),
(c.vx -= p * (y = 1 - y)),
(c.vy -= g * y));
}
}
}
function c(t) {
if (t.data) return (t.r = e[t.data.index]);
for (var n = (t.r = 0); n < 4; ++n)
t[n] && t[n].r > t.r && (t.r = t[n].r);
}
function a() {
if (n) {
var r,
o,
i = n.length;
for (e = new Array(i), r = 0; r < i; ++r)
(o = n[r]), (e[o.index] = +t(o, r, n));
}
}
return (
"function" != typeof t && (t = h(null == t ? 1 : +t)),
(u.initialize = function (t, e) {
(n = t), (r = e), a();
}),
(u.iterations = function (t) {
return arguments.length ? ((i = +t), u) : i;
}),
(u.strength = function (t) {
return arguments.length ? ((o = +t), u) : o;
}),
(u.radius = function (n) {
return arguments.length
? ((t = "function" == typeof n ? n : h(+n)), a(), u)
: t;
}),
u
);
};
function g(t) {
return (g =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function _(t) {
return t.index;
}
function x(t, n) {
var e = t.get(n);
if (!e) throw new Error("node not found: " + n);
return e;
}
var b = function (t) {
var n,
e,
r,
o,
i,
u,
c = _,
f = function (t) {
return 1 / Math.min(o[t.source.index], o[t.target.index]);
},
a = h(30),
l = 1;
function s(r) {
for (var o = 0, c = t.length; o < l; ++o)
for (var f, a, s, h, y, p, v, g = 0; g < c; ++g)
(a = (f = t[g]).source),
(h = (s = f.target).x + s.vx - a.x - a.vx || d(u)),
(y = s.y + s.vy - a.y - a.vy || d(u)),
(h *= p =
(((p = Math.sqrt(h * h + y * y)) - e[g]) / p) * r * n[g]),
(y *= p),
(s.vx -= h * (v = i[g])),
(s.vy -= y * v),
(a.vx += h * (v = 1 - v)),
(a.vy += y * v);
}
function y() {
if (r) {
var u,
f,
a = r.length,
l = t.length,
s = new Map(
r.map(function (t, n) {
return [c(t, n, r), t];
}),
);
for (u = 0, o = new Array(a); u < l; ++u)
((f = t[u]).index = u),
"object" !== g(f.source) && (f.source = x(s, f.source)),
"object" !== g(f.target) && (f.target = x(s, f.target)),
(o[f.source.index] = (o[f.source.index] || 0) + 1),
(o[f.target.index] = (o[f.target.index] || 0) + 1);
for (u = 0, i = new Array(l); u < l; ++u)
(f = t[u]),
(i[u] =
o[f.source.index] /
(o[f.source.index] + o[f.target.index]));
(n = new Array(l)), p(), (e = new Array(l)), v();
}
}
function p() {
if (r)
for (var e = 0, o = t.length; e < o; ++e) n[e] = +f(t[e], e, t);
}
function v() {
if (r)
for (var n = 0, o = t.length; n < o; ++n) e[n] = +a(t[n], n, t);
}
return (
null == t && (t = []),
(s.initialize = function (t, n) {
(r = t), (u = n), y();
}),
(s.links = function (n) {
return arguments.length ? ((t = n), y(), s) : t;
}),
(s.id = function (t) {
return arguments.length ? ((c = t), s) : c;
}),
(s.iterations = function (t) {
return arguments.length ? ((l = +t), s) : l;
}),
(s.strength = function (t) {
return arguments.length
? ((f = "function" == typeof t ? t : h(+t)), p(), s)
: f;
}),
(s.distance = function (t) {
return arguments.length
? ((a = "function" == typeof t ? t : h(+t)), v(), s)
: a;
}),
s
);
},
w = { value: function () {} };
function m() {
for (var t, n = 0, e = arguments.length, r = {}; n < e; ++n) {
if (!(t = arguments[n] + "") || t in r || /[\s.]/.test(t))
throw new Error("illegal type: " + t);
r[t] = [];
}
return new S(r);
}
function S(t) {
this._ = t;
}
function N(t, n) {
return t
.trim()
.split(/^|\s+/)
.map(function (t) {
var e = "",
r = t.indexOf(".");
if (
(r >= 0 && ((e = t.slice(r + 1)), (t = t.slice(0, r))),
t && !n.hasOwnProperty(t))
)
throw new Error("unknown type: " + t);
return { type: t, name: e };
});
}
function O(t, n) {
for (var e, r = 0, o = t.length; r < o; ++r)
if ((e = t[r]).name === n) return e.value;
}
function k(t, n, e) {
for (var r = 0, o = t.length; r < o; ++r)
if (t[r].name === n) {
(t[r] = w), (t = t.slice(0, r).concat(t.slice(r + 1)));
break;
}
return null != e && t.push({ name: n, value: e }), t;
}
S.prototype = m.prototype = {
constructor: S,
on: function (t, n) {
var e,
r = this._,
o = N(t + "", r),
i = -1,
u = o.length;
if (!(arguments.length < 2)) {
if (null != n && "function" != typeof n)
throw new Error("invalid callback: " + n);
for (; ++i < u; )
if ((e = (t = o[i]).type)) r[e] = k(r[e], t.name, n);
else if (null == n) for (e in r) r[e] = k(r[e], t.name, null);
return this;
}
for (; ++i < u; )
if ((e = (t = o[i]).type) && (e = O(r[e], t.name))) return e;
},
copy: function () {
var t = {},
n = this._;
for (var e in n) t[e] = n[e].slice();
return new S(t);
},
call: function (t, n) {
if ((e = arguments.length - 2) > 0)
for (var e, r, o = new Array(e), i = 0; i < e; ++i)
o[i] = arguments[i + 2];
if (!this._.hasOwnProperty(t)) throw new Error("unknown type: " + t);
for (i = 0, e = (r = this._[t]).length; i < e; ++i)
r[i].value.apply(n, o);
},
apply: function (t, n, e) {
if (!this._.hasOwnProperty(t)) throw new Error("unknown type: " + t);
for (var r = this._[t], o = 0, i = r.length; o < i; ++o)
r[o].value.apply(n, e);
},
};
var M = m;
function j(t) {
return (j =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var E,
A,
P = 0,
z = 0,
D = 0,
L = 0,
T = 0,
F = 0,
U =
"object" ===
("undefined" == typeof performance
? "undefined"
: j(performance)) && performance.now
? performance
: Date,
C =
"object" ===
("undefined" == typeof window ? "undefined" : j(window)) &&
window.requestAnimationFrame
? window.requestAnimationFrame.bind(window)
: function (t) {
setTimeout(t, 17);
};
function q() {
return T || (C(B), (T = U.now() + F));
}
function B() {
T = 0;
}
function Y() {
this._call = this._time = this._next = null;
}
function R(t, n, e) {
var r = new Y();
return r.restart(t, n, e), r;
}
function G() {
(T = (L = U.now()) + F), (P = z = 0);
try {
!(function () {
q(), ++P;
for (var t, n = E; n; )
(t = T - n._time) >= 0 && n._call.call(null, t), (n = n._next);
--P;
})();
} finally {
(P = 0),
(function () {
var t,
n,
e = E,
r = 1 / 0;
for (; e; )
e._call
? (r > e._time && (r = e._time), (t = e), (e = e._next))
: ((n = e._next),
(e._next = null),
(e = t ? (t._next = n) : (E = n)));
(A = t), W(r);
})(),
(T = 0);
}
}
function I() {
var t = U.now(),
n = t - L;
n > 1e3 && ((F -= n), (L = t));
}
function W(t) {
P ||
(z && (z = clearTimeout(z)),
t - T > 24
? (t < 1 / 0 && (z = setTimeout(G, t - U.now() - F)),
D && (D = clearInterval(D)))
: (D || ((L = U.now()), (D = setInterval(I, 1e3))), (P = 1), C(G)));
}
Y.prototype = R.prototype = {
constructor: Y,
restart: function (t, n, e) {
if ("function" != typeof t)
throw new TypeError("callback is not a function");
(e = (null == e ? q() : +e) + (null == n ? 0 : +n)),
this._next ||
A === this ||
(A ? (A._next = this) : (E = this), (A = this)),
(this._call = t),
(this._time = e),
W();
},
stop: function () {
this._call && ((this._call = null), (this._time = 1 / 0), W());
},
};
var X = 4294967296;
function K(t) {
return t.x;
}
function H(t) {
return t.y;
}
var J = Math.PI * (3 - Math.sqrt(5)),
Q = function (t) {
var n,
e,
r = 1,
o = 0.001,
i = 1 - Math.pow(o, 1 / 300),
u = 0,
c = 0.6,
f = new Map(),
a = R(h),
l = M("tick", "end"),
s =
((e = 1),
function () {
return (e = (1664525 * e + 1013904223) % X) / X;
});
function h() {
d(), l.call("tick", n), r < o && (a.stop(), l.call("end", n));
}
function d(e) {
var o,
a,
l = t.length;
void 0 === e && (e = 1);
for (var s = 0; s < e; ++s)
for (
r += (u - r) * i,
f.forEach(function (t) {
t(r);
}),
o = 0;
o < l;
++o
)
null == (a = t[o]).fx
? (a.x += a.vx *= c)
: ((a.x = a.fx), (a.vx = 0)),
null == a.fy
? (a.y += a.vy *= c)
: ((a.y = a.fy), (a.vy = 0));
return n;
}
function y() {
for (var n, e = 0, r = t.length; e < r; ++e) {
if (
(((n = t[e]).index = e),
null != n.fx && (n.x = n.fx),
null != n.fy && (n.y = n.fy),
isNaN(n.x) || isNaN(n.y))
) {
var o = 10 * Math.sqrt(0.5 + e),
i = e * J;
(n.x = o * Math.cos(i)), (n.y = o * Math.sin(i));
}
(isNaN(n.vx) || isNaN(n.vy)) && (n.vx = n.vy = 0);
}
}
function p(n) {
return n.initialize && n.initialize(t, s), n;
}
return (
null == t && (t = []),
y(),
(n = {
tick: d,
restart: function () {
return a.restart(h), n;
},
stop: function () {
return a.stop(), n;
},
nodes: function (e) {
return arguments.length ? ((t = e), y(), f.forEach(p), n) : t;
},
alpha: function (t) {
return arguments.length ? ((r = +t), n) : r;
},
alphaMin: function (t) {
return arguments.length ? ((o = +t), n) : o;
},
alphaDecay: function (t) {
return arguments.length ? ((i = +t), n) : +i;
},
alphaTarget: function (t) {
return arguments.length ? ((u = +t), n) : u;
},
velocityDecay: function (t) {
return arguments.length ? ((c = 1 - t), n) : 1 - c;
},
randomSource: function (t) {
return arguments.length ? ((s = t), f.forEach(p), n) : s;
},
force: function (t, e) {
return arguments.length > 1
? (null == e ? f.delete(t) : f.set(t, p(e)), n)
: f.get(t);
},
find: function (n, e, r) {
var o,
i,
u,
c,
f,
a = 0,
l = t.length;
for (null == r ? (r = 1 / 0) : (r *= r), a = 0; a < l; ++a)
(u = (o = n - (c = t[a]).x) * o + (i = e - c.y) * i) < r &&
((f = c), (r = u));
return f;
},
on: function (t, e) {
return arguments.length > 1 ? (l.on(t, e), n) : l.on(t);
},
})
);
},
V = function () {
var t,
n,
e,
r,
o,
i = h(-30),
u = 1,
c = 1 / 0,
a = 0.81;
function l(e) {
var o,
i = t.length,
u = f(t, K, H).visitAfter(y);
for (r = e, o = 0; o < i; ++o) (n = t[o]), u.visit(p);
}
function s() {
if (t) {
var n,
e,
r = t.length;
for (o = new Array(r), n = 0; n < r; ++n)
(e = t[n]), (o[e.index] = +i(e, n, t));
}
}
function y(t) {
var n,
e,
r,
i,
u,
c = 0,
f = 0;
if (t.length) {
for (r = i = u = 0; u < 4; ++u)
(n = t[u]) &&
(e = Math.abs(n.value)) &&
((c += n.value), (f += e), (r += e * n.x), (i += e * n.y));
(t.x = r / f), (t.y = i / f);
} else {
((n = t).x = n.data.x), (n.y = n.data.y);
do {
c += o[n.data.index];
} while ((n = n.next));
}
t.value = c;
}
function p(t, i, f, l) {
if (!t.value) return !0;
var s = t.x - n.x,
h = t.y - n.y,
y = l - i,
p = s * s + h * h;
if ((y * y) / a < p)
return (
p < c &&
(0 === s && (p += (s = d(e)) * s),
0 === h && (p += (h = d(e)) * h),
p < u && (p = Math.sqrt(u * p)),
(n.vx += (s * t.value * r) / p),
(n.vy += (h * t.value * r) / p)),
!0
);
if (!(t.length || p >= c)) {
(t.data !== n || t.next) &&
(0 === s && (p += (s = d(e)) * s),
0 === h && (p += (h = d(e)) * h),
p < u && (p = Math.sqrt(u * p)));
do {
t.data !== n &&
((y = (o[t.data.index] * r) / p),
(n.vx += s * y),
(n.vy += h * y));
} while ((t = t.next));
}
}
return (
(l.initialize = function (n, r) {
(t = n), (e = r), s();
}),
(l.strength = function (t) {
return arguments.length
? ((i = "function" == typeof t ? t : h(+t)), s(), l)
: i;
}),
(l.distanceMin = function (t) {
return arguments.length ? ((u = t * t), l) : Math.sqrt(u);
}),
(l.distanceMax = function (t) {
return arguments.length ? ((c = t * t), l) : Math.sqrt(c);
}),
(l.theta = function (t) {
return arguments.length ? ((a = t * t), l) : Math.sqrt(a);
}),
l
);
},
Z = function (t, n, e) {
var r,
o,
i,
u = h(0.1);
function c(t) {
for (var u = 0, c = r.length; u < c; ++u) {
var f = r[u],
a = f.x - n || 1e-6,
l = f.y - e || 1e-6,
s = Math.sqrt(a * a + l * l),
h = ((i[u] - s) * o[u] * t) / s;
(f.vx += a * h), (f.vy += l * h);
}
}
function f() {
if (r) {
var n,
e = r.length;
for (o = new Array(e), i = new Array(e), n = 0; n < e; ++n)
(i[n] = +t(r[n], n, r)),
(o[n] = isNaN(i[n]) ? 0 : +u(r[n], n, r));
}
}
return (
"function" != typeof t && (t = h(+t)),
null == n && (n = 0),
null == e && (e = 0),
(c.initialize = function (t) {
(r = t), f();
}),
(c.strength = function (t) {
return arguments.length
? ((u = "function" == typeof t ? t : h(+t)), f(), c)
: u;
}),
(c.radius = function (n) {
return arguments.length
? ((t = "function" == typeof n ? n : h(+n)), f(), c)
: t;
}),
(c.x = function (t) {
return arguments.length ? ((n = +t), c) : n;
}),
(c.y = function (t) {
return arguments.length ? ((e = +t), c) : e;
}),
c
);
},
$ = function (t) {
var n,
e,
r,
o = h(0.1);
function i(t) {
for (var o, i = 0, u = n.length; i < u; ++i)
(o = n[i]).vx += (r[i] - o.x) * e[i] * t;
}
function u() {
if (n) {
var i,
u = n.length;
for (e = new Array(u), r = new Array(u), i = 0; i < u; ++i)
e[i] = isNaN((r[i] = +t(n[i], i, n))) ? 0 : +o(n[i], i, n);
}
}
return (
"function" != typeof t && (t = h(null == t ? 0 : +t)),
(i.initialize = function (t) {
(n = t), u();
}),
(i.strength = function (t) {
return arguments.length
? ((o = "function" == typeof t ? t : h(+t)), u(), i)
: o;
}),
(i.x = function (n) {
return arguments.length
? ((t = "function" == typeof n ? n : h(+n)), u(), i)
: t;
}),
i
);
},
tt = function (t) {
var n,
e,
r,
o = h(0.1);
function i(t) {
for (var o, i = 0, u = n.length; i < u; ++i)
(o = n[i]).vy += (r[i] - o.y) * e[i] * t;
}
function u() {
if (n) {
var i,
u = n.length;
for (e = new Array(u), r = new Array(u), i = 0; i < u; ++i)
e[i] = isNaN((r[i] = +t(n[i], i, n))) ? 0 : +o(n[i], i, n);
}
}
return (
"function" != typeof t && (t = h(null == t ? 0 : +t)),
(i.initialize = function (t) {
(n = t), u();
}),
(i.strength = function (t) {
return arguments.length
? ((o = "function" == typeof t ? t : h(+t)), u(), i)
: o;
}),
(i.y = function (n) {
return arguments.length
? ((t = "function" == typeof n ? n : h(+n)), u(), i)
: t;
}),
i
);
};
},
16: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.isFunction = void 0);
n.isFunction = function (t) {
return "function" == typeof t;
};
},
163: function (t, n, e) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, n, e, r) {
void 0 === r && (r = e),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return n[e];
},
});
}
: function (t, n, e, r) {
void 0 === r && (r = e), (t[r] = n[e]);
}),
o =
(this && this.__exportStar) ||
function (t, n) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(n, e) ||
r(n, t, e);
};
Object.defineProperty(n, "__esModule", { value: !0 }), o(e(383), n);
},
382: function (t, n, e) {
"use strict";
e.r(n);
var r = e(163);
n.default = r.ForceLayout;
},
383: function (t, n, e) {
"use strict";
var r,
o =
(this && this.__extends) ||
((r = function (t, n) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, n) {
t.__proto__ = n;
}) ||
function (t, n) {
for (var e in n)
Object.prototype.hasOwnProperty.call(n, e) && (t[e] = n[e]);
})(t, n);
}),
function (t, n) {
if ("function" != typeof n && null !== n)
throw new TypeError(
"Class extends value " +
String(n) +
" is not a constructor or null",
);
function e() {
this.constructor = t;
}
r(t, n),
(t.prototype =
null === n
? Object.create(n)
: ((e.prototype = n.prototype), new e()));
}),
i =
(this && this.__createBinding) ||
(Object.create
? function (t, n, e, r) {
void 0 === r && (r = e),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return n[e];
},
});
}
: function (t, n, e, r) {
void 0 === r && (r = e), (t[r] = n[e]);
}),
u =
(this && this.__setModuleDefault) ||
(Object.create
? function (t, n) {
Object.defineProperty(t, "default", {
enumerable: !0,
value: n,
});
}
: function (t, n) {
t.default = n;
}),
c =
(this && this.__importStar) ||
function (t) {
if (t && t.__esModule) return t;
var n = {};
if (null != t)
for (var e in t)
"default" !== e &&
Object.prototype.hasOwnProperty.call(t, e) &&
i(n, t, e);
return u(n, t), n;
},
f =
(this && this.__importDefault) ||
function (t) {
return t && t.__esModule ? t : { default: t };
};
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.ForceLayout = void 0);
var a = c(e(156)),
l = f(e(384)),
s = e(10),
h = e(9),
d = e(385),
y = (function (t) {
function n(n) {
var e = t.call(this) || this;
return (
(e.center = [0, 0]),
(e.nodeStrength = null),
(e.edgeStrength = null),
(e.preventOverlap = !1),
(e.clusterNodeStrength = null),
(e.clusterEdgeStrength = null),
(e.clusterEdgeDistance = null),
(e.clusterNodeSize = null),
(e.clusterFociStrength = null),
(e.linkDistance = 50),
(e.alphaDecay = 0.028),
(e.alphaMin = 0.001),
(e.alpha = 0.3),
(e.collideStrength = 1),
(e.workerEnabled = !1),
(e.tick = function () {}),
(e.onLayoutEnd = function () {}),
(e.ticking = void 0),
n && e.updateCfg(n),
e
);
}
return (
o(n, t),
(n.prototype.getDefaultCfg = function () {
return {
center: [0, 0],
nodeStrength: null,
edgeStrength: null,
preventOverlap: !1,
nodeSize: void 0,
nodeSpacing: void 0,
linkDistance: 50,
forceSimulation: null,
alphaDecay: 0.028,
alphaMin: 0.001,
alpha: 0.3,
collideStrength: 1,
clustering: !1,
clusterNodeStrength: -1,
clusterEdgeStrength: 0.1,
clusterEdgeDistance: 100,
clusterFociStrength: 0.8,
clusterNodeSize: 10,
tick: function () {},
onLayoutEnd: function () {},
workerEnabled: !1,
};
}),
(n.prototype.init = function (t) {
this.nodes = t.nodes || [];
var n = t.edges || [];
(this.edges = n.map(function (t) {
var n = {},
e = ["targetNode", "sourceNode", "startPoint", "endPoint"];
return (
Object.keys(t).forEach(function (r) {
e.indexOf(r) > -1 || (n[r] = t[r]);
}),
n
);
})),
(this.ticking = !1);
}),
(n.prototype.execute = function (t) {
var n = this,
e = n.nodes,
r = n.edges;
if (!n.ticking) {
var o = n.forceSimulation,
i = n.alphaMin,
u = n.alphaDecay,
c = n.alpha;
if (o) {
if (t)
if (
(n.clustering &&
n.clusterForce &&
(n.clusterForce.nodes(e), n.clusterForce.links(r)),
o.nodes(e),
r && n.edgeForce)
)
n.edgeForce.links(r);
else if (r && !n.edgeForce) {
h = a
.forceLink()
.id(function (t) {
return t.id;
})
.links(r);
n.edgeStrength && h.strength(n.edgeStrength),
n.linkDistance && h.distance(n.linkDistance),
(n.edgeForce = h),
o.force("link", h);
}
n.preventOverlap && n.overlapProcess(o),
o.alpha(c).restart(),
(this.ticking = !0);
} else
try {
var f = a.forceManyBody();
if (
(n.nodeStrength && f.strength(n.nodeStrength),
(o = a.forceSimulation().nodes(e)),
n.clustering)
) {
var s = l.default();
s
.centerX(n.center[0])
.centerY(n.center[1])
.template("force")
.strength(n.clusterFociStrength),
r && s.links(r),
e && s.nodes(e),
s
.forceLinkDistance(n.clusterEdgeDistance)
.forceLinkStrength(n.clusterEdgeStrength)
.forceCharge(n.clusterNodeStrength)
.forceNodeSize(n.clusterNodeSize),
(n.clusterForce = s),
o.force("group", s);
}
if (
(o
.force(
"center",
a.forceCenter(n.center[0], n.center[1]),
)
.force("charge", f)
.alpha(c)
.alphaDecay(u)
.alphaMin(i),
n.preventOverlap && n.overlapProcess(o),
r)
) {
var h = a
.forceLink()
.id(function (t) {
return t.id;
})
.links(r);
n.edgeStrength && h.strength(n.edgeStrength),
n.linkDistance && h.distance(n.linkDistance),
(n.edgeForce = h),
o.force("link", h);
}
if (
(n.workerEnabled &&
!p() &&
((n.workerEnabled = !1),
console.warn(
"workerEnabled option is only supported when running in web worker.",
)),
n.workerEnabled)
) {
o.stop();
for (
var y = (function (t) {
var n = t.alphaMin(),
e = t.alphaTarget(),
r = t.alpha(),
o =
Math.log((n - e) / (r - e)) /
Math.log(1 - t.alphaDecay());
return Math.ceil(o);
})(o),
v = 1;
v <= y;
v++
)
o.tick(),
postMessage(
{
nodes: e,
currentTick: v,
totalTicks: y,
type: d.LAYOUT_MESSAGE.TICK,
},
void 0,
);
n.ticking = !1;
} else
o
.on("tick", function () {
n.tick();
})
.on("end", function () {
(n.ticking = !1), n.onLayoutEnd && n.onLayoutEnd();
}),
(n.ticking = !0);
(n.forceSimulation = o), (n.ticking = !0);
} catch (t) {
(n.ticking = !1), console.warn(t);
}
}
}),
(n.prototype.overlapProcess = function (t) {
var n,
e,
r = this.nodeSize,
o = this.nodeSpacing,
i = this.collideStrength;
if (
((e = s.isNumber(o)
? function () {
return o;
}
: s.isFunction(o)
? o
: function () {
return 0;
}),
r)
)
if (s.isFunction(r))
n = function (t) {
return r(t) + e(t);
};
else if (s.isArray(r)) {
var u = (r[0] > r[1] ? r[0] : r[1]) / 2;
n = function (t) {
return u + e(t);
};
} else if (s.isNumber(r)) {
var c = r / 2;
n = function (t) {
return c + e(t);
};
} else
n = function () {
return 10;
};
else
n = function (t) {
return t.size
? s.isArray(t.size)
? (t.size[0] > t.size[1] ? t.size[0] : t.size[1]) / 2 +
e(t)
: t.size / 2 + e(t)
: 10 + e(t);
};
t.force("collisionForce", a.forceCollide(n).strength(i));
}),
(n.prototype.updateCfg = function (t) {
this.ticking &&
(this.forceSimulation.stop(), (this.ticking = !1)),
(this.forceSimulation = null),
Object.assign(this, t);
}),
(n.prototype.destroy = function () {
this.ticking &&
(this.forceSimulation.stop(), (this.ticking = !1)),
(this.nodes = null),
(this.edges = null),
(this.destroyed = !0);
}),
n
);
})(h.Base);
function p() {
return (
"undefined" != typeof WorkerGlobalScope &&
self instanceof WorkerGlobalScope
);
}
n.ForceLayout = y;
},
384: function (t, n, e) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, n, e, r) {
void 0 === r && (r = e),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return n[e];
},
});
}
: function (t, n, e, r) {
void 0 === r && (r = e), (t[r] = n[e]);
}),
o =
(this && this.__setModuleDefault) ||
(Object.create
? function (t, n) {
Object.defineProperty(t, "default", {
enumerable: !0,
value: n,
});
}
: function (t, n) {
t.default = n;
}),
i =
(this && this.__importStar) ||
function (t) {
if (t && t.__esModule) return t;
var n = {};
if (null != t)
for (var e in t)
"default" !== e &&
Object.prototype.hasOwnProperty.call(t, e) &&
r(n, t, e);
return o(n, t), n;
};
Object.defineProperty(n, "__esModule", { value: !0 });
var u = i(e(156));
n.default = function () {
function t(t) {
return function () {
return t;
};
}
var n,
e = function (t) {
return t.cluster;
},
r = t(1),
o = t(-1),
i = t(100),
c = t(0.1),
f = [0, 0],
a = [],
l = {},
s = [],
h = 100,
d = 100,
y = { none: { x: 0, y: 0 } },
p = [],
v = "force",
g = !0,
_ = 0.1;
function x(t) {
if (!g) return x;
n.tick(), w();
for (var r = 0, o = a.length, i = void 0, u = t * _; r < o; ++r)
((i = a[r]).vx += (y[e(i)].x - i.x) * u),
(i.vy += (y[e(i)].y - i.y) * u);
}
function b() {
a &&
(function () {
if (!a || !a.length) return;
if (void 0 === e(a[0]))
throw Error(
"Couldnt find the grouping attribute for the nodes. Make sure to set it up with forceInABox.groupBy('clusterAttr') before calling .links()",
);
var t =
((y = []),
(v = []),
(g = {}),
(_ = []),
(f = (function (t) {
var n = {};
return (
t.forEach(function (t) {
var r = e(t);
n[r] || (n[r] = { count: 0, sumforceNodeSize: 0 });
}),
t.forEach(function (t) {
var o = e(t),
i = r(t),
u = n[o];
(u.count = u.count + 1),
(u.sumforceNodeSize =
u.sumforceNodeSize + Math.PI * (i * i) * 1.3),
(n[o] = u);
}),
n
);
})(a)),
(_ = (function (t) {
var n = {},
r = [];
return (
t.forEach(function (t) {
var r = (function (t) {
var n = e(l[t.source]),
r = e(l[t.target]);
return n <= r ? n + "~" + r : r + "~" + n;
})(t),
o = 0;
void 0 !== n[r] && (o = n[r]), (o += 1), (n[r] = o);
}),
Object.entries(n).forEach(function (t) {
var n = t[0],
e = t[1],
o = n.split("~")[0],
i = n.split("~")[1];
void 0 !== o &&
void 0 !== i &&
r.push({ source: o, target: i, count: e });
}),
r
);
})(s)),
Object.keys(f).forEach(function (t, n) {
var e = f[t];
y.push({
id: t,
size: e.count,
r: Math.sqrt(e.sumforceNodeSize / Math.PI),
}),
(g[t] = n);
}),
_.forEach(function (t) {
var n = g[t.source],
e = g[t.target];
void 0 !== n &&
void 0 !== e &&
v.push({ source: n, target: e, count: t.count });
}),
{ nodes: y, links: v });
var f, y, v, g, _;
(n = u
.forceSimulation(t.nodes)
.force("x", u.forceX(h).strength(0.1))
.force("y", u.forceY(d).strength(0.1))
.force(
"collide",
u
.forceCollide(function (t) {
return t.r;
})
.iterations(4),
)
.force("charge", u.forceManyBody().strength(o))
.force(
"links",
u
.forceLink(t.nodes.length ? t.links : [])
.distance(i)
.strength(c),
)),
(p = n.nodes()),
w();
})();
}
function w() {
return (
(y = { none: { x: 0, y: 0 } }),
p.forEach(function (t) {
y[t.id] = { x: t.x - f[0], y: t.y - f[1] };
}),
y
);
}
function m(t) {
(l = {}),
t.forEach(function (t) {
l[t.id] = t;
});
}
return (
(x.initialize = function (t) {
(a = t), b();
}),
(x.template = function (t) {
return arguments.length ? ((v = t), b(), x) : v;
}),
(x.groupBy = function (t) {
return arguments.length
? "string" == typeof t
? ((e = function (n) {
return n[t];
}),
x)
: ((e = t), x)
: e;
}),
(x.enableGrouping = function (t) {
return arguments.length ? ((g = t), x) : g;
}),
(x.strength = function (t) {
return arguments.length ? ((_ = t), x) : _;
}),
(x.centerX = function (t) {
return arguments.length ? ((h = t), x) : h;
}),
(x.centerY = function (t) {
return arguments.length ? ((d = t), x) : d;
}),
(x.nodes = function (t) {
return arguments.length ? (m(t || []), (a = t || []), x) : a;
}),
(x.links = function (t) {
return arguments.length ? ((s = t || []), b(), x) : s;
}),
(x.forceNodeSize = function (n) {
return arguments.length
? ((r = "function" == typeof n ? n : t(+n)), b(), x)
: r;
}),
(x.nodeSize = x.forceNodeSize),
(x.forceCharge = function (n) {
return arguments.length
? ((o = "function" == typeof n ? n : t(+n)), b(), x)
: o;
}),
(x.forceLinkDistance = function (n) {
return arguments.length
? ((i = "function" == typeof n ? n : t(+n)), b(), x)
: i;
}),
(x.forceLinkStrength = function (n) {
return arguments.length
? ((c = "function" == typeof n ? n : t(+n)), b(), x)
: c;
}),
(x.offset = function (t) {
return arguments.length ? ((f = t), x) : f;
}),
(x.getFocis = w),
x
);
};
},
385: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }),
(n.LAYOUT_MESSAGE = void 0),
(n.LAYOUT_MESSAGE = {
RUN: "LAYOUT_RUN",
END: "LAYOUT_END",
ERROR: "LAYOUT_ERROR",
TICK: "LAYOUT_TICK",
GPURUN: "GPU_LAYOUT_RUN",
GPUEND: "GPU_LAYOUT_END",
});
},
9: function (t, n, e) {
"use strict";
Object.defineProperty(n, "__esModule", { value: !0 }), (n.Base = void 0);
var r = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
n.Base = r;
},
}).default;
});
//# sourceMappingURL=forceLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/fruchtermanLayout.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.FruchtermanLayout = e())
: (t.FruchtermanLayout = e());
})(this, function () {
return (function (t) {
var e = {};
function n(r) {
if (e[r]) return e[r].exports;
var o = (e[r] = { i: r, l: !1, exports: {} });
return t[r].call(o.exports, o, o.exports, n), (o.l = !0), o.exports;
}
return (
(n.m = t),
(n.c = e),
(n.d = function (t, e, r) {
n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: r });
}),
(n.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(n.t = function (t, e) {
if ((1 & e && (t = n(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(n.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var o in t)
n.d(
r,
o,
function (e) {
return t[e];
}.bind(null, o),
);
return r;
}),
(n.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return n.d(e, "a", e), e;
}),
(n.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(n.p = ""),
n((n.s = 386))
);
})({
10: function (t, e, n) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, e, n, r) {
void 0 === r && (r = n),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return e[n];
},
});
}
: function (t, e, n, r) {
void 0 === r && (r = n), (t[r] = e[n]);
}),
o =
(this && this.__exportStar) ||
function (t, e) {
for (var n in t)
"default" === n ||
Object.prototype.hasOwnProperty.call(e, n) ||
r(e, t, n);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
o(n(11), e),
o(n(12), e),
o(n(13), e),
o(n(14), e),
o(n(15), e),
o(n(16), e);
},
11: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.camelize = e.isString = void 0);
e.isString = function (t) {
return "string" == typeof t;
};
var r,
o,
i = /-(\w)/g;
e.camelize =
((r = function (t) {
return t.replace(i, function (t, e) {
return e ? e.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (t) {
return o[t] || (o[t] = r(t));
});
},
12: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isArray = void 0),
(e.isArray = Array.isArray);
},
13: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.toNumber = e.isNaN = e.isNumber = void 0);
e.isNumber = function (t) {
return "number" == typeof t;
};
e.isNaN = function (t) {
return Number.isNaN(Number(t));
};
e.toNumber = function (t) {
var n = parseFloat(t);
return e.isNaN(n) ? t : n;
};
},
14: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.traverseTreeUp =
e.scaleMatrix =
e.getAdjMatrix =
e.floydWarshall =
e.getDegree =
void 0);
e.getDegree = function (t, e, n) {
for (var r = [], o = 0; o < t; o++) r[o] = 0;
return n
? (n.forEach(function (t) {
t.source && (r[e[t.source]] += 1),
t.target && (r[e[t.target]] += 1);
}),
r)
: r;
};
e.floydWarshall = function (t) {
for (var e = [], n = t.length, r = 0; r < n; r += 1) {
e[r] = [];
for (var o = 0; o < n; o += 1)
r === o
? (e[r][o] = 0)
: 0 !== t[r][o] && t[r][o]
? (e[r][o] = t[r][o])
: (e[r][o] = 1 / 0);
}
for (var i = 0; i < n; i += 1)
for (r = 0; r < n; r += 1)
for (o = 0; o < n; o += 1)
e[r][o] > e[r][i] + e[i][o] && (e[r][o] = e[r][i] + e[i][o]);
return e;
};
e.getAdjMatrix = function (t, e) {
var n = t.nodes,
r = t.edges,
o = [],
i = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
i[t.id] = e;
o.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
u = i[n],
c = i[r];
(o[u][c] = 1), e || (o[c][u] = 1);
}),
o
);
};
e.scaleMatrix = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * e);
}),
n.push(r);
}),
n
);
};
e.traverseTreeUp = function (t, e) {
"function" == typeof e &&
(function t(e, n) {
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return;
return !!n(e);
})(t, e);
};
},
15: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (t) {
for (var e, n = 1, r = arguments.length; n < r; n++)
for (var o in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clone = e.isObject = void 0);
e.isObject = function (t) {
return null !== t && "object" === r(t);
};
e.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var n = [];
return (
t.forEach(function (t) {
n.push(t);
}),
n.map(function (t) {
return e.clone(t);
})
);
}
if ("object" === r(t) && t !== {}) {
var i = o({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = e.clone(i[t]);
}),
i
);
}
return t;
};
},
16: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isFunction = void 0);
e.isFunction = function (t) {
return "function" == typeof t;
};
},
164: function (t, e, n) {
"use strict";
var r,
o =
(this && this.__extends) ||
((r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.FruchtermanLayout = void 0);
var i = n(9),
u = n(10),
c = (function (t) {
function e(e) {
var n = t.call(this) || this;
return (
(n.maxIteration = 1e3),
(n.gravity = 10),
(n.speed = 5),
(n.clustering = !1),
(n.clusterGravity = 10),
(n.nodes = []),
(n.edges = []),
(n.width = 300),
(n.height = 300),
(n.nodeMap = {}),
(n.nodeIdxMap = {}),
(n.onLayoutEnd = function () {}),
(n.tick = function () {}),
n.updateCfg(e),
n
);
}
return (
o(e, t),
(e.prototype.getDefaultCfg = function () {
return {
maxIteration: 1e3,
gravity: 10,
speed: 1,
clustering: !1,
clusterGravity: 10,
};
}),
(e.prototype.execute = function () {
var t = this,
e = this.nodes;
if (
(void 0 !== this.timeInterval &&
"undefined" != typeof window &&
window.clearInterval(this.timeInterval),
e && 0 !== e.length)
) {
this.width ||
"undefined" == typeof window ||
(this.width = window.innerWidth),
this.height ||
"undefined" == typeof window ||
(this.height = window.innerHeight),
this.center ||
(this.center = [this.width / 2, this.height / 2]);
var n = this.center;
if (1 === e.length)
return (
(e[0].x = n[0]),
(e[0].y = n[1]),
void (this.onLayoutEnd && this.onLayoutEnd())
);
var r = {},
o = {};
return (
e.forEach(function (e, n) {
u.isNumber(e.x) || (e.x = Math.random() * t.width),
u.isNumber(e.y) || (e.y = Math.random() * t.height),
(r[e.id] = e),
(o[e.id] = n);
}),
(this.nodeMap = r),
(this.nodeIdxMap = o),
this.run()
);
}
this.onLayoutEnd && this.onLayoutEnd();
}),
(e.prototype.run = function () {
var t = this,
e = t.nodes;
if (e) {
var n = t.edges,
r = t.maxIteration,
o = t.center,
i = t.height * t.width,
c = Math.sqrt(i) / 10,
s = i / (e.length + 1),
a = Math.sqrt(s),
f = t.gravity,
y = t.speed,
l = t.clustering,
d = {};
if (l)
for (var p in (e.forEach(function (t) {
if (void 0 === d[t.cluster]) {
var e = { name: t.cluster, cx: 0, cy: 0, count: 0 };
d[t.cluster] = e;
}
var n = d[t.cluster];
u.isNumber(t.x) && (n.cx += t.x),
u.isNumber(t.y) && (n.cy += t.y),
n.count++;
}),
d))
(d[p].cx /= d[p].count), (d[p].cy /= d[p].count);
if ("undefined" != typeof window) {
var h = 0;
return (
(this.timeInterval = window.setInterval(function () {
if (e) {
var i = [];
if (
(e.forEach(function (t, e) {
i[e] = { x: 0, y: 0 };
}),
t.applyCalculate(e, n, i, a, s),
l)
) {
var p = t.clusterGravity || f;
for (var v in (e.forEach(function (t, e) {
if (u.isNumber(t.x) && u.isNumber(t.y)) {
var n = d[t.cluster],
r = Math.sqrt(
(t.x - n.cx) * (t.x - n.cx) +
(t.y - n.cy) * (t.y - n.cy),
),
o = a * p;
(i[e].x -= (o * (t.x - n.cx)) / r),
(i[e].y -= (o * (t.y - n.cy)) / r);
}
}),
d))
(d[v].cx = 0), (d[v].cy = 0), (d[v].count = 0);
for (var v in (e.forEach(function (t) {
var e = d[t.cluster];
u.isNumber(t.x) && (e.cx += t.x),
u.isNumber(t.y) && (e.cy += t.y),
e.count++;
}),
d))
(d[v].cx /= d[v].count), (d[v].cy /= d[v].count);
}
e.forEach(function (t, e) {
if (u.isNumber(t.x) && u.isNumber(t.y)) {
var n = 0.01 * a * f;
(i[e].x -= n * (t.x - o[0])),
(i[e].y -= n * (t.y - o[1]));
}
}),
e.forEach(function (t, e) {
if (u.isNumber(t.fx) && u.isNumber(t.fy))
return (t.x = t.fx), void (t.y = t.fy);
if (u.isNumber(t.x) && u.isNumber(t.y)) {
var n = Math.sqrt(
i[e].x * i[e].x + i[e].y * i[e].y,
);
if (n > 0) {
var r = Math.min(c * (y / 800), n);
(t.x += (i[e].x / n) * r),
(t.y += (i[e].y / n) * r);
}
}
}),
t.tick && t.tick(),
++h >= r &&
(t.onLayoutEnd && t.onLayoutEnd(),
window.clearInterval(t.timeInterval));
}
}, 0)),
{ nodes: e, edges: n }
);
}
}
}),
(e.prototype.applyCalculate = function (t, e, n, r, o) {
this.calRepulsive(t, n, o), e && this.calAttractive(e, n, r);
}),
(e.prototype.calRepulsive = function (t, e, n) {
t.forEach(function (r, o) {
(e[o] = { x: 0, y: 0 }),
t.forEach(function (t, i) {
if (
o !== i &&
u.isNumber(r.x) &&
u.isNumber(t.x) &&
u.isNumber(r.y) &&
u.isNumber(t.y)
) {
var c = r.x - t.x,
s = r.y - t.y,
a = c * c + s * s;
if (0 === a) {
a = 1;
var f = o > i ? 1 : -1;
(c = 0.01 * f), (s = 0.01 * f);
}
var y = n / a;
(e[o].x += c * y), (e[o].y += s * y);
}
});
});
}),
(e.prototype.calAttractive = function (t, e, n) {
var r = this;
t.forEach(function (t) {
if (t.source && t.target) {
var o = r.nodeIdxMap[t.source],
i = r.nodeIdxMap[t.target];
if (o !== i) {
var c = r.nodeMap[t.source],
s = r.nodeMap[t.target];
if (
u.isNumber(s.x) &&
u.isNumber(c.x) &&
u.isNumber(s.y) &&
u.isNumber(c.y)
) {
var a = s.x - c.x,
f = s.y - c.y,
y = Math.sqrt(a * a + f * f),
l = (y * y) / n;
(e[i].x -= (a / y) * l),
(e[i].y -= (f / y) * l),
(e[o].x += (a / y) * l),
(e[o].y += (f / y) * l);
}
}
}
});
}),
(e.prototype.stop = function () {
this.timeInterval &&
"undefined" != typeof window &&
window.clearInterval(this.timeInterval);
}),
(e.prototype.destroy = function () {
this.stop(),
(this.tick = null),
(this.nodes = null),
(this.edges = null),
(this.destroyed = !0);
}),
(e.prototype.getType = function () {
return "fruchterman";
}),
e
);
})(i.Base);
e.FruchtermanLayout = c;
},
386: function (t, e, n) {
"use strict";
n.r(e);
var r = n(164);
e.default = r.FruchtermanLayout;
},
9: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var r = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = r;
},
}).default;
});
//# sourceMappingURL=fruchtermanLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/gForceLayout.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.GForceLayout = e())
: (t.GForceLayout = e());
})(this, function () {
return (function (t) {
var e = {};
function n(r) {
if (e[r]) return e[r].exports;
var o = (e[r] = { i: r, l: !1, exports: {} });
return t[r].call(o.exports, o, o.exports, n), (o.l = !0), o.exports;
}
return (
(n.m = t),
(n.c = e),
(n.d = function (t, e, r) {
n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: r });
}),
(n.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(n.t = function (t, e) {
if ((1 & e && (t = n(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(n.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var o in t)
n.d(
r,
o,
function (e) {
return t[e];
}.bind(null, o),
);
return r;
}),
(n.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return n.d(e, "a", e), e;
}),
(n.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(n.p = ""),
n((n.s = 387))
);
})({
10: function (t, e, n) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (t, e, n, r) {
void 0 === r && (r = n),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return e[n];
},
});
}
: function (t, e, n, r) {
void 0 === r && (r = n), (t[r] = e[n]);
}),
o =
(this && this.__exportStar) ||
function (t, e) {
for (var n in t)
"default" === n ||
Object.prototype.hasOwnProperty.call(e, n) ||
r(e, t, n);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
o(n(11), e),
o(n(12), e),
o(n(13), e),
o(n(14), e),
o(n(15), e),
o(n(16), e);
},
11: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.camelize = e.isString = void 0);
e.isString = function (t) {
return "string" == typeof t;
};
var r,
o,
i = /-(\w)/g;
e.camelize =
((r = function (t) {
return t.replace(i, function (t, e) {
return e ? e.toUpperCase() : "";
});
}),
(o = Object.create(null)),
function (t) {
return o[t] || (o[t] = r(t));
});
},
12: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isArray = void 0),
(e.isArray = Array.isArray);
},
13: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.toNumber = e.isNaN = e.isNumber = void 0);
e.isNumber = function (t) {
return "number" == typeof t;
};
e.isNaN = function (t) {
return Number.isNaN(Number(t));
};
e.toNumber = function (t) {
var n = parseFloat(t);
return e.isNaN(n) ? t : n;
};
},
14: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.traverseTreeUp =
e.scaleMatrix =
e.getAdjMatrix =
e.floydWarshall =
e.getDegree =
void 0);
e.getDegree = function (t, e, n) {
for (var r = [], o = 0; o < t; o++) r[o] = 0;
return n
? (n.forEach(function (t) {
t.source && (r[e[t.source]] += 1),
t.target && (r[e[t.target]] += 1);
}),
r)
: r;
};
e.floydWarshall = function (t) {
for (var e = [], n = t.length, r = 0; r < n; r += 1) {
e[r] = [];
for (var o = 0; o < n; o += 1)
r === o
? (e[r][o] = 0)
: 0 !== t[r][o] && t[r][o]
? (e[r][o] = t[r][o])
: (e[r][o] = 1 / 0);
}
for (var i = 0; i < n; i += 1)
for (r = 0; r < n; r += 1)
for (o = 0; o < n; o += 1)
e[r][o] > e[r][i] + e[i][o] && (e[r][o] = e[r][i] + e[i][o]);
return e;
};
e.getAdjMatrix = function (t, e) {
var n = t.nodes,
r = t.edges,
o = [],
i = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
i[t.id] = e;
o.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
u = i[n],
a = i[r];
(o[u][a] = 1), e || (o[a][u] = 1);
}),
o
);
};
e.scaleMatrix = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * e);
}),
n.push(r);
}),
n
);
};
e.traverseTreeUp = function (t, e) {
"function" == typeof e &&
(function t(e, n) {
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return;
return !!n(e);
})(t, e);
};
},
15: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var o =
(this && this.__assign) ||
function () {
return (o =
Object.assign ||
function (t) {
for (var e, n = 1, r = arguments.length; n < r; n++)
for (var o in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clone = e.isObject = void 0);
e.isObject = function (t) {
return null !== t && "object" === r(t);
};
e.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var n = [];
return (
t.forEach(function (t) {
n.push(t);
}),
n.map(function (t) {
return e.clone(t);
})
);
}
if ("object" === r(t) && t !== {}) {
var i = o({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = e.clone(i[t]);
}),
i
);
}
return t;
};
},
16: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isFunction = void 0);
e.isFunction = function (t) {
return "function" == typeof t;
};
},
165: function (t, e, n) {
"use strict";
var r,
o =
(this && this.__extends) ||
((r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.GForceLayout = void 0);
var i = n(9),
u = n(10),
a = function (t, e) {
return t
? u.isNumber(t)
? function (e) {
return t;
}
: t
: function (t) {
return e || 1;
};
},
c = (function (t) {
function e(e) {
var n = t.call(this) || this;
return (
(n.maxIteration = 1e3),
(n.edgeStrength = 200),
(n.nodeStrength = 1e3),
(n.coulombDisScale = 0.005),
(n.damping = 0.9),
(n.maxSpeed = 1e3),
(n.minMovement = 0.5),
(n.interval = 0.02),
(n.factor = 1),
(n.linkDistance = 1),
(n.gravity = 10),
(n.preventOverlap = !0),
(n.tick = function () {}),
(n.nodes = []),
(n.edges = []),
(n.width = 300),
(n.height = 300),
(n.nodeMap = {}),
(n.nodeIdxMap = {}),
n.updateCfg(e),
n
);
}
return (
o(e, t),
(e.prototype.getDefaultCfg = function () {
return { maxIteration: 500, gravity: 10, enableTick: !0 };
}),
(e.prototype.execute = function () {
var t = this,
e = t.nodes;
if (
(void 0 !== t.timeInterval &&
"undefined" != typeof window &&
window.clearInterval(t.timeInterval),
e && 0 !== e.length)
) {
t.width ||
"undefined" == typeof window ||
(t.width = window.innerWidth),
t.height ||
"undefined" == typeof window ||
(t.height = window.innerHeight),
t.center || (t.center = [t.width / 2, t.height / 2]);
var n = t.center;
if (1 === e.length)
return (
(e[0].x = n[0]),
(e[0].y = n[1]),
void (t.onLayoutEnd && t.onLayoutEnd())
);
var r = {},
o = {};
e.forEach(function (e, n) {
u.isNumber(e.x) || (e.x = Math.random() * t.width),
u.isNumber(e.y) || (e.y = Math.random() * t.height),
(r[e.id] = e),
(o[e.id] = n);
}),
(t.nodeMap = r),
(t.nodeIdxMap = o),
(t.linkDistance = a(t.linkDistance, 1)),
(t.nodeStrength = a(t.nodeStrength, 1)),
(t.edgeStrength = a(t.edgeStrength, 1));
var i,
c = t.nodeSize;
if (t.preventOverlap) {
var s,
f = t.nodeSpacing;
(s = u.isNumber(f)
? function () {
return f;
}
: u.isFunction(f)
? f
: function () {
return 0;
}),
(i = c
? u.isArray(c)
? function (t) {
return (c[0] > c[1] ? c[0] : c[1]) + s(t);
}
: function (t) {
return c + s(t);
}
: function (t) {
return t.size
? u.isArray(t.size)
? (t.size[0] > t.size[1]
? t.size[0]
: t.size[1]) + s(t)
: t.size + s(t)
: 10 + s(t);
});
}
t.nodeSize = i;
var d = t.edges;
(t.degrees = u.getDegree(e.length, t.nodeIdxMap, d)),
t.getMass ||
(t.getMass = function (e) {
return t.degrees[t.nodeIdxMap[e.id]] || 1;
}),
t.run();
} else t.onLayoutEnd && t.onLayoutEnd();
}),
(e.prototype.run = function () {
var t = this,
e = t.nodes,
n = t.edges,
r = t.maxIteration;
if ("undefined" != typeof window) {
var o = 0;
this.timeInterval = window.setInterval(function () {
var i = [],
u = [];
if (e) {
e.forEach(function (t, e) {
(i[2 * e] = 0),
(i[2 * e + 1] = 0),
(u[2 * e] = 0),
(u[2 * e + 1] = 0);
}),
t.calRepulsive(i, e),
n && t.calAttractive(i, n),
t.calGravity(i, e);
var a = Math.max(0.02, t.interval - 0.002 * o);
t.updateVelocity(i, u, a, e);
var c = [];
e.forEach(function (t) {
c.push({ x: t.x, y: t.y });
}),
t.updatePosition(u, a, e),
t.tick && t.tick();
var s = 0;
e.forEach(function (t, e) {
var n = t.x - c[e].x,
r = t.y - c[e].y;
s += Math.sqrt(n * n + r * r);
}),
(s /= e.length) < t.minMovement &&
(window.clearInterval(t.timeInterval),
t.onLayoutEnd && t.onLayoutEnd()),
++o >= r &&
(t.onLayoutEnd && t.onLayoutEnd(),
window.clearInterval(t.timeInterval));
}
}, 0);
}
}),
(e.prototype.calRepulsive = function (t, e) {
var n = this.getMass,
r = this.nodeStrength,
o = this.factor,
i = this.coulombDisScale,
u = this.preventOverlap,
a = this.nodeSize;
e.forEach(function (c, s) {
var f = n ? n(c) : 1;
e.forEach(function (e, d) {
if (!(s >= d)) {
var l = c.x - e.x,
p = c.y - e.y,
y = Math.sqrt(l * l + p * p) + 0.01,
h = (y + 0.1) * i,
v = l / y,
g = p / y,
b = (((r(c) + r(e)) / 2) * o) / (h * h),
m = n ? n(e) : 1;
if (
((t[2 * s] += v * b),
(t[2 * s + 1] += g * b),
(t[2 * d] -= v * b),
(t[2 * d + 1] -= g * b),
u && y < (a(c) + a(e)) / 2)
) {
var x = (r(c) + r(e)) / 2 / (y * y);
(t[2 * s] += (v * x) / f),
(t[2 * s + 1] += (g * x) / f),
(t[2 * d] -= (v * x) / m),
(t[2 * d + 1] -= (g * x) / m);
}
}
});
});
}),
(e.prototype.calAttractive = function (t, e) {
var n = this.nodeMap,
r = this.nodeIdxMap,
o = this.linkDistance,
i = this.edgeStrength,
u = this.getMass;
e.forEach(function (e, a) {
var c = n[e.source],
s = n[e.target],
f = s.x - c.x,
d = s.y - c.y,
l = Math.sqrt(f * f + d * d) + 0.01,
p = f / l,
y = d / l,
h = ((o(e) || 1) - l) * i(e),
v = r[e.source],
g = r[e.target],
b = u ? u(c) : 1,
m = u ? u(s) : 1;
(t[2 * v] -= (p * h) / b),
(t[2 * v + 1] -= (y * h) / b),
(t[2 * g] += (p * h) / m),
(t[2 * g + 1] += (y * h) / m);
});
}),
(e.prototype.calGravity = function (t, e) {
for (
var n = this.center,
r = this.gravity,
o = this.degrees,
i = e.length,
a = 0;
a < i;
a++
) {
var c = e[a],
s = c.x - n[0],
f = c.y - n[1],
d = r;
if (this.getCenter) {
var l = this.getCenter(c, o[a]);
l &&
u.isNumber(l[0]) &&
u.isNumber(l[1]) &&
u.isNumber(l[2]) &&
((s = c.x - l[0]), (f = c.y - l[1]), (d = l[2]));
}
d && ((t[2 * a] -= d * s), (t[2 * a + 1] -= d * f));
}
}),
(e.prototype.updateVelocity = function (t, e, n, r) {
var o = this,
i = n * o.damping;
r.forEach(function (n, r) {
var u = t[2 * r] * i || 0.01,
a = t[2 * r + 1] * i || 0.01,
c = Math.sqrt(u * u + a * a);
if (c > o.maxSpeed) {
var s = o.maxSpeed / c;
(u *= s), (a *= s);
}
(e[2 * r] = u), (e[2 * r + 1] = a);
});
}),
(e.prototype.updatePosition = function (t, e, n) {
n.forEach(function (n, r) {
if (u.isNumber(n.fx) && u.isNumber(n.fy))
return (n.x = n.fx), void (n.y = n.fy);
var o = t[2 * r] * e,
i = t[2 * r + 1] * e;
(n.x += o), (n.y += i);
});
}),
(e.prototype.stop = function () {
this.timeInterval &&
"undefined" != typeof window &&
window.clearInterval(this.timeInterval);
}),
(e.prototype.destroy = function () {
this.stop(),
(this.tick = null),
(this.nodes = null),
(this.edges = null),
(this.destroyed = !0);
}),
(e.prototype.getType = function () {
return "gForce";
}),
e
);
})(i.Base);
e.GForceLayout = c;
},
387: function (t, e, n) {
"use strict";
n.r(e);
var r = n(165);
e.default = r.GForceLayout;
},
9: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var r = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = r;
},
}).default;
});
//# sourceMappingURL=gForceLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/gridLayout.js
================================================
!(function (e, t) {
"object" == typeof exports && "object" == typeof module
? (module.exports = t())
: "function" == typeof define && define.amd
? define([], t)
: "object" == typeof exports
? (exports.GridLayout = t())
: (e.GridLayout = t());
})(this, function () {
return (function (e) {
var t = {};
function o(r) {
if (t[r]) return t[r].exports;
var n = (t[r] = { i: r, l: !1, exports: {} });
return e[r].call(n.exports, n, n.exports, o), (n.l = !0), n.exports;
}
return (
(o.m = e),
(o.c = t),
(o.d = function (e, t, r) {
o.o(e, t) || Object.defineProperty(e, t, { enumerable: !0, get: r });
}),
(o.r = function (e) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(e, "__esModule", { value: !0 });
}),
(o.t = function (e, t) {
if ((1 & t && (e = o(e)), 8 & t)) return e;
if (4 & t && "object" == typeof e && e && e.__esModule) return e;
var r = Object.create(null);
if (
(o.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: e }),
2 & t && "string" != typeof e)
)
for (var n in e)
o.d(
r,
n,
function (t) {
return e[t];
}.bind(null, n),
);
return r;
}),
(o.n = function (e) {
var t =
e && e.__esModule
? function () {
return e.default;
}
: function () {
return e;
};
return o.d(t, "a", t), t;
}),
(o.o = function (e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}),
(o.p = ""),
o((o.s = 388))
);
})({
10: function (e, t, o) {
"use strict";
var r =
(this && this.__createBinding) ||
(Object.create
? function (e, t, o, r) {
void 0 === r && (r = o),
Object.defineProperty(e, r, {
enumerable: !0,
get: function () {
return t[o];
},
});
}
: function (e, t, o, r) {
void 0 === r && (r = o), (e[r] = t[o]);
}),
n =
(this && this.__exportStar) ||
function (e, t) {
for (var o in e)
"default" === o ||
Object.prototype.hasOwnProperty.call(t, o) ||
r(t, e, o);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
n(o(11), t),
n(o(12), t),
n(o(13), t),
n(o(14), t),
n(o(15), t),
n(o(16), t);
},
11: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.camelize = t.isString = void 0);
t.isString = function (e) {
return "string" == typeof e;
};
var r,
n,
i = /-(\w)/g;
t.camelize =
((r = function (e) {
return e.replace(i, function (e, t) {
return t ? t.toUpperCase() : "";
});
}),
(n = Object.create(null)),
function (e) {
return n[e] || (n[e] = r(e));
});
},
12: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isArray = void 0),
(t.isArray = Array.isArray);
},
13: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.toNumber = t.isNaN = t.isNumber = void 0);
t.isNumber = function (e) {
return "number" == typeof e;
};
t.isNaN = function (e) {
return Number.isNaN(Number(e));
};
t.toNumber = function (e) {
var o = parseFloat(e);
return t.isNaN(o) ? e : o;
};
},
14: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.traverseTreeUp =
t.scaleMatrix =
t.getAdjMatrix =
t.floydWarshall =
t.getDegree =
void 0);
t.getDegree = function (e, t, o) {
for (var r = [], n = 0; n < e; n++) r[n] = 0;
return o
? (o.forEach(function (e) {
e.source && (r[t[e.source]] += 1),
e.target && (r[t[e.target]] += 1);
}),
r)
: r;
};
t.floydWarshall = function (e) {
for (var t = [], o = e.length, r = 0; r < o; r += 1) {
t[r] = [];
for (var n = 0; n < o; n += 1)
r === n
? (t[r][n] = 0)
: 0 !== e[r][n] && e[r][n]
? (t[r][n] = e[r][n])
: (t[r][n] = 1 / 0);
}
for (var i = 0; i < o; i += 1)
for (r = 0; r < o; r += 1)
for (n = 0; n < o; n += 1)
t[r][n] > t[r][i] + t[i][n] && (t[r][n] = t[r][i] + t[i][n]);
return t;
};
t.getAdjMatrix = function (e, t) {
var o = e.nodes,
r = e.edges,
n = [],
i = {};
if (!o) throw new Error("invalid nodes data!");
return (
o &&
o.forEach(function (e, t) {
i[e.id] = t;
n.push([]);
}),
r &&
r.forEach(function (e) {
var o = e.source,
r = e.target,
s = i[o],
u = i[r];
(n[s][u] = 1), t || (n[u][s] = 1);
}),
n
);
};
t.scaleMatrix = function (e, t) {
var o = [];
return (
e.forEach(function (e) {
var r = [];
e.forEach(function (e) {
r.push(e * t);
}),
o.push(r);
}),
o
);
};
t.traverseTreeUp = function (e, t) {
"function" == typeof t &&
(function e(t, o) {
if (t && t.children)
for (var r = t.children.length - 1; r >= 0; r--)
if (!e(t.children[r], o)) return;
return !!o(t);
})(e, t);
};
},
15: function (e, t, o) {
"use strict";
function r(e) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (e) {
return typeof e;
}
: function (e) {
return e &&
"function" == typeof Symbol &&
e.constructor === Symbol &&
e !== Symbol.prototype
? "symbol"
: typeof e;
})(e);
}
var n =
(this && this.__assign) ||
function () {
return (n =
Object.assign ||
function (e) {
for (var t, o = 1, r = arguments.length; o < r; o++)
for (var n in (t = arguments[o]))
Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
return e;
}).apply(this, arguments);
};
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.clone = t.isObject = void 0);
t.isObject = function (e) {
return null !== e && "object" === r(e);
};
t.clone = function (e) {
if (null === e) return e;
if (e instanceof Date) return new Date(e.getTime());
if (e instanceof Array) {
var o = [];
return (
e.forEach(function (e) {
o.push(e);
}),
o.map(function (e) {
return t.clone(e);
})
);
}
if ("object" === r(e) && e !== {}) {
var i = n({}, e);
return (
Object.keys(i).forEach(function (e) {
i[e] = t.clone(i[e]);
}),
i
);
}
return e;
};
},
16: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.isFunction = void 0);
t.isFunction = function (e) {
return "function" == typeof e;
};
},
166: function (e, t, o) {
"use strict";
var r,
n =
(this && this.__extends) ||
((r = function (e, t) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (e, t) {
e.__proto__ = t;
}) ||
function (e, t) {
for (var o in t)
Object.prototype.hasOwnProperty.call(t, o) && (e[o] = t[o]);
})(e, t);
}),
function (e, t) {
if ("function" != typeof t && null !== t)
throw new TypeError(
"Class extends value " +
String(t) +
" is not a constructor or null",
);
function o() {
this.constructor = e;
}
r(e, t),
(e.prototype =
null === t
? Object.create(t)
: ((o.prototype = t.prototype), new o()));
});
Object.defineProperty(t, "__esModule", { value: !0 }),
(t.GridLayout = void 0);
var i = o(10),
s = (function (e) {
function t(t) {
var o = e.call(this) || this;
return (
(o.begin = [0, 0]),
(o.preventOverlap = !0),
(o.preventOverlapPadding = 10),
(o.condense = !1),
(o.sortBy = "degree"),
(o.nodeSize = 30),
(o.nodes = []),
(o.edges = []),
(o.width = 300),
(o.height = 300),
(o.row = 0),
(o.col = 0),
(o.cellWidth = 0),
(o.cellHeight = 0),
(o.cellUsed = {}),
(o.id2manPos = {}),
(o.onLayoutEnd = function () {}),
o.updateCfg(t),
o
);
}
return (
n(t, e),
(t.prototype.getDefaultCfg = function () {
return {
begin: [0, 0],
preventOverlap: !0,
preventOverlapPadding: 10,
condense: !1,
rows: void 0,
cols: void 0,
position: void 0,
sortBy: "degree",
nodeSize: 30,
};
}),
(t.prototype.execute = function () {
var e = this,
t = e.nodes,
o = t.length,
r = e.begin;
if (0 !== o) {
if (1 === o)
return (
(t[0].x = r[0]),
(t[0].y = r[1]),
void (e.onLayoutEnd && e.onLayoutEnd())
);
var n = e.edges,
s = [];
t.forEach(function (e) {
s.push(e);
});
var u = {};
if (
(s.forEach(function (e, t) {
u[e.id] = t;
}),
("degree" === e.sortBy ||
!i.isString(e.sortBy) ||
void 0 === s[0][e.sortBy]) &&
((e.sortBy = "degree"), i.isNaN(t[0].degree)))
) {
var c = i.getDegree(s.length, u, n);
s.forEach(function (e, t) {
e.degree = c[t];
});
}
s.sort(function (t, o) {
return o[e.sortBy] - t[e.sortBy];
}),
e.width ||
"undefined" == typeof window ||
(e.width = window.innerWidth),
e.height ||
"undefined" == typeof window ||
(e.height = window.innerHeight);
var l = e.rows,
a = null != e.cols ? e.cols : e.columns;
if (
((e.cells = o),
null != l && null != a
? ((e.rows = l), (e.cols = a))
: null != l && null == a
? ((e.rows = l), (e.cols = Math.ceil(e.cells / e.rows)))
: null == l && null != a
? ((e.cols = a), (e.rows = Math.ceil(e.cells / e.cols)))
: ((e.splits = Math.sqrt((e.cells * e.height) / e.width)),
(e.rows = Math.round(e.splits)),
(e.cols = Math.round((e.width / e.height) * e.splits))),
e.cols * e.rows > e.cells)
)
((d = e.small()) - 1) * (f = e.large()) >= e.cells
? e.small(d - 1)
: (f - 1) * d >= e.cells && e.large(f - 1);
else
for (; e.cols * e.rows < e.cells; ) {
var f,
d = e.small();
((f = e.large()) + 1) * d >= e.cells
? e.large(f + 1)
: e.small(d + 1);
}
(e.cellWidth = e.width / e.cols),
(e.cellHeight = e.height / e.rows),
e.condense && ((e.cellWidth = 0), (e.cellHeight = 0)),
e.preventOverlap &&
s.forEach(function (t) {
var o, r;
(t.x && t.y) || ((t.x = 0), (t.y = 0)),
i.isArray(t.size)
? ((o = t.size[0]), (r = t.size[1]))
: i.isNumber(t.size) && ((o = t.size), (r = t.size)),
(void 0 !== o && void 0 !== r) ||
(i.isArray(e.nodeSize)
? ((o = e.nodeSize[0]), (r = e.nodeSize[1]))
: i.isNumber(e.nodeSize)
? ((o = e.nodeSize), (r = e.nodeSize))
: ((o = 30), (r = 30)));
var n = e.preventOverlapPadding,
s = o + n,
u = r + n;
(e.cellWidth = Math.max(e.cellWidth, s)),
(e.cellHeight = Math.max(e.cellHeight, u));
}),
(e.cellUsed = {}),
(e.row = 0),
(e.col = 0),
(e.id2manPos = {});
for (var p = 0; p < s.length; p++) {
var h = s[p],
y = void 0;
if (
(e.position && (y = e.position(h)),
y && (void 0 !== y.row || void 0 !== y.col))
) {
var v = { row: y.row, col: y.col };
if (void 0 === v.col)
for (v.col = 0; e.used(v.row, v.col); ) v.col++;
else if (void 0 === v.row)
for (v.row = 0; e.used(v.row, v.col); ) v.row++;
(e.id2manPos[h.id] = v), e.use(v.row, v.col);
}
e.getPos(h);
}
return e.onLayoutEnd && e.onLayoutEnd(), { edges: n, nodes: s };
}
e.onLayoutEnd && e.onLayoutEnd();
}),
(t.prototype.small = function (e) {
var t,
o = this.rows || 5,
r = this.cols || 5;
null == e
? (t = Math.min(o, r))
: Math.min(o, r) === this.rows
? (this.rows = e)
: (this.cols = e);
return t;
}),
(t.prototype.large = function (e) {
var t,
o = this.rows || 5,
r = this.cols || 5;
null == e
? (t = Math.max(o, r))
: Math.max(o, r) === this.rows
? (this.rows = e)
: (this.cols = e);
return t;
}),
(t.prototype.used = function (e, t) {
return this.cellUsed["c-" + e + "-" + t] || !1;
}),
(t.prototype.use = function (e, t) {
this.cellUsed["c-" + e + "-" + t] = !0;
}),
(t.prototype.moveToNextCell = function () {
var e = this.cols || 5;
this.col++, this.col >= e && ((this.col = 0), this.row++);
}),
(t.prototype.getPos = function (e) {
var t,
o,
r = this.begin,
n = this.cellWidth,
i = this.cellHeight,
s = this.id2manPos[e.id];
if (s)
(t = s.col * n + n / 2 + r[0]), (o = s.row * i + i / 2 + r[1]);
else {
for (; this.used(this.row, this.col); ) this.moveToNextCell();
(t = this.col * n + n / 2 + r[0]),
(o = this.row * i + i / 2 + r[1]),
this.use(this.row, this.col),
this.moveToNextCell();
}
(e.x = t), (e.y = o);
}),
(t.prototype.getType = function () {
return "grid";
}),
t
);
})(o(9).Base);
t.GridLayout = s;
},
388: function (e, t, o) {
"use strict";
o.r(t);
var r = o(166);
t.default = r.GridLayout;
},
9: function (e, t, o) {
"use strict";
Object.defineProperty(t, "__esModule", { value: !0 }), (t.Base = void 0);
var r = (function () {
function e() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(e.prototype.layout = function (e) {
return this.init(e), this.execute(!0);
}),
(e.prototype.init = function (e) {
(this.nodes = e.nodes || []),
(this.edges = e.edges || []),
(this.combos = e.combos || []);
}),
(e.prototype.execute = function (e) {}),
(e.prototype.executeWithWorker = function () {}),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.updateCfg = function (e) {
e && Object.assign(this, e);
}),
(e.prototype.getType = function () {
return "base";
}),
(e.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
e
);
})();
t.Base = r;
},
}).default;
});
//# sourceMappingURL=gridLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/mdsLayout.js
================================================
!(function (t, r) {
"object" == typeof exports && "object" == typeof module
? (module.exports = r())
: "function" == typeof define && define.amd
? define([], r)
: "object" == typeof exports
? (exports.MdsLayout = r())
: (t.MdsLayout = r());
})(this, function () {
return (function (t) {
var r = {};
function e(o) {
if (r[o]) return r[o].exports;
var n = (r[o] = { i: o, l: !1, exports: {} });
return t[o].call(n.exports, n, n.exports, e), (n.l = !0), n.exports;
}
return (
(e.m = t),
(e.c = r),
(e.d = function (t, r, o) {
e.o(t, r) || Object.defineProperty(t, r, { enumerable: !0, get: o });
}),
(e.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(e.t = function (t, r) {
if ((1 & r && (t = e(t)), 8 & r)) return t;
if (4 & r && "object" == typeof t && t && t.__esModule) return t;
var o = Object.create(null);
if (
(e.r(o),
Object.defineProperty(o, "default", { enumerable: !0, value: t }),
2 & r && "string" != typeof t)
)
for (var n in t)
e.d(
o,
n,
function (r) {
return t[r];
}.bind(null, n),
);
return o;
}),
(e.n = function (t) {
var r =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return e.d(r, "a", r), r;
}),
(e.o = function (t, r) {
return Object.prototype.hasOwnProperty.call(t, r);
}),
(e.p = ""),
e((e.s = 389))
);
})({
10: function (t, r, e) {
"use strict";
var o =
(this && this.__createBinding) ||
(Object.create
? function (t, r, e, o) {
void 0 === o && (o = e),
Object.defineProperty(t, o, {
enumerable: !0,
get: function () {
return r[e];
},
});
}
: function (t, r, e, o) {
void 0 === o && (o = e), (t[o] = r[e]);
}),
n =
(this && this.__exportStar) ||
function (t, r) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(r, e) ||
o(r, t, e);
};
Object.defineProperty(r, "__esModule", { value: !0 }),
n(e(11), r),
n(e(12), r),
n(e(13), r),
n(e(14), r),
n(e(15), r),
n(e(16), r);
},
11: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.camelize = r.isString = void 0);
r.isString = function (t) {
return "string" == typeof t;
};
var o,
n,
i = /-(\w)/g;
r.camelize =
((o = function (t) {
return t.replace(i, function (t, r) {
return r ? r.toUpperCase() : "";
});
}),
(n = Object.create(null)),
function (t) {
return n[t] || (n[t] = o(t));
});
},
12: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.isArray = void 0),
(r.isArray = Array.isArray);
},
13: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.toNumber = r.isNaN = r.isNumber = void 0);
r.isNumber = function (t) {
return "number" == typeof t;
};
r.isNaN = function (t) {
return Number.isNaN(Number(t));
};
r.toNumber = function (t) {
var e = parseFloat(t);
return r.isNaN(e) ? t : e;
};
},
14: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.traverseTreeUp =
r.scaleMatrix =
r.getAdjMatrix =
r.floydWarshall =
r.getDegree =
void 0);
r.getDegree = function (t, r, e) {
for (var o = [], n = 0; n < t; n++) o[n] = 0;
return e
? (e.forEach(function (t) {
t.source && (o[r[t.source]] += 1),
t.target && (o[r[t.target]] += 1);
}),
o)
: o;
};
r.floydWarshall = function (t) {
for (var r = [], e = t.length, o = 0; o < e; o += 1) {
r[o] = [];
for (var n = 0; n < e; n += 1)
o === n
? (r[o][n] = 0)
: 0 !== t[o][n] && t[o][n]
? (r[o][n] = t[o][n])
: (r[o][n] = 1 / 0);
}
for (var i = 0; i < e; i += 1)
for (o = 0; o < e; o += 1)
for (n = 0; n < e; n += 1)
r[o][n] > r[o][i] + r[i][n] && (r[o][n] = r[o][i] + r[i][n]);
return r;
};
r.getAdjMatrix = function (t, r) {
var e = t.nodes,
o = t.edges,
n = [],
i = {};
if (!e) throw new Error("invalid nodes data!");
return (
e &&
e.forEach(function (t, r) {
i[t.id] = r;
n.push([]);
}),
o &&
o.forEach(function (t) {
var e = t.source,
o = t.target,
s = i[e],
u = i[o];
(n[s][u] = 1), r || (n[u][s] = 1);
}),
n
);
};
r.scaleMatrix = function (t, r) {
var e = [];
return (
t.forEach(function (t) {
var o = [];
t.forEach(function (t) {
o.push(t * r);
}),
e.push(o);
}),
e
);
};
r.traverseTreeUp = function (t, r) {
"function" == typeof r &&
(function t(r, e) {
if (r && r.children)
for (var o = r.children.length - 1; o >= 0; o--)
if (!t(r.children[o], e)) return;
return !!e(r);
})(t, r);
};
},
15: function (t, r, e) {
"use strict";
function o(t) {
return (o =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var n =
(this && this.__assign) ||
function () {
return (n =
Object.assign ||
function (t) {
for (var r, e = 1, o = arguments.length; e < o; e++)
for (var n in (r = arguments[e]))
Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.clone = r.isObject = void 0);
r.isObject = function (t) {
return null !== t && "object" === o(t);
};
r.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var e = [];
return (
t.forEach(function (t) {
e.push(t);
}),
e.map(function (t) {
return r.clone(t);
})
);
}
if ("object" === o(t) && t !== {}) {
var i = n({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = r.clone(i[t]);
}),
i
);
}
return t;
};
},
16: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.isFunction = void 0);
r.isFunction = function (t) {
return "function" == typeof t;
};
},
167: function (t, r, e) {
"use strict";
var o,
n =
(this && this.__extends) ||
((o = function (t, r) {
return (o =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, r) {
t.__proto__ = r;
}) ||
function (t, r) {
for (var e in r)
Object.prototype.hasOwnProperty.call(r, e) && (t[e] = r[e]);
})(t, r);
}),
function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Class extends value " +
String(r) +
" is not a constructor or null",
);
function e() {
this.constructor = t;
}
o(t, r),
(t.prototype =
null === r
? Object.create(r)
: ((e.prototype = r.prototype), new e()));
});
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.MDSLayout = void 0);
var i = e(96),
s = e(10),
u = (function (t) {
function r(r) {
var e = t.call(this) || this;
return (
(e.center = [0, 0]),
(e.linkDistance = 50),
(e.nodes = []),
(e.edges = []),
(e.onLayoutEnd = function () {}),
e.updateCfg(r),
e
);
}
return (
n(r, t),
(r.prototype.getDefaultCfg = function () {
return { center: [0, 0], linkDistance: 50 };
}),
(r.prototype.execute = function () {
var t = this.nodes,
r = this.edges,
e = void 0 === r ? [] : r,
o = this.center;
if (t && 0 !== t.length) {
if (1 === t.length)
return (
(t[0].x = o[0]),
(t[0].y = o[1]),
void (this.onLayoutEnd && this.onLayoutEnd())
);
var n = this.linkDistance,
i = s.getAdjMatrix({ nodes: t, edges: e }, !1),
u = s.floydWarshall(i);
this.handleInfinity(u);
var a = s.scaleMatrix(u, n);
this.scaledDistances = a;
var f = this.runMDS();
return (
(this.positions = f),
f.forEach(function (r, e) {
(t[e].x = r[0] + o[0]), (t[e].y = r[1] + o[1]);
}),
this.onLayoutEnd && this.onLayoutEnd(),
{ nodes: t, edges: e }
);
}
this.onLayoutEnd && this.onLayoutEnd();
}),
(r.prototype.runMDS = function () {
var t = this.scaledDistances,
r = i.Matrix.mul(i.Matrix.pow(t, 2), -0.5),
e = r.mean("row"),
o = r.mean("column"),
n = r.mean();
r.add(n).subRowVector(e).subColumnVector(o);
var s = new i.SingularValueDecomposition(r),
u = i.Matrix.sqrt(s.diagonalMatrix).diagonal();
return s.leftSingularVectors.toJSON().map(function (t) {
return i.Matrix.mul([t], [u]).toJSON()[0].splice(0, 2);
});
}),
(r.prototype.handleInfinity = function (t) {
var r = -999999;
t.forEach(function (t) {
t.forEach(function (t) {
t !== 1 / 0 && r < t && (r = t);
});
}),
t.forEach(function (e, o) {
e.forEach(function (e, n) {
e === 1 / 0 && (t[o][n] = r);
});
});
}),
(r.prototype.getType = function () {
return "mds";
}),
r
);
})(e(9).Base);
r.MDSLayout = u;
},
389: function (t, r, e) {
"use strict";
e.r(r);
var o = e(167);
r.default = o.MDSLayout;
},
9: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }), (r.Base = void 0);
var o = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
r.Base = o;
},
96: function (t, r, e) {
"use strict";
e.r(r),
e.d(r, "AbstractMatrix", function () {
return U;
}),
e.d(r, "default", function () {
return Y;
}),
e.d(r, "Matrix", function () {
return Y;
}),
e.d(r, "MatrixColumnView", function () {
return ut;
}),
e.d(r, "MatrixColumnSelectionView", function () {
return yt;
}),
e.d(r, "MatrixFlipColumnView", function () {
return Mt;
}),
e.d(r, "MatrixFlipRowView", function () {
return Rt;
}),
e.d(r, "MatrixRowView", function () {
return It;
}),
e.d(r, "MatrixRowSelectionView", function () {
return zt;
}),
e.d(r, "MatrixSelectionView", function () {
return Kt;
}),
e.d(r, "MatrixSubView", function () {
return er;
}),
e.d(r, "MatrixTransposeView", function () {
return fr;
}),
e.d(r, "wrap", function () {
return Or;
}),
e.d(r, "WrapperMatrix1D", function () {
return gr;
}),
e.d(r, "WrapperMatrix2D", function () {
return Sr;
}),
e.d(r, "solve", function () {
return Ir;
}),
e.d(r, "inverse", function () {
return Dr;
}),
e.d(r, "determinant", function () {
return Vr;
}),
e.d(r, "linearDependencies", function () {
return Fr;
}),
e.d(r, "pseudoInverse", function () {
return Lr;
}),
e.d(r, "covariance", function () {
return zr;
}),
e.d(r, "correlation", function () {
return Wr;
}),
e.d(r, "SingularValueDecomposition", function () {
return Nr;
}),
e.d(r, "SVD", function () {
return Nr;
}),
e.d(r, "EigenvalueDecomposition", function () {
return Yr;
}),
e.d(r, "EVD", function () {
return Yr;
}),
e.d(r, "CholeskyDecomposition", function () {
return te;
}),
e.d(r, "CHO", function () {
return te;
}),
e.d(r, "LuDecomposition", function () {
return jr;
}),
e.d(r, "LU", function () {
return jr;
}),
e.d(r, "QrDecomposition", function () {
return _r;
}),
e.d(r, "QR", function () {
return _r;
}),
e.d(r, "Nipals", function () {
return ne;
}),
e.d(r, "NIPALS", function () {
return ne;
});
var o = Object.prototype.toString;
function n(t) {
return o.call(t).endsWith("Array]");
}
function i(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
var e = r.fromIndex,
o = void 0 === e ? 0 : e,
i = r.toIndex,
s = void 0 === i ? t.length : i;
if (o < 0 || o >= t.length || !Number.isInteger(o))
throw new Error(
"fromIndex must be a positive integer smaller than length",
);
if (s <= o || s > t.length || !Number.isInteger(s))
throw new Error(
"toIndex must be an integer greater than fromIndex and at most equal to length",
);
for (var u = t[o], a = o + 1; a < s; a++) t[a] > u && (u = t[a]);
return u;
}
function s(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
var e = r.fromIndex,
o = void 0 === e ? 0 : e,
i = r.toIndex,
s = void 0 === i ? t.length : i;
if (o < 0 || o >= t.length || !Number.isInteger(o))
throw new Error(
"fromIndex must be a positive integer smaller than length",
);
if (s <= o || s > t.length || !Number.isInteger(s))
throw new Error(
"toIndex must be an integer greater than fromIndex and at most equal to length",
);
for (var u = t[o], a = o + 1; a < s; a++) t[a] < u && (u = t[a]);
return u;
}
function u(t) {
var r,
e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
if (void 0 !== e.output) {
if (!n(e.output))
throw new TypeError("output option must be an array if specified");
r = e.output;
} else r = new Array(t.length);
var o = s(t),
u = i(t);
if (o === u)
throw new RangeError(
"minimum and maximum input values are equal. Cannot rescale a constant array",
);
var a = e.min,
f = void 0 === a ? (e.autoMinMax ? o : 0) : a,
c = e.max,
h = void 0 === c ? (e.autoMinMax ? u : 1) : c;
if (f >= h)
throw new RangeError("min option must be smaller than max option");
for (var l = (h - f) / (u - o), p = 0; p < t.length; p++)
r[p] = (t[p] - o) * l + f;
return r;
}
var a = " ".repeat(2),
f = " ".repeat(4);
function c(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {},
e = r.maxRows,
o = void 0 === e ? 15 : e,
n = r.maxColumns,
i = void 0 === n ? 10 : n,
s = r.maxNumSize,
u = void 0 === s ? 8 : s;
return ""
.concat(t.constructor.name, " {\n")
.concat(a, "[\n")
.concat(f)
.concat(h(t, o, i, u), "\n")
.concat(a, "]\n")
.concat(a, "rows: ")
.concat(t.rows, "\n")
.concat(a, "columns: ")
.concat(t.columns, "\n}");
}
function h(t, r, e, o) {
for (
var n = t.rows,
i = t.columns,
s = Math.min(n, r),
u = Math.min(i, e),
a = [],
c = 0;
c < s;
c++
) {
for (var h = [], p = 0; p < u; p++) h.push(l(t.get(c, p), o));
a.push("".concat(h.join(" ")));
}
return (
u !== i &&
(a[a.length - 1] += " ... ".concat(i - e, " more columns")),
s !== n && a.push("... ".concat(n - r, " more rows")),
a.join("\n".concat(f))
);
}
function l(t, r) {
var e = String(t);
if (e.length <= r) return e.padEnd(r, " ");
var o = t.toPrecision(r - 2);
if (o.length <= r) return o;
var n = t.toExponential(r - 2),
i = n.indexOf("e"),
s = n.slice(i);
return n.slice(0, r - s.length) + s;
}
function p(t, r, e) {
var o = e ? t.rows : t.rows - 1;
if (r < 0 || r > o) throw new RangeError("Row index out of range");
}
function y(t, r, e) {
var o = e ? t.columns : t.columns - 1;
if (r < 0 || r > o) throw new RangeError("Column index out of range");
}
function v(t, r) {
if ((r.to1DArray && (r = r.to1DArray()), r.length !== t.columns))
throw new RangeError(
"vector size must be the same as the number of columns",
);
return r;
}
function m(t, r) {
if ((r.to1DArray && (r = r.to1DArray()), r.length !== t.rows))
throw new RangeError(
"vector size must be the same as the number of rows",
);
return r;
}
function g(t, r) {
if (!n(r)) throw new TypeError("row indices must be an array");
for (var e = 0; e < r.length; e++)
if (r[e] < 0 || r[e] >= t.rows)
throw new RangeError("row indices are out of range");
}
function w(t, r) {
if (!n(r)) throw new TypeError("column indices must be an array");
for (var e = 0; e < r.length; e++)
if (r[e] < 0 || r[e] >= t.columns)
throw new RangeError("column indices are out of range");
}
function b(t, r, e, o, n) {
if (5 !== arguments.length)
throw new RangeError("expected 4 arguments");
if (
(M("startRow", r),
M("endRow", e),
M("startColumn", o),
M("endColumn", n),
r > e ||
o > n ||
r < 0 ||
r >= t.rows ||
e < 0 ||
e >= t.rows ||
o < 0 ||
o >= t.columns ||
n < 0 ||
n >= t.columns)
)
throw new RangeError("Submatrix indices are out of range");
}
function d(t) {
for (
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: 0,
e = [],
o = 0;
o < t;
o++
)
e.push(r);
return e;
}
function M(t, r) {
if ("number" != typeof r)
throw new TypeError("".concat(t, " must be a number"));
}
function x(t) {
if (t.isEmpty())
throw new Error("Empty matrix has no elements to index");
}
function k(t, r, e) {
for (var o = t.rows, n = t.columns, i = [], s = 0; s < o; s++) {
for (var u = 0, a = 0, f = 0, c = 0; c < n; c++)
(u += f = t.get(s, c) - e[s]), (a += f * f);
r
? i.push((a - (u * u) / n) / (n - 1))
: i.push((a - (u * u) / n) / n);
}
return i;
}
function S(t, r, e) {
for (var o = t.rows, n = t.columns, i = [], s = 0; s < n; s++) {
for (var u = 0, a = 0, f = 0, c = 0; c < o; c++)
(u += f = t.get(c, s) - e[s]), (a += f * f);
r
? i.push((a - (u * u) / o) / (o - 1))
: i.push((a - (u * u) / o) / o);
}
return i;
}
function O(t, r, e) {
for (
var o = t.rows, n = t.columns, i = o * n, s = 0, u = 0, a = 0, f = 0;
f < o;
f++
)
for (var c = 0; c < n; c++) (s += a = t.get(f, c) - e), (u += a * a);
return r ? (u - (s * s) / i) / (i - 1) : (u - (s * s) / i) / i;
}
function E(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r[e]);
}
function j(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r[o]);
}
function R(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r);
}
function P(t) {
for (var r = [], e = 0; e < t.rows; e++) {
for (var o = 0, n = 0; n < t.columns; n++)
o += Math.pow(t.get(e, n), 2) / (t.columns - 1);
r.push(Math.sqrt(o));
}
return r;
}
function _(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r[e]);
}
function T(t) {
for (var r = [], e = 0; e < t.columns; e++) {
for (var o = 0, n = 0; n < t.rows; n++)
o += Math.pow(t.get(n, e), 2) / (t.rows - 1);
r.push(Math.sqrt(o));
}
return r;
}
function C(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r[o]);
}
function N(t) {
for (var r = t.size - 1, e = 0, o = 0; o < t.columns; o++)
for (var n = 0; n < t.rows; n++) e += Math.pow(t.get(n, o), 2) / r;
return Math.sqrt(e);
}
function D(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r);
}
function I(t, r) {
return (I =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function V(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = A(t);
if (r) {
var n = A(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return q(this, e);
};
}
function q(t, r) {
if (r && ("object" === F(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function A(t) {
return (A = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
function F(t) {
return (F =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function L(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function B(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function z(t, r, e) {
return (
r && B(t.prototype, r),
e && B(t, e),
Object.defineProperty(t, "prototype", { writable: !1 }),
t
);
}
var U = (function () {
function t() {
L(this, t);
}
return (
z(
t,
[
{
key: "size",
get: function () {
return this.rows * this.columns;
},
},
{
key: "apply",
value: function (t) {
if ("function" != typeof t)
throw new TypeError("callback must be a function");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++) t.call(this, r, e);
return this;
},
},
{
key: "to1DArray",
value: function () {
for (var t = [], r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
t.push(this.get(r, e));
return t;
},
},
{
key: "to2DArray",
value: function () {
for (var t = [], r = 0; r < this.rows; r++) {
t.push([]);
for (var e = 0; e < this.columns; e++)
t[r].push(this.get(r, e));
}
return t;
},
},
{
key: "toJSON",
value: function () {
return this.to2DArray();
},
},
{
key: "isRowVector",
value: function () {
return 1 === this.rows;
},
},
{
key: "isColumnVector",
value: function () {
return 1 === this.columns;
},
},
{
key: "isVector",
value: function () {
return 1 === this.rows || 1 === this.columns;
},
},
{
key: "isSquare",
value: function () {
return this.rows === this.columns;
},
},
{
key: "isEmpty",
value: function () {
return 0 === this.rows || 0 === this.columns;
},
},
{
key: "isSymmetric",
value: function () {
if (this.isSquare()) {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r <= t; r++)
if (this.get(t, r) !== this.get(r, t)) return !1;
return !0;
}
return !1;
},
},
{
key: "isEchelonForm",
value: function () {
for (
var t = 0, r = 0, e = -1, o = !0, n = !1;
t < this.rows && o;
) {
for (r = 0, n = !1; r < this.columns && !1 === n; )
0 === this.get(t, r)
? r++
: 1 === this.get(t, r) && r > e
? ((n = !0), (e = r))
: ((o = !1), (n = !0));
t++;
}
return o;
},
},
{
key: "isReducedEchelonForm",
value: function () {
for (
var t = 0, r = 0, e = -1, o = !0, n = !1;
t < this.rows && o;
) {
for (r = 0, n = !1; r < this.columns && !1 === n; )
0 === this.get(t, r)
? r++
: 1 === this.get(t, r) && r > e
? ((n = !0), (e = r))
: ((o = !1), (n = !0));
for (var i = r + 1; i < this.rows; i++)
0 !== this.get(t, i) && (o = !1);
t++;
}
return o;
},
},
{
key: "echelonForm",
value: function () {
for (
var t = this.clone(), r = 0, e = 0;
r < t.rows && e < t.columns;
) {
for (var o = r, n = r; n < t.rows; n++)
t.get(n, e) > t.get(o, e) && (o = n);
if (0 === t.get(o, e)) e++;
else {
t.swapRows(r, o);
for (var i = t.get(r, e), s = e; s < t.columns; s++)
t.set(r, s, t.get(r, s) / i);
for (var u = r + 1; u < t.rows; u++) {
var a = t.get(u, e) / t.get(r, e);
t.set(u, e, 0);
for (var f = e + 1; f < t.columns; f++)
t.set(u, f, t.get(u, f) - t.get(r, f) * a);
}
r++, e++;
}
}
return t;
},
},
{
key: "reducedEchelonForm",
value: function () {
for (
var t = this.echelonForm(),
r = t.columns,
e = t.rows,
o = e - 1;
o >= 0;
)
if (0 === t.maxRow(o)) o--;
else {
for (var n = 0, i = !1; n < e && !1 === i; )
1 === t.get(o, n) ? (i = !0) : n++;
for (var s = 0; s < o; s++)
for (var u = t.get(s, n), a = n; a < r; a++) {
var f = t.get(s, a) - u * t.get(o, a);
t.set(s, a, f);
}
o--;
}
return t;
},
},
{
key: "set",
value: function () {
throw new Error("set method is unimplemented");
},
},
{
key: "get",
value: function () {
throw new Error("get method is unimplemented");
},
},
{
key: "repeat",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.rows,
e = void 0 === r ? 1 : r,
o = t.columns,
n = void 0 === o ? 1 : o;
if (!Number.isInteger(e) || e <= 0)
throw new TypeError("rows must be a positive integer");
if (!Number.isInteger(n) || n <= 0)
throw new TypeError("columns must be a positive integer");
for (
var i = new Y(this.rows * e, this.columns * n), s = 0;
s < e;
s++
)
for (var u = 0; u < n; u++)
i.setSubMatrix(this, this.rows * s, this.columns * u);
return i;
},
},
{
key: "fill",
value: function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++) this.set(r, e, t);
return this;
},
},
{
key: "neg",
value: function () {
return this.mulS(-1);
},
},
{
key: "getRow",
value: function (t) {
p(this, t);
for (var r = [], e = 0; e < this.columns; e++)
r.push(this.get(t, e));
return r;
},
},
{
key: "getRowVector",
value: function (t) {
return Y.rowVector(this.getRow(t));
},
},
{
key: "setRow",
value: function (t, r) {
p(this, t), (r = v(this, r));
for (var e = 0; e < this.columns; e++) this.set(t, e, r[e]);
return this;
},
},
{
key: "swapRows",
value: function (t, r) {
p(this, t), p(this, r);
for (var e = 0; e < this.columns; e++) {
var o = this.get(t, e);
this.set(t, e, this.get(r, e)), this.set(r, e, o);
}
return this;
},
},
{
key: "getColumn",
value: function (t) {
y(this, t);
for (var r = [], e = 0; e < this.rows; e++)
r.push(this.get(e, t));
return r;
},
},
{
key: "getColumnVector",
value: function (t) {
return Y.columnVector(this.getColumn(t));
},
},
{
key: "setColumn",
value: function (t, r) {
y(this, t), (r = m(this, r));
for (var e = 0; e < this.rows; e++) this.set(e, t, r[e]);
return this;
},
},
{
key: "swapColumns",
value: function (t, r) {
y(this, t), y(this, r);
for (var e = 0; e < this.rows; e++) {
var o = this.get(e, t);
this.set(e, t, this.get(e, r)), this.set(e, r, o);
}
return this;
},
},
{
key: "addRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t[e]);
return this;
},
},
{
key: "subRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t[e]);
return this;
},
},
{
key: "mulRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t[e]);
return this;
},
},
{
key: "divRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t[e]);
return this;
},
},
{
key: "addColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t[r]);
return this;
},
},
{
key: "subColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t[r]);
return this;
},
},
{
key: "mulColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t[r]);
return this;
},
},
{
key: "divColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t[r]);
return this;
},
},
{
key: "mulRow",
value: function (t, r) {
p(this, t);
for (var e = 0; e < this.columns; e++)
this.set(t, e, this.get(t, e) * r);
return this;
},
},
{
key: "mulColumn",
value: function (t, r) {
y(this, t);
for (var e = 0; e < this.rows; e++)
this.set(e, t, this.get(e, t) * r);
return this;
},
},
{
key: "max",
value: function () {
if (this.isEmpty()) return NaN;
for (var t = this.get(0, 0), r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.get(r, e) > t && (t = this.get(r, e));
return t;
},
},
{
key: "maxIndex",
value: function () {
x(this);
for (
var t = this.get(0, 0), r = [0, 0], e = 0;
e < this.rows;
e++
)
for (var o = 0; o < this.columns; o++)
this.get(e, o) > t &&
((t = this.get(e, o)), (r[0] = e), (r[1] = o));
return r;
},
},
{
key: "min",
value: function () {
if (this.isEmpty()) return NaN;
for (var t = this.get(0, 0), r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.get(r, e) < t && (t = this.get(r, e));
return t;
},
},
{
key: "minIndex",
value: function () {
x(this);
for (
var t = this.get(0, 0), r = [0, 0], e = 0;
e < this.rows;
e++
)
for (var o = 0; o < this.columns; o++)
this.get(e, o) < t &&
((t = this.get(e, o)), (r[0] = e), (r[1] = o));
return r;
},
},
{
key: "maxRow",
value: function (t) {
if ((p(this, t), this.isEmpty())) return NaN;
for (var r = this.get(t, 0), e = 1; e < this.columns; e++)
this.get(t, e) > r && (r = this.get(t, e));
return r;
},
},
{
key: "maxRowIndex",
value: function (t) {
p(this, t), x(this);
for (
var r = this.get(t, 0), e = [t, 0], o = 1;
o < this.columns;
o++
)
this.get(t, o) > r && ((r = this.get(t, o)), (e[1] = o));
return e;
},
},
{
key: "minRow",
value: function (t) {
if ((p(this, t), this.isEmpty())) return NaN;
for (var r = this.get(t, 0), e = 1; e < this.columns; e++)
this.get(t, e) < r && (r = this.get(t, e));
return r;
},
},
{
key: "minRowIndex",
value: function (t) {
p(this, t), x(this);
for (
var r = this.get(t, 0), e = [t, 0], o = 1;
o < this.columns;
o++
)
this.get(t, o) < r && ((r = this.get(t, o)), (e[1] = o));
return e;
},
},
{
key: "maxColumn",
value: function (t) {
if ((y(this, t), this.isEmpty())) return NaN;
for (var r = this.get(0, t), e = 1; e < this.rows; e++)
this.get(e, t) > r && (r = this.get(e, t));
return r;
},
},
{
key: "maxColumnIndex",
value: function (t) {
y(this, t), x(this);
for (
var r = this.get(0, t), e = [0, t], o = 1;
o < this.rows;
o++
)
this.get(o, t) > r && ((r = this.get(o, t)), (e[0] = o));
return e;
},
},
{
key: "minColumn",
value: function (t) {
if ((y(this, t), this.isEmpty())) return NaN;
for (var r = this.get(0, t), e = 1; e < this.rows; e++)
this.get(e, t) < r && (r = this.get(e, t));
return r;
},
},
{
key: "minColumnIndex",
value: function (t) {
y(this, t), x(this);
for (
var r = this.get(0, t), e = [0, t], o = 1;
o < this.rows;
o++
)
this.get(o, t) < r && ((r = this.get(o, t)), (e[0] = o));
return e;
},
},
{
key: "diag",
value: function () {
for (
var t = Math.min(this.rows, this.columns), r = [], e = 0;
e < t;
e++
)
r.push(this.get(e, e));
return r;
},
},
{
key: "norm",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: "frobenius",
r = 0;
if ("max" === t) return this.max();
if ("frobenius" === t) {
for (var e = 0; e < this.rows; e++)
for (var o = 0; o < this.columns; o++)
r += this.get(e, o) * this.get(e, o);
return Math.sqrt(r);
}
throw new RangeError("unknown norm type: ".concat(t));
},
},
{
key: "cumulativeSum",
value: function () {
for (var t = 0, r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
(t += this.get(r, e)), this.set(r, e, t);
return this;
},
},
{
key: "dot",
value: function (r) {
t.isMatrix(r) && (r = r.to1DArray());
var e = this.to1DArray();
if (e.length !== r.length)
throw new RangeError("vectors do not have the same size");
for (var o = 0, n = 0; n < e.length; n++) o += e[n] * r[n];
return o;
},
},
{
key: "mmul",
value: function (t) {
t = Y.checkMatrix(t);
for (
var r = this.rows,
e = this.columns,
o = t.columns,
n = new Y(r, o),
i = new Float64Array(e),
s = 0;
s < o;
s++
) {
for (var u = 0; u < e; u++) i[u] = t.get(u, s);
for (var a = 0; a < r; a++) {
for (var f = 0, c = 0; c < e; c++)
f += this.get(a, c) * i[c];
n.set(a, s, f);
}
}
return n;
},
},
{
key: "strassen2x2",
value: function (t) {
t = Y.checkMatrix(t);
var r = new Y(2, 2),
e = this.get(0, 0),
o = t.get(0, 0),
n = this.get(0, 1),
i = t.get(0, 1),
s = this.get(1, 0),
u = t.get(1, 0),
a = this.get(1, 1),
f = t.get(1, 1),
c = (e + a) * (o + f),
h = (s + a) * o,
l = e * (i - f),
p = a * (u - o),
y = (e + n) * f,
v = c + p - y + (n - a) * (u + f),
m = l + y,
g = h + p,
w = c - h + l + (s - e) * (o + i);
return (
r.set(0, 0, v),
r.set(0, 1, m),
r.set(1, 0, g),
r.set(1, 1, w),
r
);
},
},
{
key: "strassen3x3",
value: function (t) {
t = Y.checkMatrix(t);
var r = new Y(3, 3),
e = this.get(0, 0),
o = this.get(0, 1),
n = this.get(0, 2),
i = this.get(1, 0),
s = this.get(1, 1),
u = this.get(1, 2),
a = this.get(2, 0),
f = this.get(2, 1),
c = this.get(2, 2),
h = t.get(0, 0),
l = t.get(0, 1),
p = t.get(0, 2),
y = t.get(1, 0),
v = t.get(1, 1),
m = t.get(1, 2),
g = t.get(2, 0),
w = t.get(2, 1),
b = t.get(2, 2),
d = (e - i) * (-l + v),
M = (-e + i + s) * (h - l + v),
x = (i + s) * (-h + l),
k = e * h,
S = (-e + a + f) * (h - p + m),
O = (-e + a) * (p - m),
E = (a + f) * (-h + p),
j = (-n + f + c) * (v + g - w),
R = (n - c) * (v - w),
P = n * g,
_ = (f + c) * (-g + w),
T = (-n + s + u) * (m + g - b),
C = (n - u) * (m - b),
N = (s + u) * (-g + b),
D = k + P + o * y,
I = (e + o + n - i - s - f - c) * v + M + x + k + j + P + _,
V = k + S + E + (e + o + n - s - u - a - f) * m + P + T + N,
q =
d + s * (-h + l + y - v - m - g + b) + M + k + P + T + C,
A = d + M + x + k + u * w,
F = P + T + C + N + i * p,
L =
k + S + O + f * (-h + p + y - v - m - g + w) + j + R + P,
B = j + R + P + _ + a * l,
z = k + S + O + E + c * b;
return (
r.set(0, 0, D),
r.set(0, 1, I),
r.set(0, 2, V),
r.set(1, 0, q),
r.set(1, 1, A),
r.set(1, 2, F),
r.set(2, 0, L),
r.set(2, 1, B),
r.set(2, 2, z),
r
);
},
},
{
key: "mmulStrassen",
value: function (r) {
r = Y.checkMatrix(r);
var e = this.clone(),
o = e.rows,
n = e.columns,
i = r.rows,
s = r.columns;
function u(r, e, o) {
var n = r.rows,
i = r.columns;
if (n === e && i === o) return r;
var s = t.zeros(e, o);
return (s = s.setSubMatrix(r, 0, 0));
}
n !== i &&
console.warn(
"Multiplying "
.concat(o, " x ")
.concat(n, " and ")
.concat(i, " x ")
.concat(s, " matrix: dimensions do not match."),
);
var a = Math.max(o, i),
f = Math.max(n, s);
return (function r(e, o, n, i) {
if (n <= 512 || i <= 512) return e.mmul(o);
n % 2 == 1 && i % 2 == 1
? ((e = u(e, n + 1, i + 1)), (o = u(o, n + 1, i + 1)))
: n % 2 == 1
? ((e = u(e, n + 1, i)), (o = u(o, n + 1, i)))
: i % 2 == 1 &&
((e = u(e, n, i + 1)), (o = u(o, n, i + 1)));
var s = parseInt(e.rows / 2, 10),
a = parseInt(e.columns / 2, 10),
f = e.subMatrix(0, s - 1, 0, a - 1),
c = o.subMatrix(0, s - 1, 0, a - 1),
h = e.subMatrix(0, s - 1, a, e.columns - 1),
l = o.subMatrix(0, s - 1, a, o.columns - 1),
p = e.subMatrix(s, e.rows - 1, 0, a - 1),
y = o.subMatrix(s, o.rows - 1, 0, a - 1),
v = e.subMatrix(s, e.rows - 1, a, e.columns - 1),
m = o.subMatrix(s, o.rows - 1, a, o.columns - 1),
g = r(t.add(f, v), t.add(c, m), s, a),
w = r(t.add(p, v), c, s, a),
b = r(f, t.sub(l, m), s, a),
d = r(v, t.sub(y, c), s, a),
M = r(t.add(f, h), m, s, a),
x = r(t.sub(p, f), t.add(c, l), s, a),
k = r(t.sub(h, v), t.add(y, m), s, a),
S = t.add(g, d);
S.sub(M), S.add(k);
var O = t.add(b, M),
E = t.add(w, d),
j = t.sub(g, w);
j.add(b), j.add(x);
var R = t.zeros(2 * S.rows, 2 * S.columns);
return (R = (R = (R = (R = R.setSubMatrix(
S,
0,
0,
)).setSubMatrix(O, S.rows, 0)).setSubMatrix(
E,
0,
S.columns,
)).setSubMatrix(j, S.rows, S.columns)).subMatrix(
0,
n - 1,
0,
i - 1,
);
})((e = u(e, a, f)), (r = u(r, a, f)), a, f);
},
},
{
key: "scaleRows",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.min,
e = void 0 === r ? 0 : r,
o = t.max,
n = void 0 === o ? 1 : o;
if (!Number.isFinite(e))
throw new TypeError("min must be a number");
if (!Number.isFinite(n))
throw new TypeError("max must be a number");
if (e >= n)
throw new RangeError("min must be smaller than max");
for (
var i = new Y(this.rows, this.columns), s = 0;
s < this.rows;
s++
) {
var a = this.getRow(s);
a.length > 0 && u(a, { min: e, max: n, output: a }),
i.setRow(s, a);
}
return i;
},
},
{
key: "scaleColumns",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.min,
e = void 0 === r ? 0 : r,
o = t.max,
n = void 0 === o ? 1 : o;
if (!Number.isFinite(e))
throw new TypeError("min must be a number");
if (!Number.isFinite(n))
throw new TypeError("max must be a number");
if (e >= n)
throw new RangeError("min must be smaller than max");
for (
var i = new Y(this.rows, this.columns), s = 0;
s < this.columns;
s++
) {
var a = this.getColumn(s);
a.length && u(a, { min: e, max: n, output: a }),
i.setColumn(s, a);
}
return i;
},
},
{
key: "flipRows",
value: function () {
for (
var t = Math.ceil(this.columns / 2), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < t; e++) {
var o = this.get(r, e),
n = this.get(r, this.columns - 1 - e);
this.set(r, e, n), this.set(r, this.columns - 1 - e, o);
}
return this;
},
},
{
key: "flipColumns",
value: function () {
for (
var t = Math.ceil(this.rows / 2), r = 0;
r < this.columns;
r++
)
for (var e = 0; e < t; e++) {
var o = this.get(e, r),
n = this.get(this.rows - 1 - e, r);
this.set(e, r, n), this.set(this.rows - 1 - e, r, o);
}
return this;
},
},
{
key: "kroneckerProduct",
value: function (t) {
t = Y.checkMatrix(t);
for (
var r = this.rows,
e = this.columns,
o = t.rows,
n = t.columns,
i = new Y(r * o, e * n),
s = 0;
s < r;
s++
)
for (var u = 0; u < e; u++)
for (var a = 0; a < o; a++)
for (var f = 0; f < n; f++)
i.set(
o * s + a,
n * u + f,
this.get(s, u) * t.get(a, f),
);
return i;
},
},
{
key: "kroneckerSum",
value: function (t) {
if (
((t = Y.checkMatrix(t)), !this.isSquare() || !t.isSquare())
)
throw new Error("Kronecker Sum needs two Square Matrices");
var r = this.rows,
e = t.rows,
o = this.kroneckerProduct(Y.eye(e, e)),
n = Y.eye(r, r).kroneckerProduct(t);
return o.add(n);
},
},
{
key: "transpose",
value: function () {
for (
var t = new Y(this.columns, this.rows), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < this.columns; e++)
t.set(e, r, this.get(r, e));
return t;
},
},
{
key: "sortRows",
value: function () {
for (
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: W,
r = 0;
r < this.rows;
r++
)
this.setRow(r, this.getRow(r).sort(t));
return this;
},
},
{
key: "sortColumns",
value: function () {
for (
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: W,
r = 0;
r < this.columns;
r++
)
this.setColumn(r, this.getColumn(r).sort(t));
return this;
},
},
{
key: "subMatrix",
value: function (t, r, e, o) {
b(this, t, r, e, o);
for (var n = new Y(r - t + 1, o - e + 1), i = t; i <= r; i++)
for (var s = e; s <= o; s++)
n.set(i - t, s - e, this.get(i, s));
return n;
},
},
{
key: "subMatrixRow",
value: function (t, r, e) {
if (
(void 0 === r && (r = 0),
void 0 === e && (e = this.columns - 1),
r > e ||
r < 0 ||
r >= this.columns ||
e < 0 ||
e >= this.columns)
)
throw new RangeError("Argument out of range");
for (
var o = new Y(t.length, e - r + 1), n = 0;
n < t.length;
n++
)
for (var i = r; i <= e; i++) {
if (t[n] < 0 || t[n] >= this.rows)
throw new RangeError(
"Row index out of range: ".concat(t[n]),
);
o.set(n, i - r, this.get(t[n], i));
}
return o;
},
},
{
key: "subMatrixColumn",
value: function (t, r, e) {
if (
(void 0 === r && (r = 0),
void 0 === e && (e = this.rows - 1),
r > e || r < 0 || r >= this.rows || e < 0 || e >= this.rows)
)
throw new RangeError("Argument out of range");
for (
var o = new Y(e - r + 1, t.length), n = 0;
n < t.length;
n++
)
for (var i = r; i <= e; i++) {
if (t[n] < 0 || t[n] >= this.columns)
throw new RangeError(
"Column index out of range: ".concat(t[n]),
);
o.set(i - r, n, this.get(i, t[n]));
}
return o;
},
},
{
key: "setSubMatrix",
value: function (t, r, e) {
if ((t = Y.checkMatrix(t)).isEmpty()) return this;
b(this, r, r + t.rows - 1, e, e + t.columns - 1);
for (var o = 0; o < t.rows; o++)
for (var n = 0; n < t.columns; n++)
this.set(r + o, e + n, t.get(o, n));
return this;
},
},
{
key: "selection",
value: function (t, r) {
g(this, t), w(this, r);
for (
var e = new Y(t.length, r.length), o = 0;
o < t.length;
o++
)
for (var n = t[o], i = 0; i < r.length; i++) {
var s = r[i];
e.set(o, i, this.get(n, s));
}
return e;
},
},
{
key: "trace",
value: function () {
for (
var t = Math.min(this.rows, this.columns), r = 0, e = 0;
e < t;
e++
)
r += this.get(e, e);
return r;
},
},
{
key: "clone",
value: function () {
for (
var t = new Y(this.rows, this.columns), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < this.columns; e++)
t.set(r, e, this.get(r, e));
return t;
},
},
{
key: "sum",
value: function (t) {
switch (t) {
case "row":
return (function (t) {
for (var r = d(t.rows), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[e] += t.get(e, o);
return r;
})(this);
case "column":
return (function (t) {
for (var r = d(t.columns), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[o] += t.get(e, o);
return r;
})(this);
case void 0:
return (function (t) {
for (var r = 0, e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) r += t.get(e, o);
return r;
})(this);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "product",
value: function (t) {
switch (t) {
case "row":
return (function (t) {
for (var r = d(t.rows, 1), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[e] *= t.get(e, o);
return r;
})(this);
case "column":
return (function (t) {
for (var r = d(t.columns, 1), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[o] *= t.get(e, o);
return r;
})(this);
case void 0:
return (function (t) {
for (var r = 1, e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) r *= t.get(e, o);
return r;
})(this);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "mean",
value: function (t) {
var r = this.sum(t);
switch (t) {
case "row":
for (var e = 0; e < this.rows; e++) r[e] /= this.columns;
return r;
case "column":
for (var o = 0; o < this.columns; o++) r[o] /= this.rows;
return r;
case void 0:
return r / this.size;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "variance",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r,
o = e.unbiased,
i = void 0 === o || o,
s = e.mean,
u = void 0 === s ? this.mean(t) : s;
if ("boolean" != typeof i)
throw new TypeError("unbiased must be a boolean");
switch (t) {
case "row":
if (!n(u)) throw new TypeError("mean must be an array");
return k(this, i, u);
case "column":
if (!n(u)) throw new TypeError("mean must be an array");
return S(this, i, u);
case void 0:
if ("number" != typeof u)
throw new TypeError("mean must be a number");
return O(this, i, u);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "standardDeviation",
value: function (t, r) {
"object" === F(t) && ((r = t), (t = void 0));
var e = this.variance(t, r);
if (void 0 === t) return Math.sqrt(e);
for (var o = 0; o < e.length; o++) e[o] = Math.sqrt(e[o]);
return e;
},
},
{
key: "center",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r,
o = e.center,
i = void 0 === o ? this.mean(t) : o;
switch (t) {
case "row":
if (!n(i)) throw new TypeError("center must be an array");
return E(this, i), this;
case "column":
if (!n(i)) throw new TypeError("center must be an array");
return j(this, i), this;
case void 0:
if ("number" != typeof i)
throw new TypeError("center must be a number");
return R(this, i), this;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "scale",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r.scale;
switch (t) {
case "row":
if (void 0 === e) e = P(this);
else if (!n(e))
throw new TypeError("scale must be an array");
return _(this, e), this;
case "column":
if (void 0 === e) e = T(this);
else if (!n(e))
throw new TypeError("scale must be an array");
return C(this, e), this;
case void 0:
if (void 0 === e) e = N(this);
else if ("number" != typeof e)
throw new TypeError("scale must be a number");
return D(this, e), this;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "toString",
value: function (t) {
return c(this, t);
},
},
],
[
{
key: "from1DArray",
value: function (t, r, e) {
if (t * r !== e.length)
throw new RangeError(
"data length does not match given dimensions",
);
for (var o = new Y(t, r), n = 0; n < t; n++)
for (var i = 0; i < r; i++) o.set(n, i, e[n * r + i]);
return o;
},
},
{
key: "rowVector",
value: function (t) {
for (var r = new Y(1, t.length), e = 0; e < t.length; e++)
r.set(0, e, t[e]);
return r;
},
},
{
key: "columnVector",
value: function (t) {
for (var r = new Y(t.length, 1), e = 0; e < t.length; e++)
r.set(e, 0, t[e]);
return r;
},
},
{
key: "zeros",
value: function (t, r) {
return new Y(t, r);
},
},
{
key: "ones",
value: function (t, r) {
return new Y(t, r).fill(1);
},
},
{
key: "rand",
value: function (t, r) {
var e =
arguments.length > 2 && void 0 !== arguments[2]
? arguments[2]
: {};
if ("object" !== F(e))
throw new TypeError("options must be an object");
for (
var o = e.random,
n = void 0 === o ? Math.random : o,
i = new Y(t, r),
s = 0;
s < t;
s++
)
for (var u = 0; u < r; u++) i.set(s, u, n());
return i;
},
},
{
key: "randInt",
value: function (t, r) {
var e =
arguments.length > 2 && void 0 !== arguments[2]
? arguments[2]
: {};
if ("object" !== F(e))
throw new TypeError("options must be an object");
var o = e.min,
n = void 0 === o ? 0 : o,
i = e.max,
s = void 0 === i ? 1e3 : i,
u = e.random,
a = void 0 === u ? Math.random : u;
if (!Number.isInteger(n))
throw new TypeError("min must be an integer");
if (!Number.isInteger(s))
throw new TypeError("max must be an integer");
if (n >= s)
throw new RangeError("min must be smaller than max");
for (var f = s - n, c = new Y(t, r), h = 0; h < t; h++)
for (var l = 0; l < r; l++) {
var p = n + Math.round(a() * f);
c.set(h, l, p);
}
return c;
},
},
{
key: "eye",
value: function (t, r, e) {
void 0 === r && (r = t), void 0 === e && (e = 1);
for (
var o = Math.min(t, r), n = this.zeros(t, r), i = 0;
i < o;
i++
)
n.set(i, i, e);
return n;
},
},
{
key: "diag",
value: function (t, r, e) {
var o = t.length;
void 0 === r && (r = o), void 0 === e && (e = r);
for (
var n = Math.min(o, r, e), i = this.zeros(r, e), s = 0;
s < n;
s++
)
i.set(s, s, t[s]);
return i;
},
},
{
key: "min",
value: function (t, r) {
(t = this.checkMatrix(t)), (r = this.checkMatrix(r));
for (
var e = t.rows, o = t.columns, n = new Y(e, o), i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
n.set(i, s, Math.min(t.get(i, s), r.get(i, s)));
return n;
},
},
{
key: "max",
value: function (t, r) {
(t = this.checkMatrix(t)), (r = this.checkMatrix(r));
for (
var e = t.rows, o = t.columns, n = new this(e, o), i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
n.set(i, s, Math.max(t.get(i, s), r.get(i, s)));
return n;
},
},
{
key: "checkMatrix",
value: function (r) {
return t.isMatrix(r) ? r : new Y(r);
},
},
{
key: "isMatrix",
value: function (t) {
return null != t && "Matrix" === t.klass;
},
},
],
),
t
);
})();
function W(t, r) {
return t - r;
}
(U.prototype.klass = "Matrix"),
"undefined" != typeof Symbol &&
(U.prototype[Symbol.for("nodejs.util.inspect.custom")] = function () {
return c(this);
}),
(U.random = U.rand),
(U.randomInt = U.randInt),
(U.diagonal = U.diag),
(U.prototype.diagonal = U.prototype.diag),
(U.identity = U.eye),
(U.prototype.negate = U.prototype.neg),
(U.prototype.tensorProduct = U.prototype.kroneckerProduct);
var Q,
J,
Y = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && I(t, r);
})(e, t);
var r = V(e);
function e(t, o) {
var i;
if ((L(this, e), (i = r.call(this)), e.isMatrix(t)))
return q(i, t.clone());
if (Number.isInteger(t) && t >= 0) {
if (((i.data = []), !(Number.isInteger(o) && o >= 0)))
throw new TypeError("nColumns must be a positive integer");
for (var s = 0; s < t; s++) i.data.push(new Float64Array(o));
} else {
if (!n(t))
throw new TypeError(
"First argument must be a positive number or an array",
);
var u = t;
if ("number" != typeof (o = (t = u.length) ? u[0].length : 0))
throw new TypeError(
"Data must be a 2D array with at least one element",
);
i.data = [];
for (var a = 0; a < t; a++) {
if (u[a].length !== o)
throw new RangeError("Inconsistent array dimensions");
i.data.push(Float64Array.from(u[a]));
}
}
return (i.rows = t), (i.columns = o), i;
}
return (
z(e, [
{
key: "set",
value: function (t, r, e) {
return (this.data[t][r] = e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.data[t][r];
},
},
{
key: "removeRow",
value: function (t) {
return (
p(this, t), this.data.splice(t, 1), (this.rows -= 1), this
);
},
},
{
key: "addRow",
value: function (t, r) {
return (
void 0 === r && ((r = t), (t = this.rows)),
p(this, t, !0),
(r = Float64Array.from(v(this, r))),
this.data.splice(t, 0, r),
(this.rows += 1),
this
);
},
},
{
key: "removeColumn",
value: function (t) {
y(this, t);
for (var r = 0; r < this.rows; r++) {
for (
var e = new Float64Array(this.columns - 1), o = 0;
o < t;
o++
)
e[o] = this.data[r][o];
for (var n = t + 1; n < this.columns; n++)
e[n - 1] = this.data[r][n];
this.data[r] = e;
}
return (this.columns -= 1), this;
},
},
{
key: "addColumn",
value: function (t, r) {
void 0 === r && ((r = t), (t = this.columns)),
y(this, t, !0),
(r = m(this, r));
for (var e = 0; e < this.rows; e++) {
for (
var o = new Float64Array(this.columns + 1), n = 0;
n < t;
n++
)
o[n] = this.data[e][n];
for (o[n++] = r[e]; n < this.columns + 1; n++)
o[n] = this.data[e][n - 1];
this.data[e] = o;
}
return (this.columns += 1), this;
},
},
]),
e
);
})(U);
function H(t) {
return (H =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function K(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function X(t, r) {
return (X =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function G(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = $(t);
if (r) {
var n = $(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Z(this, e);
};
}
function Z(t, r) {
if (r && ("object" === H(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function $(t) {
return ($ = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
(J = Y),
((Q = U).prototype.add = function (t) {
return "number" == typeof t ? this.addS(t) : this.addM(t);
}),
(Q.prototype.addS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t);
return this;
}),
(Q.prototype.addM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t.get(r, e));
return this;
}),
(Q.add = function (t, r) {
return new J(t).add(r);
}),
(Q.prototype.sub = function (t) {
return "number" == typeof t ? this.subS(t) : this.subM(t);
}),
(Q.prototype.subS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t);
return this;
}),
(Q.prototype.subM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t.get(r, e));
return this;
}),
(Q.sub = function (t, r) {
return new J(t).sub(r);
}),
(Q.prototype.subtract = Q.prototype.sub),
(Q.prototype.subtractS = Q.prototype.subS),
(Q.prototype.subtractM = Q.prototype.subM),
(Q.subtract = Q.sub),
(Q.prototype.mul = function (t) {
return "number" == typeof t ? this.mulS(t) : this.mulM(t);
}),
(Q.prototype.mulS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t);
return this;
}),
(Q.prototype.mulM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t.get(r, e));
return this;
}),
(Q.mul = function (t, r) {
return new J(t).mul(r);
}),
(Q.prototype.multiply = Q.prototype.mul),
(Q.prototype.multiplyS = Q.prototype.mulS),
(Q.prototype.multiplyM = Q.prototype.mulM),
(Q.multiply = Q.mul),
(Q.prototype.div = function (t) {
return "number" == typeof t ? this.divS(t) : this.divM(t);
}),
(Q.prototype.divS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t);
return this;
}),
(Q.prototype.divM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t.get(r, e));
return this;
}),
(Q.div = function (t, r) {
return new J(t).div(r);
}),
(Q.prototype.divide = Q.prototype.div),
(Q.prototype.divideS = Q.prototype.divS),
(Q.prototype.divideM = Q.prototype.divM),
(Q.divide = Q.div),
(Q.prototype.mod = function (t) {
return "number" == typeof t ? this.modS(t) : this.modM(t);
}),
(Q.prototype.modS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) % t);
return this;
}),
(Q.prototype.modM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) % t.get(r, e));
return this;
}),
(Q.mod = function (t, r) {
return new J(t).mod(r);
}),
(Q.prototype.modulus = Q.prototype.mod),
(Q.prototype.modulusS = Q.prototype.modS),
(Q.prototype.modulusM = Q.prototype.modM),
(Q.modulus = Q.mod),
(Q.prototype.and = function (t) {
return "number" == typeof t ? this.andS(t) : this.andM(t);
}),
(Q.prototype.andS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) & t);
return this;
}),
(Q.prototype.andM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) & t.get(r, e));
return this;
}),
(Q.and = function (t, r) {
return new J(t).and(r);
}),
(Q.prototype.or = function (t) {
return "number" == typeof t ? this.orS(t) : this.orM(t);
}),
(Q.prototype.orS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) | t);
return this;
}),
(Q.prototype.orM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) | t.get(r, e));
return this;
}),
(Q.or = function (t, r) {
return new J(t).or(r);
}),
(Q.prototype.xor = function (t) {
return "number" == typeof t ? this.xorS(t) : this.xorM(t);
}),
(Q.prototype.xorS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) ^ t);
return this;
}),
(Q.prototype.xorM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) ^ t.get(r, e));
return this;
}),
(Q.xor = function (t, r) {
return new J(t).xor(r);
}),
(Q.prototype.leftShift = function (t) {
return "number" == typeof t ? this.leftShiftS(t) : this.leftShiftM(t);
}),
(Q.prototype.leftShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) << t);
return this;
}),
(Q.prototype.leftShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) << t.get(r, e));
return this;
}),
(Q.leftShift = function (t, r) {
return new J(t).leftShift(r);
}),
(Q.prototype.signPropagatingRightShift = function (t) {
return "number" == typeof t
? this.signPropagatingRightShiftS(t)
: this.signPropagatingRightShiftM(t);
}),
(Q.prototype.signPropagatingRightShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >> t);
return this;
}),
(Q.prototype.signPropagatingRightShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >> t.get(r, e));
return this;
}),
(Q.signPropagatingRightShift = function (t, r) {
return new J(t).signPropagatingRightShift(r);
}),
(Q.prototype.rightShift = function (t) {
return "number" == typeof t
? this.rightShiftS(t)
: this.rightShiftM(t);
}),
(Q.prototype.rightShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >>> t);
return this;
}),
(Q.prototype.rightShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >>> t.get(r, e));
return this;
}),
(Q.rightShift = function (t, r) {
return new J(t).rightShift(r);
}),
(Q.prototype.zeroFillRightShift = Q.prototype.rightShift),
(Q.prototype.zeroFillRightShiftS = Q.prototype.rightShiftS),
(Q.prototype.zeroFillRightShiftM = Q.prototype.rightShiftM),
(Q.zeroFillRightShift = Q.rightShift),
(Q.prototype.not = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, ~this.get(t, r));
return this;
}),
(Q.not = function (t) {
return new J(t).not();
}),
(Q.prototype.abs = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.abs(this.get(t, r)));
return this;
}),
(Q.abs = function (t) {
return new J(t).abs();
}),
(Q.prototype.acos = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.acos(this.get(t, r)));
return this;
}),
(Q.acos = function (t) {
return new J(t).acos();
}),
(Q.prototype.acosh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.acosh(this.get(t, r)));
return this;
}),
(Q.acosh = function (t) {
return new J(t).acosh();
}),
(Q.prototype.asin = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.asin(this.get(t, r)));
return this;
}),
(Q.asin = function (t) {
return new J(t).asin();
}),
(Q.prototype.asinh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.asinh(this.get(t, r)));
return this;
}),
(Q.asinh = function (t) {
return new J(t).asinh();
}),
(Q.prototype.atan = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.atan(this.get(t, r)));
return this;
}),
(Q.atan = function (t) {
return new J(t).atan();
}),
(Q.prototype.atanh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.atanh(this.get(t, r)));
return this;
}),
(Q.atanh = function (t) {
return new J(t).atanh();
}),
(Q.prototype.cbrt = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cbrt(this.get(t, r)));
return this;
}),
(Q.cbrt = function (t) {
return new J(t).cbrt();
}),
(Q.prototype.ceil = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.ceil(this.get(t, r)));
return this;
}),
(Q.ceil = function (t) {
return new J(t).ceil();
}),
(Q.prototype.clz32 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.clz32(this.get(t, r)));
return this;
}),
(Q.clz32 = function (t) {
return new J(t).clz32();
}),
(Q.prototype.cos = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cos(this.get(t, r)));
return this;
}),
(Q.cos = function (t) {
return new J(t).cos();
}),
(Q.prototype.cosh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cosh(this.get(t, r)));
return this;
}),
(Q.cosh = function (t) {
return new J(t).cosh();
}),
(Q.prototype.exp = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.exp(this.get(t, r)));
return this;
}),
(Q.exp = function (t) {
return new J(t).exp();
}),
(Q.prototype.expm1 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.expm1(this.get(t, r)));
return this;
}),
(Q.expm1 = function (t) {
return new J(t).expm1();
}),
(Q.prototype.floor = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.floor(this.get(t, r)));
return this;
}),
(Q.floor = function (t) {
return new J(t).floor();
}),
(Q.prototype.fround = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.fround(this.get(t, r)));
return this;
}),
(Q.fround = function (t) {
return new J(t).fround();
}),
(Q.prototype.log = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log(this.get(t, r)));
return this;
}),
(Q.log = function (t) {
return new J(t).log();
}),
(Q.prototype.log1p = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log1p(this.get(t, r)));
return this;
}),
(Q.log1p = function (t) {
return new J(t).log1p();
}),
(Q.prototype.log10 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log10(this.get(t, r)));
return this;
}),
(Q.log10 = function (t) {
return new J(t).log10();
}),
(Q.prototype.log2 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log2(this.get(t, r)));
return this;
}),
(Q.log2 = function (t) {
return new J(t).log2();
}),
(Q.prototype.round = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.round(this.get(t, r)));
return this;
}),
(Q.round = function (t) {
return new J(t).round();
}),
(Q.prototype.sign = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sign(this.get(t, r)));
return this;
}),
(Q.sign = function (t) {
return new J(t).sign();
}),
(Q.prototype.sin = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sin(this.get(t, r)));
return this;
}),
(Q.sin = function (t) {
return new J(t).sin();
}),
(Q.prototype.sinh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sinh(this.get(t, r)));
return this;
}),
(Q.sinh = function (t) {
return new J(t).sinh();
}),
(Q.prototype.sqrt = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sqrt(this.get(t, r)));
return this;
}),
(Q.sqrt = function (t) {
return new J(t).sqrt();
}),
(Q.prototype.tan = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.tan(this.get(t, r)));
return this;
}),
(Q.tan = function (t) {
return new J(t).tan();
}),
(Q.prototype.tanh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.tanh(this.get(t, r)));
return this;
}),
(Q.tanh = function (t) {
return new J(t).tanh();
}),
(Q.prototype.trunc = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.trunc(this.get(t, r)));
return this;
}),
(Q.trunc = function (t) {
return new J(t).trunc();
}),
(Q.pow = function (t, r) {
return new J(t).pow(r);
}),
(Q.prototype.pow = function (t) {
return "number" == typeof t ? this.powS(t) : this.powM(t);
}),
(Q.prototype.powS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, Math.pow(this.get(r, e), t));
return this;
}),
(Q.prototype.powM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, Math.pow(this.get(r, e), t.get(r, e)));
return this;
});
var tt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && X(t, r);
})(i, t);
var r,
e,
o,
n = G(i);
function i(t, r, e) {
var o;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
((o = n.call(this)).matrix = t),
(o.rows = r),
(o.columns = e),
o
);
}
return (
(r = i),
e && K(r.prototype, e),
o && K(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
r
);
})(U);
function rt(t) {
return (rt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function et(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ot(t, r) {
return (ot =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function nt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = st(t);
if (r) {
var n = st(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return it(this, e);
};
}
function it(t, r) {
if (r && ("object" === rt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function st(t) {
return (st = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var ut = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ot(t, r);
})(i, t);
var r,
e,
o,
n = nt(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
y(t, r),
((e = n.call(this, t, t.rows, 1)).column = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.column, e), this;
},
},
{
key: "get",
value: function (t) {
return this.matrix.get(t, this.column);
},
},
]) && et(r.prototype, e),
o && et(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function at(t) {
return (at =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function ft(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ct(t, r) {
return (ct =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function ht(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = pt(t);
if (r) {
var n = pt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return lt(this, e);
};
}
function lt(t, r) {
if (r && ("object" === at(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function pt(t) {
return (pt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var yt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ct(t, r);
})(i, t);
var r,
e,
o,
n = ht(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
w(t, r),
((e = n.call(this, t, t.rows, r.length)).columnIndices = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.columnIndices[r], e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(t, this.columnIndices[r]);
},
},
]) && ft(r.prototype, e),
o && ft(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function vt(t) {
return (vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function mt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function gt(t, r) {
return (gt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function wt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = dt(t);
if (r) {
var n = dt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return bt(this, e);
};
}
function bt(t, r) {
if (r && ("object" === vt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function dt(t) {
return (dt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Mt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && gt(t, r);
})(i, t);
var r,
e,
o,
n = wt(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.rows, t.columns)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.columns - r - 1, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(t, this.columns - r - 1);
},
},
]) && mt(r.prototype, e),
o && mt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function xt(t) {
return (xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function kt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function St(t, r) {
return (St =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Ot(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = jt(t);
if (r) {
var n = jt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Et(this, e);
};
}
function Et(t, r) {
if (r && ("object" === xt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function jt(t) {
return (jt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Rt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && St(t, r);
})(i, t);
var r,
e,
o,
n = Ot(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.rows, t.columns)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.rows - t - 1, r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.rows - t - 1, r);
},
},
]) && kt(r.prototype, e),
o && kt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Pt(t) {
return (Pt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function _t(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Tt(t, r) {
return (Tt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Ct(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = Dt(t);
if (r) {
var n = Dt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Nt(this, e);
};
}
function Nt(t, r) {
if (r && ("object" === Pt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Dt(t) {
return (Dt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var It = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Tt(t, r);
})(i, t);
var r,
e,
o,
n = Ct(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
p(t, r),
((e = n.call(this, t, 1, t.columns)).row = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.row, r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.row, r);
},
},
]) && _t(r.prototype, e),
o && _t(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Vt(t) {
return (Vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function qt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function At(t, r) {
return (At =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Ft(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = Bt(t);
if (r) {
var n = Bt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Lt(this, e);
};
}
function Lt(t, r) {
if (r && ("object" === Vt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Bt(t) {
return (Bt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var zt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && At(t, r);
})(i, t);
var r,
e,
o,
n = Ft(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
g(t, r),
((e = n.call(this, t, r.length, t.columns)).rowIndices = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.rowIndices[t], r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.rowIndices[t], r);
},
},
]) && qt(r.prototype, e),
o && qt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Ut(t) {
return (Ut =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Wt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Qt(t, r) {
return (Qt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Jt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = Ht(t);
if (r) {
var n = Ht(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Yt(this, e);
};
}
function Yt(t, r) {
if (r && ("object" === Ut(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Ht(t) {
return (Ht = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Kt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Qt(t, r);
})(i, t);
var r,
e,
o,
n = Jt(i);
function i(t, r, e) {
var o;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
g(t, r),
w(t, e),
((o = n.call(this, t, r.length, e.length)).rowIndices = r),
(o.columnIndices = e),
o
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (
this.matrix.set(this.rowIndices[t], this.columnIndices[r], e),
this
);
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(
this.rowIndices[t],
this.columnIndices[r],
);
},
},
]) && Wt(r.prototype, e),
o && Wt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Xt(t) {
return (Xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Gt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Zt(t, r) {
return (Zt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function $t(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = rr(t);
if (r) {
var n = rr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return tr(this, e);
};
}
function tr(t, r) {
if (r && ("object" === Xt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function rr(t) {
return (rr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var er = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Zt(t, r);
})(i, t);
var r,
e,
o,
n = $t(i);
function i(t, r, e, o, s) {
var u;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
b(t, r, e, o, s),
((u = n.call(this, t, e - r + 1, s - o + 1)).startRow = r),
(u.startColumn = o),
u
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (
this.matrix.set(this.startRow + t, this.startColumn + r, e),
this
);
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.startRow + t, this.startColumn + r);
},
},
]) && Gt(r.prototype, e),
o && Gt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function or(t) {
return (or =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function nr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ir(t, r) {
return (ir =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function sr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = ar(t);
if (r) {
var n = ar(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return ur(this, e);
};
}
function ur(t, r) {
if (r && ("object" === or(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function ar(t) {
return (ar = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var fr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ir(t, r);
})(i, t);
var r,
e,
o,
n = sr(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.columns, t.rows)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(r, t, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(r, t);
},
},
]) && nr(r.prototype, e),
o && nr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function cr(t) {
return (cr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function hr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function lr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function pr(t, r) {
return (pr =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function yr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = mr(t);
if (r) {
var n = mr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return vr(this, e);
};
}
function vr(t, r) {
if (r && ("object" === cr(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function mr(t) {
return (mr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var gr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && pr(t, r);
})(i, t);
var r,
e,
o,
n = yr(i);
function i(t) {
var r,
e =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
hr(this, i);
var o = e.rows,
s = void 0 === o ? 1 : o;
if (t.length % s != 0)
throw new Error(
"the data length is not divisible by the number of rows",
);
return (
((r = n.call(this)).rows = s),
(r.columns = t.length / s),
(r.data = t),
r
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
var o = this._calculateIndex(t, r);
return (this.data[o] = e), this;
},
},
{
key: "get",
value: function (t, r) {
var e = this._calculateIndex(t, r);
return this.data[e];
},
},
{
key: "_calculateIndex",
value: function (t, r) {
return t * this.columns + r;
},
},
]) && lr(r.prototype, e),
o && lr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(U);
function wr(t) {
return (wr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function br(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function dr(t, r) {
return (dr =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Mr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = kr(t);
if (r) {
var n = kr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return xr(this, e);
};
}
function xr(t, r) {
if (r && ("object" === wr(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function kr(t) {
return (kr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Sr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && dr(t, r);
})(i, t);
var r,
e,
o,
n = Mr(i);
function i(t) {
var r;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
((r = n.call(this)).data = t),
(r.rows = t.length),
(r.columns = t[0].length),
r
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (this.data[t][r] = e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.data[t][r];
},
},
]) && br(r.prototype, e),
o && br(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(U);
function Or(t, r) {
if (n(t)) return t[0] && n(t[0]) ? new Sr(t) : new gr(t, r);
throw new Error("the argument is not an array");
}
function Er(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var jr = (function () {
function t(r) {
!(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t);
var e,
o,
n,
i,
s,
u,
a,
f,
c,
h = (r = Sr.checkMatrix(r)).clone(),
l = h.rows,
p = h.columns,
y = new Float64Array(l),
v = 1;
for (e = 0; e < l; e++) y[e] = e;
for (f = new Float64Array(l), o = 0; o < p; o++) {
for (e = 0; e < l; e++) f[e] = h.get(e, o);
for (e = 0; e < l; e++) {
for (c = Math.min(e, o), s = 0, n = 0; n < c; n++)
s += h.get(e, n) * f[n];
(f[e] -= s), h.set(e, o, f[e]);
}
for (i = o, e = o + 1; e < l; e++)
Math.abs(f[e]) > Math.abs(f[i]) && (i = e);
if (i !== o) {
for (n = 0; n < p; n++)
(u = h.get(i, n)), h.set(i, n, h.get(o, n)), h.set(o, n, u);
(a = y[i]), (y[i] = y[o]), (y[o] = a), (v = -v);
}
if (o < l && 0 !== h.get(o, o))
for (e = o + 1; e < l; e++)
h.set(e, o, h.get(e, o) / h.get(o, o));
}
(this.LU = h), (this.pivotVector = y), (this.pivotSign = v);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "isSingular",
value: function () {
for (var t = this.LU, r = t.columns, e = 0; e < r; e++)
if (0 === t.get(e, e)) return !0;
return !1;
},
},
{
key: "solve",
value: function (t) {
t = Y.checkMatrix(t);
var r = this.LU;
if (r.rows !== t.rows)
throw new Error("Invalid matrix dimensions");
if (this.isSingular()) throw new Error("LU matrix is singular");
var e,
o,
n,
i = t.columns,
s = t.subMatrixRow(this.pivotVector, 0, i - 1),
u = r.columns;
for (n = 0; n < u; n++)
for (e = n + 1; e < u; e++)
for (o = 0; o < i; o++)
s.set(e, o, s.get(e, o) - s.get(n, o) * r.get(e, n));
for (n = u - 1; n >= 0; n--) {
for (o = 0; o < i; o++)
s.set(n, o, s.get(n, o) / r.get(n, n));
for (e = 0; e < n; e++)
for (o = 0; o < i; o++)
s.set(e, o, s.get(e, o) - s.get(n, o) * r.get(e, n));
}
return s;
},
},
{
key: "determinant",
get: function () {
var t = this.LU;
if (!t.isSquare()) throw new Error("Matrix must be square");
for (var r = this.pivotSign, e = t.columns, o = 0; o < e; o++)
r *= t.get(o, o);
return r;
},
},
{
key: "lowerTriangularMatrix",
get: function () {
for (
var t = this.LU,
r = t.rows,
e = t.columns,
o = new Y(r, e),
n = 0;
n < r;
n++
)
for (var i = 0; i < e; i++)
n > i
? o.set(n, i, t.get(n, i))
: n === i
? o.set(n, i, 1)
: o.set(n, i, 0);
return o;
},
},
{
key: "upperTriangularMatrix",
get: function () {
for (
var t = this.LU,
r = t.rows,
e = t.columns,
o = new Y(r, e),
n = 0;
n < r;
n++
)
for (var i = 0; i < e; i++)
n <= i ? o.set(n, i, t.get(n, i)) : o.set(n, i, 0);
return o;
},
},
{
key: "pivotPermutationVector",
get: function () {
return Array.from(this.pivotVector);
},
},
]) && Er(r.prototype, e),
o && Er(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Rr(t, r) {
var e = 0;
return Math.abs(t) > Math.abs(r)
? ((e = r / t), Math.abs(t) * Math.sqrt(1 + e * e))
: 0 !== r
? ((e = t / r), Math.abs(r) * Math.sqrt(1 + e * e))
: 0;
}
function Pr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var _r = (function () {
function t(r) {
!(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t);
var e,
o,
n,
i,
s = (r = Sr.checkMatrix(r)).clone(),
u = r.rows,
a = r.columns,
f = new Float64Array(a);
for (n = 0; n < a; n++) {
var c = 0;
for (e = n; e < u; e++) c = Rr(c, s.get(e, n));
if (0 !== c) {
for (s.get(n, n) < 0 && (c = -c), e = n; e < u; e++)
s.set(e, n, s.get(e, n) / c);
for (s.set(n, n, s.get(n, n) + 1), o = n + 1; o < a; o++) {
for (i = 0, e = n; e < u; e++) i += s.get(e, n) * s.get(e, o);
for (i = -i / s.get(n, n), e = n; e < u; e++)
s.set(e, o, s.get(e, o) + i * s.get(e, n));
}
}
f[n] = -c;
}
(this.QR = s), (this.Rdiag = f);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "solve",
value: function (t) {
t = Y.checkMatrix(t);
var r = this.QR,
e = r.rows;
if (t.rows !== e)
throw new Error("Matrix row dimensions must agree");
if (!this.isFullRank())
throw new Error("Matrix is rank deficient");
var o,
n,
i,
s,
u = t.columns,
a = t.clone(),
f = r.columns;
for (i = 0; i < f; i++)
for (n = 0; n < u; n++) {
for (s = 0, o = i; o < e; o++)
s += r.get(o, i) * a.get(o, n);
for (s = -s / r.get(i, i), o = i; o < e; o++)
a.set(o, n, a.get(o, n) + s * r.get(o, i));
}
for (i = f - 1; i >= 0; i--) {
for (n = 0; n < u; n++)
a.set(i, n, a.get(i, n) / this.Rdiag[i]);
for (o = 0; o < i; o++)
for (n = 0; n < u; n++)
a.set(o, n, a.get(o, n) - a.get(i, n) * r.get(o, i));
}
return a.subMatrix(0, f - 1, 0, u - 1);
},
},
{
key: "isFullRank",
value: function () {
for (var t = this.QR.columns, r = 0; r < t; r++)
if (0 === this.Rdiag[r]) return !1;
return !0;
},
},
{
key: "upperTriangularMatrix",
get: function () {
var t,
r,
e = this.QR,
o = e.columns,
n = new Y(o, o);
for (t = 0; t < o; t++)
for (r = 0; r < o; r++)
t < r
? n.set(t, r, e.get(t, r))
: t === r
? n.set(t, r, this.Rdiag[t])
: n.set(t, r, 0);
return n;
},
},
{
key: "orthogonalMatrix",
get: function () {
var t,
r,
e,
o,
n = this.QR,
i = n.rows,
s = n.columns,
u = new Y(i, s);
for (e = s - 1; e >= 0; e--) {
for (t = 0; t < i; t++) u.set(t, e, 0);
for (u.set(e, e, 1), r = e; r < s; r++)
if (0 !== n.get(e, e)) {
for (o = 0, t = e; t < i; t++)
o += n.get(t, e) * u.get(t, r);
for (o = -o / n.get(e, e), t = e; t < i; t++)
u.set(t, r, u.get(t, r) + o * n.get(t, e));
}
}
return u;
},
},
]) && Pr(r.prototype, e),
o && Pr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Tr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function Cr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var Nr = (function () {
function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if ((Tr(this, t), (r = Sr.checkMatrix(r)).isEmpty()))
throw new Error("Matrix must be non-empty");
var o,
n = r.rows,
i = r.columns,
s = e.computeLeftSingularVectors,
u = void 0 === s || s,
a = e.computeRightSingularVectors,
f = void 0 === a || a,
c = e.autoTranspose,
h = void 0 !== c && c,
l = Boolean(u),
p = Boolean(f),
y = !1;
if (n < i)
if (h) {
(n = (o = r.transpose()).rows), (i = o.columns), (y = !0);
var v = l;
(l = p), (p = v);
} else
(o = r.clone()),
console.warn(
"Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose",
);
else o = r.clone();
for (
var m = Math.min(n, i),
g = Math.min(n + 1, i),
w = new Float64Array(g),
b = new Y(n, m),
d = new Y(i, i),
M = new Float64Array(i),
x = new Float64Array(n),
k = new Float64Array(g),
S = 0;
S < g;
S++
)
k[S] = S;
for (
var O = Math.min(n - 1, i),
E = Math.max(0, Math.min(i - 2, n)),
j = Math.max(O, E),
R = 0;
R < j;
R++
) {
if (R < O) {
w[R] = 0;
for (var P = R; P < n; P++) w[R] = Rr(w[R], o.get(P, R));
if (0 !== w[R]) {
o.get(R, R) < 0 && (w[R] = -w[R]);
for (var _ = R; _ < n; _++) o.set(_, R, o.get(_, R) / w[R]);
o.set(R, R, o.get(R, R) + 1);
}
w[R] = -w[R];
}
for (var T = R + 1; T < i; T++) {
if (R < O && 0 !== w[R]) {
for (var C = 0, N = R; N < n; N++)
C += o.get(N, R) * o.get(N, T);
C = -C / o.get(R, R);
for (var D = R; D < n; D++)
o.set(D, T, o.get(D, T) + C * o.get(D, R));
}
M[T] = o.get(R, T);
}
if (l && R < O)
for (var I = R; I < n; I++) b.set(I, R, o.get(I, R));
if (R < E) {
M[R] = 0;
for (var V = R + 1; V < i; V++) M[R] = Rr(M[R], M[V]);
if (0 !== M[R]) {
M[R + 1] < 0 && (M[R] = 0 - M[R]);
for (var q = R + 1; q < i; q++) M[q] /= M[R];
M[R + 1] += 1;
}
if (((M[R] = -M[R]), R + 1 < n && 0 !== M[R])) {
for (var A = R + 1; A < n; A++) x[A] = 0;
for (var F = R + 1; F < n; F++)
for (var L = R + 1; L < i; L++) x[F] += M[L] * o.get(F, L);
for (var B = R + 1; B < i; B++)
for (var z = -M[B] / M[R + 1], U = R + 1; U < n; U++)
o.set(U, B, o.get(U, B) + z * x[U]);
}
if (p) for (var W = R + 1; W < i; W++) d.set(W, R, M[W]);
}
}
var Q = Math.min(i, n + 1);
if (
(O < i && (w[O] = o.get(O, O)),
n < Q && (w[Q - 1] = 0),
E + 1 < Q && (M[E] = o.get(E, Q - 1)),
(M[Q - 1] = 0),
l)
) {
for (var J = O; J < m; J++) {
for (var H = 0; H < n; H++) b.set(H, J, 0);
b.set(J, J, 1);
}
for (var K = O - 1; K >= 0; K--)
if (0 !== w[K]) {
for (var X = K + 1; X < m; X++) {
for (var G = 0, Z = K; Z < n; Z++)
G += b.get(Z, K) * b.get(Z, X);
G = -G / b.get(K, K);
for (var $ = K; $ < n; $++)
b.set($, X, b.get($, X) + G * b.get($, K));
}
for (var tt = K; tt < n; tt++) b.set(tt, K, -b.get(tt, K));
b.set(K, K, 1 + b.get(K, K));
for (var rt = 0; rt < K - 1; rt++) b.set(rt, K, 0);
} else {
for (var et = 0; et < n; et++) b.set(et, K, 0);
b.set(K, K, 1);
}
}
if (p)
for (var ot = i - 1; ot >= 0; ot--) {
if (ot < E && 0 !== M[ot])
for (var nt = ot + 1; nt < i; nt++) {
for (var it = 0, st = ot + 1; st < i; st++)
it += d.get(st, ot) * d.get(st, nt);
it = -it / d.get(ot + 1, ot);
for (var ut = ot + 1; ut < i; ut++)
d.set(ut, nt, d.get(ut, nt) + it * d.get(ut, ot));
}
for (var at = 0; at < i; at++) d.set(at, ot, 0);
d.set(ot, ot, 1);
}
for (var ft = Q - 1, ct = Number.EPSILON; Q > 0; ) {
var ht = void 0,
lt = void 0;
for (ht = Q - 2; ht >= -1 && -1 !== ht; ht--) {
var pt =
Number.MIN_VALUE + ct * Math.abs(w[ht] + Math.abs(w[ht + 1]));
if (Math.abs(M[ht]) <= pt || Number.isNaN(M[ht])) {
M[ht] = 0;
break;
}
}
if (ht === Q - 2) lt = 4;
else {
var yt = void 0;
for (yt = Q - 1; yt >= ht && yt !== ht; yt--) {
var vt =
(yt !== Q ? Math.abs(M[yt]) : 0) +
(yt !== ht + 1 ? Math.abs(M[yt - 1]) : 0);
if (Math.abs(w[yt]) <= ct * vt) {
w[yt] = 0;
break;
}
}
yt === ht
? (lt = 3)
: yt === Q - 1
? (lt = 1)
: ((lt = 2), (ht = yt));
}
switch ((ht++, lt)) {
case 1:
var mt = M[Q - 2];
M[Q - 2] = 0;
for (var gt = Q - 2; gt >= ht; gt--) {
var wt = Rr(w[gt], mt),
bt = w[gt] / wt,
dt = mt / wt;
if (
((w[gt] = wt),
gt !== ht &&
((mt = -dt * M[gt - 1]), (M[gt - 1] = bt * M[gt - 1])),
p)
)
for (var Mt = 0; Mt < i; Mt++)
(wt = bt * d.get(Mt, gt) + dt * d.get(Mt, Q - 1)),
d.set(
Mt,
Q - 1,
-dt * d.get(Mt, gt) + bt * d.get(Mt, Q - 1),
),
d.set(Mt, gt, wt);
}
break;
case 2:
var xt = M[ht - 1];
M[ht - 1] = 0;
for (var kt = ht; kt < Q; kt++) {
var St = Rr(w[kt], xt),
Ot = w[kt] / St,
Et = xt / St;
if (
((w[kt] = St), (xt = -Et * M[kt]), (M[kt] = Ot * M[kt]), l)
)
for (var jt = 0; jt < n; jt++)
(St = Ot * b.get(jt, kt) + Et * b.get(jt, ht - 1)),
b.set(
jt,
ht - 1,
-Et * b.get(jt, kt) + Ot * b.get(jt, ht - 1),
),
b.set(jt, kt, St);
}
break;
case 3:
var Rt = Math.max(
Math.abs(w[Q - 1]),
Math.abs(w[Q - 2]),
Math.abs(M[Q - 2]),
Math.abs(w[ht]),
Math.abs(M[ht]),
),
Pt = w[Q - 1] / Rt,
_t = w[Q - 2] / Rt,
Tt = M[Q - 2] / Rt,
Ct = w[ht] / Rt,
Nt = M[ht] / Rt,
Dt = ((_t + Pt) * (_t - Pt) + Tt * Tt) / 2,
It = Pt * Tt * (Pt * Tt),
Vt = 0;
(0 === Dt && 0 === It) ||
(Vt =
It /
(Dt +
(Vt =
Dt < 0
? 0 - Math.sqrt(Dt * Dt + It)
: Math.sqrt(Dt * Dt + It))));
for (
var qt = (Ct + Pt) * (Ct - Pt) + Vt, At = Ct * Nt, Ft = ht;
Ft < Q - 1;
Ft++
) {
var Lt = Rr(qt, At);
0 === Lt && (Lt = Number.MIN_VALUE);
var Bt = qt / Lt,
zt = At / Lt;
if (
(Ft !== ht && (M[Ft - 1] = Lt),
(qt = Bt * w[Ft] + zt * M[Ft]),
(M[Ft] = Bt * M[Ft] - zt * w[Ft]),
(At = zt * w[Ft + 1]),
(w[Ft + 1] = Bt * w[Ft + 1]),
p)
)
for (var Ut = 0; Ut < i; Ut++)
(Lt = Bt * d.get(Ut, Ft) + zt * d.get(Ut, Ft + 1)),
d.set(
Ut,
Ft + 1,
-zt * d.get(Ut, Ft) + Bt * d.get(Ut, Ft + 1),
),
d.set(Ut, Ft, Lt);
if (
(0 === (Lt = Rr(qt, At)) && (Lt = Number.MIN_VALUE),
(Bt = qt / Lt),
(zt = At / Lt),
(w[Ft] = Lt),
(qt = Bt * M[Ft] + zt * w[Ft + 1]),
(w[Ft + 1] = -zt * M[Ft] + Bt * w[Ft + 1]),
(At = zt * M[Ft + 1]),
(M[Ft + 1] = Bt * M[Ft + 1]),
l && Ft < n - 1)
)
for (var Wt = 0; Wt < n; Wt++)
(Lt = Bt * b.get(Wt, Ft) + zt * b.get(Wt, Ft + 1)),
b.set(
Wt,
Ft + 1,
-zt * b.get(Wt, Ft) + Bt * b.get(Wt, Ft + 1),
),
b.set(Wt, Ft, Lt);
}
(M[Q - 2] = qt), 1;
break;
case 4:
if (w[ht] <= 0 && ((w[ht] = w[ht] < 0 ? -w[ht] : 0), p))
for (var Qt = 0; Qt <= ft; Qt++)
d.set(Qt, ht, -d.get(Qt, ht));
for (; ht < ft && !(w[ht] >= w[ht + 1]); ) {
var Jt = w[ht];
if (((w[ht] = w[ht + 1]), (w[ht + 1] = Jt), p && ht < i - 1))
for (var Yt = 0; Yt < i; Yt++)
(Jt = d.get(Yt, ht + 1)),
d.set(Yt, ht + 1, d.get(Yt, ht)),
d.set(Yt, ht, Jt);
if (l && ht < n - 1)
for (var Ht = 0; Ht < n; Ht++)
(Jt = b.get(Ht, ht + 1)),
b.set(Ht, ht + 1, b.get(Ht, ht)),
b.set(Ht, ht, Jt);
ht++;
}
0, Q--;
}
}
if (y) {
var Kt = d;
(d = b), (b = Kt);
}
(this.m = n), (this.n = i), (this.s = w), (this.U = b), (this.V = d);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "solve",
value: function (t) {
for (
var r = t,
e = this.threshold,
o = this.s.length,
n = Y.zeros(o, o),
i = 0;
i < o;
i++
)
Math.abs(this.s[i]) <= e
? n.set(i, i, 0)
: n.set(i, i, 1 / this.s[i]);
for (
var s = this.U,
u = this.rightSingularVectors,
a = u.mmul(n),
f = u.rows,
c = s.rows,
h = Y.zeros(f, c),
l = 0;
l < f;
l++
)
for (var p = 0; p < c; p++) {
for (var y = 0, v = 0; v < o; v++)
y += a.get(l, v) * s.get(p, v);
h.set(l, p, y);
}
return h.mmul(r);
},
},
{
key: "solveForDiagonal",
value: function (t) {
return this.solve(Y.diag(t));
},
},
{
key: "inverse",
value: function () {
for (
var t = this.V,
r = this.threshold,
e = t.rows,
o = t.columns,
n = new Y(e, this.s.length),
i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
Math.abs(this.s[s]) > r &&
n.set(i, s, t.get(i, s) / this.s[s]);
for (
var u = this.U,
a = u.rows,
f = u.columns,
c = new Y(e, a),
h = 0;
h < e;
h++
)
for (var l = 0; l < a; l++) {
for (var p = 0, y = 0; y < f; y++)
p += n.get(h, y) * u.get(l, y);
c.set(h, l, p);
}
return c;
},
},
{
key: "condition",
get: function () {
return this.s[0] / this.s[Math.min(this.m, this.n) - 1];
},
},
{
key: "norm2",
get: function () {
return this.s[0];
},
},
{
key: "rank",
get: function () {
for (
var t = Math.max(this.m, this.n) * this.s[0] * Number.EPSILON,
r = 0,
e = this.s,
o = 0,
n = e.length;
o < n;
o++
)
e[o] > t && r++;
return r;
},
},
{
key: "diagonal",
get: function () {
return Array.from(this.s);
},
},
{
key: "threshold",
get: function () {
return (
(Number.EPSILON / 2) * Math.max(this.m, this.n) * this.s[0]
);
},
},
{
key: "leftSingularVectors",
get: function () {
return this.U;
},
},
{
key: "rightSingularVectors",
get: function () {
return this.V;
},
},
{
key: "diagonalMatrix",
get: function () {
return Y.diag(this.s);
},
},
]) && Cr(r.prototype, e),
o && Cr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Dr(t) {
var r = arguments.length > 1 && void 0 !== arguments[1] && arguments[1];
return (
(t = Sr.checkMatrix(t)),
r ? new Nr(t).inverse() : Ir(t, Y.eye(t.rows))
);
}
function Ir(t, r) {
var e = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
return (
(t = Sr.checkMatrix(t)),
(r = Sr.checkMatrix(r)),
e
? new Nr(t).solve(r)
: t.isSquare()
? new jr(t).solve(r)
: new _r(t).solve(r)
);
}
function Vr(t) {
var r, e, o, n, i, s;
if ((t = Y.checkMatrix(t)).isSquare())
return 0 === t.columns
? 1
: 2 === t.columns
? ((r = t.get(0, 0)),
(e = t.get(0, 1)),
(o = t.get(1, 0)),
r * t.get(1, 1) - e * o)
: 3 === t.columns
? ((n = new Kt(t, [1, 2], [1, 2])),
(i = new Kt(t, [1, 2], [0, 2])),
(s = new Kt(t, [1, 2], [0, 1])),
(r = t.get(0, 0)),
(e = t.get(0, 1)),
(o = t.get(0, 2)),
r * Vr(n) - e * Vr(i) + o * Vr(s))
: new jr(t).determinant;
throw Error("determinant can only be calculated for a square matrix");
}
function qr(t, r) {
for (var e = [], o = 0; o < t; o++) o !== r && e.push(o);
return e;
}
function Ar(t, r, e) {
var o =
arguments.length > 3 && void 0 !== arguments[3]
? arguments[3]
: 1e-9,
n =
arguments.length > 4 && void 0 !== arguments[4]
? arguments[4]
: 1e-9;
if (t > n) return new Array(r.rows + 1).fill(0);
for (var i = r.addRow(e, [0]), s = 0; s < i.rows; s++)
Math.abs(i.get(s, 0)) < o && i.set(s, 0, 0);
return i.to1DArray();
}
function Fr(t) {
for (
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {},
e = r.thresholdValue,
o = void 0 === e ? 1e-9 : e,
n = r.thresholdError,
i = void 0 === n ? 1e-9 : n,
s = (t = Y.checkMatrix(t)).rows,
u = new Y(s, s),
a = 0;
a < s;
a++
) {
var f = Y.columnVector(t.getRow(a)),
c = t.subMatrixRow(qr(s, a)).transpose(),
h = new Nr(c),
l = h.solve(f),
p = Y.sub(f, c.mmul(l)).abs().max();
u.setRow(a, Ar(p, l, a, o, i));
}
return u;
}
function Lr(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: Number.EPSILON;
if ((t = Y.checkMatrix(t)).isEmpty()) return t.transpose();
for (
var e = new Nr(t, { autoTranspose: !0 }),
o = e.leftSingularVectors,
n = e.rightSingularVectors,
i = e.diagonal,
s = 0;
s < i.length;
s++
)
Math.abs(i[s]) > r ? (i[s] = 1 / i[s]) : (i[s] = 0);
return n.mmul(Y.diag(i).mmul(o.transpose()));
}
function Br(t) {
return (Br =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function zr(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : t,
e =
arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
t = new Y(t);
var o = !1;
if (
("object" !== Br(r) || Y.isMatrix(r) || n(r)
? (r = new Y(r))
: ((e = r), (r = t), (o = !0)),
t.rows !== r.rows)
)
throw new TypeError(
"Both matrices must have the same number of rows",
);
var i = e,
s = i.center,
u = void 0 === s || s;
u && ((t = t.center("column")), o || (r = r.center("column")));
for (var a = t.transpose().mmul(r), f = 0; f < a.rows; f++)
for (var c = 0; c < a.columns; c++)
a.set(f, c, a.get(f, c) * (1 / (t.rows - 1)));
return a;
}
function Ur(t) {
return (Ur =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Wr(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : t,
e =
arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
t = new Y(t);
var o = !1;
if (
("object" !== Ur(r) || Y.isMatrix(r) || n(r)
? (r = new Y(r))
: ((e = r), (r = t), (o = !0)),
t.rows !== r.rows)
)
throw new TypeError(
"Both matrices must have the same number of rows",
);
var i = e,
s = i.center,
u = void 0 === s || s,
a = i.scale,
f = void 0 === a || a;
u && (t.center("column"), o || r.center("column")),
f && (t.scale("column"), o || r.scale("column"));
for (
var c = t.standardDeviation("column", { unbiased: !0 }),
h = o ? c : r.standardDeviation("column", { unbiased: !0 }),
l = t.transpose().mmul(r),
p = 0;
p < l.rows;
p++
)
for (var y = 0; y < l.columns; y++)
l.set(p, y, l.get(p, y) * (1 / (c[p] * h[y])) * (1 / (t.rows - 1)));
return l;
}
function Qr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function Jr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var Yr = (function () {
function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
Qr(this, t);
var o = e.assumeSymmetric,
n = void 0 !== o && o;
if (!(r = Sr.checkMatrix(r)).isSquare())
throw new Error("Matrix is not a square matrix");
if (r.isEmpty()) throw new Error("Matrix must be non-empty");
var i,
s,
u = r.columns,
a = new Y(u, u),
f = new Float64Array(u),
c = new Float64Array(u),
h = r;
if (!!n || r.isSymmetric()) {
for (i = 0; i < u; i++)
for (s = 0; s < u; s++) a.set(i, s, h.get(i, s));
Hr(u, c, f, a), Kr(u, c, f, a);
} else {
var l = new Y(u, u),
p = new Float64Array(u);
for (s = 0; s < u; s++)
for (i = 0; i < u; i++) l.set(i, s, h.get(i, s));
Xr(u, l, p, a), Gr(u, c, f, a, l);
}
(this.n = u), (this.e = c), (this.d = f), (this.V = a);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "realEigenvalues",
get: function () {
return Array.from(this.d);
},
},
{
key: "imaginaryEigenvalues",
get: function () {
return Array.from(this.e);
},
},
{
key: "eigenvectorMatrix",
get: function () {
return this.V;
},
},
{
key: "diagonalMatrix",
get: function () {
var t,
r,
e = this.n,
o = this.e,
n = this.d,
i = new Y(e, e);
for (t = 0; t < e; t++) {
for (r = 0; r < e; r++) i.set(t, r, 0);
i.set(t, t, n[t]),
o[t] > 0
? i.set(t, t + 1, o[t])
: o[t] < 0 && i.set(t, t - 1, o[t]);
}
return i;
},
},
]) && Jr(r.prototype, e),
o && Jr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Hr(t, r, e, o) {
var n, i, s, u, a, f, c, h;
for (a = 0; a < t; a++) e[a] = o.get(t - 1, a);
for (u = t - 1; u > 0; u--) {
for (h = 0, s = 0, f = 0; f < u; f++) h += Math.abs(e[f]);
if (0 === h)
for (r[u] = e[u - 1], a = 0; a < u; a++)
(e[a] = o.get(u - 1, a)), o.set(u, a, 0), o.set(a, u, 0);
else {
for (f = 0; f < u; f++) (e[f] /= h), (s += e[f] * e[f]);
for (
n = e[u - 1],
i = Math.sqrt(s),
n > 0 && (i = -i),
r[u] = h * i,
s -= n * i,
e[u - 1] = n - i,
a = 0;
a < u;
a++
)
r[a] = 0;
for (a = 0; a < u; a++) {
for (
n = e[a], o.set(a, u, n), i = r[a] + o.get(a, a) * n, f = a + 1;
f <= u - 1;
f++
)
(i += o.get(f, a) * e[f]), (r[f] += o.get(f, a) * n);
r[a] = i;
}
for (n = 0, a = 0; a < u; a++) (r[a] /= s), (n += r[a] * e[a]);
for (c = n / (s + s), a = 0; a < u; a++) r[a] -= c * e[a];
for (a = 0; a < u; a++) {
for (n = e[a], i = r[a], f = a; f <= u - 1; f++)
o.set(f, a, o.get(f, a) - (n * r[f] + i * e[f]));
(e[a] = o.get(u - 1, a)), o.set(u, a, 0);
}
}
e[u] = s;
}
for (u = 0; u < t - 1; u++) {
if (
(o.set(t - 1, u, o.get(u, u)), o.set(u, u, 1), 0 !== (s = e[u + 1]))
) {
for (f = 0; f <= u; f++) e[f] = o.get(f, u + 1) / s;
for (a = 0; a <= u; a++) {
for (i = 0, f = 0; f <= u; f++)
i += o.get(f, u + 1) * o.get(f, a);
for (f = 0; f <= u; f++) o.set(f, a, o.get(f, a) - i * e[f]);
}
}
for (f = 0; f <= u; f++) o.set(f, u + 1, 0);
}
for (a = 0; a < t; a++) (e[a] = o.get(t - 1, a)), o.set(t - 1, a, 0);
o.set(t - 1, t - 1, 1), (r[0] = 0);
}
function Kr(t, r, e, o) {
var n, i, s, u, a, f, c, h, l, p, y, v, m, g, w, b;
for (s = 1; s < t; s++) r[s - 1] = r[s];
r[t - 1] = 0;
var d = 0,
M = 0,
x = Number.EPSILON;
for (f = 0; f < t; f++) {
for (
M = Math.max(M, Math.abs(e[f]) + Math.abs(r[f])), c = f;
c < t && !(Math.abs(r[c]) <= x * M);
)
c++;
if (c > f) {
0;
do {
for (
1,
n = e[f],
l = Rr((h = (e[f + 1] - n) / (2 * r[f])), 1),
h < 0 && (l = -l),
e[f] = r[f] / (h + l),
e[f + 1] = r[f] * (h + l),
p = e[f + 1],
i = n - e[f],
s = f + 2;
s < t;
s++
)
e[s] -= i;
for (
d += i,
h = e[c],
v = y = 1,
m = y,
g = r[f + 1],
w = 0,
b = 0,
s = c - 1;
s >= f;
s--
)
for (
m = v,
v = y,
b = w,
n = y * r[s],
i = y * h,
l = Rr(h, r[s]),
r[s + 1] = w * l,
w = r[s] / l,
h = (y = h / l) * e[s] - w * n,
e[s + 1] = i + w * (y * n + w * e[s]),
a = 0;
a < t;
a++
)
(i = o.get(a, s + 1)),
o.set(a, s + 1, w * o.get(a, s) + y * i),
o.set(a, s, y * o.get(a, s) - w * i);
(h = (-w * b * m * g * r[f]) / p), (r[f] = w * h), (e[f] = y * h);
} while (Math.abs(r[f]) > x * M);
}
(e[f] = e[f] + d), (r[f] = 0);
}
for (s = 0; s < t - 1; s++) {
for (a = s, h = e[s], u = s + 1; u < t; u++)
e[u] < h && ((a = u), (h = e[u]));
if (a !== s)
for (e[a] = e[s], e[s] = h, u = 0; u < t; u++)
(h = o.get(u, s)), o.set(u, s, o.get(u, a)), o.set(u, a, h);
}
}
function Xr(t, r, e, o) {
var n,
i,
s,
u,
a,
f,
c,
h = t - 1;
for (f = 1; f <= h - 1; f++) {
for (c = 0, u = f; u <= h; u++) c += Math.abs(r.get(u, f - 1));
if (0 !== c) {
for (s = 0, u = h; u >= f; u--)
(e[u] = r.get(u, f - 1) / c), (s += e[u] * e[u]);
for (
i = Math.sqrt(s),
e[f] > 0 && (i = -i),
s -= e[f] * i,
e[f] = e[f] - i,
a = f;
a < t;
a++
) {
for (n = 0, u = h; u >= f; u--) n += e[u] * r.get(u, a);
for (n /= s, u = f; u <= h; u++)
r.set(u, a, r.get(u, a) - n * e[u]);
}
for (u = 0; u <= h; u++) {
for (n = 0, a = h; a >= f; a--) n += e[a] * r.get(u, a);
for (n /= s, a = f; a <= h; a++)
r.set(u, a, r.get(u, a) - n * e[a]);
}
(e[f] = c * e[f]), r.set(f, f - 1, c * i);
}
}
for (u = 0; u < t; u++)
for (a = 0; a < t; a++) o.set(u, a, u === a ? 1 : 0);
for (f = h - 1; f >= 1; f--)
if (0 !== r.get(f, f - 1)) {
for (u = f + 1; u <= h; u++) e[u] = r.get(u, f - 1);
for (a = f; a <= h; a++) {
for (i = 0, u = f; u <= h; u++) i += e[u] * o.get(u, a);
for (i = i / e[f] / r.get(f, f - 1), u = f; u <= h; u++)
o.set(u, a, o.get(u, a) + i * e[u]);
}
}
}
function Gr(t, r, e, o, n) {
var i,
s,
u,
a,
f,
c,
h,
l,
p,
y,
v,
m,
g,
w,
b,
d = t - 1,
M = t - 1,
x = Number.EPSILON,
k = 0,
S = 0,
O = 0,
E = 0,
j = 0,
R = 0,
P = 0,
_ = 0;
for (i = 0; i < t; i++)
for (
(i < 0 || i > M) && ((e[i] = n.get(i, i)), (r[i] = 0)),
s = Math.max(i - 1, 0);
s < t;
s++
)
S += Math.abs(n.get(i, s));
for (; d >= 0; ) {
for (
a = d;
a > 0 &&
(0 ===
(R = Math.abs(n.get(a - 1, a - 1)) + Math.abs(n.get(a, a))) &&
(R = S),
!(Math.abs(n.get(a, a - 1)) < x * R));
)
a--;
if (a === d)
n.set(d, d, n.get(d, d) + k),
(e[d] = n.get(d, d)),
(r[d] = 0),
d--,
(_ = 0);
else if (a === d - 1) {
if (
((h = n.get(d, d - 1) * n.get(d - 1, d)),
(E = (O = (n.get(d - 1, d - 1) - n.get(d, d)) / 2) * O + h),
(P = Math.sqrt(Math.abs(E))),
n.set(d, d, n.get(d, d) + k),
n.set(d - 1, d - 1, n.get(d - 1, d - 1) + k),
(l = n.get(d, d)),
E >= 0)
) {
for (
P = O >= 0 ? O + P : O - P,
e[d - 1] = l + P,
e[d] = e[d - 1],
0 !== P && (e[d] = l - h / P),
r[d - 1] = 0,
r[d] = 0,
O = (l = n.get(d, d - 1)) / (R = Math.abs(l) + Math.abs(P)),
E = P / R,
O /= j = Math.sqrt(O * O + E * E),
E /= j,
s = d - 1;
s < t;
s++
)
(P = n.get(d - 1, s)),
n.set(d - 1, s, E * P + O * n.get(d, s)),
n.set(d, s, E * n.get(d, s) - O * P);
for (i = 0; i <= d; i++)
(P = n.get(i, d - 1)),
n.set(i, d - 1, E * P + O * n.get(i, d)),
n.set(i, d, E * n.get(i, d) - O * P);
for (i = 0; i <= M; i++)
(P = o.get(i, d - 1)),
o.set(i, d - 1, E * P + O * o.get(i, d)),
o.set(i, d, E * o.get(i, d) - O * P);
} else
(e[d - 1] = l + O), (e[d] = l + O), (r[d - 1] = P), (r[d] = -P);
(d -= 2), (_ = 0);
} else {
if (
((l = n.get(d, d)),
(p = 0),
(h = 0),
a < d &&
((p = n.get(d - 1, d - 1)),
(h = n.get(d, d - 1) * n.get(d - 1, d))),
10 === _)
) {
for (k += l, i = 0; i <= d; i++) n.set(i, i, n.get(i, i) - l);
(l = p =
0.75 *
(R =
Math.abs(n.get(d, d - 1)) + Math.abs(n.get(d - 1, d - 2)))),
(h = -0.4375 * R * R);
}
if (30 === _ && (R = (R = (p - l) / 2) * R + h) > 0) {
for (
R = Math.sqrt(R),
p < l && (R = -R),
R = l - h / ((p - l) / 2 + R),
i = 0;
i <= d;
i++
)
n.set(i, i, n.get(i, i) - R);
(k += R), (l = p = h = 0.964);
}
for (
_ += 1, f = d - 2;
f >= a &&
((O =
((j = l - (P = n.get(f, f))) * (R = p - P) - h) /
n.get(f + 1, f) +
n.get(f, f + 1)),
(E = n.get(f + 1, f + 1) - P - j - R),
(j = n.get(f + 2, f + 1)),
(O /= R = Math.abs(O) + Math.abs(E) + Math.abs(j)),
(E /= R),
(j /= R),
f !== a) &&
!(
Math.abs(n.get(f, f - 1)) * (Math.abs(E) + Math.abs(j)) <
x *
(Math.abs(O) *
(Math.abs(n.get(f - 1, f - 1)) +
Math.abs(P) +
Math.abs(n.get(f + 1, f + 1))))
);
)
f--;
for (i = f + 2; i <= d; i++)
n.set(i, i - 2, 0), i > f + 2 && n.set(i, i - 3, 0);
for (
u = f;
u <= d - 1 &&
((w = u !== d - 1),
u !== f &&
((O = n.get(u, u - 1)),
(E = n.get(u + 1, u - 1)),
(j = w ? n.get(u + 2, u - 1) : 0),
0 !== (l = Math.abs(O) + Math.abs(E) + Math.abs(j)) &&
((O /= l), (E /= l), (j /= l))),
0 !== l);
u++
)
if (
((R = Math.sqrt(O * O + E * E + j * j)),
O < 0 && (R = -R),
0 !== R)
) {
for (
u !== f
? n.set(u, u - 1, -R * l)
: a !== f && n.set(u, u - 1, -n.get(u, u - 1)),
l = (O += R) / R,
p = E / R,
P = j / R,
E /= O,
j /= O,
s = u;
s < t;
s++
)
(O = n.get(u, s) + E * n.get(u + 1, s)),
w &&
((O += j * n.get(u + 2, s)),
n.set(u + 2, s, n.get(u + 2, s) - O * P)),
n.set(u, s, n.get(u, s) - O * l),
n.set(u + 1, s, n.get(u + 1, s) - O * p);
for (i = 0; i <= Math.min(d, u + 3); i++)
(O = l * n.get(i, u) + p * n.get(i, u + 1)),
w &&
((O += P * n.get(i, u + 2)),
n.set(i, u + 2, n.get(i, u + 2) - O * j)),
n.set(i, u, n.get(i, u) - O),
n.set(i, u + 1, n.get(i, u + 1) - O * E);
for (i = 0; i <= M; i++)
(O = l * o.get(i, u) + p * o.get(i, u + 1)),
w &&
((O += P * o.get(i, u + 2)),
o.set(i, u + 2, o.get(i, u + 2) - O * j)),
o.set(i, u, o.get(i, u) - O),
o.set(i, u + 1, o.get(i, u + 1) - O * E);
}
}
}
if (0 !== S) {
for (d = t - 1; d >= 0; d--)
if (((O = e[d]), 0 === (E = r[d])))
for (a = d, n.set(d, d, 1), i = d - 1; i >= 0; i--) {
for (h = n.get(i, i) - O, j = 0, s = a; s <= d; s++)
j += n.get(i, s) * n.get(s, d);
if (r[i] < 0) (P = h), (R = j);
else if (
((a = i),
0 === r[i]
? n.set(i, d, 0 !== h ? -j / h : -j / (x * S))
: ((l = n.get(i, i + 1)),
(p = n.get(i + 1, i)),
(c =
(l * R - P * j) /
(E = (e[i] - O) * (e[i] - O) + r[i] * r[i])),
n.set(i, d, c),
n.set(
i + 1,
d,
Math.abs(l) > Math.abs(P)
? (-j - h * c) / l
: (-R - p * c) / P,
)),
x * (c = Math.abs(n.get(i, d))) * c > 1)
)
for (s = i; s <= d; s++) n.set(s, d, n.get(s, d) / c);
}
else if (E < 0)
for (
a = d - 1,
Math.abs(n.get(d, d - 1)) > Math.abs(n.get(d - 1, d))
? (n.set(d - 1, d - 1, E / n.get(d, d - 1)),
n.set(d - 1, d, -(n.get(d, d) - O) / n.get(d, d - 1)))
: ((b = Zr(
0,
-n.get(d - 1, d),
n.get(d - 1, d - 1) - O,
E,
)),
n.set(d - 1, d - 1, b[0]),
n.set(d - 1, d, b[1])),
n.set(d, d - 1, 0),
n.set(d, d, 1),
i = d - 2;
i >= 0;
i--
) {
for (y = 0, v = 0, s = a; s <= d; s++)
(y += n.get(i, s) * n.get(s, d - 1)),
(v += n.get(i, s) * n.get(s, d));
if (((h = n.get(i, i) - O), r[i] < 0))
(P = h), (j = y), (R = v);
else if (
((a = i),
0 === r[i]
? ((b = Zr(-y, -v, h, E)),
n.set(i, d - 1, b[0]),
n.set(i, d, b[1]))
: ((l = n.get(i, i + 1)),
(p = n.get(i + 1, i)),
(m = (e[i] - O) * (e[i] - O) + r[i] * r[i] - E * E),
(g = 2 * (e[i] - O) * E),
0 === m &&
0 === g &&
(m =
x *
S *
(Math.abs(h) +
Math.abs(E) +
Math.abs(l) +
Math.abs(p) +
Math.abs(P))),
(b = Zr(
l * j - P * y + E * v,
l * R - P * v - E * y,
m,
g,
)),
n.set(i, d - 1, b[0]),
n.set(i, d, b[1]),
Math.abs(l) > Math.abs(P) + Math.abs(E)
? (n.set(
i + 1,
d - 1,
(-y - h * n.get(i, d - 1) + E * n.get(i, d)) / l,
),
n.set(
i + 1,
d,
(-v - h * n.get(i, d) - E * n.get(i, d - 1)) / l,
))
: ((b = Zr(
-j - p * n.get(i, d - 1),
-R - p * n.get(i, d),
P,
E,
)),
n.set(i + 1, d - 1, b[0]),
n.set(i + 1, d, b[1]))),
x *
(c = Math.max(
Math.abs(n.get(i, d - 1)),
Math.abs(n.get(i, d)),
)) *
c >
1)
)
for (s = i; s <= d; s++)
n.set(s, d - 1, n.get(s, d - 1) / c),
n.set(s, d, n.get(s, d) / c);
}
for (i = 0; i < t; i++)
if (i < 0 || i > M)
for (s = i; s < t; s++) o.set(i, s, n.get(i, s));
for (s = t - 1; s >= 0; s--)
for (i = 0; i <= M; i++) {
for (P = 0, u = 0; u <= Math.min(s, M); u++)
P += o.get(i, u) * n.get(u, s);
o.set(i, s, P);
}
}
}
function Zr(t, r, e, o) {
var n, i;
return Math.abs(e) > Math.abs(o)
? [(t + (n = o / e) * r) / (i = e + n * o), (r - n * t) / i]
: [((n = e / o) * t + r) / (i = o + n * e), (n * r - t) / i];
}
function $r(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var te = (function () {
function t(r) {
if (
((function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t),
!(r = Sr.checkMatrix(r)).isSymmetric())
)
throw new Error("Matrix is not symmetric");
var e,
o,
n,
i = r,
s = i.rows,
u = new Y(s, s),
a = !0;
for (o = 0; o < s; o++) {
var f = 0;
for (n = 0; n < o; n++) {
var c = 0;
for (e = 0; e < n; e++) c += u.get(n, e) * u.get(o, e);
(c = (i.get(o, n) - c) / u.get(n, n)),
u.set(o, n, c),
(f += c * c);
}
for (
a &= (f = i.get(o, o) - f) > 0,
u.set(o, o, Math.sqrt(Math.max(f, 0))),
n = o + 1;
n < s;
n++
)
u.set(o, n, 0);
}
(this.L = u), (this.positiveDefinite = Boolean(a));
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "isPositiveDefinite",
value: function () {
return this.positiveDefinite;
},
},
{
key: "solve",
value: function (t) {
t = Sr.checkMatrix(t);
var r = this.L,
e = r.rows;
if (t.rows !== e)
throw new Error("Matrix dimensions do not match");
if (!1 === this.isPositiveDefinite())
throw new Error("Matrix is not positive definite");
var o,
n,
i,
s = t.columns,
u = t.clone();
for (i = 0; i < e; i++)
for (n = 0; n < s; n++) {
for (o = 0; o < i; o++)
u.set(i, n, u.get(i, n) - u.get(o, n) * r.get(i, o));
u.set(i, n, u.get(i, n) / r.get(i, i));
}
for (i = e - 1; i >= 0; i--)
for (n = 0; n < s; n++) {
for (o = i + 1; o < e; o++)
u.set(i, n, u.get(i, n) - u.get(o, n) * r.get(o, i));
u.set(i, n, u.get(i, n) / r.get(i, i));
}
return u;
},
},
{
key: "lowerTriangularMatrix",
get: function () {
return this.L;
},
},
]) && $r(r.prototype, e),
o && $r(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function re(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ee(t, r, e) {
return (
r && re(t.prototype, r),
e && re(t, e),
Object.defineProperty(t, "prototype", { writable: !1 }),
t
);
}
function oe(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
var ne = ee(function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
oe(this, t), (r = Sr.checkMatrix(r));
var o,
i = e.Y,
s = e.scaleScores,
u = void 0 !== s && s,
a = e.maxIterations,
f = void 0 === a ? 1e3 : a,
c = e.terminationCriteria,
h = void 0 === c ? 1e-10 : c;
if (i) {
if (
(i =
n(i) && "number" == typeof i[0]
? Y.columnVector(i)
: Sr.checkMatrix(i)).rows !== r.rows
)
throw new Error("Y should have the same number of rows as X");
o = i.getColumnVector(0);
} else o = r.getColumnVector(0);
for (var l, p, y, v, m = 1, g = 0; g < f && m > h; g++)
(y = (y = r
.transpose()
.mmul(o)
.div(o.transpose().mmul(o).get(0, 0))).div(y.norm())),
(l = r.mmul(y).div(y.transpose().mmul(y).get(0, 0))),
g > 0 && (m = l.clone().sub(v).pow(2).sum()),
(v = l.clone()),
i
? ((p = (p = i
.transpose()
.mmul(l)
.div(l.transpose().mmul(l).get(0, 0))).div(p.norm())),
(o = i.mmul(p).div(p.transpose().mmul(p).get(0, 0))))
: (o = l);
if (i) {
var w = r.transpose().mmul(l).div(l.transpose().mmul(l).get(0, 0));
w = w.div(w.norm());
var b = r.clone().sub(l.clone().mmul(w.transpose())),
d = o.transpose().mmul(l).div(l.transpose().mmul(l).get(0, 0)),
M = i.clone().sub(l.clone().mulS(d.get(0, 0)).mmul(p.transpose()));
(this.t = l),
(this.p = w.transpose()),
(this.w = y.transpose()),
(this.q = p),
(this.u = o),
(this.s = l.transpose().mmul(l)),
(this.xResidual = b),
(this.yResidual = M),
(this.betas = d);
} else
(this.w = y.transpose()),
(this.s = l.transpose().mmul(l).sqrt()),
(this.t = u ? l.clone().div(this.s.get(0, 0)) : l),
(this.xResidual = r.sub(l.mmul(y.transpose())));
});
},
}).default;
});
//# sourceMappingURL=mdsLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/radialLayout.js
================================================
!(function (t, r) {
"object" == typeof exports && "object" == typeof module
? (module.exports = r())
: "function" == typeof define && define.amd
? define([], r)
: "object" == typeof exports
? (exports.RadialLayout = r())
: (t.RadialLayout = r());
})(this, function () {
return (function (t) {
var r = {};
function e(o) {
if (r[o]) return r[o].exports;
var n = (r[o] = { i: o, l: !1, exports: {} });
return t[o].call(n.exports, n, n.exports, e), (n.l = !0), n.exports;
}
return (
(e.m = t),
(e.c = r),
(e.d = function (t, r, o) {
e.o(t, r) || Object.defineProperty(t, r, { enumerable: !0, get: o });
}),
(e.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(e.t = function (t, r) {
if ((1 & r && (t = e(t)), 8 & r)) return t;
if (4 & r && "object" == typeof t && t && t.__esModule) return t;
var o = Object.create(null);
if (
(e.r(o),
Object.defineProperty(o, "default", { enumerable: !0, value: t }),
2 & r && "string" != typeof t)
)
for (var n in t)
e.d(
o,
n,
function (r) {
return t[r];
}.bind(null, n),
);
return o;
}),
(e.n = function (t) {
var r =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return e.d(r, "a", r), r;
}),
(e.o = function (t, r) {
return Object.prototype.hasOwnProperty.call(t, r);
}),
(e.p = ""),
e((e.s = 390))
);
})({
10: function (t, r, e) {
"use strict";
var o =
(this && this.__createBinding) ||
(Object.create
? function (t, r, e, o) {
void 0 === o && (o = e),
Object.defineProperty(t, o, {
enumerable: !0,
get: function () {
return r[e];
},
});
}
: function (t, r, e, o) {
void 0 === o && (o = e), (t[o] = r[e]);
}),
n =
(this && this.__exportStar) ||
function (t, r) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(r, e) ||
o(r, t, e);
};
Object.defineProperty(r, "__esModule", { value: !0 }),
n(e(11), r),
n(e(12), r),
n(e(13), r),
n(e(14), r),
n(e(15), r),
n(e(16), r);
},
11: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.camelize = r.isString = void 0);
r.isString = function (t) {
return "string" == typeof t;
};
var o,
n,
i = /-(\w)/g;
r.camelize =
((o = function (t) {
return t.replace(i, function (t, r) {
return r ? r.toUpperCase() : "";
});
}),
(n = Object.create(null)),
function (t) {
return n[t] || (n[t] = o(t));
});
},
12: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.isArray = void 0),
(r.isArray = Array.isArray);
},
13: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.toNumber = r.isNaN = r.isNumber = void 0);
r.isNumber = function (t) {
return "number" == typeof t;
};
r.isNaN = function (t) {
return Number.isNaN(Number(t));
};
r.toNumber = function (t) {
var e = parseFloat(t);
return r.isNaN(e) ? t : e;
};
},
14: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.traverseTreeUp =
r.scaleMatrix =
r.getAdjMatrix =
r.floydWarshall =
r.getDegree =
void 0);
r.getDegree = function (t, r, e) {
for (var o = [], n = 0; n < t; n++) o[n] = 0;
return e
? (e.forEach(function (t) {
t.source && (o[r[t.source]] += 1),
t.target && (o[r[t.target]] += 1);
}),
o)
: o;
};
r.floydWarshall = function (t) {
for (var r = [], e = t.length, o = 0; o < e; o += 1) {
r[o] = [];
for (var n = 0; n < e; n += 1)
o === n
? (r[o][n] = 0)
: 0 !== t[o][n] && t[o][n]
? (r[o][n] = t[o][n])
: (r[o][n] = 1 / 0);
}
for (var i = 0; i < e; i += 1)
for (o = 0; o < e; o += 1)
for (n = 0; n < e; n += 1)
r[o][n] > r[o][i] + r[i][n] && (r[o][n] = r[o][i] + r[i][n]);
return r;
};
r.getAdjMatrix = function (t, r) {
var e = t.nodes,
o = t.edges,
n = [],
i = {};
if (!e) throw new Error("invalid nodes data!");
return (
e &&
e.forEach(function (t, r) {
i[t.id] = r;
n.push([]);
}),
o &&
o.forEach(function (t) {
var e = t.source,
o = t.target,
s = i[e],
u = i[o];
(n[s][u] = 1), r || (n[u][s] = 1);
}),
n
);
};
r.scaleMatrix = function (t, r) {
var e = [];
return (
t.forEach(function (t) {
var o = [];
t.forEach(function (t) {
o.push(t * r);
}),
e.push(o);
}),
e
);
};
r.traverseTreeUp = function (t, r) {
"function" == typeof r &&
(function t(r, e) {
if (r && r.children)
for (var o = r.children.length - 1; o >= 0; o--)
if (!t(r.children[o], e)) return;
return !!e(r);
})(t, r);
};
},
15: function (t, r, e) {
"use strict";
function o(t) {
return (o =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var n =
(this && this.__assign) ||
function () {
return (n =
Object.assign ||
function (t) {
for (var r, e = 1, o = arguments.length; e < o; e++)
for (var n in (r = arguments[e]))
Object.prototype.hasOwnProperty.call(r, n) && (t[n] = r[n]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.clone = r.isObject = void 0);
r.isObject = function (t) {
return null !== t && "object" === o(t);
};
r.clone = function (t) {
if (null === t) return t;
if (t instanceof Date) return new Date(t.getTime());
if (t instanceof Array) {
var e = [];
return (
t.forEach(function (t) {
e.push(t);
}),
e.map(function (t) {
return r.clone(t);
})
);
}
if ("object" === o(t) && t !== {}) {
var i = n({}, t);
return (
Object.keys(i).forEach(function (t) {
i[t] = r.clone(i[t]);
}),
i
);
}
return t;
};
},
16: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.isFunction = void 0);
r.isFunction = function (t) {
return "function" == typeof t;
};
},
168: function (t, r, e) {
"use strict";
var o =
(this && this.__createBinding) ||
(Object.create
? function (t, r, e, o) {
void 0 === o && (o = e),
Object.defineProperty(t, o, {
enumerable: !0,
get: function () {
return r[e];
},
});
}
: function (t, r, e, o) {
void 0 === o && (o = e), (t[o] = r[e]);
}),
n =
(this && this.__exportStar) ||
function (t, r) {
for (var e in t)
"default" === e ||
Object.prototype.hasOwnProperty.call(r, e) ||
o(r, t, e);
};
Object.defineProperty(r, "__esModule", { value: !0 }), n(e(391), r);
},
390: function (t, r, e) {
"use strict";
e.r(r);
var o = e(168);
r.default = o.RadialLayout;
},
391: function (t, r, e) {
"use strict";
var o,
n =
(this && this.__extends) ||
((o = function (t, r) {
return (o =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, r) {
t.__proto__ = r;
}) ||
function (t, r) {
for (var e in r)
Object.prototype.hasOwnProperty.call(r, e) && (t[e] = r[e]);
})(t, r);
}),
function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Class extends value " +
String(r) +
" is not a constructor or null",
);
function e() {
this.constructor = t;
}
o(t, r),
(t.prototype =
null === r
? Object.create(r)
: ((e.prototype = r.prototype), new e()));
}),
i =
(this && this.__importDefault) ||
function (t) {
return t && t.__esModule ? t : { default: t };
};
Object.defineProperty(r, "__esModule", { value: !0 }),
(r.RadialLayout = void 0);
var s = e(10),
u = e(9),
a = i(e(392)),
f = i(e(393));
function c(t, r) {
return Math.sqrt(
(t[0] - r[0]) * (t[0] - r[0]) + (t[1] - r[1]) * (t[1] - r[1]),
);
}
var h = (function (t) {
function r(r) {
var e = t.call(this) || this;
return (
(e.maxIteration = 1e3),
(e.focusNode = null),
(e.unitRadius = null),
(e.linkDistance = 50),
(e.preventOverlap = !1),
(e.strictRadial = !0),
(e.maxPreventOverlapIteration = 200),
(e.sortStrength = 10),
(e.nodes = []),
(e.edges = []),
e.updateCfg(r),
e
);
}
return (
n(r, t),
(r.prototype.getDefaultCfg = function () {
return {
maxIteration: 1e3,
focusNode: null,
unitRadius: null,
linkDistance: 50,
preventOverlap: !1,
nodeSize: void 0,
nodeSpacing: void 0,
strictRadial: !0,
maxPreventOverlapIteration: 200,
sortBy: void 0,
sortStrength: 10,
};
}),
(r.prototype.execute = function () {
var t = this,
r = t.nodes,
e = t.edges || [];
if (r && 0 !== r.length) {
t.width ||
"undefined" == typeof window ||
(t.width = window.innerWidth),
t.height ||
"undefined" == typeof window ||
(t.height = window.innerHeight),
t.center || (t.center = [t.width / 2, t.height / 2]);
var o = t.center;
if (1 === r.length)
return (
(r[0].x = o[0]),
(r[0].y = o[1]),
void (t.onLayoutEnd && t.onLayoutEnd())
);
var n = t.linkDistance,
i = null;
if (s.isString(t.focusNode)) {
for (var u = !1, c = 0; c < r.length; c++)
r[c].id === t.focusNode &&
((i = r[c]), (t.focusNode = i), (u = !0), (c = r.length));
u || (i = null);
} else i = t.focusNode;
i || ((i = r[0]), (t.focusNode = i));
var h,
l,
p,
y =
((h = r),
(l = i.id),
(p = -1),
h.forEach(function (t, r) {
t.id === l && (p = r);
}),
p);
t.focusIndex = y;
var v = s.getAdjMatrix({ nodes: r, edges: e }, !1),
m = s.floydWarshall(v),
g = t.maxToFocus(m, y);
t.handleInfinity(m, y, g + 1), (t.distances = m);
var w = m[y],
d = t.width || 500,
b = t.height || 500,
M = d - o[0] > o[0] ? o[0] : d - o[0],
x = b - o[1] > o[1] ? o[1] : b - o[1];
0 === M && (M = d / 2), 0 === x && (x = b / 2);
var k = x > M ? M : x,
S = Math.max.apply(Math, w),
O = [];
w.forEach(function (r, e) {
t.unitRadius || (t.unitRadius = k / S),
(O[e] = r * t.unitRadius);
}),
(t.radii = O);
var E = t.eIdealDisMatrix();
t.eIdealDistances = E;
var j = (function (t) {
for (
var r = t.length, e = t[0].length, o = [], n = 0;
n < r;
n++
) {
for (var i = [], s = 0; s < e; s++)
0 !== t[n][s] ? i.push(1 / (t[n][s] * t[n][s])) : i.push(0);
o.push(i);
}
return o;
})(E);
t.weights = j;
var R = new a.default({ linkDistance: n, distances: E }).layout();
R.forEach(function (t) {
s.isNaN(t[0]) && (t[0] = Math.random() * n),
s.isNaN(t[1]) && (t[1] = Math.random() * n);
}),
(t.positions = R),
R.forEach(function (t, e) {
(r[e].x = t[0] + o[0]), (r[e].y = t[1] + o[1]);
}),
R.forEach(function (t) {
(t[0] -= R[y][0]), (t[1] -= R[y][1]);
}),
t.run();
var P,
_ = t.preventOverlap,
T = t.nodeSize,
I = t.strictRadial;
if (_) {
var N,
C = t.nodeSpacing;
(N = s.isNumber(C)
? function () {
return C;
}
: s.isFunction(C)
? C
: function () {
return 0;
}),
(P = T
? s.isArray(T)
? function (t) {
return (T[0] > T[1] ? T[0] : T[1]) + N(t);
}
: function (t) {
return T + N(t);
}
: function (t) {
return t.size
? s.isArray(t.size)
? (t.size[0] > t.size[1] ? t.size[0] : t.size[1]) +
N(t)
: t.size + N(t)
: 10 + N(t);
});
var D = {
nodes: r,
nodeSizeFunc: P,
adjMatrix: v,
positions: R,
radii: O,
height: b,
width: d,
strictRadial: I,
focusID: y,
iterations: t.maxPreventOverlapIteration || 200,
k: R.length / 4.5,
},
V = new f.default(D);
R = V.layout();
}
return (
R.forEach(function (t, e) {
(r[e].x = t[0] + o[0]), (r[e].y = t[1] + o[1]);
}),
t.onLayoutEnd && t.onLayoutEnd(),
{ nodes: r, edges: e }
);
}
t.onLayoutEnd && t.onLayoutEnd();
}),
(r.prototype.run = function () {
for (
var t = this.maxIteration,
r = this.positions || [],
e = this.weights || [],
o = this.eIdealDistances || [],
n = this.radii || [],
i = 0;
i <= t;
i++
) {
var s = i / t;
this.oneIteration(s, r, n, o, e);
}
}),
(r.prototype.oneIteration = function (t, r, e, o, n) {
var i = 1 - t,
s = this.focusIndex;
r.forEach(function (u, a) {
var f = c(u, [0, 0]),
h = 0 === f ? 0 : 1 / f;
if (a !== s) {
var l = 0,
p = 0,
y = 0;
r.forEach(function (t, r) {
if (a !== r) {
var e = c(u, t),
i = 0 === e ? 0 : 1 / e,
s = o[r][a];
(y += n[a][r]),
(l += n[a][r] * (t[0] + s * (u[0] - t[0]) * i)),
(p += n[a][r] * (t[1] + s * (u[1] - t[1]) * i));
}
});
var v = 0 === e[a] ? 0 : 1 / e[a];
(y *= i),
(y += t * v * v),
(l *= i),
(l += t * v * u[0] * h),
(u[0] = l / y),
(p *= i),
(p += t * v * u[1] * h),
(u[1] = p / y);
}
});
}),
(r.prototype.eIdealDisMatrix = function () {
var t = this,
r = t.nodes;
if (!r) return [];
var e = t.distances,
o = t.linkDistance,
n = t.radii || [],
i = t.unitRadius || 50,
u = [];
return (
e &&
e.forEach(function (e, a) {
var f = [];
e.forEach(function (e, u) {
if (a === u) f.push(0);
else if (n[a] === n[u])
if ("data" === t.sortBy)
f.push(
(e * (Math.abs(a - u) * t.sortStrength)) / (n[a] / i),
);
else if (t.sortBy) {
var c = r[a][t.sortBy] || 0,
h = r[u][t.sortBy] || 0;
s.isString(c) && (c = c.charCodeAt(0)),
s.isString(h) && (h = h.charCodeAt(0)),
f.push(
(e * (Math.abs(c - h) * t.sortStrength)) /
(n[a] / i),
);
} else f.push((e * o) / (n[a] / i));
else {
var l = (o + i) / 2;
f.push(e * l);
}
}),
u.push(f);
}),
u
);
}),
(r.prototype.handleInfinity = function (t, r, e) {
for (var o = t.length, n = 0; n < o; n++)
if (t[r][n] === 1 / 0) {
(t[r][n] = e), (t[n][r] = e);
for (var i = 0; i < o; i++)
t[n][i] !== 1 / 0 &&
t[r][i] === 1 / 0 &&
((t[r][i] = e + t[n][i]), (t[i][r] = e + t[n][i]));
}
for (n = 0; n < o; n++)
if (n !== r)
for (i = 0; i < o; i++)
if (t[n][i] === 1 / 0) {
var s = Math.abs(t[r][n] - t[r][i]);
(s = 0 === s ? 1 : s), (t[n][i] = s);
}
}),
(r.prototype.maxToFocus = function (t, r) {
for (var e = 0, o = 0; o < t[r].length; o++)
t[r][o] !== 1 / 0 && (e = t[r][o] > e ? t[r][o] : e);
return e;
}),
(r.prototype.getType = function () {
return "radial";
}),
r
);
})(u.Base);
r.RadialLayout = h;
},
392: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 });
var o = e(96),
n = (function () {
function t(t) {
(this.distances = t.distances),
(this.dimension = t.dimension || 2),
(this.linkDistance = t.linkDistance);
}
return (
(t.prototype.layout = function () {
var t = this.dimension,
r = this.distances,
e = this.linkDistance;
try {
var n = o.Matrix.mul(o.Matrix.pow(r, 2), -0.5),
i = n.mean("row"),
s = n.mean("column"),
u = n.mean();
n.add(u).subRowVector(i).subColumnVector(s);
var a = new o.SingularValueDecomposition(n),
f = o.Matrix.sqrt(a.diagonalMatrix).diagonal();
return a.leftSingularVectors.toJSON().map(function (r) {
return o.Matrix.mul([r], [f]).toJSON()[0].splice(0, t);
});
} catch (t) {
for (var c = [], h = 0; h < r.length; h++) {
var l = Math.random() * e,
p = Math.random() * e;
c.push([l, p]);
}
return c;
}
}),
t
);
})();
r.default = n;
},
393: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 });
var o = (function () {
function t(t) {
(this.disp = []),
(this.positions = t.positions),
(this.adjMatrix = t.adjMatrix),
(this.focusID = t.focusID),
(this.radii = t.radii),
(this.iterations = t.iterations || 10),
(this.height = t.height || 10),
(this.width = t.width || 10),
(this.speed = t.speed || 100),
(this.gravity = t.gravity || 10),
(this.nodeSizeFunc = t.nodeSizeFunc),
(this.k = t.k || 5),
(this.strictRadial = t.strictRadial),
(this.nodes = t.nodes);
}
return (
(t.prototype.layout = function () {
var t = this.positions,
r = [],
e = this.iterations,
o = this.width / 10;
(this.maxDisplace = o), (this.disp = r);
for (var n = 0; n < e; n++)
t.forEach(function (t, e) {
r[e] = { x: 0, y: 0 };
}),
this.getRepulsion(),
this.updatePositions();
return t;
}),
(t.prototype.getRepulsion = function () {
var t = this,
r = t.positions,
e = t.nodes,
o = t.disp,
n = t.k,
i = t.radii || [];
r.forEach(function (s, u) {
(o[u] = { x: 0, y: 0 }),
r.forEach(function (r, a) {
if (u !== a && i[u] === i[a]) {
var f = s[0] - r[0],
c = s[1] - r[1],
h = Math.sqrt(f * f + c * c);
if (0 === h) {
h = 1;
var l = u > a ? 1 : -1;
(f = 0.01 * l), (c = 0.01 * l);
}
if (
h <
t.nodeSizeFunc(e[u]) / 2 + t.nodeSizeFunc(e[a]) / 2
) {
var p = (n * n) / h;
(o[u].x += (f / h) * p), (o[u].y += (c / h) * p);
}
}
});
});
}),
(t.prototype.updatePositions = function () {
var t = this.positions,
r = this.disp,
e = this.speed,
o = this.strictRadial,
n = this.focusID,
i = this.maxDisplace || this.width / 10;
o &&
r.forEach(function (r, e) {
var o = t[e][0] - t[n][0],
i = t[e][1] - t[n][1],
s = Math.sqrt(o * o + i * i),
u = i / s,
a = -o / s,
f = Math.sqrt(r.x * r.x + r.y * r.y),
c = Math.acos((u * r.x + a * r.y) / f);
c > Math.PI / 2 && ((c -= Math.PI / 2), (u *= -1), (a *= -1));
var h = Math.cos(c) * f;
(r.x = u * h), (r.y = a * h);
});
var s = this.radii;
t.forEach(function (u, a) {
if (a !== n) {
var f = Math.sqrt(r[a].x * r[a].x + r[a].y * r[a].y);
if (f > 0 && a !== n) {
var c = Math.min(i * (e / 800), f);
if (
((u[0] += (r[a].x / f) * c), (u[1] += (r[a].y / f) * c), o)
) {
var h = u[0] - t[n][0],
l = u[1] - t[n][1],
p = Math.sqrt(h * h + l * l);
(h = (h / p) * s[a]),
(l = (l / p) * s[a]),
(u[0] = t[n][0] + h),
(u[1] = t[n][1] + l);
}
}
}
});
}),
t
);
})();
r.default = o;
},
9: function (t, r, e) {
"use strict";
Object.defineProperty(r, "__esModule", { value: !0 }), (r.Base = void 0);
var o = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function (t) {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
r.Base = o;
},
96: function (t, r, e) {
"use strict";
e.r(r),
e.d(r, "AbstractMatrix", function () {
return U;
}),
e.d(r, "default", function () {
return H;
}),
e.d(r, "Matrix", function () {
return H;
}),
e.d(r, "MatrixColumnView", function () {
return ut;
}),
e.d(r, "MatrixColumnSelectionView", function () {
return yt;
}),
e.d(r, "MatrixFlipColumnView", function () {
return Mt;
}),
e.d(r, "MatrixFlipRowView", function () {
return Rt;
}),
e.d(r, "MatrixRowView", function () {
return Dt;
}),
e.d(r, "MatrixRowSelectionView", function () {
return Lt;
}),
e.d(r, "MatrixSelectionView", function () {
return Kt;
}),
e.d(r, "MatrixSubView", function () {
return er;
}),
e.d(r, "MatrixTransposeView", function () {
return fr;
}),
e.d(r, "wrap", function () {
return Or;
}),
e.d(r, "WrapperMatrix1D", function () {
return gr;
}),
e.d(r, "WrapperMatrix2D", function () {
return Sr;
}),
e.d(r, "solve", function () {
return Dr;
}),
e.d(r, "inverse", function () {
return Cr;
}),
e.d(r, "determinant", function () {
return Vr;
}),
e.d(r, "linearDependencies", function () {
return Fr;
}),
e.d(r, "pseudoInverse", function () {
return Br;
}),
e.d(r, "covariance", function () {
return Lr;
}),
e.d(r, "correlation", function () {
return Wr;
}),
e.d(r, "SingularValueDecomposition", function () {
return Nr;
}),
e.d(r, "SVD", function () {
return Nr;
}),
e.d(r, "EigenvalueDecomposition", function () {
return Hr;
}),
e.d(r, "EVD", function () {
return Hr;
}),
e.d(r, "CholeskyDecomposition", function () {
return te;
}),
e.d(r, "CHO", function () {
return te;
}),
e.d(r, "LuDecomposition", function () {
return jr;
}),
e.d(r, "LU", function () {
return jr;
}),
e.d(r, "QrDecomposition", function () {
return _r;
}),
e.d(r, "QR", function () {
return _r;
}),
e.d(r, "Nipals", function () {
return ne;
}),
e.d(r, "NIPALS", function () {
return ne;
});
var o = Object.prototype.toString;
function n(t) {
return o.call(t).endsWith("Array]");
}
function i(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
var e = r.fromIndex,
o = void 0 === e ? 0 : e,
i = r.toIndex,
s = void 0 === i ? t.length : i;
if (o < 0 || o >= t.length || !Number.isInteger(o))
throw new Error(
"fromIndex must be a positive integer smaller than length",
);
if (s <= o || s > t.length || !Number.isInteger(s))
throw new Error(
"toIndex must be an integer greater than fromIndex and at most equal to length",
);
for (var u = t[o], a = o + 1; a < s; a++) t[a] > u && (u = t[a]);
return u;
}
function s(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
var e = r.fromIndex,
o = void 0 === e ? 0 : e,
i = r.toIndex,
s = void 0 === i ? t.length : i;
if (o < 0 || o >= t.length || !Number.isInteger(o))
throw new Error(
"fromIndex must be a positive integer smaller than length",
);
if (s <= o || s > t.length || !Number.isInteger(s))
throw new Error(
"toIndex must be an integer greater than fromIndex and at most equal to length",
);
for (var u = t[o], a = o + 1; a < s; a++) t[a] < u && (u = t[a]);
return u;
}
function u(t) {
var r,
e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if (!n(t)) throw new TypeError("input must be an array");
if (0 === t.length) throw new TypeError("input must not be empty");
if (void 0 !== e.output) {
if (!n(e.output))
throw new TypeError("output option must be an array if specified");
r = e.output;
} else r = new Array(t.length);
var o = s(t),
u = i(t);
if (o === u)
throw new RangeError(
"minimum and maximum input values are equal. Cannot rescale a constant array",
);
var a = e.min,
f = void 0 === a ? (e.autoMinMax ? o : 0) : a,
c = e.max,
h = void 0 === c ? (e.autoMinMax ? u : 1) : c;
if (f >= h)
throw new RangeError("min option must be smaller than max option");
for (var l = (h - f) / (u - o), p = 0; p < t.length; p++)
r[p] = (t[p] - o) * l + f;
return r;
}
var a = " ".repeat(2),
f = " ".repeat(4);
function c(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {},
e = r.maxRows,
o = void 0 === e ? 15 : e,
n = r.maxColumns,
i = void 0 === n ? 10 : n,
s = r.maxNumSize,
u = void 0 === s ? 8 : s;
return ""
.concat(t.constructor.name, " {\n")
.concat(a, "[\n")
.concat(f)
.concat(h(t, o, i, u), "\n")
.concat(a, "]\n")
.concat(a, "rows: ")
.concat(t.rows, "\n")
.concat(a, "columns: ")
.concat(t.columns, "\n}");
}
function h(t, r, e, o) {
for (
var n = t.rows,
i = t.columns,
s = Math.min(n, r),
u = Math.min(i, e),
a = [],
c = 0;
c < s;
c++
) {
for (var h = [], p = 0; p < u; p++) h.push(l(t.get(c, p), o));
a.push("".concat(h.join(" ")));
}
return (
u !== i &&
(a[a.length - 1] += " ... ".concat(i - e, " more columns")),
s !== n && a.push("... ".concat(n - r, " more rows")),
a.join("\n".concat(f))
);
}
function l(t, r) {
var e = String(t);
if (e.length <= r) return e.padEnd(r, " ");
var o = t.toPrecision(r - 2);
if (o.length <= r) return o;
var n = t.toExponential(r - 2),
i = n.indexOf("e"),
s = n.slice(i);
return n.slice(0, r - s.length) + s;
}
function p(t, r, e) {
var o = e ? t.rows : t.rows - 1;
if (r < 0 || r > o) throw new RangeError("Row index out of range");
}
function y(t, r, e) {
var o = e ? t.columns : t.columns - 1;
if (r < 0 || r > o) throw new RangeError("Column index out of range");
}
function v(t, r) {
if ((r.to1DArray && (r = r.to1DArray()), r.length !== t.columns))
throw new RangeError(
"vector size must be the same as the number of columns",
);
return r;
}
function m(t, r) {
if ((r.to1DArray && (r = r.to1DArray()), r.length !== t.rows))
throw new RangeError(
"vector size must be the same as the number of rows",
);
return r;
}
function g(t, r) {
if (!n(r)) throw new TypeError("row indices must be an array");
for (var e = 0; e < r.length; e++)
if (r[e] < 0 || r[e] >= t.rows)
throw new RangeError("row indices are out of range");
}
function w(t, r) {
if (!n(r)) throw new TypeError("column indices must be an array");
for (var e = 0; e < r.length; e++)
if (r[e] < 0 || r[e] >= t.columns)
throw new RangeError("column indices are out of range");
}
function d(t, r, e, o, n) {
if (5 !== arguments.length)
throw new RangeError("expected 4 arguments");
if (
(M("startRow", r),
M("endRow", e),
M("startColumn", o),
M("endColumn", n),
r > e ||
o > n ||
r < 0 ||
r >= t.rows ||
e < 0 ||
e >= t.rows ||
o < 0 ||
o >= t.columns ||
n < 0 ||
n >= t.columns)
)
throw new RangeError("Submatrix indices are out of range");
}
function b(t) {
for (
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: 0,
e = [],
o = 0;
o < t;
o++
)
e.push(r);
return e;
}
function M(t, r) {
if ("number" != typeof r)
throw new TypeError("".concat(t, " must be a number"));
}
function x(t) {
if (t.isEmpty())
throw new Error("Empty matrix has no elements to index");
}
function k(t, r, e) {
for (var o = t.rows, n = t.columns, i = [], s = 0; s < o; s++) {
for (var u = 0, a = 0, f = 0, c = 0; c < n; c++)
(u += f = t.get(s, c) - e[s]), (a += f * f);
r
? i.push((a - (u * u) / n) / (n - 1))
: i.push((a - (u * u) / n) / n);
}
return i;
}
function S(t, r, e) {
for (var o = t.rows, n = t.columns, i = [], s = 0; s < n; s++) {
for (var u = 0, a = 0, f = 0, c = 0; c < o; c++)
(u += f = t.get(c, s) - e[s]), (a += f * f);
r
? i.push((a - (u * u) / o) / (o - 1))
: i.push((a - (u * u) / o) / o);
}
return i;
}
function O(t, r, e) {
for (
var o = t.rows, n = t.columns, i = o * n, s = 0, u = 0, a = 0, f = 0;
f < o;
f++
)
for (var c = 0; c < n; c++) (s += a = t.get(f, c) - e), (u += a * a);
return r ? (u - (s * s) / i) / (i - 1) : (u - (s * s) / i) / i;
}
function E(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r[e]);
}
function j(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r[o]);
}
function R(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) - r);
}
function P(t) {
for (var r = [], e = 0; e < t.rows; e++) {
for (var o = 0, n = 0; n < t.columns; n++)
o += Math.pow(t.get(e, n), 2) / (t.columns - 1);
r.push(Math.sqrt(o));
}
return r;
}
function _(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r[e]);
}
function T(t) {
for (var r = [], e = 0; e < t.columns; e++) {
for (var o = 0, n = 0; n < t.rows; n++)
o += Math.pow(t.get(n, e), 2) / (t.rows - 1);
r.push(Math.sqrt(o));
}
return r;
}
function I(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r[o]);
}
function N(t) {
for (var r = t.size - 1, e = 0, o = 0; o < t.columns; o++)
for (var n = 0; n < t.rows; n++) e += Math.pow(t.get(n, o), 2) / r;
return Math.sqrt(e);
}
function C(t, r) {
for (var e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) t.set(e, o, t.get(e, o) / r);
}
function D(t, r) {
return (D =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function V(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = A(t);
if (r) {
var n = A(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return q(this, e);
};
}
function q(t, r) {
if (r && ("object" === F(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function A(t) {
return (A = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
function F(t) {
return (F =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function B(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function z(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function L(t, r, e) {
return (
r && z(t.prototype, r),
e && z(t, e),
Object.defineProperty(t, "prototype", { writable: !1 }),
t
);
}
var U = (function () {
function t() {
B(this, t);
}
return (
L(
t,
[
{
key: "size",
get: function () {
return this.rows * this.columns;
},
},
{
key: "apply",
value: function (t) {
if ("function" != typeof t)
throw new TypeError("callback must be a function");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++) t.call(this, r, e);
return this;
},
},
{
key: "to1DArray",
value: function () {
for (var t = [], r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
t.push(this.get(r, e));
return t;
},
},
{
key: "to2DArray",
value: function () {
for (var t = [], r = 0; r < this.rows; r++) {
t.push([]);
for (var e = 0; e < this.columns; e++)
t[r].push(this.get(r, e));
}
return t;
},
},
{
key: "toJSON",
value: function () {
return this.to2DArray();
},
},
{
key: "isRowVector",
value: function () {
return 1 === this.rows;
},
},
{
key: "isColumnVector",
value: function () {
return 1 === this.columns;
},
},
{
key: "isVector",
value: function () {
return 1 === this.rows || 1 === this.columns;
},
},
{
key: "isSquare",
value: function () {
return this.rows === this.columns;
},
},
{
key: "isEmpty",
value: function () {
return 0 === this.rows || 0 === this.columns;
},
},
{
key: "isSymmetric",
value: function () {
if (this.isSquare()) {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r <= t; r++)
if (this.get(t, r) !== this.get(r, t)) return !1;
return !0;
}
return !1;
},
},
{
key: "isEchelonForm",
value: function () {
for (
var t = 0, r = 0, e = -1, o = !0, n = !1;
t < this.rows && o;
) {
for (r = 0, n = !1; r < this.columns && !1 === n; )
0 === this.get(t, r)
? r++
: 1 === this.get(t, r) && r > e
? ((n = !0), (e = r))
: ((o = !1), (n = !0));
t++;
}
return o;
},
},
{
key: "isReducedEchelonForm",
value: function () {
for (
var t = 0, r = 0, e = -1, o = !0, n = !1;
t < this.rows && o;
) {
for (r = 0, n = !1; r < this.columns && !1 === n; )
0 === this.get(t, r)
? r++
: 1 === this.get(t, r) && r > e
? ((n = !0), (e = r))
: ((o = !1), (n = !0));
for (var i = r + 1; i < this.rows; i++)
0 !== this.get(t, i) && (o = !1);
t++;
}
return o;
},
},
{
key: "echelonForm",
value: function () {
for (
var t = this.clone(), r = 0, e = 0;
r < t.rows && e < t.columns;
) {
for (var o = r, n = r; n < t.rows; n++)
t.get(n, e) > t.get(o, e) && (o = n);
if (0 === t.get(o, e)) e++;
else {
t.swapRows(r, o);
for (var i = t.get(r, e), s = e; s < t.columns; s++)
t.set(r, s, t.get(r, s) / i);
for (var u = r + 1; u < t.rows; u++) {
var a = t.get(u, e) / t.get(r, e);
t.set(u, e, 0);
for (var f = e + 1; f < t.columns; f++)
t.set(u, f, t.get(u, f) - t.get(r, f) * a);
}
r++, e++;
}
}
return t;
},
},
{
key: "reducedEchelonForm",
value: function () {
for (
var t = this.echelonForm(),
r = t.columns,
e = t.rows,
o = e - 1;
o >= 0;
)
if (0 === t.maxRow(o)) o--;
else {
for (var n = 0, i = !1; n < e && !1 === i; )
1 === t.get(o, n) ? (i = !0) : n++;
for (var s = 0; s < o; s++)
for (var u = t.get(s, n), a = n; a < r; a++) {
var f = t.get(s, a) - u * t.get(o, a);
t.set(s, a, f);
}
o--;
}
return t;
},
},
{
key: "set",
value: function () {
throw new Error("set method is unimplemented");
},
},
{
key: "get",
value: function () {
throw new Error("get method is unimplemented");
},
},
{
key: "repeat",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.rows,
e = void 0 === r ? 1 : r,
o = t.columns,
n = void 0 === o ? 1 : o;
if (!Number.isInteger(e) || e <= 0)
throw new TypeError("rows must be a positive integer");
if (!Number.isInteger(n) || n <= 0)
throw new TypeError("columns must be a positive integer");
for (
var i = new H(this.rows * e, this.columns * n), s = 0;
s < e;
s++
)
for (var u = 0; u < n; u++)
i.setSubMatrix(this, this.rows * s, this.columns * u);
return i;
},
},
{
key: "fill",
value: function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++) this.set(r, e, t);
return this;
},
},
{
key: "neg",
value: function () {
return this.mulS(-1);
},
},
{
key: "getRow",
value: function (t) {
p(this, t);
for (var r = [], e = 0; e < this.columns; e++)
r.push(this.get(t, e));
return r;
},
},
{
key: "getRowVector",
value: function (t) {
return H.rowVector(this.getRow(t));
},
},
{
key: "setRow",
value: function (t, r) {
p(this, t), (r = v(this, r));
for (var e = 0; e < this.columns; e++) this.set(t, e, r[e]);
return this;
},
},
{
key: "swapRows",
value: function (t, r) {
p(this, t), p(this, r);
for (var e = 0; e < this.columns; e++) {
var o = this.get(t, e);
this.set(t, e, this.get(r, e)), this.set(r, e, o);
}
return this;
},
},
{
key: "getColumn",
value: function (t) {
y(this, t);
for (var r = [], e = 0; e < this.rows; e++)
r.push(this.get(e, t));
return r;
},
},
{
key: "getColumnVector",
value: function (t) {
return H.columnVector(this.getColumn(t));
},
},
{
key: "setColumn",
value: function (t, r) {
y(this, t), (r = m(this, r));
for (var e = 0; e < this.rows; e++) this.set(e, t, r[e]);
return this;
},
},
{
key: "swapColumns",
value: function (t, r) {
y(this, t), y(this, r);
for (var e = 0; e < this.rows; e++) {
var o = this.get(e, t);
this.set(e, t, this.get(e, r)), this.set(e, r, o);
}
return this;
},
},
{
key: "addRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t[e]);
return this;
},
},
{
key: "subRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t[e]);
return this;
},
},
{
key: "mulRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t[e]);
return this;
},
},
{
key: "divRowVector",
value: function (t) {
t = v(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t[e]);
return this;
},
},
{
key: "addColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t[r]);
return this;
},
},
{
key: "subColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t[r]);
return this;
},
},
{
key: "mulColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t[r]);
return this;
},
},
{
key: "divColumnVector",
value: function (t) {
t = m(this, t);
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t[r]);
return this;
},
},
{
key: "mulRow",
value: function (t, r) {
p(this, t);
for (var e = 0; e < this.columns; e++)
this.set(t, e, this.get(t, e) * r);
return this;
},
},
{
key: "mulColumn",
value: function (t, r) {
y(this, t);
for (var e = 0; e < this.rows; e++)
this.set(e, t, this.get(e, t) * r);
return this;
},
},
{
key: "max",
value: function () {
if (this.isEmpty()) return NaN;
for (var t = this.get(0, 0), r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.get(r, e) > t && (t = this.get(r, e));
return t;
},
},
{
key: "maxIndex",
value: function () {
x(this);
for (
var t = this.get(0, 0), r = [0, 0], e = 0;
e < this.rows;
e++
)
for (var o = 0; o < this.columns; o++)
this.get(e, o) > t &&
((t = this.get(e, o)), (r[0] = e), (r[1] = o));
return r;
},
},
{
key: "min",
value: function () {
if (this.isEmpty()) return NaN;
for (var t = this.get(0, 0), r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.get(r, e) < t && (t = this.get(r, e));
return t;
},
},
{
key: "minIndex",
value: function () {
x(this);
for (
var t = this.get(0, 0), r = [0, 0], e = 0;
e < this.rows;
e++
)
for (var o = 0; o < this.columns; o++)
this.get(e, o) < t &&
((t = this.get(e, o)), (r[0] = e), (r[1] = o));
return r;
},
},
{
key: "maxRow",
value: function (t) {
if ((p(this, t), this.isEmpty())) return NaN;
for (var r = this.get(t, 0), e = 1; e < this.columns; e++)
this.get(t, e) > r && (r = this.get(t, e));
return r;
},
},
{
key: "maxRowIndex",
value: function (t) {
p(this, t), x(this);
for (
var r = this.get(t, 0), e = [t, 0], o = 1;
o < this.columns;
o++
)
this.get(t, o) > r && ((r = this.get(t, o)), (e[1] = o));
return e;
},
},
{
key: "minRow",
value: function (t) {
if ((p(this, t), this.isEmpty())) return NaN;
for (var r = this.get(t, 0), e = 1; e < this.columns; e++)
this.get(t, e) < r && (r = this.get(t, e));
return r;
},
},
{
key: "minRowIndex",
value: function (t) {
p(this, t), x(this);
for (
var r = this.get(t, 0), e = [t, 0], o = 1;
o < this.columns;
o++
)
this.get(t, o) < r && ((r = this.get(t, o)), (e[1] = o));
return e;
},
},
{
key: "maxColumn",
value: function (t) {
if ((y(this, t), this.isEmpty())) return NaN;
for (var r = this.get(0, t), e = 1; e < this.rows; e++)
this.get(e, t) > r && (r = this.get(e, t));
return r;
},
},
{
key: "maxColumnIndex",
value: function (t) {
y(this, t), x(this);
for (
var r = this.get(0, t), e = [0, t], o = 1;
o < this.rows;
o++
)
this.get(o, t) > r && ((r = this.get(o, t)), (e[0] = o));
return e;
},
},
{
key: "minColumn",
value: function (t) {
if ((y(this, t), this.isEmpty())) return NaN;
for (var r = this.get(0, t), e = 1; e < this.rows; e++)
this.get(e, t) < r && (r = this.get(e, t));
return r;
},
},
{
key: "minColumnIndex",
value: function (t) {
y(this, t), x(this);
for (
var r = this.get(0, t), e = [0, t], o = 1;
o < this.rows;
o++
)
this.get(o, t) < r && ((r = this.get(o, t)), (e[0] = o));
return e;
},
},
{
key: "diag",
value: function () {
for (
var t = Math.min(this.rows, this.columns), r = [], e = 0;
e < t;
e++
)
r.push(this.get(e, e));
return r;
},
},
{
key: "norm",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: "frobenius",
r = 0;
if ("max" === t) return this.max();
if ("frobenius" === t) {
for (var e = 0; e < this.rows; e++)
for (var o = 0; o < this.columns; o++)
r += this.get(e, o) * this.get(e, o);
return Math.sqrt(r);
}
throw new RangeError("unknown norm type: ".concat(t));
},
},
{
key: "cumulativeSum",
value: function () {
for (var t = 0, r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
(t += this.get(r, e)), this.set(r, e, t);
return this;
},
},
{
key: "dot",
value: function (r) {
t.isMatrix(r) && (r = r.to1DArray());
var e = this.to1DArray();
if (e.length !== r.length)
throw new RangeError("vectors do not have the same size");
for (var o = 0, n = 0; n < e.length; n++) o += e[n] * r[n];
return o;
},
},
{
key: "mmul",
value: function (t) {
t = H.checkMatrix(t);
for (
var r = this.rows,
e = this.columns,
o = t.columns,
n = new H(r, o),
i = new Float64Array(e),
s = 0;
s < o;
s++
) {
for (var u = 0; u < e; u++) i[u] = t.get(u, s);
for (var a = 0; a < r; a++) {
for (var f = 0, c = 0; c < e; c++)
f += this.get(a, c) * i[c];
n.set(a, s, f);
}
}
return n;
},
},
{
key: "strassen2x2",
value: function (t) {
t = H.checkMatrix(t);
var r = new H(2, 2),
e = this.get(0, 0),
o = t.get(0, 0),
n = this.get(0, 1),
i = t.get(0, 1),
s = this.get(1, 0),
u = t.get(1, 0),
a = this.get(1, 1),
f = t.get(1, 1),
c = (e + a) * (o + f),
h = (s + a) * o,
l = e * (i - f),
p = a * (u - o),
y = (e + n) * f,
v = c + p - y + (n - a) * (u + f),
m = l + y,
g = h + p,
w = c - h + l + (s - e) * (o + i);
return (
r.set(0, 0, v),
r.set(0, 1, m),
r.set(1, 0, g),
r.set(1, 1, w),
r
);
},
},
{
key: "strassen3x3",
value: function (t) {
t = H.checkMatrix(t);
var r = new H(3, 3),
e = this.get(0, 0),
o = this.get(0, 1),
n = this.get(0, 2),
i = this.get(1, 0),
s = this.get(1, 1),
u = this.get(1, 2),
a = this.get(2, 0),
f = this.get(2, 1),
c = this.get(2, 2),
h = t.get(0, 0),
l = t.get(0, 1),
p = t.get(0, 2),
y = t.get(1, 0),
v = t.get(1, 1),
m = t.get(1, 2),
g = t.get(2, 0),
w = t.get(2, 1),
d = t.get(2, 2),
b = (e - i) * (-l + v),
M = (-e + i + s) * (h - l + v),
x = (i + s) * (-h + l),
k = e * h,
S = (-e + a + f) * (h - p + m),
O = (-e + a) * (p - m),
E = (a + f) * (-h + p),
j = (-n + f + c) * (v + g - w),
R = (n - c) * (v - w),
P = n * g,
_ = (f + c) * (-g + w),
T = (-n + s + u) * (m + g - d),
I = (n - u) * (m - d),
N = (s + u) * (-g + d),
C = k + P + o * y,
D = (e + o + n - i - s - f - c) * v + M + x + k + j + P + _,
V = k + S + E + (e + o + n - s - u - a - f) * m + P + T + N,
q =
b + s * (-h + l + y - v - m - g + d) + M + k + P + T + I,
A = b + M + x + k + u * w,
F = P + T + I + N + i * p,
B =
k + S + O + f * (-h + p + y - v - m - g + w) + j + R + P,
z = j + R + P + _ + a * l,
L = k + S + O + E + c * d;
return (
r.set(0, 0, C),
r.set(0, 1, D),
r.set(0, 2, V),
r.set(1, 0, q),
r.set(1, 1, A),
r.set(1, 2, F),
r.set(2, 0, B),
r.set(2, 1, z),
r.set(2, 2, L),
r
);
},
},
{
key: "mmulStrassen",
value: function (r) {
r = H.checkMatrix(r);
var e = this.clone(),
o = e.rows,
n = e.columns,
i = r.rows,
s = r.columns;
function u(r, e, o) {
var n = r.rows,
i = r.columns;
if (n === e && i === o) return r;
var s = t.zeros(e, o);
return (s = s.setSubMatrix(r, 0, 0));
}
n !== i &&
console.warn(
"Multiplying "
.concat(o, " x ")
.concat(n, " and ")
.concat(i, " x ")
.concat(s, " matrix: dimensions do not match."),
);
var a = Math.max(o, i),
f = Math.max(n, s);
return (function r(e, o, n, i) {
if (n <= 512 || i <= 512) return e.mmul(o);
n % 2 == 1 && i % 2 == 1
? ((e = u(e, n + 1, i + 1)), (o = u(o, n + 1, i + 1)))
: n % 2 == 1
? ((e = u(e, n + 1, i)), (o = u(o, n + 1, i)))
: i % 2 == 1 &&
((e = u(e, n, i + 1)), (o = u(o, n, i + 1)));
var s = parseInt(e.rows / 2, 10),
a = parseInt(e.columns / 2, 10),
f = e.subMatrix(0, s - 1, 0, a - 1),
c = o.subMatrix(0, s - 1, 0, a - 1),
h = e.subMatrix(0, s - 1, a, e.columns - 1),
l = o.subMatrix(0, s - 1, a, o.columns - 1),
p = e.subMatrix(s, e.rows - 1, 0, a - 1),
y = o.subMatrix(s, o.rows - 1, 0, a - 1),
v = e.subMatrix(s, e.rows - 1, a, e.columns - 1),
m = o.subMatrix(s, o.rows - 1, a, o.columns - 1),
g = r(t.add(f, v), t.add(c, m), s, a),
w = r(t.add(p, v), c, s, a),
d = r(f, t.sub(l, m), s, a),
b = r(v, t.sub(y, c), s, a),
M = r(t.add(f, h), m, s, a),
x = r(t.sub(p, f), t.add(c, l), s, a),
k = r(t.sub(h, v), t.add(y, m), s, a),
S = t.add(g, b);
S.sub(M), S.add(k);
var O = t.add(d, M),
E = t.add(w, b),
j = t.sub(g, w);
j.add(d), j.add(x);
var R = t.zeros(2 * S.rows, 2 * S.columns);
return (R = (R = (R = (R = R.setSubMatrix(
S,
0,
0,
)).setSubMatrix(O, S.rows, 0)).setSubMatrix(
E,
0,
S.columns,
)).setSubMatrix(j, S.rows, S.columns)).subMatrix(
0,
n - 1,
0,
i - 1,
);
})((e = u(e, a, f)), (r = u(r, a, f)), a, f);
},
},
{
key: "scaleRows",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.min,
e = void 0 === r ? 0 : r,
o = t.max,
n = void 0 === o ? 1 : o;
if (!Number.isFinite(e))
throw new TypeError("min must be a number");
if (!Number.isFinite(n))
throw new TypeError("max must be a number");
if (e >= n)
throw new RangeError("min must be smaller than max");
for (
var i = new H(this.rows, this.columns), s = 0;
s < this.rows;
s++
) {
var a = this.getRow(s);
a.length > 0 && u(a, { min: e, max: n, output: a }),
i.setRow(s, a);
}
return i;
},
},
{
key: "scaleColumns",
value: function () {
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: {};
if ("object" !== F(t))
throw new TypeError("options must be an object");
var r = t.min,
e = void 0 === r ? 0 : r,
o = t.max,
n = void 0 === o ? 1 : o;
if (!Number.isFinite(e))
throw new TypeError("min must be a number");
if (!Number.isFinite(n))
throw new TypeError("max must be a number");
if (e >= n)
throw new RangeError("min must be smaller than max");
for (
var i = new H(this.rows, this.columns), s = 0;
s < this.columns;
s++
) {
var a = this.getColumn(s);
a.length && u(a, { min: e, max: n, output: a }),
i.setColumn(s, a);
}
return i;
},
},
{
key: "flipRows",
value: function () {
for (
var t = Math.ceil(this.columns / 2), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < t; e++) {
var o = this.get(r, e),
n = this.get(r, this.columns - 1 - e);
this.set(r, e, n), this.set(r, this.columns - 1 - e, o);
}
return this;
},
},
{
key: "flipColumns",
value: function () {
for (
var t = Math.ceil(this.rows / 2), r = 0;
r < this.columns;
r++
)
for (var e = 0; e < t; e++) {
var o = this.get(e, r),
n = this.get(this.rows - 1 - e, r);
this.set(e, r, n), this.set(this.rows - 1 - e, r, o);
}
return this;
},
},
{
key: "kroneckerProduct",
value: function (t) {
t = H.checkMatrix(t);
for (
var r = this.rows,
e = this.columns,
o = t.rows,
n = t.columns,
i = new H(r * o, e * n),
s = 0;
s < r;
s++
)
for (var u = 0; u < e; u++)
for (var a = 0; a < o; a++)
for (var f = 0; f < n; f++)
i.set(
o * s + a,
n * u + f,
this.get(s, u) * t.get(a, f),
);
return i;
},
},
{
key: "kroneckerSum",
value: function (t) {
if (
((t = H.checkMatrix(t)), !this.isSquare() || !t.isSquare())
)
throw new Error("Kronecker Sum needs two Square Matrices");
var r = this.rows,
e = t.rows,
o = this.kroneckerProduct(H.eye(e, e)),
n = H.eye(r, r).kroneckerProduct(t);
return o.add(n);
},
},
{
key: "transpose",
value: function () {
for (
var t = new H(this.columns, this.rows), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < this.columns; e++)
t.set(e, r, this.get(r, e));
return t;
},
},
{
key: "sortRows",
value: function () {
for (
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: W,
r = 0;
r < this.rows;
r++
)
this.setRow(r, this.getRow(r).sort(t));
return this;
},
},
{
key: "sortColumns",
value: function () {
for (
var t =
arguments.length > 0 && void 0 !== arguments[0]
? arguments[0]
: W,
r = 0;
r < this.columns;
r++
)
this.setColumn(r, this.getColumn(r).sort(t));
return this;
},
},
{
key: "subMatrix",
value: function (t, r, e, o) {
d(this, t, r, e, o);
for (var n = new H(r - t + 1, o - e + 1), i = t; i <= r; i++)
for (var s = e; s <= o; s++)
n.set(i - t, s - e, this.get(i, s));
return n;
},
},
{
key: "subMatrixRow",
value: function (t, r, e) {
if (
(void 0 === r && (r = 0),
void 0 === e && (e = this.columns - 1),
r > e ||
r < 0 ||
r >= this.columns ||
e < 0 ||
e >= this.columns)
)
throw new RangeError("Argument out of range");
for (
var o = new H(t.length, e - r + 1), n = 0;
n < t.length;
n++
)
for (var i = r; i <= e; i++) {
if (t[n] < 0 || t[n] >= this.rows)
throw new RangeError(
"Row index out of range: ".concat(t[n]),
);
o.set(n, i - r, this.get(t[n], i));
}
return o;
},
},
{
key: "subMatrixColumn",
value: function (t, r, e) {
if (
(void 0 === r && (r = 0),
void 0 === e && (e = this.rows - 1),
r > e || r < 0 || r >= this.rows || e < 0 || e >= this.rows)
)
throw new RangeError("Argument out of range");
for (
var o = new H(e - r + 1, t.length), n = 0;
n < t.length;
n++
)
for (var i = r; i <= e; i++) {
if (t[n] < 0 || t[n] >= this.columns)
throw new RangeError(
"Column index out of range: ".concat(t[n]),
);
o.set(i - r, n, this.get(i, t[n]));
}
return o;
},
},
{
key: "setSubMatrix",
value: function (t, r, e) {
if ((t = H.checkMatrix(t)).isEmpty()) return this;
d(this, r, r + t.rows - 1, e, e + t.columns - 1);
for (var o = 0; o < t.rows; o++)
for (var n = 0; n < t.columns; n++)
this.set(r + o, e + n, t.get(o, n));
return this;
},
},
{
key: "selection",
value: function (t, r) {
g(this, t), w(this, r);
for (
var e = new H(t.length, r.length), o = 0;
o < t.length;
o++
)
for (var n = t[o], i = 0; i < r.length; i++) {
var s = r[i];
e.set(o, i, this.get(n, s));
}
return e;
},
},
{
key: "trace",
value: function () {
for (
var t = Math.min(this.rows, this.columns), r = 0, e = 0;
e < t;
e++
)
r += this.get(e, e);
return r;
},
},
{
key: "clone",
value: function () {
for (
var t = new H(this.rows, this.columns), r = 0;
r < this.rows;
r++
)
for (var e = 0; e < this.columns; e++)
t.set(r, e, this.get(r, e));
return t;
},
},
{
key: "sum",
value: function (t) {
switch (t) {
case "row":
return (function (t) {
for (var r = b(t.rows), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[e] += t.get(e, o);
return r;
})(this);
case "column":
return (function (t) {
for (var r = b(t.columns), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[o] += t.get(e, o);
return r;
})(this);
case void 0:
return (function (t) {
for (var r = 0, e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) r += t.get(e, o);
return r;
})(this);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "product",
value: function (t) {
switch (t) {
case "row":
return (function (t) {
for (var r = b(t.rows, 1), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[e] *= t.get(e, o);
return r;
})(this);
case "column":
return (function (t) {
for (var r = b(t.columns, 1), e = 0; e < t.rows; ++e)
for (var o = 0; o < t.columns; ++o)
r[o] *= t.get(e, o);
return r;
})(this);
case void 0:
return (function (t) {
for (var r = 1, e = 0; e < t.rows; e++)
for (var o = 0; o < t.columns; o++) r *= t.get(e, o);
return r;
})(this);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "mean",
value: function (t) {
var r = this.sum(t);
switch (t) {
case "row":
for (var e = 0; e < this.rows; e++) r[e] /= this.columns;
return r;
case "column":
for (var o = 0; o < this.columns; o++) r[o] /= this.rows;
return r;
case void 0:
return r / this.size;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "variance",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r,
o = e.unbiased,
i = void 0 === o || o,
s = e.mean,
u = void 0 === s ? this.mean(t) : s;
if ("boolean" != typeof i)
throw new TypeError("unbiased must be a boolean");
switch (t) {
case "row":
if (!n(u)) throw new TypeError("mean must be an array");
return k(this, i, u);
case "column":
if (!n(u)) throw new TypeError("mean must be an array");
return S(this, i, u);
case void 0:
if ("number" != typeof u)
throw new TypeError("mean must be a number");
return O(this, i, u);
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "standardDeviation",
value: function (t, r) {
"object" === F(t) && ((r = t), (t = void 0));
var e = this.variance(t, r);
if (void 0 === t) return Math.sqrt(e);
for (var o = 0; o < e.length; o++) e[o] = Math.sqrt(e[o]);
return e;
},
},
{
key: "center",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r,
o = e.center,
i = void 0 === o ? this.mean(t) : o;
switch (t) {
case "row":
if (!n(i)) throw new TypeError("center must be an array");
return E(this, i), this;
case "column":
if (!n(i)) throw new TypeError("center must be an array");
return j(this, i), this;
case void 0:
if ("number" != typeof i)
throw new TypeError("center must be a number");
return R(this, i), this;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "scale",
value: function (t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
if (
("object" === F(t) && ((r = t), (t = void 0)),
"object" !== F(r))
)
throw new TypeError("options must be an object");
var e = r.scale;
switch (t) {
case "row":
if (void 0 === e) e = P(this);
else if (!n(e))
throw new TypeError("scale must be an array");
return _(this, e), this;
case "column":
if (void 0 === e) e = T(this);
else if (!n(e))
throw new TypeError("scale must be an array");
return I(this, e), this;
case void 0:
if (void 0 === e) e = N(this);
else if ("number" != typeof e)
throw new TypeError("scale must be a number");
return C(this, e), this;
default:
throw new Error("invalid option: ".concat(t));
}
},
},
{
key: "toString",
value: function (t) {
return c(this, t);
},
},
],
[
{
key: "from1DArray",
value: function (t, r, e) {
if (t * r !== e.length)
throw new RangeError(
"data length does not match given dimensions",
);
for (var o = new H(t, r), n = 0; n < t; n++)
for (var i = 0; i < r; i++) o.set(n, i, e[n * r + i]);
return o;
},
},
{
key: "rowVector",
value: function (t) {
for (var r = new H(1, t.length), e = 0; e < t.length; e++)
r.set(0, e, t[e]);
return r;
},
},
{
key: "columnVector",
value: function (t) {
for (var r = new H(t.length, 1), e = 0; e < t.length; e++)
r.set(e, 0, t[e]);
return r;
},
},
{
key: "zeros",
value: function (t, r) {
return new H(t, r);
},
},
{
key: "ones",
value: function (t, r) {
return new H(t, r).fill(1);
},
},
{
key: "rand",
value: function (t, r) {
var e =
arguments.length > 2 && void 0 !== arguments[2]
? arguments[2]
: {};
if ("object" !== F(e))
throw new TypeError("options must be an object");
for (
var o = e.random,
n = void 0 === o ? Math.random : o,
i = new H(t, r),
s = 0;
s < t;
s++
)
for (var u = 0; u < r; u++) i.set(s, u, n());
return i;
},
},
{
key: "randInt",
value: function (t, r) {
var e =
arguments.length > 2 && void 0 !== arguments[2]
? arguments[2]
: {};
if ("object" !== F(e))
throw new TypeError("options must be an object");
var o = e.min,
n = void 0 === o ? 0 : o,
i = e.max,
s = void 0 === i ? 1e3 : i,
u = e.random,
a = void 0 === u ? Math.random : u;
if (!Number.isInteger(n))
throw new TypeError("min must be an integer");
if (!Number.isInteger(s))
throw new TypeError("max must be an integer");
if (n >= s)
throw new RangeError("min must be smaller than max");
for (var f = s - n, c = new H(t, r), h = 0; h < t; h++)
for (var l = 0; l < r; l++) {
var p = n + Math.round(a() * f);
c.set(h, l, p);
}
return c;
},
},
{
key: "eye",
value: function (t, r, e) {
void 0 === r && (r = t), void 0 === e && (e = 1);
for (
var o = Math.min(t, r), n = this.zeros(t, r), i = 0;
i < o;
i++
)
n.set(i, i, e);
return n;
},
},
{
key: "diag",
value: function (t, r, e) {
var o = t.length;
void 0 === r && (r = o), void 0 === e && (e = r);
for (
var n = Math.min(o, r, e), i = this.zeros(r, e), s = 0;
s < n;
s++
)
i.set(s, s, t[s]);
return i;
},
},
{
key: "min",
value: function (t, r) {
(t = this.checkMatrix(t)), (r = this.checkMatrix(r));
for (
var e = t.rows, o = t.columns, n = new H(e, o), i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
n.set(i, s, Math.min(t.get(i, s), r.get(i, s)));
return n;
},
},
{
key: "max",
value: function (t, r) {
(t = this.checkMatrix(t)), (r = this.checkMatrix(r));
for (
var e = t.rows, o = t.columns, n = new this(e, o), i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
n.set(i, s, Math.max(t.get(i, s), r.get(i, s)));
return n;
},
},
{
key: "checkMatrix",
value: function (r) {
return t.isMatrix(r) ? r : new H(r);
},
},
{
key: "isMatrix",
value: function (t) {
return null != t && "Matrix" === t.klass;
},
},
],
),
t
);
})();
function W(t, r) {
return t - r;
}
(U.prototype.klass = "Matrix"),
"undefined" != typeof Symbol &&
(U.prototype[Symbol.for("nodejs.util.inspect.custom")] = function () {
return c(this);
}),
(U.random = U.rand),
(U.randomInt = U.randInt),
(U.diagonal = U.diag),
(U.prototype.diagonal = U.prototype.diag),
(U.identity = U.eye),
(U.prototype.negate = U.prototype.neg),
(U.prototype.tensorProduct = U.prototype.kroneckerProduct);
var Q,
J,
H = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && D(t, r);
})(e, t);
var r = V(e);
function e(t, o) {
var i;
if ((B(this, e), (i = r.call(this)), e.isMatrix(t)))
return q(i, t.clone());
if (Number.isInteger(t) && t >= 0) {
if (((i.data = []), !(Number.isInteger(o) && o >= 0)))
throw new TypeError("nColumns must be a positive integer");
for (var s = 0; s < t; s++) i.data.push(new Float64Array(o));
} else {
if (!n(t))
throw new TypeError(
"First argument must be a positive number or an array",
);
var u = t;
if ("number" != typeof (o = (t = u.length) ? u[0].length : 0))
throw new TypeError(
"Data must be a 2D array with at least one element",
);
i.data = [];
for (var a = 0; a < t; a++) {
if (u[a].length !== o)
throw new RangeError("Inconsistent array dimensions");
i.data.push(Float64Array.from(u[a]));
}
}
return (i.rows = t), (i.columns = o), i;
}
return (
L(e, [
{
key: "set",
value: function (t, r, e) {
return (this.data[t][r] = e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.data[t][r];
},
},
{
key: "removeRow",
value: function (t) {
return (
p(this, t), this.data.splice(t, 1), (this.rows -= 1), this
);
},
},
{
key: "addRow",
value: function (t, r) {
return (
void 0 === r && ((r = t), (t = this.rows)),
p(this, t, !0),
(r = Float64Array.from(v(this, r))),
this.data.splice(t, 0, r),
(this.rows += 1),
this
);
},
},
{
key: "removeColumn",
value: function (t) {
y(this, t);
for (var r = 0; r < this.rows; r++) {
for (
var e = new Float64Array(this.columns - 1), o = 0;
o < t;
o++
)
e[o] = this.data[r][o];
for (var n = t + 1; n < this.columns; n++)
e[n - 1] = this.data[r][n];
this.data[r] = e;
}
return (this.columns -= 1), this;
},
},
{
key: "addColumn",
value: function (t, r) {
void 0 === r && ((r = t), (t = this.columns)),
y(this, t, !0),
(r = m(this, r));
for (var e = 0; e < this.rows; e++) {
for (
var o = new Float64Array(this.columns + 1), n = 0;
n < t;
n++
)
o[n] = this.data[e][n];
for (o[n++] = r[e]; n < this.columns + 1; n++)
o[n] = this.data[e][n - 1];
this.data[e] = o;
}
return (this.columns += 1), this;
},
},
]),
e
);
})(U);
function Y(t) {
return (Y =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function K(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function X(t, r) {
return (X =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function G(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = $(t);
if (r) {
var n = $(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Z(this, e);
};
}
function Z(t, r) {
if (r && ("object" === Y(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function $(t) {
return ($ = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
(J = H),
((Q = U).prototype.add = function (t) {
return "number" == typeof t ? this.addS(t) : this.addM(t);
}),
(Q.prototype.addS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t);
return this;
}),
(Q.prototype.addM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) + t.get(r, e));
return this;
}),
(Q.add = function (t, r) {
return new J(t).add(r);
}),
(Q.prototype.sub = function (t) {
return "number" == typeof t ? this.subS(t) : this.subM(t);
}),
(Q.prototype.subS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t);
return this;
}),
(Q.prototype.subM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) - t.get(r, e));
return this;
}),
(Q.sub = function (t, r) {
return new J(t).sub(r);
}),
(Q.prototype.subtract = Q.prototype.sub),
(Q.prototype.subtractS = Q.prototype.subS),
(Q.prototype.subtractM = Q.prototype.subM),
(Q.subtract = Q.sub),
(Q.prototype.mul = function (t) {
return "number" == typeof t ? this.mulS(t) : this.mulM(t);
}),
(Q.prototype.mulS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t);
return this;
}),
(Q.prototype.mulM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) * t.get(r, e));
return this;
}),
(Q.mul = function (t, r) {
return new J(t).mul(r);
}),
(Q.prototype.multiply = Q.prototype.mul),
(Q.prototype.multiplyS = Q.prototype.mulS),
(Q.prototype.multiplyM = Q.prototype.mulM),
(Q.multiply = Q.mul),
(Q.prototype.div = function (t) {
return "number" == typeof t ? this.divS(t) : this.divM(t);
}),
(Q.prototype.divS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t);
return this;
}),
(Q.prototype.divM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) / t.get(r, e));
return this;
}),
(Q.div = function (t, r) {
return new J(t).div(r);
}),
(Q.prototype.divide = Q.prototype.div),
(Q.prototype.divideS = Q.prototype.divS),
(Q.prototype.divideM = Q.prototype.divM),
(Q.divide = Q.div),
(Q.prototype.mod = function (t) {
return "number" == typeof t ? this.modS(t) : this.modM(t);
}),
(Q.prototype.modS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) % t);
return this;
}),
(Q.prototype.modM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) % t.get(r, e));
return this;
}),
(Q.mod = function (t, r) {
return new J(t).mod(r);
}),
(Q.prototype.modulus = Q.prototype.mod),
(Q.prototype.modulusS = Q.prototype.modS),
(Q.prototype.modulusM = Q.prototype.modM),
(Q.modulus = Q.mod),
(Q.prototype.and = function (t) {
return "number" == typeof t ? this.andS(t) : this.andM(t);
}),
(Q.prototype.andS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) & t);
return this;
}),
(Q.prototype.andM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) & t.get(r, e));
return this;
}),
(Q.and = function (t, r) {
return new J(t).and(r);
}),
(Q.prototype.or = function (t) {
return "number" == typeof t ? this.orS(t) : this.orM(t);
}),
(Q.prototype.orS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) | t);
return this;
}),
(Q.prototype.orM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) | t.get(r, e));
return this;
}),
(Q.or = function (t, r) {
return new J(t).or(r);
}),
(Q.prototype.xor = function (t) {
return "number" == typeof t ? this.xorS(t) : this.xorM(t);
}),
(Q.prototype.xorS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) ^ t);
return this;
}),
(Q.prototype.xorM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) ^ t.get(r, e));
return this;
}),
(Q.xor = function (t, r) {
return new J(t).xor(r);
}),
(Q.prototype.leftShift = function (t) {
return "number" == typeof t ? this.leftShiftS(t) : this.leftShiftM(t);
}),
(Q.prototype.leftShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) << t);
return this;
}),
(Q.prototype.leftShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) << t.get(r, e));
return this;
}),
(Q.leftShift = function (t, r) {
return new J(t).leftShift(r);
}),
(Q.prototype.signPropagatingRightShift = function (t) {
return "number" == typeof t
? this.signPropagatingRightShiftS(t)
: this.signPropagatingRightShiftM(t);
}),
(Q.prototype.signPropagatingRightShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >> t);
return this;
}),
(Q.prototype.signPropagatingRightShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >> t.get(r, e));
return this;
}),
(Q.signPropagatingRightShift = function (t, r) {
return new J(t).signPropagatingRightShift(r);
}),
(Q.prototype.rightShift = function (t) {
return "number" == typeof t
? this.rightShiftS(t)
: this.rightShiftM(t);
}),
(Q.prototype.rightShiftS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >>> t);
return this;
}),
(Q.prototype.rightShiftM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, this.get(r, e) >>> t.get(r, e));
return this;
}),
(Q.rightShift = function (t, r) {
return new J(t).rightShift(r);
}),
(Q.prototype.zeroFillRightShift = Q.prototype.rightShift),
(Q.prototype.zeroFillRightShiftS = Q.prototype.rightShiftS),
(Q.prototype.zeroFillRightShiftM = Q.prototype.rightShiftM),
(Q.zeroFillRightShift = Q.rightShift),
(Q.prototype.not = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, ~this.get(t, r));
return this;
}),
(Q.not = function (t) {
return new J(t).not();
}),
(Q.prototype.abs = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.abs(this.get(t, r)));
return this;
}),
(Q.abs = function (t) {
return new J(t).abs();
}),
(Q.prototype.acos = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.acos(this.get(t, r)));
return this;
}),
(Q.acos = function (t) {
return new J(t).acos();
}),
(Q.prototype.acosh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.acosh(this.get(t, r)));
return this;
}),
(Q.acosh = function (t) {
return new J(t).acosh();
}),
(Q.prototype.asin = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.asin(this.get(t, r)));
return this;
}),
(Q.asin = function (t) {
return new J(t).asin();
}),
(Q.prototype.asinh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.asinh(this.get(t, r)));
return this;
}),
(Q.asinh = function (t) {
return new J(t).asinh();
}),
(Q.prototype.atan = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.atan(this.get(t, r)));
return this;
}),
(Q.atan = function (t) {
return new J(t).atan();
}),
(Q.prototype.atanh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.atanh(this.get(t, r)));
return this;
}),
(Q.atanh = function (t) {
return new J(t).atanh();
}),
(Q.prototype.cbrt = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cbrt(this.get(t, r)));
return this;
}),
(Q.cbrt = function (t) {
return new J(t).cbrt();
}),
(Q.prototype.ceil = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.ceil(this.get(t, r)));
return this;
}),
(Q.ceil = function (t) {
return new J(t).ceil();
}),
(Q.prototype.clz32 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.clz32(this.get(t, r)));
return this;
}),
(Q.clz32 = function (t) {
return new J(t).clz32();
}),
(Q.prototype.cos = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cos(this.get(t, r)));
return this;
}),
(Q.cos = function (t) {
return new J(t).cos();
}),
(Q.prototype.cosh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.cosh(this.get(t, r)));
return this;
}),
(Q.cosh = function (t) {
return new J(t).cosh();
}),
(Q.prototype.exp = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.exp(this.get(t, r)));
return this;
}),
(Q.exp = function (t) {
return new J(t).exp();
}),
(Q.prototype.expm1 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.expm1(this.get(t, r)));
return this;
}),
(Q.expm1 = function (t) {
return new J(t).expm1();
}),
(Q.prototype.floor = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.floor(this.get(t, r)));
return this;
}),
(Q.floor = function (t) {
return new J(t).floor();
}),
(Q.prototype.fround = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.fround(this.get(t, r)));
return this;
}),
(Q.fround = function (t) {
return new J(t).fround();
}),
(Q.prototype.log = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log(this.get(t, r)));
return this;
}),
(Q.log = function (t) {
return new J(t).log();
}),
(Q.prototype.log1p = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log1p(this.get(t, r)));
return this;
}),
(Q.log1p = function (t) {
return new J(t).log1p();
}),
(Q.prototype.log10 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log10(this.get(t, r)));
return this;
}),
(Q.log10 = function (t) {
return new J(t).log10();
}),
(Q.prototype.log2 = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.log2(this.get(t, r)));
return this;
}),
(Q.log2 = function (t) {
return new J(t).log2();
}),
(Q.prototype.round = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.round(this.get(t, r)));
return this;
}),
(Q.round = function (t) {
return new J(t).round();
}),
(Q.prototype.sign = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sign(this.get(t, r)));
return this;
}),
(Q.sign = function (t) {
return new J(t).sign();
}),
(Q.prototype.sin = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sin(this.get(t, r)));
return this;
}),
(Q.sin = function (t) {
return new J(t).sin();
}),
(Q.prototype.sinh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sinh(this.get(t, r)));
return this;
}),
(Q.sinh = function (t) {
return new J(t).sinh();
}),
(Q.prototype.sqrt = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.sqrt(this.get(t, r)));
return this;
}),
(Q.sqrt = function (t) {
return new J(t).sqrt();
}),
(Q.prototype.tan = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.tan(this.get(t, r)));
return this;
}),
(Q.tan = function (t) {
return new J(t).tan();
}),
(Q.prototype.tanh = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.tanh(this.get(t, r)));
return this;
}),
(Q.tanh = function (t) {
return new J(t).tanh();
}),
(Q.prototype.trunc = function () {
for (var t = 0; t < this.rows; t++)
for (var r = 0; r < this.columns; r++)
this.set(t, r, Math.trunc(this.get(t, r)));
return this;
}),
(Q.trunc = function (t) {
return new J(t).trunc();
}),
(Q.pow = function (t, r) {
return new J(t).pow(r);
}),
(Q.prototype.pow = function (t) {
return "number" == typeof t ? this.powS(t) : this.powM(t);
}),
(Q.prototype.powS = function (t) {
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, Math.pow(this.get(r, e), t));
return this;
}),
(Q.prototype.powM = function (t) {
if (
((t = J.checkMatrix(t)),
this.rows !== t.rows || this.columns !== t.columns)
)
throw new RangeError("Matrices dimensions must be equal");
for (var r = 0; r < this.rows; r++)
for (var e = 0; e < this.columns; e++)
this.set(r, e, Math.pow(this.get(r, e), t.get(r, e)));
return this;
});
var tt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && X(t, r);
})(i, t);
var r,
e,
o,
n = G(i);
function i(t, r, e) {
var o;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
((o = n.call(this)).matrix = t),
(o.rows = r),
(o.columns = e),
o
);
}
return (
(r = i),
e && K(r.prototype, e),
o && K(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
r
);
})(U);
function rt(t) {
return (rt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function et(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ot(t, r) {
return (ot =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function nt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = st(t);
if (r) {
var n = st(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return it(this, e);
};
}
function it(t, r) {
if (r && ("object" === rt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function st(t) {
return (st = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var ut = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ot(t, r);
})(i, t);
var r,
e,
o,
n = nt(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
y(t, r),
((e = n.call(this, t, t.rows, 1)).column = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.column, e), this;
},
},
{
key: "get",
value: function (t) {
return this.matrix.get(t, this.column);
},
},
]) && et(r.prototype, e),
o && et(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function at(t) {
return (at =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function ft(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ct(t, r) {
return (ct =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function ht(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = pt(t);
if (r) {
var n = pt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return lt(this, e);
};
}
function lt(t, r) {
if (r && ("object" === at(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function pt(t) {
return (pt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var yt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ct(t, r);
})(i, t);
var r,
e,
o,
n = ht(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
w(t, r),
((e = n.call(this, t, t.rows, r.length)).columnIndices = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.columnIndices[r], e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(t, this.columnIndices[r]);
},
},
]) && ft(r.prototype, e),
o && ft(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function vt(t) {
return (vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function mt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function gt(t, r) {
return (gt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function wt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = bt(t);
if (r) {
var n = bt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return dt(this, e);
};
}
function dt(t, r) {
if (r && ("object" === vt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function bt(t) {
return (bt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Mt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && gt(t, r);
})(i, t);
var r,
e,
o,
n = wt(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.rows, t.columns)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(t, this.columns - r - 1, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(t, this.columns - r - 1);
},
},
]) && mt(r.prototype, e),
o && mt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function xt(t) {
return (xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function kt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function St(t, r) {
return (St =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Ot(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = jt(t);
if (r) {
var n = jt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Et(this, e);
};
}
function Et(t, r) {
if (r && ("object" === xt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function jt(t) {
return (jt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Rt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && St(t, r);
})(i, t);
var r,
e,
o,
n = Ot(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.rows, t.columns)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.rows - t - 1, r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.rows - t - 1, r);
},
},
]) && kt(r.prototype, e),
o && kt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Pt(t) {
return (Pt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function _t(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Tt(t, r) {
return (Tt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function It(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = Ct(t);
if (r) {
var n = Ct(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Nt(this, e);
};
}
function Nt(t, r) {
if (r && ("object" === Pt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Ct(t) {
return (Ct = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Dt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Tt(t, r);
})(i, t);
var r,
e,
o,
n = It(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
p(t, r),
((e = n.call(this, t, 1, t.columns)).row = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.row, r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.row, r);
},
},
]) && _t(r.prototype, e),
o && _t(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Vt(t) {
return (Vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function qt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function At(t, r) {
return (At =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Ft(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = zt(t);
if (r) {
var n = zt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Bt(this, e);
};
}
function Bt(t, r) {
if (r && ("object" === Vt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function zt(t) {
return (zt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Lt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && At(t, r);
})(i, t);
var r,
e,
o,
n = Ft(i);
function i(t, r) {
var e;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
g(t, r),
((e = n.call(this, t, r.length, t.columns)).rowIndices = r),
e
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(this.rowIndices[t], r, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.rowIndices[t], r);
},
},
]) && qt(r.prototype, e),
o && qt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Ut(t) {
return (Ut =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Wt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Qt(t, r) {
return (Qt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Jt(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = Yt(t);
if (r) {
var n = Yt(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return Ht(this, e);
};
}
function Ht(t, r) {
if (r && ("object" === Ut(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Yt(t) {
return (Yt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Kt = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Qt(t, r);
})(i, t);
var r,
e,
o,
n = Jt(i);
function i(t, r, e) {
var o;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
g(t, r),
w(t, e),
((o = n.call(this, t, r.length, e.length)).rowIndices = r),
(o.columnIndices = e),
o
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (
this.matrix.set(this.rowIndices[t], this.columnIndices[r], e),
this
);
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(
this.rowIndices[t],
this.columnIndices[r],
);
},
},
]) && Wt(r.prototype, e),
o && Wt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function Xt(t) {
return (Xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Gt(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function Zt(t, r) {
return (Zt =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function $t(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = rr(t);
if (r) {
var n = rr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return tr(this, e);
};
}
function tr(t, r) {
if (r && ("object" === Xt(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function rr(t) {
return (rr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var er = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && Zt(t, r);
})(i, t);
var r,
e,
o,
n = $t(i);
function i(t, r, e, o, s) {
var u;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
d(t, r, e, o, s),
((u = n.call(this, t, e - r + 1, s - o + 1)).startRow = r),
(u.startColumn = o),
u
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (
this.matrix.set(this.startRow + t, this.startColumn + r, e),
this
);
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(this.startRow + t, this.startColumn + r);
},
},
]) && Gt(r.prototype, e),
o && Gt(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function or(t) {
return (or =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function nr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ir(t, r) {
return (ir =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function sr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = ar(t);
if (r) {
var n = ar(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return ur(this, e);
};
}
function ur(t, r) {
if (r && ("object" === or(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function ar(t) {
return (ar = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var fr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && ir(t, r);
})(i, t);
var r,
e,
o,
n = sr(i);
function i(t) {
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
n.call(this, t, t.columns, t.rows)
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return this.matrix.set(r, t, e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.matrix.get(r, t);
},
},
]) && nr(r.prototype, e),
o && nr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(tt);
function cr(t) {
return (cr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function hr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function lr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function pr(t, r) {
return (pr =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function yr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = mr(t);
if (r) {
var n = mr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return vr(this, e);
};
}
function vr(t, r) {
if (r && ("object" === cr(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function mr(t) {
return (mr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var gr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && pr(t, r);
})(i, t);
var r,
e,
o,
n = yr(i);
function i(t) {
var r,
e =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {};
hr(this, i);
var o = e.rows,
s = void 0 === o ? 1 : o;
if (t.length % s != 0)
throw new Error(
"the data length is not divisible by the number of rows",
);
return (
((r = n.call(this)).rows = s),
(r.columns = t.length / s),
(r.data = t),
r
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
var o = this._calculateIndex(t, r);
return (this.data[o] = e), this;
},
},
{
key: "get",
value: function (t, r) {
var e = this._calculateIndex(t, r);
return this.data[e];
},
},
{
key: "_calculateIndex",
value: function (t, r) {
return t * this.columns + r;
},
},
]) && lr(r.prototype, e),
o && lr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(U);
function wr(t) {
return (wr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function dr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function br(t, r) {
return (br =
Object.setPrototypeOf ||
function (t, r) {
return (t.__proto__ = r), t;
})(t, r);
}
function Mr(t) {
var r = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct) return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})();
return function () {
var e,
o = kr(t);
if (r) {
var n = kr(this).constructor;
e = Reflect.construct(o, arguments, n);
} else e = o.apply(this, arguments);
return xr(this, e);
};
}
function xr(t, r) {
if (r && ("object" === wr(r) || "function" == typeof r)) return r;
if (void 0 !== r)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function kr(t) {
return (kr = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Sr = (function (t) {
!(function (t, r) {
if ("function" != typeof r && null !== r)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(r && r.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
r && br(t, r);
})(i, t);
var r,
e,
o,
n = Mr(i);
function i(t) {
var r;
return (
(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, i),
((r = n.call(this)).data = t),
(r.rows = t.length),
(r.columns = t[0].length),
r
);
}
return (
(r = i),
(e = [
{
key: "set",
value: function (t, r, e) {
return (this.data[t][r] = e), this;
},
},
{
key: "get",
value: function (t, r) {
return this.data[t][r];
},
},
]) && dr(r.prototype, e),
o && dr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
i
);
})(U);
function Or(t, r) {
if (n(t)) return t[0] && n(t[0]) ? new Sr(t) : new gr(t, r);
throw new Error("the argument is not an array");
}
function Er(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var jr = (function () {
function t(r) {
!(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t);
var e,
o,
n,
i,
s,
u,
a,
f,
c,
h = (r = Sr.checkMatrix(r)).clone(),
l = h.rows,
p = h.columns,
y = new Float64Array(l),
v = 1;
for (e = 0; e < l; e++) y[e] = e;
for (f = new Float64Array(l), o = 0; o < p; o++) {
for (e = 0; e < l; e++) f[e] = h.get(e, o);
for (e = 0; e < l; e++) {
for (c = Math.min(e, o), s = 0, n = 0; n < c; n++)
s += h.get(e, n) * f[n];
(f[e] -= s), h.set(e, o, f[e]);
}
for (i = o, e = o + 1; e < l; e++)
Math.abs(f[e]) > Math.abs(f[i]) && (i = e);
if (i !== o) {
for (n = 0; n < p; n++)
(u = h.get(i, n)), h.set(i, n, h.get(o, n)), h.set(o, n, u);
(a = y[i]), (y[i] = y[o]), (y[o] = a), (v = -v);
}
if (o < l && 0 !== h.get(o, o))
for (e = o + 1; e < l; e++)
h.set(e, o, h.get(e, o) / h.get(o, o));
}
(this.LU = h), (this.pivotVector = y), (this.pivotSign = v);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "isSingular",
value: function () {
for (var t = this.LU, r = t.columns, e = 0; e < r; e++)
if (0 === t.get(e, e)) return !0;
return !1;
},
},
{
key: "solve",
value: function (t) {
t = H.checkMatrix(t);
var r = this.LU;
if (r.rows !== t.rows)
throw new Error("Invalid matrix dimensions");
if (this.isSingular()) throw new Error("LU matrix is singular");
var e,
o,
n,
i = t.columns,
s = t.subMatrixRow(this.pivotVector, 0, i - 1),
u = r.columns;
for (n = 0; n < u; n++)
for (e = n + 1; e < u; e++)
for (o = 0; o < i; o++)
s.set(e, o, s.get(e, o) - s.get(n, o) * r.get(e, n));
for (n = u - 1; n >= 0; n--) {
for (o = 0; o < i; o++)
s.set(n, o, s.get(n, o) / r.get(n, n));
for (e = 0; e < n; e++)
for (o = 0; o < i; o++)
s.set(e, o, s.get(e, o) - s.get(n, o) * r.get(e, n));
}
return s;
},
},
{
key: "determinant",
get: function () {
var t = this.LU;
if (!t.isSquare()) throw new Error("Matrix must be square");
for (var r = this.pivotSign, e = t.columns, o = 0; o < e; o++)
r *= t.get(o, o);
return r;
},
},
{
key: "lowerTriangularMatrix",
get: function () {
for (
var t = this.LU,
r = t.rows,
e = t.columns,
o = new H(r, e),
n = 0;
n < r;
n++
)
for (var i = 0; i < e; i++)
n > i
? o.set(n, i, t.get(n, i))
: n === i
? o.set(n, i, 1)
: o.set(n, i, 0);
return o;
},
},
{
key: "upperTriangularMatrix",
get: function () {
for (
var t = this.LU,
r = t.rows,
e = t.columns,
o = new H(r, e),
n = 0;
n < r;
n++
)
for (var i = 0; i < e; i++)
n <= i ? o.set(n, i, t.get(n, i)) : o.set(n, i, 0);
return o;
},
},
{
key: "pivotPermutationVector",
get: function () {
return Array.from(this.pivotVector);
},
},
]) && Er(r.prototype, e),
o && Er(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Rr(t, r) {
var e = 0;
return Math.abs(t) > Math.abs(r)
? ((e = r / t), Math.abs(t) * Math.sqrt(1 + e * e))
: 0 !== r
? ((e = t / r), Math.abs(r) * Math.sqrt(1 + e * e))
: 0;
}
function Pr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var _r = (function () {
function t(r) {
!(function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t);
var e,
o,
n,
i,
s = (r = Sr.checkMatrix(r)).clone(),
u = r.rows,
a = r.columns,
f = new Float64Array(a);
for (n = 0; n < a; n++) {
var c = 0;
for (e = n; e < u; e++) c = Rr(c, s.get(e, n));
if (0 !== c) {
for (s.get(n, n) < 0 && (c = -c), e = n; e < u; e++)
s.set(e, n, s.get(e, n) / c);
for (s.set(n, n, s.get(n, n) + 1), o = n + 1; o < a; o++) {
for (i = 0, e = n; e < u; e++) i += s.get(e, n) * s.get(e, o);
for (i = -i / s.get(n, n), e = n; e < u; e++)
s.set(e, o, s.get(e, o) + i * s.get(e, n));
}
}
f[n] = -c;
}
(this.QR = s), (this.Rdiag = f);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "solve",
value: function (t) {
t = H.checkMatrix(t);
var r = this.QR,
e = r.rows;
if (t.rows !== e)
throw new Error("Matrix row dimensions must agree");
if (!this.isFullRank())
throw new Error("Matrix is rank deficient");
var o,
n,
i,
s,
u = t.columns,
a = t.clone(),
f = r.columns;
for (i = 0; i < f; i++)
for (n = 0; n < u; n++) {
for (s = 0, o = i; o < e; o++)
s += r.get(o, i) * a.get(o, n);
for (s = -s / r.get(i, i), o = i; o < e; o++)
a.set(o, n, a.get(o, n) + s * r.get(o, i));
}
for (i = f - 1; i >= 0; i--) {
for (n = 0; n < u; n++)
a.set(i, n, a.get(i, n) / this.Rdiag[i]);
for (o = 0; o < i; o++)
for (n = 0; n < u; n++)
a.set(o, n, a.get(o, n) - a.get(i, n) * r.get(o, i));
}
return a.subMatrix(0, f - 1, 0, u - 1);
},
},
{
key: "isFullRank",
value: function () {
for (var t = this.QR.columns, r = 0; r < t; r++)
if (0 === this.Rdiag[r]) return !1;
return !0;
},
},
{
key: "upperTriangularMatrix",
get: function () {
var t,
r,
e = this.QR,
o = e.columns,
n = new H(o, o);
for (t = 0; t < o; t++)
for (r = 0; r < o; r++)
t < r
? n.set(t, r, e.get(t, r))
: t === r
? n.set(t, r, this.Rdiag[t])
: n.set(t, r, 0);
return n;
},
},
{
key: "orthogonalMatrix",
get: function () {
var t,
r,
e,
o,
n = this.QR,
i = n.rows,
s = n.columns,
u = new H(i, s);
for (e = s - 1; e >= 0; e--) {
for (t = 0; t < i; t++) u.set(t, e, 0);
for (u.set(e, e, 1), r = e; r < s; r++)
if (0 !== n.get(e, e)) {
for (o = 0, t = e; t < i; t++)
o += n.get(t, e) * u.get(t, r);
for (o = -o / n.get(e, e), t = e; t < i; t++)
u.set(t, r, u.get(t, r) + o * n.get(t, e));
}
}
return u;
},
},
]) && Pr(r.prototype, e),
o && Pr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Tr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function Ir(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var Nr = (function () {
function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
if ((Tr(this, t), (r = Sr.checkMatrix(r)).isEmpty()))
throw new Error("Matrix must be non-empty");
var o,
n = r.rows,
i = r.columns,
s = e.computeLeftSingularVectors,
u = void 0 === s || s,
a = e.computeRightSingularVectors,
f = void 0 === a || a,
c = e.autoTranspose,
h = void 0 !== c && c,
l = Boolean(u),
p = Boolean(f),
y = !1;
if (n < i)
if (h) {
(n = (o = r.transpose()).rows), (i = o.columns), (y = !0);
var v = l;
(l = p), (p = v);
} else
(o = r.clone()),
console.warn(
"Computing SVD on a matrix with more columns than rows. Consider enabling autoTranspose",
);
else o = r.clone();
for (
var m = Math.min(n, i),
g = Math.min(n + 1, i),
w = new Float64Array(g),
d = new H(n, m),
b = new H(i, i),
M = new Float64Array(i),
x = new Float64Array(n),
k = new Float64Array(g),
S = 0;
S < g;
S++
)
k[S] = S;
for (
var O = Math.min(n - 1, i),
E = Math.max(0, Math.min(i - 2, n)),
j = Math.max(O, E),
R = 0;
R < j;
R++
) {
if (R < O) {
w[R] = 0;
for (var P = R; P < n; P++) w[R] = Rr(w[R], o.get(P, R));
if (0 !== w[R]) {
o.get(R, R) < 0 && (w[R] = -w[R]);
for (var _ = R; _ < n; _++) o.set(_, R, o.get(_, R) / w[R]);
o.set(R, R, o.get(R, R) + 1);
}
w[R] = -w[R];
}
for (var T = R + 1; T < i; T++) {
if (R < O && 0 !== w[R]) {
for (var I = 0, N = R; N < n; N++)
I += o.get(N, R) * o.get(N, T);
I = -I / o.get(R, R);
for (var C = R; C < n; C++)
o.set(C, T, o.get(C, T) + I * o.get(C, R));
}
M[T] = o.get(R, T);
}
if (l && R < O)
for (var D = R; D < n; D++) d.set(D, R, o.get(D, R));
if (R < E) {
M[R] = 0;
for (var V = R + 1; V < i; V++) M[R] = Rr(M[R], M[V]);
if (0 !== M[R]) {
M[R + 1] < 0 && (M[R] = 0 - M[R]);
for (var q = R + 1; q < i; q++) M[q] /= M[R];
M[R + 1] += 1;
}
if (((M[R] = -M[R]), R + 1 < n && 0 !== M[R])) {
for (var A = R + 1; A < n; A++) x[A] = 0;
for (var F = R + 1; F < n; F++)
for (var B = R + 1; B < i; B++) x[F] += M[B] * o.get(F, B);
for (var z = R + 1; z < i; z++)
for (var L = -M[z] / M[R + 1], U = R + 1; U < n; U++)
o.set(U, z, o.get(U, z) + L * x[U]);
}
if (p) for (var W = R + 1; W < i; W++) b.set(W, R, M[W]);
}
}
var Q = Math.min(i, n + 1);
if (
(O < i && (w[O] = o.get(O, O)),
n < Q && (w[Q - 1] = 0),
E + 1 < Q && (M[E] = o.get(E, Q - 1)),
(M[Q - 1] = 0),
l)
) {
for (var J = O; J < m; J++) {
for (var Y = 0; Y < n; Y++) d.set(Y, J, 0);
d.set(J, J, 1);
}
for (var K = O - 1; K >= 0; K--)
if (0 !== w[K]) {
for (var X = K + 1; X < m; X++) {
for (var G = 0, Z = K; Z < n; Z++)
G += d.get(Z, K) * d.get(Z, X);
G = -G / d.get(K, K);
for (var $ = K; $ < n; $++)
d.set($, X, d.get($, X) + G * d.get($, K));
}
for (var tt = K; tt < n; tt++) d.set(tt, K, -d.get(tt, K));
d.set(K, K, 1 + d.get(K, K));
for (var rt = 0; rt < K - 1; rt++) d.set(rt, K, 0);
} else {
for (var et = 0; et < n; et++) d.set(et, K, 0);
d.set(K, K, 1);
}
}
if (p)
for (var ot = i - 1; ot >= 0; ot--) {
if (ot < E && 0 !== M[ot])
for (var nt = ot + 1; nt < i; nt++) {
for (var it = 0, st = ot + 1; st < i; st++)
it += b.get(st, ot) * b.get(st, nt);
it = -it / b.get(ot + 1, ot);
for (var ut = ot + 1; ut < i; ut++)
b.set(ut, nt, b.get(ut, nt) + it * b.get(ut, ot));
}
for (var at = 0; at < i; at++) b.set(at, ot, 0);
b.set(ot, ot, 1);
}
for (var ft = Q - 1, ct = Number.EPSILON; Q > 0; ) {
var ht = void 0,
lt = void 0;
for (ht = Q - 2; ht >= -1 && -1 !== ht; ht--) {
var pt =
Number.MIN_VALUE + ct * Math.abs(w[ht] + Math.abs(w[ht + 1]));
if (Math.abs(M[ht]) <= pt || Number.isNaN(M[ht])) {
M[ht] = 0;
break;
}
}
if (ht === Q - 2) lt = 4;
else {
var yt = void 0;
for (yt = Q - 1; yt >= ht && yt !== ht; yt--) {
var vt =
(yt !== Q ? Math.abs(M[yt]) : 0) +
(yt !== ht + 1 ? Math.abs(M[yt - 1]) : 0);
if (Math.abs(w[yt]) <= ct * vt) {
w[yt] = 0;
break;
}
}
yt === ht
? (lt = 3)
: yt === Q - 1
? (lt = 1)
: ((lt = 2), (ht = yt));
}
switch ((ht++, lt)) {
case 1:
var mt = M[Q - 2];
M[Q - 2] = 0;
for (var gt = Q - 2; gt >= ht; gt--) {
var wt = Rr(w[gt], mt),
dt = w[gt] / wt,
bt = mt / wt;
if (
((w[gt] = wt),
gt !== ht &&
((mt = -bt * M[gt - 1]), (M[gt - 1] = dt * M[gt - 1])),
p)
)
for (var Mt = 0; Mt < i; Mt++)
(wt = dt * b.get(Mt, gt) + bt * b.get(Mt, Q - 1)),
b.set(
Mt,
Q - 1,
-bt * b.get(Mt, gt) + dt * b.get(Mt, Q - 1),
),
b.set(Mt, gt, wt);
}
break;
case 2:
var xt = M[ht - 1];
M[ht - 1] = 0;
for (var kt = ht; kt < Q; kt++) {
var St = Rr(w[kt], xt),
Ot = w[kt] / St,
Et = xt / St;
if (
((w[kt] = St), (xt = -Et * M[kt]), (M[kt] = Ot * M[kt]), l)
)
for (var jt = 0; jt < n; jt++)
(St = Ot * d.get(jt, kt) + Et * d.get(jt, ht - 1)),
d.set(
jt,
ht - 1,
-Et * d.get(jt, kt) + Ot * d.get(jt, ht - 1),
),
d.set(jt, kt, St);
}
break;
case 3:
var Rt = Math.max(
Math.abs(w[Q - 1]),
Math.abs(w[Q - 2]),
Math.abs(M[Q - 2]),
Math.abs(w[ht]),
Math.abs(M[ht]),
),
Pt = w[Q - 1] / Rt,
_t = w[Q - 2] / Rt,
Tt = M[Q - 2] / Rt,
It = w[ht] / Rt,
Nt = M[ht] / Rt,
Ct = ((_t + Pt) * (_t - Pt) + Tt * Tt) / 2,
Dt = Pt * Tt * (Pt * Tt),
Vt = 0;
(0 === Ct && 0 === Dt) ||
(Vt =
Dt /
(Ct +
(Vt =
Ct < 0
? 0 - Math.sqrt(Ct * Ct + Dt)
: Math.sqrt(Ct * Ct + Dt))));
for (
var qt = (It + Pt) * (It - Pt) + Vt, At = It * Nt, Ft = ht;
Ft < Q - 1;
Ft++
) {
var Bt = Rr(qt, At);
0 === Bt && (Bt = Number.MIN_VALUE);
var zt = qt / Bt,
Lt = At / Bt;
if (
(Ft !== ht && (M[Ft - 1] = Bt),
(qt = zt * w[Ft] + Lt * M[Ft]),
(M[Ft] = zt * M[Ft] - Lt * w[Ft]),
(At = Lt * w[Ft + 1]),
(w[Ft + 1] = zt * w[Ft + 1]),
p)
)
for (var Ut = 0; Ut < i; Ut++)
(Bt = zt * b.get(Ut, Ft) + Lt * b.get(Ut, Ft + 1)),
b.set(
Ut,
Ft + 1,
-Lt * b.get(Ut, Ft) + zt * b.get(Ut, Ft + 1),
),
b.set(Ut, Ft, Bt);
if (
(0 === (Bt = Rr(qt, At)) && (Bt = Number.MIN_VALUE),
(zt = qt / Bt),
(Lt = At / Bt),
(w[Ft] = Bt),
(qt = zt * M[Ft] + Lt * w[Ft + 1]),
(w[Ft + 1] = -Lt * M[Ft] + zt * w[Ft + 1]),
(At = Lt * M[Ft + 1]),
(M[Ft + 1] = zt * M[Ft + 1]),
l && Ft < n - 1)
)
for (var Wt = 0; Wt < n; Wt++)
(Bt = zt * d.get(Wt, Ft) + Lt * d.get(Wt, Ft + 1)),
d.set(
Wt,
Ft + 1,
-Lt * d.get(Wt, Ft) + zt * d.get(Wt, Ft + 1),
),
d.set(Wt, Ft, Bt);
}
(M[Q - 2] = qt), 1;
break;
case 4:
if (w[ht] <= 0 && ((w[ht] = w[ht] < 0 ? -w[ht] : 0), p))
for (var Qt = 0; Qt <= ft; Qt++)
b.set(Qt, ht, -b.get(Qt, ht));
for (; ht < ft && !(w[ht] >= w[ht + 1]); ) {
var Jt = w[ht];
if (((w[ht] = w[ht + 1]), (w[ht + 1] = Jt), p && ht < i - 1))
for (var Ht = 0; Ht < i; Ht++)
(Jt = b.get(Ht, ht + 1)),
b.set(Ht, ht + 1, b.get(Ht, ht)),
b.set(Ht, ht, Jt);
if (l && ht < n - 1)
for (var Yt = 0; Yt < n; Yt++)
(Jt = d.get(Yt, ht + 1)),
d.set(Yt, ht + 1, d.get(Yt, ht)),
d.set(Yt, ht, Jt);
ht++;
}
0, Q--;
}
}
if (y) {
var Kt = b;
(b = d), (d = Kt);
}
(this.m = n), (this.n = i), (this.s = w), (this.U = d), (this.V = b);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "solve",
value: function (t) {
for (
var r = t,
e = this.threshold,
o = this.s.length,
n = H.zeros(o, o),
i = 0;
i < o;
i++
)
Math.abs(this.s[i]) <= e
? n.set(i, i, 0)
: n.set(i, i, 1 / this.s[i]);
for (
var s = this.U,
u = this.rightSingularVectors,
a = u.mmul(n),
f = u.rows,
c = s.rows,
h = H.zeros(f, c),
l = 0;
l < f;
l++
)
for (var p = 0; p < c; p++) {
for (var y = 0, v = 0; v < o; v++)
y += a.get(l, v) * s.get(p, v);
h.set(l, p, y);
}
return h.mmul(r);
},
},
{
key: "solveForDiagonal",
value: function (t) {
return this.solve(H.diag(t));
},
},
{
key: "inverse",
value: function () {
for (
var t = this.V,
r = this.threshold,
e = t.rows,
o = t.columns,
n = new H(e, this.s.length),
i = 0;
i < e;
i++
)
for (var s = 0; s < o; s++)
Math.abs(this.s[s]) > r &&
n.set(i, s, t.get(i, s) / this.s[s]);
for (
var u = this.U,
a = u.rows,
f = u.columns,
c = new H(e, a),
h = 0;
h < e;
h++
)
for (var l = 0; l < a; l++) {
for (var p = 0, y = 0; y < f; y++)
p += n.get(h, y) * u.get(l, y);
c.set(h, l, p);
}
return c;
},
},
{
key: "condition",
get: function () {
return this.s[0] / this.s[Math.min(this.m, this.n) - 1];
},
},
{
key: "norm2",
get: function () {
return this.s[0];
},
},
{
key: "rank",
get: function () {
for (
var t = Math.max(this.m, this.n) * this.s[0] * Number.EPSILON,
r = 0,
e = this.s,
o = 0,
n = e.length;
o < n;
o++
)
e[o] > t && r++;
return r;
},
},
{
key: "diagonal",
get: function () {
return Array.from(this.s);
},
},
{
key: "threshold",
get: function () {
return (
(Number.EPSILON / 2) * Math.max(this.m, this.n) * this.s[0]
);
},
},
{
key: "leftSingularVectors",
get: function () {
return this.U;
},
},
{
key: "rightSingularVectors",
get: function () {
return this.V;
},
},
{
key: "diagonalMatrix",
get: function () {
return H.diag(this.s);
},
},
]) && Ir(r.prototype, e),
o && Ir(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Cr(t) {
var r = arguments.length > 1 && void 0 !== arguments[1] && arguments[1];
return (
(t = Sr.checkMatrix(t)),
r ? new Nr(t).inverse() : Dr(t, H.eye(t.rows))
);
}
function Dr(t, r) {
var e = arguments.length > 2 && void 0 !== arguments[2] && arguments[2];
return (
(t = Sr.checkMatrix(t)),
(r = Sr.checkMatrix(r)),
e
? new Nr(t).solve(r)
: t.isSquare()
? new jr(t).solve(r)
: new _r(t).solve(r)
);
}
function Vr(t) {
var r, e, o, n, i, s;
if ((t = H.checkMatrix(t)).isSquare())
return 0 === t.columns
? 1
: 2 === t.columns
? ((r = t.get(0, 0)),
(e = t.get(0, 1)),
(o = t.get(1, 0)),
r * t.get(1, 1) - e * o)
: 3 === t.columns
? ((n = new Kt(t, [1, 2], [1, 2])),
(i = new Kt(t, [1, 2], [0, 2])),
(s = new Kt(t, [1, 2], [0, 1])),
(r = t.get(0, 0)),
(e = t.get(0, 1)),
(o = t.get(0, 2)),
r * Vr(n) - e * Vr(i) + o * Vr(s))
: new jr(t).determinant;
throw Error("determinant can only be calculated for a square matrix");
}
function qr(t, r) {
for (var e = [], o = 0; o < t; o++) o !== r && e.push(o);
return e;
}
function Ar(t, r, e) {
var o =
arguments.length > 3 && void 0 !== arguments[3]
? arguments[3]
: 1e-9,
n =
arguments.length > 4 && void 0 !== arguments[4]
? arguments[4]
: 1e-9;
if (t > n) return new Array(r.rows + 1).fill(0);
for (var i = r.addRow(e, [0]), s = 0; s < i.rows; s++)
Math.abs(i.get(s, 0)) < o && i.set(s, 0, 0);
return i.to1DArray();
}
function Fr(t) {
for (
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {},
e = r.thresholdValue,
o = void 0 === e ? 1e-9 : e,
n = r.thresholdError,
i = void 0 === n ? 1e-9 : n,
s = (t = H.checkMatrix(t)).rows,
u = new H(s, s),
a = 0;
a < s;
a++
) {
var f = H.columnVector(t.getRow(a)),
c = t.subMatrixRow(qr(s, a)).transpose(),
h = new Nr(c),
l = h.solve(f),
p = H.sub(f, c.mmul(l)).abs().max();
u.setRow(a, Ar(p, l, a, o, i));
}
return u;
}
function Br(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: Number.EPSILON;
if ((t = H.checkMatrix(t)).isEmpty()) return t.transpose();
for (
var e = new Nr(t, { autoTranspose: !0 }),
o = e.leftSingularVectors,
n = e.rightSingularVectors,
i = e.diagonal,
s = 0;
s < i.length;
s++
)
Math.abs(i[s]) > r ? (i[s] = 1 / i[s]) : (i[s] = 0);
return n.mmul(H.diag(i).mmul(o.transpose()));
}
function zr(t) {
return (zr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Lr(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : t,
e =
arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
t = new H(t);
var o = !1;
if (
("object" !== zr(r) || H.isMatrix(r) || n(r)
? (r = new H(r))
: ((e = r), (r = t), (o = !0)),
t.rows !== r.rows)
)
throw new TypeError(
"Both matrices must have the same number of rows",
);
var i = e,
s = i.center,
u = void 0 === s || s;
u && ((t = t.center("column")), o || (r = r.center("column")));
for (var a = t.transpose().mmul(r), f = 0; f < a.rows; f++)
for (var c = 0; c < a.columns; c++)
a.set(f, c, a.get(f, c) * (1 / (t.rows - 1)));
return a;
}
function Ur(t) {
return (Ur =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Wr(t) {
var r =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : t,
e =
arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {};
t = new H(t);
var o = !1;
if (
("object" !== Ur(r) || H.isMatrix(r) || n(r)
? (r = new H(r))
: ((e = r), (r = t), (o = !0)),
t.rows !== r.rows)
)
throw new TypeError(
"Both matrices must have the same number of rows",
);
var i = e,
s = i.center,
u = void 0 === s || s,
a = i.scale,
f = void 0 === a || a;
u && (t.center("column"), o || r.center("column")),
f && (t.scale("column"), o || r.scale("column"));
for (
var c = t.standardDeviation("column", { unbiased: !0 }),
h = o ? c : r.standardDeviation("column", { unbiased: !0 }),
l = t.transpose().mmul(r),
p = 0;
p < l.rows;
p++
)
for (var y = 0; y < l.columns; y++)
l.set(p, y, l.get(p, y) * (1 / (c[p] * h[y])) * (1 / (t.rows - 1)));
return l;
}
function Qr(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
function Jr(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var Hr = (function () {
function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
Qr(this, t);
var o = e.assumeSymmetric,
n = void 0 !== o && o;
if (!(r = Sr.checkMatrix(r)).isSquare())
throw new Error("Matrix is not a square matrix");
if (r.isEmpty()) throw new Error("Matrix must be non-empty");
var i,
s,
u = r.columns,
a = new H(u, u),
f = new Float64Array(u),
c = new Float64Array(u),
h = r;
if (!!n || r.isSymmetric()) {
for (i = 0; i < u; i++)
for (s = 0; s < u; s++) a.set(i, s, h.get(i, s));
Yr(u, c, f, a), Kr(u, c, f, a);
} else {
var l = new H(u, u),
p = new Float64Array(u);
for (s = 0; s < u; s++)
for (i = 0; i < u; i++) l.set(i, s, h.get(i, s));
Xr(u, l, p, a), Gr(u, c, f, a, l);
}
(this.n = u), (this.e = c), (this.d = f), (this.V = a);
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "realEigenvalues",
get: function () {
return Array.from(this.d);
},
},
{
key: "imaginaryEigenvalues",
get: function () {
return Array.from(this.e);
},
},
{
key: "eigenvectorMatrix",
get: function () {
return this.V;
},
},
{
key: "diagonalMatrix",
get: function () {
var t,
r,
e = this.n,
o = this.e,
n = this.d,
i = new H(e, e);
for (t = 0; t < e; t++) {
for (r = 0; r < e; r++) i.set(t, r, 0);
i.set(t, t, n[t]),
o[t] > 0
? i.set(t, t + 1, o[t])
: o[t] < 0 && i.set(t, t - 1, o[t]);
}
return i;
},
},
]) && Jr(r.prototype, e),
o && Jr(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function Yr(t, r, e, o) {
var n, i, s, u, a, f, c, h;
for (a = 0; a < t; a++) e[a] = o.get(t - 1, a);
for (u = t - 1; u > 0; u--) {
for (h = 0, s = 0, f = 0; f < u; f++) h += Math.abs(e[f]);
if (0 === h)
for (r[u] = e[u - 1], a = 0; a < u; a++)
(e[a] = o.get(u - 1, a)), o.set(u, a, 0), o.set(a, u, 0);
else {
for (f = 0; f < u; f++) (e[f] /= h), (s += e[f] * e[f]);
for (
n = e[u - 1],
i = Math.sqrt(s),
n > 0 && (i = -i),
r[u] = h * i,
s -= n * i,
e[u - 1] = n - i,
a = 0;
a < u;
a++
)
r[a] = 0;
for (a = 0; a < u; a++) {
for (
n = e[a], o.set(a, u, n), i = r[a] + o.get(a, a) * n, f = a + 1;
f <= u - 1;
f++
)
(i += o.get(f, a) * e[f]), (r[f] += o.get(f, a) * n);
r[a] = i;
}
for (n = 0, a = 0; a < u; a++) (r[a] /= s), (n += r[a] * e[a]);
for (c = n / (s + s), a = 0; a < u; a++) r[a] -= c * e[a];
for (a = 0; a < u; a++) {
for (n = e[a], i = r[a], f = a; f <= u - 1; f++)
o.set(f, a, o.get(f, a) - (n * r[f] + i * e[f]));
(e[a] = o.get(u - 1, a)), o.set(u, a, 0);
}
}
e[u] = s;
}
for (u = 0; u < t - 1; u++) {
if (
(o.set(t - 1, u, o.get(u, u)), o.set(u, u, 1), 0 !== (s = e[u + 1]))
) {
for (f = 0; f <= u; f++) e[f] = o.get(f, u + 1) / s;
for (a = 0; a <= u; a++) {
for (i = 0, f = 0; f <= u; f++)
i += o.get(f, u + 1) * o.get(f, a);
for (f = 0; f <= u; f++) o.set(f, a, o.get(f, a) - i * e[f]);
}
}
for (f = 0; f <= u; f++) o.set(f, u + 1, 0);
}
for (a = 0; a < t; a++) (e[a] = o.get(t - 1, a)), o.set(t - 1, a, 0);
o.set(t - 1, t - 1, 1), (r[0] = 0);
}
function Kr(t, r, e, o) {
var n, i, s, u, a, f, c, h, l, p, y, v, m, g, w, d;
for (s = 1; s < t; s++) r[s - 1] = r[s];
r[t - 1] = 0;
var b = 0,
M = 0,
x = Number.EPSILON;
for (f = 0; f < t; f++) {
for (
M = Math.max(M, Math.abs(e[f]) + Math.abs(r[f])), c = f;
c < t && !(Math.abs(r[c]) <= x * M);
)
c++;
if (c > f) {
0;
do {
for (
1,
n = e[f],
l = Rr((h = (e[f + 1] - n) / (2 * r[f])), 1),
h < 0 && (l = -l),
e[f] = r[f] / (h + l),
e[f + 1] = r[f] * (h + l),
p = e[f + 1],
i = n - e[f],
s = f + 2;
s < t;
s++
)
e[s] -= i;
for (
b += i,
h = e[c],
v = y = 1,
m = y,
g = r[f + 1],
w = 0,
d = 0,
s = c - 1;
s >= f;
s--
)
for (
m = v,
v = y,
d = w,
n = y * r[s],
i = y * h,
l = Rr(h, r[s]),
r[s + 1] = w * l,
w = r[s] / l,
h = (y = h / l) * e[s] - w * n,
e[s + 1] = i + w * (y * n + w * e[s]),
a = 0;
a < t;
a++
)
(i = o.get(a, s + 1)),
o.set(a, s + 1, w * o.get(a, s) + y * i),
o.set(a, s, y * o.get(a, s) - w * i);
(h = (-w * d * m * g * r[f]) / p), (r[f] = w * h), (e[f] = y * h);
} while (Math.abs(r[f]) > x * M);
}
(e[f] = e[f] + b), (r[f] = 0);
}
for (s = 0; s < t - 1; s++) {
for (a = s, h = e[s], u = s + 1; u < t; u++)
e[u] < h && ((a = u), (h = e[u]));
if (a !== s)
for (e[a] = e[s], e[s] = h, u = 0; u < t; u++)
(h = o.get(u, s)), o.set(u, s, o.get(u, a)), o.set(u, a, h);
}
}
function Xr(t, r, e, o) {
var n,
i,
s,
u,
a,
f,
c,
h = t - 1;
for (f = 1; f <= h - 1; f++) {
for (c = 0, u = f; u <= h; u++) c += Math.abs(r.get(u, f - 1));
if (0 !== c) {
for (s = 0, u = h; u >= f; u--)
(e[u] = r.get(u, f - 1) / c), (s += e[u] * e[u]);
for (
i = Math.sqrt(s),
e[f] > 0 && (i = -i),
s -= e[f] * i,
e[f] = e[f] - i,
a = f;
a < t;
a++
) {
for (n = 0, u = h; u >= f; u--) n += e[u] * r.get(u, a);
for (n /= s, u = f; u <= h; u++)
r.set(u, a, r.get(u, a) - n * e[u]);
}
for (u = 0; u <= h; u++) {
for (n = 0, a = h; a >= f; a--) n += e[a] * r.get(u, a);
for (n /= s, a = f; a <= h; a++)
r.set(u, a, r.get(u, a) - n * e[a]);
}
(e[f] = c * e[f]), r.set(f, f - 1, c * i);
}
}
for (u = 0; u < t; u++)
for (a = 0; a < t; a++) o.set(u, a, u === a ? 1 : 0);
for (f = h - 1; f >= 1; f--)
if (0 !== r.get(f, f - 1)) {
for (u = f + 1; u <= h; u++) e[u] = r.get(u, f - 1);
for (a = f; a <= h; a++) {
for (i = 0, u = f; u <= h; u++) i += e[u] * o.get(u, a);
for (i = i / e[f] / r.get(f, f - 1), u = f; u <= h; u++)
o.set(u, a, o.get(u, a) + i * e[u]);
}
}
}
function Gr(t, r, e, o, n) {
var i,
s,
u,
a,
f,
c,
h,
l,
p,
y,
v,
m,
g,
w,
d,
b = t - 1,
M = t - 1,
x = Number.EPSILON,
k = 0,
S = 0,
O = 0,
E = 0,
j = 0,
R = 0,
P = 0,
_ = 0;
for (i = 0; i < t; i++)
for (
(i < 0 || i > M) && ((e[i] = n.get(i, i)), (r[i] = 0)),
s = Math.max(i - 1, 0);
s < t;
s++
)
S += Math.abs(n.get(i, s));
for (; b >= 0; ) {
for (
a = b;
a > 0 &&
(0 ===
(R = Math.abs(n.get(a - 1, a - 1)) + Math.abs(n.get(a, a))) &&
(R = S),
!(Math.abs(n.get(a, a - 1)) < x * R));
)
a--;
if (a === b)
n.set(b, b, n.get(b, b) + k),
(e[b] = n.get(b, b)),
(r[b] = 0),
b--,
(_ = 0);
else if (a === b - 1) {
if (
((h = n.get(b, b - 1) * n.get(b - 1, b)),
(E = (O = (n.get(b - 1, b - 1) - n.get(b, b)) / 2) * O + h),
(P = Math.sqrt(Math.abs(E))),
n.set(b, b, n.get(b, b) + k),
n.set(b - 1, b - 1, n.get(b - 1, b - 1) + k),
(l = n.get(b, b)),
E >= 0)
) {
for (
P = O >= 0 ? O + P : O - P,
e[b - 1] = l + P,
e[b] = e[b - 1],
0 !== P && (e[b] = l - h / P),
r[b - 1] = 0,
r[b] = 0,
O = (l = n.get(b, b - 1)) / (R = Math.abs(l) + Math.abs(P)),
E = P / R,
O /= j = Math.sqrt(O * O + E * E),
E /= j,
s = b - 1;
s < t;
s++
)
(P = n.get(b - 1, s)),
n.set(b - 1, s, E * P + O * n.get(b, s)),
n.set(b, s, E * n.get(b, s) - O * P);
for (i = 0; i <= b; i++)
(P = n.get(i, b - 1)),
n.set(i, b - 1, E * P + O * n.get(i, b)),
n.set(i, b, E * n.get(i, b) - O * P);
for (i = 0; i <= M; i++)
(P = o.get(i, b - 1)),
o.set(i, b - 1, E * P + O * o.get(i, b)),
o.set(i, b, E * o.get(i, b) - O * P);
} else
(e[b - 1] = l + O), (e[b] = l + O), (r[b - 1] = P), (r[b] = -P);
(b -= 2), (_ = 0);
} else {
if (
((l = n.get(b, b)),
(p = 0),
(h = 0),
a < b &&
((p = n.get(b - 1, b - 1)),
(h = n.get(b, b - 1) * n.get(b - 1, b))),
10 === _)
) {
for (k += l, i = 0; i <= b; i++) n.set(i, i, n.get(i, i) - l);
(l = p =
0.75 *
(R =
Math.abs(n.get(b, b - 1)) + Math.abs(n.get(b - 1, b - 2)))),
(h = -0.4375 * R * R);
}
if (30 === _ && (R = (R = (p - l) / 2) * R + h) > 0) {
for (
R = Math.sqrt(R),
p < l && (R = -R),
R = l - h / ((p - l) / 2 + R),
i = 0;
i <= b;
i++
)
n.set(i, i, n.get(i, i) - R);
(k += R), (l = p = h = 0.964);
}
for (
_ += 1, f = b - 2;
f >= a &&
((O =
((j = l - (P = n.get(f, f))) * (R = p - P) - h) /
n.get(f + 1, f) +
n.get(f, f + 1)),
(E = n.get(f + 1, f + 1) - P - j - R),
(j = n.get(f + 2, f + 1)),
(O /= R = Math.abs(O) + Math.abs(E) + Math.abs(j)),
(E /= R),
(j /= R),
f !== a) &&
!(
Math.abs(n.get(f, f - 1)) * (Math.abs(E) + Math.abs(j)) <
x *
(Math.abs(O) *
(Math.abs(n.get(f - 1, f - 1)) +
Math.abs(P) +
Math.abs(n.get(f + 1, f + 1))))
);
)
f--;
for (i = f + 2; i <= b; i++)
n.set(i, i - 2, 0), i > f + 2 && n.set(i, i - 3, 0);
for (
u = f;
u <= b - 1 &&
((w = u !== b - 1),
u !== f &&
((O = n.get(u, u - 1)),
(E = n.get(u + 1, u - 1)),
(j = w ? n.get(u + 2, u - 1) : 0),
0 !== (l = Math.abs(O) + Math.abs(E) + Math.abs(j)) &&
((O /= l), (E /= l), (j /= l))),
0 !== l);
u++
)
if (
((R = Math.sqrt(O * O + E * E + j * j)),
O < 0 && (R = -R),
0 !== R)
) {
for (
u !== f
? n.set(u, u - 1, -R * l)
: a !== f && n.set(u, u - 1, -n.get(u, u - 1)),
l = (O += R) / R,
p = E / R,
P = j / R,
E /= O,
j /= O,
s = u;
s < t;
s++
)
(O = n.get(u, s) + E * n.get(u + 1, s)),
w &&
((O += j * n.get(u + 2, s)),
n.set(u + 2, s, n.get(u + 2, s) - O * P)),
n.set(u, s, n.get(u, s) - O * l),
n.set(u + 1, s, n.get(u + 1, s) - O * p);
for (i = 0; i <= Math.min(b, u + 3); i++)
(O = l * n.get(i, u) + p * n.get(i, u + 1)),
w &&
((O += P * n.get(i, u + 2)),
n.set(i, u + 2, n.get(i, u + 2) - O * j)),
n.set(i, u, n.get(i, u) - O),
n.set(i, u + 1, n.get(i, u + 1) - O * E);
for (i = 0; i <= M; i++)
(O = l * o.get(i, u) + p * o.get(i, u + 1)),
w &&
((O += P * o.get(i, u + 2)),
o.set(i, u + 2, o.get(i, u + 2) - O * j)),
o.set(i, u, o.get(i, u) - O),
o.set(i, u + 1, o.get(i, u + 1) - O * E);
}
}
}
if (0 !== S) {
for (b = t - 1; b >= 0; b--)
if (((O = e[b]), 0 === (E = r[b])))
for (a = b, n.set(b, b, 1), i = b - 1; i >= 0; i--) {
for (h = n.get(i, i) - O, j = 0, s = a; s <= b; s++)
j += n.get(i, s) * n.get(s, b);
if (r[i] < 0) (P = h), (R = j);
else if (
((a = i),
0 === r[i]
? n.set(i, b, 0 !== h ? -j / h : -j / (x * S))
: ((l = n.get(i, i + 1)),
(p = n.get(i + 1, i)),
(c =
(l * R - P * j) /
(E = (e[i] - O) * (e[i] - O) + r[i] * r[i])),
n.set(i, b, c),
n.set(
i + 1,
b,
Math.abs(l) > Math.abs(P)
? (-j - h * c) / l
: (-R - p * c) / P,
)),
x * (c = Math.abs(n.get(i, b))) * c > 1)
)
for (s = i; s <= b; s++) n.set(s, b, n.get(s, b) / c);
}
else if (E < 0)
for (
a = b - 1,
Math.abs(n.get(b, b - 1)) > Math.abs(n.get(b - 1, b))
? (n.set(b - 1, b - 1, E / n.get(b, b - 1)),
n.set(b - 1, b, -(n.get(b, b) - O) / n.get(b, b - 1)))
: ((d = Zr(
0,
-n.get(b - 1, b),
n.get(b - 1, b - 1) - O,
E,
)),
n.set(b - 1, b - 1, d[0]),
n.set(b - 1, b, d[1])),
n.set(b, b - 1, 0),
n.set(b, b, 1),
i = b - 2;
i >= 0;
i--
) {
for (y = 0, v = 0, s = a; s <= b; s++)
(y += n.get(i, s) * n.get(s, b - 1)),
(v += n.get(i, s) * n.get(s, b));
if (((h = n.get(i, i) - O), r[i] < 0))
(P = h), (j = y), (R = v);
else if (
((a = i),
0 === r[i]
? ((d = Zr(-y, -v, h, E)),
n.set(i, b - 1, d[0]),
n.set(i, b, d[1]))
: ((l = n.get(i, i + 1)),
(p = n.get(i + 1, i)),
(m = (e[i] - O) * (e[i] - O) + r[i] * r[i] - E * E),
(g = 2 * (e[i] - O) * E),
0 === m &&
0 === g &&
(m =
x *
S *
(Math.abs(h) +
Math.abs(E) +
Math.abs(l) +
Math.abs(p) +
Math.abs(P))),
(d = Zr(
l * j - P * y + E * v,
l * R - P * v - E * y,
m,
g,
)),
n.set(i, b - 1, d[0]),
n.set(i, b, d[1]),
Math.abs(l) > Math.abs(P) + Math.abs(E)
? (n.set(
i + 1,
b - 1,
(-y - h * n.get(i, b - 1) + E * n.get(i, b)) / l,
),
n.set(
i + 1,
b,
(-v - h * n.get(i, b) - E * n.get(i, b - 1)) / l,
))
: ((d = Zr(
-j - p * n.get(i, b - 1),
-R - p * n.get(i, b),
P,
E,
)),
n.set(i + 1, b - 1, d[0]),
n.set(i + 1, b, d[1]))),
x *
(c = Math.max(
Math.abs(n.get(i, b - 1)),
Math.abs(n.get(i, b)),
)) *
c >
1)
)
for (s = i; s <= b; s++)
n.set(s, b - 1, n.get(s, b - 1) / c),
n.set(s, b, n.get(s, b) / c);
}
for (i = 0; i < t; i++)
if (i < 0 || i > M)
for (s = i; s < t; s++) o.set(i, s, n.get(i, s));
for (s = t - 1; s >= 0; s--)
for (i = 0; i <= M; i++) {
for (P = 0, u = 0; u <= Math.min(s, M); u++)
P += o.get(i, u) * n.get(u, s);
o.set(i, s, P);
}
}
}
function Zr(t, r, e, o) {
var n, i;
return Math.abs(e) > Math.abs(o)
? [(t + (n = o / e) * r) / (i = e + n * o), (r - n * t) / i]
: [((n = e / o) * t + r) / (i = o + n * e), (n * r - t) / i];
}
function $r(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
var te = (function () {
function t(r) {
if (
((function (t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
})(this, t),
!(r = Sr.checkMatrix(r)).isSymmetric())
)
throw new Error("Matrix is not symmetric");
var e,
o,
n,
i = r,
s = i.rows,
u = new H(s, s),
a = !0;
for (o = 0; o < s; o++) {
var f = 0;
for (n = 0; n < o; n++) {
var c = 0;
for (e = 0; e < n; e++) c += u.get(n, e) * u.get(o, e);
(c = (i.get(o, n) - c) / u.get(n, n)),
u.set(o, n, c),
(f += c * c);
}
for (
a &= (f = i.get(o, o) - f) > 0,
u.set(o, o, Math.sqrt(Math.max(f, 0))),
n = o + 1;
n < s;
n++
)
u.set(o, n, 0);
}
(this.L = u), (this.positiveDefinite = Boolean(a));
}
var r, e, o;
return (
(r = t),
(e = [
{
key: "isPositiveDefinite",
value: function () {
return this.positiveDefinite;
},
},
{
key: "solve",
value: function (t) {
t = Sr.checkMatrix(t);
var r = this.L,
e = r.rows;
if (t.rows !== e)
throw new Error("Matrix dimensions do not match");
if (!1 === this.isPositiveDefinite())
throw new Error("Matrix is not positive definite");
var o,
n,
i,
s = t.columns,
u = t.clone();
for (i = 0; i < e; i++)
for (n = 0; n < s; n++) {
for (o = 0; o < i; o++)
u.set(i, n, u.get(i, n) - u.get(o, n) * r.get(i, o));
u.set(i, n, u.get(i, n) / r.get(i, i));
}
for (i = e - 1; i >= 0; i--)
for (n = 0; n < s; n++) {
for (o = i + 1; o < e; o++)
u.set(i, n, u.get(i, n) - u.get(o, n) * r.get(o, i));
u.set(i, n, u.get(i, n) / r.get(i, i));
}
return u;
},
},
{
key: "lowerTriangularMatrix",
get: function () {
return this.L;
},
},
]) && $r(r.prototype, e),
o && $r(r, o),
Object.defineProperty(r, "prototype", { writable: !1 }),
t
);
})();
function re(t, r) {
for (var e = 0; e < r.length; e++) {
var o = r[e];
(o.enumerable = o.enumerable || !1),
(o.configurable = !0),
"value" in o && (o.writable = !0),
Object.defineProperty(t, o.key, o);
}
}
function ee(t, r, e) {
return (
r && re(t.prototype, r),
e && re(t, e),
Object.defineProperty(t, "prototype", { writable: !1 }),
t
);
}
function oe(t, r) {
if (!(t instanceof r))
throw new TypeError("Cannot call a class as a function");
}
var ne = ee(function t(r) {
var e =
arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {};
oe(this, t), (r = Sr.checkMatrix(r));
var o,
i = e.Y,
s = e.scaleScores,
u = void 0 !== s && s,
a = e.maxIterations,
f = void 0 === a ? 1e3 : a,
c = e.terminationCriteria,
h = void 0 === c ? 1e-10 : c;
if (i) {
if (
(i =
n(i) && "number" == typeof i[0]
? H.columnVector(i)
: Sr.checkMatrix(i)).rows !== r.rows
)
throw new Error("Y should have the same number of rows as X");
o = i.getColumnVector(0);
} else o = r.getColumnVector(0);
for (var l, p, y, v, m = 1, g = 0; g < f && m > h; g++)
(y = (y = r
.transpose()
.mmul(o)
.div(o.transpose().mmul(o).get(0, 0))).div(y.norm())),
(l = r.mmul(y).div(y.transpose().mmul(y).get(0, 0))),
g > 0 && (m = l.clone().sub(v).pow(2).sum()),
(v = l.clone()),
i
? ((p = (p = i
.transpose()
.mmul(l)
.div(l.transpose().mmul(l).get(0, 0))).div(p.norm())),
(o = i.mmul(p).div(p.transpose().mmul(p).get(0, 0))))
: (o = l);
if (i) {
var w = r.transpose().mmul(l).div(l.transpose().mmul(l).get(0, 0));
w = w.div(w.norm());
var d = r.clone().sub(l.clone().mmul(w.transpose())),
b = o.transpose().mmul(l).div(l.transpose().mmul(l).get(0, 0)),
M = i.clone().sub(l.clone().mulS(b.get(0, 0)).mmul(p.transpose()));
(this.t = l),
(this.p = w.transpose()),
(this.w = y.transpose()),
(this.q = p),
(this.u = o),
(this.s = l.transpose().mmul(l)),
(this.xResidual = d),
(this.yResidual = M),
(this.betas = b);
} else
(this.w = y.transpose()),
(this.s = l.transpose().mmul(l).sqrt()),
(this.t = u ? l.clone().div(this.s.get(0, 0)) : l),
(this.xResidual = r.sub(l.mmul(y.transpose())));
});
},
}).default;
});
//# sourceMappingURL=radialLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/extends/layout/randomLayout.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.RandomLayout = e())
: (t.RandomLayout = e());
})(this, function () {
return (function (t) {
var e = {};
function o(n) {
if (e[n]) return e[n].exports;
var r = (e[n] = { i: n, l: !1, exports: {} });
return t[n].call(r.exports, r, r.exports, o), (r.l = !0), r.exports;
}
return (
(o.m = t),
(o.c = e),
(o.d = function (t, e, n) {
o.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: n });
}),
(o.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(o.t = function (t, e) {
if ((1 & e && (t = o(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var n = Object.create(null);
if (
(o.r(n),
Object.defineProperty(n, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var r in t)
o.d(
n,
r,
function (e) {
return t[e];
}.bind(null, r),
);
return n;
}),
(o.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return o.d(e, "a", e), e;
}),
(o.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(o.p = ""),
o((o.s = 394))
);
})({
394: function (t, e, o) {
"use strict";
o.r(e);
var n = o(52);
e.default = n.RandomLayout;
},
52: function (t, e, o) {
"use strict";
var n,
r =
((n = function (t, e) {
return (n =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var o in e)
Object.prototype.hasOwnProperty.call(e, o) && (t[o] = e[o]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function o() {
this.constructor = t;
}
n(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((o.prototype = e.prototype), new o()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.RandomLayout = void 0);
var i = (function (t) {
function e(e) {
var o = t.call(this) || this;
return (
(o.center = [0, 0]),
(o.width = 300),
(o.height = 300),
(o.nodes = []),
(o.edges = []),
(o.onLayoutEnd = function () {}),
o.updateCfg(e),
o
);
}
return (
r(e, t),
(e.prototype.getDefaultCfg = function () {
return { center: [0, 0], width: 300, height: 300 };
}),
(e.prototype.execute = function () {
var t = this,
e = t.nodes,
o = t.center;
return (
t.width ||
"undefined" == typeof window ||
(t.width = window.innerWidth),
t.height ||
"undefined" == typeof window ||
(t.height = window.innerHeight),
e &&
e.forEach(function (e) {
(e.x = 0.9 * (Math.random() - 0.5) * t.width + o[0]),
(e.y = 0.9 * (Math.random() - 0.5) * t.height + o[1]);
}),
t.onLayoutEnd && t.onLayoutEnd(),
{ nodes: e, edges: this.edges }
);
}),
(e.prototype.getType = function () {
return "random";
}),
e
);
})(o(53).Base);
e.RandomLayout = i;
},
53: function (t, e, o) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var n = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function () {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = n;
},
}).default;
});
//# sourceMappingURL=randomLayout.js.map
================================================
FILE: packages/examples-uniapp/f6/index.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.F6 = e())
: (t.F6 = e());
})(this, function () {
return (function (t) {
var e = {};
function n(r) {
if (e[r]) return e[r].exports;
var i = (e[r] = { i: r, l: !1, exports: {} });
return t[r].call(i.exports, i, i.exports, n), (i.l = !0), i.exports;
}
return (
(n.m = t),
(n.c = e),
(n.d = function (t, e, r) {
n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: r });
}),
(n.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(n.t = function (t, e) {
if ((1 & e && (t = n(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(n.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var i in t)
n.d(
r,
i,
function (e) {
return t[e];
}.bind(null, i),
);
return r;
}),
(n.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return n.d(e, "a", e), e;
}),
(n.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(n.p = ""),
n((n.s = 177))
);
})({
0: function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "contains", function () {
return i;
}),
n.d(e, "includes", function () {
return i;
}),
n.d(e, "difference", function () {
return a;
}),
n.d(e, "find", function () {
return x;
}),
n.d(e, "findIndex", function () {
return w;
}),
n.d(e, "firstValue", function () {
return S;
}),
n.d(e, "flatten", function () {
return O;
}),
n.d(e, "flattenDeep", function () {
return M;
}),
n.d(e, "getRange", function () {
return E;
}),
n.d(e, "pull", function () {
return I;
}),
n.d(e, "pullAt", function () {
return N;
}),
n.d(e, "reduce", function () {
return B;
}),
n.d(e, "remove", function () {
return L;
}),
n.d(e, "sortBy", function () {
return _;
}),
n.d(e, "union", function () {
return F;
}),
n.d(e, "uniq", function () {
return R;
}),
n.d(e, "valuesOfKey", function () {
return Y;
}),
n.d(e, "head", function () {
return X;
}),
n.d(e, "last", function () {
return z;
}),
n.d(e, "startsWith", function () {
return W;
}),
n.d(e, "endsWith", function () {
return q;
}),
n.d(e, "filter", function () {
return o;
}),
n.d(e, "every", function () {
return V;
}),
n.d(e, "some", function () {
return G;
}),
n.d(e, "group", function () {
return K;
}),
n.d(e, "groupBy", function () {
return U;
}),
n.d(e, "groupToMap", function () {
return Z;
}),
n.d(e, "getWrapBehavior", function () {
return $;
}),
n.d(e, "wrapBehavior", function () {
return Q;
}),
n.d(e, "number2color", function () {
return tt;
}),
n.d(e, "parseRadius", function () {
return et;
}),
n.d(e, "clamp", function () {
return nt;
}),
n.d(e, "fixedBase", function () {
return rt;
}),
n.d(e, "isDecimal", function () {
return ot;
}),
n.d(e, "isEven", function () {
return at;
}),
n.d(e, "isInteger", function () {
return st;
}),
n.d(e, "isNegative", function () {
return ct;
}),
n.d(e, "isNumberEqual", function () {
return ut;
}),
n.d(e, "isOdd", function () {
return ht;
}),
n.d(e, "isPositive", function () {
return lt;
}),
n.d(e, "max", function () {
return k;
}),
n.d(e, "maxBy", function () {
return ft;
}),
n.d(e, "min", function () {
return C;
}),
n.d(e, "minBy", function () {
return dt;
}),
n.d(e, "mod", function () {
return pt;
}),
n.d(e, "toDegree", function () {
return vt;
}),
n.d(e, "toInteger", function () {
return yt;
}),
n.d(e, "toRadian", function () {
return bt;
}),
n.d(e, "forIn", function () {
return xt;
}),
n.d(e, "has", function () {
return wt;
}),
n.d(e, "hasKey", function () {
return St;
}),
n.d(e, "hasValue", function () {
return Mt;
}),
n.d(e, "keys", function () {
return g;
}),
n.d(e, "isMatch", function () {
return v;
}),
n.d(e, "values", function () {
return Ot;
}),
n.d(e, "lowerCase", function () {
return Ct;
}),
n.d(e, "lowerFirst", function () {
return Et;
}),
n.d(e, "substitute", function () {
return jt;
}),
n.d(e, "upperCase", function () {
return Pt;
}),
n.d(e, "upperFirst", function () {
return At;
}),
n.d(e, "getType", function () {
return Tt;
}),
n.d(e, "isArguments", function () {
return Nt;
}),
n.d(e, "isArray", function () {
return l;
}),
n.d(e, "isArrayLike", function () {
return r;
}),
n.d(e, "isBoolean", function () {
return Bt;
}),
n.d(e, "isDate", function () {
return Lt;
}),
n.d(e, "isError", function () {
return Dt;
}),
n.d(e, "isFunction", function () {
return u;
}),
n.d(e, "isFinite", function () {
return _t;
}),
n.d(e, "isNil", function () {
return h;
}),
n.d(e, "isNull", function () {
return Rt;
}),
n.d(e, "isNumber", function () {
return it;
}),
n.d(e, "isObject", function () {
return d;
}),
n.d(e, "isObjectLike", function () {
return m;
}),
n.d(e, "isPlainObject", function () {
return b;
}),
n.d(e, "isPrototype", function () {
return Yt;
}),
n.d(e, "isRegExp", function () {
return Xt;
}),
n.d(e, "isString", function () {
return D;
}),
n.d(e, "isType", function () {
return c;
}),
n.d(e, "isUndefined", function () {
return zt;
}),
n.d(e, "isElement", function () {
return Wt;
}),
n.d(e, "requestAnimationFrame", function () {
return qt;
}),
n.d(e, "clearAnimationFrame", function () {
return Vt;
}),
n.d(e, "augment", function () {
return Ut;
}),
n.d(e, "clone", function () {
return Kt;
}),
n.d(e, "debounce", function () {
return $t;
}),
n.d(e, "memoize", function () {
return Qt;
}),
n.d(e, "deepMix", function () {
return te;
}),
n.d(e, "each", function () {
return p;
}),
n.d(e, "extend", function () {
return ee;
}),
n.d(e, "indexOf", function () {
return ne;
}),
n.d(e, "isEmpty", function () {
return ie;
}),
n.d(e, "isEqual", function () {
return oe;
}),
n.d(e, "isEqualWith", function () {
return ae;
}),
n.d(e, "map", function () {
return se;
}),
n.d(e, "mapValues", function () {
return ue;
}),
n.d(e, "mix", function () {
return Ht;
}),
n.d(e, "assign", function () {
return Ht;
}),
n.d(e, "get", function () {
return he;
}),
n.d(e, "set", function () {
return le;
}),
n.d(e, "pick", function () {
return de;
}),
n.d(e, "omit", function () {
return pe;
}),
n.d(e, "throttle", function () {
return ge;
}),
n.d(e, "toArray", function () {
return ve;
}),
n.d(e, "toString", function () {
return kt;
}),
n.d(e, "uniqueId", function () {
return me;
}),
n.d(e, "noop", function () {
return be;
}),
n.d(e, "identity", function () {
return xe;
}),
n.d(e, "size", function () {
return we;
}),
n.d(e, "measureTextWidth", function () {
return Me;
}),
n.d(e, "getEllipsisText", function () {
return ke;
}),
n.d(e, "Cache", function () {
return Ce;
});
var r = function (t) {
return null !== t && "function" != typeof t && isFinite(t.length);
},
i = function (t, e) {
return !!r(t) && t.indexOf(e) > -1;
},
o = function (t, e) {
if (!r(t)) return t;
for (var n = [], i = 0; i < t.length; i++) {
var o = t[i];
e(o, i) && n.push(o);
}
return n;
},
a = function (t, e) {
return (
void 0 === e && (e = []),
o(t, function (t) {
return !i(e, t);
})
);
},
s = {}.toString,
c = function (t, e) {
return s.call(t) === "[object " + e + "]";
},
u = function (t) {
return c(t, "Function");
},
h = function (t) {
return null == t;
},
l = function (t) {
return Array.isArray ? Array.isArray(t) : c(t, "Array");
};
function f(t) {
return (f =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var d = function (t) {
var e = f(t);
return (null !== t && "object" === e) || "function" === e;
};
var p = function (t, e) {
if (t)
if (l(t))
for (var n = 0, r = t.length; n < r && !1 !== e(t[n], n); n++);
else if (d(t))
for (var i in t)
if (t.hasOwnProperty(i) && !1 === e(t[i], i)) break;
},
g = Object.keys
? function (t) {
return Object.keys(t);
}
: function (t) {
var e = [];
return (
p(t, function (n, r) {
(u(t) && "prototype" === r) || e.push(r);
}),
e
);
};
var v = function (t, e) {
var n = g(e),
r = n.length;
if (h(t)) return !r;
for (var i = 0; i < r; i += 1) {
var o = n[i];
if (e[o] !== t[o] || !(o in t)) return !1;
}
return !0;
};
function y(t) {
return (y =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var m = function (t) {
return "object" === y(t) && null !== t;
},
b = function (t) {
if (!m(t) || !c(t, "Object")) return !1;
if (null === Object.getPrototypeOf(t)) return !0;
for (var e = t; null !== Object.getPrototypeOf(e); )
e = Object.getPrototypeOf(e);
return Object.getPrototypeOf(t) === e;
};
var x = function (t, e) {
if (!l(t)) return null;
var n;
if (
(u(e) && (n = e),
b(e) &&
(n = function (t) {
return v(t, e);
}),
n)
)
for (var r = 0; r < t.length; r += 1) if (n(t[r])) return t[r];
return null;
};
var w = function (t, e, n) {
void 0 === n && (n = 0);
for (var r = n; r < t.length; r++) if (e(t[r], r)) return r;
return -1;
},
S = function (t, e) {
for (var n = null, r = 0; r < t.length; r++) {
var i = t[r][e];
if (!h(i)) {
n = l(i) ? i[0] : i;
break;
}
}
return n;
},
O = function (t) {
if (!l(t)) return [];
for (var e = [], n = 0; n < t.length; n++) e = e.concat(t[n]);
return e;
},
M = function t(e, n) {
if ((void 0 === n && (n = []), l(e)))
for (var r = 0; r < e.length; r += 1) t(e[r], n);
else n.push(e);
return n;
},
k = function (t) {
if (l(t))
return t.reduce(function (t, e) {
return Math.max(t, e);
}, t[0]);
},
C = function (t) {
if (l(t))
return t.reduce(function (t, e) {
return Math.min(t, e);
}, t[0]);
},
E = function (t) {
var e = t.filter(function (t) {
return !isNaN(t);
});
if (!e.length) return { min: 0, max: 0 };
if (l(t[0])) {
for (var n = [], r = 0; r < t.length; r++) n = n.concat(t[r]);
e = n;
}
var i = k(e);
return { min: C(e), max: i };
},
j = Array.prototype,
P = j.splice,
A = j.indexOf,
I = function (t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
for (var r = 0; r < e.length; r++)
for (var i = e[r], o = -1; (o = A.call(t, i)) > -1; )
P.call(t, o, 1);
return t;
},
T = Array.prototype.splice,
N = function (t, e) {
if (!r(t)) return [];
for (var n = t ? e.length : 0, i = n - 1; n--; ) {
var o = void 0,
a = e[n];
(n !== i && a === o) || ((o = a), T.call(t, a, 1));
}
return t;
},
B = function (t, e, n) {
if (!l(t) && !b(t)) return t;
var r = n;
return (
p(t, function (t, n) {
r = e(r, t, n);
}),
r
);
},
L = function (t, e) {
var n = [];
if (!r(t)) return n;
for (var i = -1, o = [], a = t.length; ++i < a; ) {
var s = t[i];
e(s, i, t) && (n.push(s), o.push(i));
}
return N(t, o), n;
},
D = function (t) {
return c(t, "String");
};
var _ = function (t, e) {
var n;
if (u(e))
n = function (t, n) {
return e(t) - e(n);
};
else {
var r = [];
D(e) ? r.push(e) : l(e) && (r = e),
(n = function (t, e) {
for (var n = 0; n < r.length; n += 1) {
var i = r[n];
if (t[i] > e[i]) return 1;
if (t[i] < e[i]) return -1;
}
return 0;
});
}
return t.sort(n), t;
};
function R(t, e) {
void 0 === e && (e = new Map());
var n = [];
if (Array.isArray(t))
for (var r = 0, i = t.length; r < i; r++) {
var o = t[r];
e.has(o) || (n.push(o), e.set(o, !0));
}
return n;
}
var F = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
return R([].concat.apply([], t));
},
Y = function (t, e) {
for (var n = [], r = {}, i = 0; i < t.length; i++) {
var o = t[i][e];
if (!h(o)) {
l(o) || (o = [o]);
for (var a = 0; a < o.length; a++) {
var s = o[a];
r[s] || (n.push(s), (r[s] = !0));
}
}
}
return n;
};
function X(t) {
if (r(t)) return t[0];
}
function z(t) {
if (r(t)) {
return t[t.length - 1];
}
}
var W = function (t, e) {
return !(!l(t) && !D(t)) && t[0] === e;
};
var q = function (t, e) {
return !(!l(t) && !D(t)) && t[t.length - 1] === e;
},
V = function (t, e) {
for (var n = 0; n < t.length; n++) if (!e(t[n], n)) return !1;
return !0;
},
G = function (t, e) {
for (var n = 0; n < t.length; n++) if (e(t[n], n)) return !0;
return !1;
},
H = Object.prototype.hasOwnProperty;
var U = function (t, e) {
if (!e || !l(t)) return {};
for (
var n,
r = {},
i = u(e)
? e
: function (t) {
return t[e];
},
o = 0;
o < t.length;
o++
) {
var a = t[o];
(n = i(a)), H.call(r, n) ? r[n].push(a) : (r[n] = [a]);
}
return r;
};
function Z(t, e) {
if (!e) return { 0: t };
if (!u(e)) {
var n = l(e) ? e : e.replace(/\s+/g, "").split("*");
e = function (t) {
for (var e = "_", r = 0, i = n.length; r < i; r++)
e += t[n[r]] && t[n[r]].toString();
return e;
};
}
return U(t, e);
}
var K = function (t, e) {
if (!e) return [t];
var n = Z(t, e),
r = [];
for (var i in n) r.push(n[i]);
return r;
};
var $ = function (t, e) {
return t["_wrap_" + e];
};
var Q = function (t, e) {
if (t["_wrap_" + e]) return t["_wrap_" + e];
var n = function (n) {
t[e](n);
};
return (t["_wrap_" + e] = n), n;
},
J = {};
var tt = function (t) {
var e = J[t];
if (!e) {
for (var n = t.toString(16), r = n.length; r < 6; r++) n = "0" + n;
(e = "#" + n), (J[t] = e);
}
return e;
};
var et = function (t) {
var e = 0,
n = 0,
r = 0,
i = 0;
return (
l(t)
? 1 === t.length
? (e = n = r = i = t[0])
: 2 === t.length
? ((e = r = t[0]), (n = i = t[1]))
: 3 === t.length
? ((e = t[0]), (n = i = t[1]), (r = t[2]))
: ((e = t[0]), (n = t[1]), (r = t[2]), (i = t[3]))
: (e = n = r = i = t),
{ r1: e, r2: n, r3: r, r4: i }
);
},
nt = function (t, e, n) {
return t < e ? e : t > n ? n : t;
},
rt = function (t, e) {
var n = e.toString(),
r = n.indexOf(".");
if (-1 === r) return Math.round(t);
var i = n.substr(r + 1).length;
return i > 20 && (i = 20), parseFloat(t.toFixed(i));
},
it = function (t) {
return c(t, "Number");
},
ot = function (t) {
return it(t) && t % 1 != 0;
},
at = function (t) {
return it(t) && t % 2 == 0;
},
st = Number.isInteger
? Number.isInteger
: function (t) {
return it(t) && t % 1 == 0;
},
ct = function (t) {
return it(t) && t < 0;
};
function ut(t, e, n) {
return void 0 === n && (n = 1e-5), Math.abs(t - e) < n;
}
var ht = function (t) {
return it(t) && t % 2 != 0;
},
lt = function (t) {
return it(t) && t > 0;
},
ft = function (t, e) {
if (l(t)) {
for (var n, r = -1 / 0, i = 0; i < t.length; i++) {
var o = t[i],
a = u(e) ? e(o) : o[e];
a > r && ((n = o), (r = a));
}
return n;
}
},
dt = function (t, e) {
if (l(t)) {
for (var n, r = 1 / 0, i = 0; i < t.length; i++) {
var o = t[i],
a = u(e) ? e(o) : o[e];
a < r && ((n = o), (r = a));
}
return n;
}
},
pt = function (t, e) {
return ((t % e) + e) % e;
},
gt = 180 / Math.PI,
vt = function (t) {
return gt * t;
},
yt = parseInt,
mt = Math.PI / 180,
bt = function (t) {
return mt * t;
},
xt = p,
wt = function (t, e) {
return t.hasOwnProperty(e);
},
St = wt,
Ot = Object.values
? function (t) {
return Object.values(t);
}
: function (t) {
var e = [];
return (
p(t, function (n, r) {
(u(t) && "prototype" === r) || e.push(n);
}),
e
);
},
Mt = function (t, e) {
return i(Ot(t), e);
},
kt = function (t) {
return h(t) ? "" : t.toString();
},
Ct = function (t) {
return kt(t).toLowerCase();
},
Et = function (t) {
var e = kt(t);
return e.charAt(0).toLowerCase() + e.substring(1);
};
var jt = function (t, e) {
return t && e
? t.replace(/\\?\{([^{}]+)\}/g, function (t, n) {
return "\\" === t.charAt(0)
? t.slice(1)
: void 0 === e[n]
? ""
: e[n];
})
: t;
},
Pt = function (t) {
return kt(t).toUpperCase();
},
At = function (t) {
var e = kt(t);
return e.charAt(0).toUpperCase() + e.substring(1);
},
It = {}.toString,
Tt = function (t) {
return It.call(t)
.replace(/^\[object /, "")
.replace(/]$/, "");
},
Nt = function (t) {
return c(t, "Arguments");
},
Bt = function (t) {
return c(t, "Boolean");
},
Lt = function (t) {
return c(t, "Date");
},
Dt = function (t) {
return c(t, "Error");
},
_t = function (t) {
return it(t) && isFinite(t);
},
Rt = function (t) {
return null === t;
},
Ft = Object.prototype,
Yt = function (t) {
var e = t && t.constructor;
return t === (("function" == typeof e && e.prototype) || Ft);
},
Xt = function (t) {
return c(t, "RegExp");
},
zt = function (t) {
return void 0 === t;
},
Wt = function (t) {
return t instanceof Element || t instanceof HTMLDocument;
};
function qt(t) {
return (
window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
window.msRequestAnimationFrame ||
function (t) {
return setTimeout(t, 16);
}
)(t);
}
function Vt(t) {
(
window.cancelAnimationFrame ||
window.webkitCancelAnimationFrame ||
window.mozCancelAnimationFrame ||
window.msCancelAnimationFrame ||
clearTimeout
)(t);
}
function Gt(t, e) {
for (var n in e)
e.hasOwnProperty(n) &&
"constructor" !== n &&
void 0 !== e[n] &&
(t[n] = e[n]);
}
function Ht(t, e, n, r) {
return e && Gt(t, e), n && Gt(t, n), r && Gt(t, r), t;
}
var Ut = function () {
for (var t = [], e = 0; e < arguments.length; e++) t[e] = arguments[e];
for (var n = t[0], r = 1; r < t.length; r++) {
var i = t[r];
u(i) && (i = i.prototype), Ht(n.prototype, i);
}
};
function Zt(t) {
return (Zt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var Kt = function t(e) {
if ("object" !== Zt(e) || null === e) return e;
var n;
if (l(e)) {
n = [];
for (var r = 0, i = e.length; r < i; r++)
"object" === Zt(e[r]) && null != e[r]
? (n[r] = t(e[r]))
: (n[r] = e[r]);
} else
for (var o in ((n = {}), e))
"object" === Zt(e[o]) && null != e[o]
? (n[o] = t(e[o]))
: (n[o] = e[o]);
return n;
};
var $t = function (t, e, n) {
var r;
return function () {
var i = this,
o = arguments,
a = function () {
(r = null), n || t.apply(i, o);
},
s = n && !r;
clearTimeout(r), (r = setTimeout(a, e)), s && t.apply(i, o);
};
},
Qt = function (t, e) {
if (!u(t)) throw new TypeError("Expected a function");
var n = function n() {
for (var r = [], i = 0; i < arguments.length; i++)
r[i] = arguments[i];
var o = e ? e.apply(this, r) : r[0],
a = n.cache;
if (a.has(o)) return a.get(o);
var s = t.apply(this, r);
return a.set(o, s), s;
};
return (n.cache = new Map()), n;
};
function Jt(t, e, n, r) {
for (var i in ((n = n || 0), (r = r || 5), e))
if (e.hasOwnProperty(i)) {
var o = e[i];
null !== o && b(o)
? (b(t[i]) || (t[i] = {}),
n < r ? Jt(t[i], o, n + 1, r) : (t[i] = e[i]))
: l(o)
? ((t[i] = []), (t[i] = t[i].concat(o)))
: void 0 !== o && (t[i] = o);
}
}
var te = function (t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
for (var r = 0; r < e.length; r += 1) Jt(t, e[r]);
return t;
},
ee = function (t, e, n, r) {
u(e) || ((n = e), (e = t), (t = function () {}));
var i = Object.create
? function (t, e) {
return Object.create(t, { constructor: { value: e } });
}
: function (t, e) {
function n() {}
n.prototype = t;
var r = new n();
return (r.constructor = e), r;
},
o = i(e.prototype, t);
return (
(t.prototype = Ht(o, t.prototype)),
(t.superclass = i(e.prototype, e)),
Ht(o, n),
Ht(t, r),
t
);
},
ne = function (t, e) {
if (!r(t)) return -1;
var n = Array.prototype.indexOf;
if (n) return n.call(t, e);
for (var i = -1, o = 0; o < t.length; o++)
if (t[o] === e) {
i = o;
break;
}
return i;
},
re = Object.prototype.hasOwnProperty;
var ie = function (t) {
if (h(t)) return !0;
if (r(t)) return !t.length;
var e = Tt(t);
if ("Map" === e || "Set" === e) return !t.size;
if (Yt(t)) return !Object.keys(t).length;
for (var n in t) if (re.call(t, n)) return !1;
return !0;
},
oe = function t(e, n) {
if (e === n) return !0;
if (!e || !n) return !1;
if (D(e) || D(n)) return !1;
if (r(e) || r(n)) {
if (e.length !== n.length) return !1;
for (var i = !0, o = 0; o < e.length && (i = t(e[o], n[o])); o++);
return i;
}
if (m(e) || m(n)) {
var a = Object.keys(e),
s = Object.keys(n);
if (a.length !== s.length) return !1;
for (i = !0, o = 0; o < a.length && (i = t(e[a[o]], n[a[o]])); o++);
return i;
}
return !1;
},
ae = function (t, e, n) {
return u(n) ? !!n(t, e) : oe(t, e);
},
se = function (t, e) {
if (!r(t)) return t;
for (var n = [], i = 0; i < t.length; i++) {
var o = t[i];
n.push(e(o, i));
}
return n;
},
ce = function (t) {
return t;
},
ue = function (t, e) {
void 0 === e && (e = ce);
var n = {};
return (
d(t) &&
!h(t) &&
Object.keys(t).forEach(function (r) {
n[r] = e(t[r], r);
}),
n
);
},
he = function (t, e, n) {
for (var r = 0, i = D(e) ? e.split(".") : e; t && r < i.length; )
t = t[i[r++]];
return void 0 === t || r < i.length ? n : t;
},
le = function (t, e, n) {
var r = t,
i = D(e) ? e.split(".") : e;
return (
i.forEach(function (t, e) {
e < i.length - 1
? (d(r[t]) || (r[t] = it(i[e + 1]) ? [] : {}), (r = r[t]))
: (r[t] = n);
}),
t
);
},
fe = Object.prototype.hasOwnProperty,
de = function (t, e) {
if (null === t || !b(t)) return {};
var n = {};
return (
p(e, function (e) {
fe.call(t, e) && (n[e] = t[e]);
}),
n
);
},
pe = function (t, e) {
return B(
t,
function (t, n, r) {
return e.includes(r) || (t[r] = n), t;
},
{},
);
},
ge = function (t, e, n) {
var r,
i,
o,
a,
s = 0;
n || (n = {});
var c = function () {
(s = !1 === n.leading ? 0 : Date.now()),
(r = null),
(a = t.apply(i, o)),
r || (i = o = null);
},
u = function () {
var u = Date.now();
s || !1 !== n.leading || (s = u);
var h = e - (u - s);
return (
(i = this),
(o = arguments),
h <= 0 || h > e
? (r && (clearTimeout(r), (r = null)),
(s = u),
(a = t.apply(i, o)),
r || (i = o = null))
: r || !1 === n.trailing || (r = setTimeout(c, h)),
a
);
};
return (
(u.cancel = function () {
clearTimeout(r), (s = 0), (r = i = o = null);
}),
u
);
},
ve = function (t) {
return r(t) ? Array.prototype.slice.call(t) : [];
},
ye = {},
me = function (t) {
return ye[(t = t || "g")] ? (ye[t] += 1) : (ye[t] = 1), t + ye[t];
},
be = function () {},
xe = function (t) {
return t;
};
function we(t) {
return h(t) ? 0 : r(t) ? t.length : Object.keys(t).length;
}
var Se,
Oe = n(1),
Me = Qt(
function (t, e) {
void 0 === e && (e = {});
var n = e.fontSize,
r = e.fontFamily,
i = e.fontWeight,
o = e.fontStyle,
a = e.fontVariant;
return (
Se || (Se = document.createElement("canvas").getContext("2d")),
(Se.font = [o, a, i, n + "px", r].join(" ")),
Se.measureText(D(t) ? t : "").width
);
},
function (t, e) {
return void 0 === e && (e = {}), Object(Oe.g)([t], Ot(e)).join("");
},
),
ke = function (t, e, n, r) {
void 0 === r && (r = "...");
var i,
o,
a = Me(r, n),
s = D(t) ? t : kt(t),
c = e,
u = [];
if (Me(t, n) <= e) return t;
for (; (i = s.substr(0, 16)), !((o = Me(i, n)) + a > c && o > c); )
if ((u.push(i), (c -= o), !(s = s.substr(16)))) return u.join("");
for (; (i = s.substr(0, 1)), !((o = Me(i, n)) + a > c); )
if ((u.push(i), (c -= o), !(s = s.substr(1)))) return u.join("");
return "" + u.join("") + r;
},
Ce = (function () {
function t() {
this.map = {};
}
return (
(t.prototype.has = function (t) {
return void 0 !== this.map[t];
}),
(t.prototype.get = function (t, e) {
var n = this.map[t];
return void 0 === n ? e : n;
}),
(t.prototype.set = function (t, e) {
this.map[t] = e;
}),
(t.prototype.clear = function () {
this.map = {};
}),
(t.prototype.delete = function (t) {
delete this.map[t];
}),
(t.prototype.size = function () {
return Object.keys(this.map).length;
}),
t
);
})();
},
1: function (t, e, n) {
"use strict";
n.d(e, "c", function () {
return i;
}),
n.d(e, "a", function () {
return o;
}),
n.d(e, "e", function () {
return a;
}),
n.d(e, "b", function () {
return s;
}),
n.d(e, "d", function () {
return c;
}),
n.d(e, "g", function () {
return u;
}),
n.d(e, "f", function () {
return h;
});
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
};
function i(t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
}
var o = function () {
return (o =
Object.assign ||
function (t) {
for (var e, n = 1, r = arguments.length; n < r; n++)
for (var i in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
return t;
}).apply(this, arguments);
};
function a(t, e) {
var n = {};
for (var r in t)
Object.prototype.hasOwnProperty.call(t, r) &&
e.indexOf(r) < 0 &&
(n[r] = t[r]);
if (null != t && "function" == typeof Object.getOwnPropertySymbols) {
var i = 0;
for (r = Object.getOwnPropertySymbols(t); i < r.length; i++)
e.indexOf(r[i]) < 0 &&
Object.prototype.propertyIsEnumerable.call(t, r[i]) &&
(n[r[i]] = t[r[i]]);
}
return n;
}
function s(t, e, n, r) {
return new (n || (n = Promise))(function (i, o) {
function a(t) {
try {
c(r.next(t));
} catch (t) {
o(t);
}
}
function s(t) {
try {
c(r.throw(t));
} catch (t) {
o(t);
}
}
function c(t) {
var e;
t.done
? i(t.value)
: ((e = t.value),
e instanceof n
? e
: new n(function (t) {
t(e);
})).then(a, s);
}
c((r = r.apply(t, e || [])).next());
});
}
function c(t, e) {
var n,
r,
i,
o,
a = {
label: 0,
sent: function () {
if (1 & i[0]) throw i[1];
return i[1];
},
trys: [],
ops: [],
};
return (
(o = { next: s(0), throw: s(1), return: s(2) }),
"function" == typeof Symbol &&
(o[Symbol.iterator] = function () {
return this;
}),
o
);
function s(o) {
return function (s) {
return (function (o) {
if (n) throw new TypeError("Generator is already executing.");
for (; a; )
try {
if (
((n = 1),
r &&
(i =
2 & o[0]
? r.return
: o[0]
? r.throw || ((i = r.return) && i.call(r), 0)
: r.next) &&
!(i = i.call(r, o[1])).done)
)
return i;
switch (((r = 0), i && (o = [2 & o[0], i.value]), o[0])) {
case 0:
case 1:
i = o;
break;
case 4:
return a.label++, { value: o[1], done: !1 };
case 5:
a.label++, (r = o[1]), (o = [0]);
continue;
case 7:
(o = a.ops.pop()), a.trys.pop();
continue;
default:
if (
!((i = a.trys),
(i = i.length > 0 && i[i.length - 1]) ||
(6 !== o[0] && 2 !== o[0]))
) {
a = 0;
continue;
}
if (3 === o[0] && (!i || (o[1] > i[0] && o[1] < i[3]))) {
a.label = o[1];
break;
}
if (6 === o[0] && a.label < i[1]) {
(a.label = i[1]), (i = o);
break;
}
if (i && a.label < i[2]) {
(a.label = i[2]), a.ops.push(o);
break;
}
i[2] && a.ops.pop(), a.trys.pop();
continue;
}
o = e.call(t, a);
} catch (t) {
(o = [6, t]), (r = 0);
} finally {
n = i = 0;
}
if (5 & o[0]) throw o[1];
return { value: o[0] ? o[1] : void 0, done: !0 };
})([o, s]);
};
}
}
Object.create;
function u() {
for (var t = 0, e = 0, n = arguments.length; e < n; e++)
t += arguments[e].length;
var r = Array(t),
i = 0;
for (e = 0; e < n; e++)
for (var o = arguments[e], a = 0, s = o.length; a < s; a++, i++)
r[i] = o[a];
return r;
}
function h(t, e, n) {
if (n || 2 === arguments.length)
for (var r, i = 0, o = e.length; i < o; i++)
(!r && i in e) ||
(r || (r = Array.prototype.slice.call(e, 0, i)), (r[i] = e[i]));
return t.concat(r || Array.prototype.slice.call(e));
}
Object.create;
},
100: function (t, e, n) {
"use strict";
var r = n(186),
i = {};
for (var o in r) r.hasOwnProperty(o) && (i[r[o]] = o);
var a = (t.exports = {
rgb: { channels: 3, labels: "rgb" },
hsl: { channels: 3, labels: "hsl" },
hsv: { channels: 3, labels: "hsv" },
hwb: { channels: 3, labels: "hwb" },
cmyk: { channels: 4, labels: "cmyk" },
xyz: { channels: 3, labels: "xyz" },
lab: { channels: 3, labels: "lab" },
lch: { channels: 3, labels: "lch" },
hex: { channels: 1, labels: ["hex"] },
keyword: { channels: 1, labels: ["keyword"] },
ansi16: { channels: 1, labels: ["ansi16"] },
ansi256: { channels: 1, labels: ["ansi256"] },
hcg: { channels: 3, labels: ["h", "c", "g"] },
apple: { channels: 3, labels: ["r16", "g16", "b16"] },
gray: { channels: 1, labels: ["gray"] },
});
for (var s in a)
if (a.hasOwnProperty(s)) {
if (!("channels" in a[s]))
throw new Error("missing channels property: " + s);
if (!("labels" in a[s]))
throw new Error("missing channel labels property: " + s);
if (a[s].labels.length !== a[s].channels)
throw new Error("channel and label counts mismatch: " + s);
var c = a[s].channels,
u = a[s].labels;
delete a[s].channels,
delete a[s].labels,
Object.defineProperty(a[s], "channels", { value: c }),
Object.defineProperty(a[s], "labels", { value: u });
}
function h(t, e) {
return (
Math.pow(t[0] - e[0], 2) +
Math.pow(t[1] - e[1], 2) +
Math.pow(t[2] - e[2], 2)
);
}
(a.rgb.hsl = function (t) {
var e,
n,
r = t[0] / 255,
i = t[1] / 255,
o = t[2] / 255,
a = Math.min(r, i, o),
s = Math.max(r, i, o),
c = s - a;
return (
s === a
? (e = 0)
: r === s
? (e = (i - o) / c)
: i === s
? (e = 2 + (o - r) / c)
: o === s && (e = 4 + (r - i) / c),
(e = Math.min(60 * e, 360)) < 0 && (e += 360),
(n = (a + s) / 2),
[
e,
100 * (s === a ? 0 : n <= 0.5 ? c / (s + a) : c / (2 - s - a)),
100 * n,
]
);
}),
(a.rgb.hsv = function (t) {
var e,
n,
r,
i,
o,
a = t[0] / 255,
s = t[1] / 255,
c = t[2] / 255,
u = Math.max(a, s, c),
h = u - Math.min(a, s, c),
l = function (t) {
return (u - t) / 6 / h + 0.5;
};
return (
0 === h
? (i = o = 0)
: ((o = h / u),
(e = l(a)),
(n = l(s)),
(r = l(c)),
a === u
? (i = r - n)
: s === u
? (i = 1 / 3 + e - r)
: c === u && (i = 2 / 3 + n - e),
i < 0 ? (i += 1) : i > 1 && (i -= 1)),
[360 * i, 100 * o, 100 * u]
);
}),
(a.rgb.hwb = function (t) {
var e = t[0],
n = t[1],
r = t[2];
return [
a.rgb.hsl(t)[0],
(1 / 255) * Math.min(e, Math.min(n, r)) * 100,
100 * (r = 1 - (1 / 255) * Math.max(e, Math.max(n, r))),
];
}),
(a.rgb.cmyk = function (t) {
var e = t[0] / 255,
n = t[1] / 255,
r = t[2] / 255,
i = Math.min(1 - e, 1 - n, 1 - r);
return [
100 * ((1 - e - i) / (1 - i) || 0),
100 * ((1 - n - i) / (1 - i) || 0),
100 * ((1 - r - i) / (1 - i) || 0),
100 * i,
];
}),
(a.rgb.keyword = function (t) {
var e,
n = i[t];
if (n) return n;
var o,
a = 1 / 0;
for (var s in r)
r.hasOwnProperty(s) && (e = h(t, r[s])) < a && ((a = e), (o = s));
return o;
}),
(a.keyword.rgb = function (t) {
return r[t];
}),
(a.rgb.xyz = function (t) {
var e = t[0] / 255,
n = t[1] / 255,
r = t[2] / 255;
return [
100 *
(0.4124 *
(e =
e > 0.04045
? Math.pow((e + 0.055) / 1.055, 2.4)
: e / 12.92) +
0.3576 *
(n =
n > 0.04045
? Math.pow((n + 0.055) / 1.055, 2.4)
: n / 12.92) +
0.1805 *
(r =
r > 0.04045
? Math.pow((r + 0.055) / 1.055, 2.4)
: r / 12.92)),
100 * (0.2126 * e + 0.7152 * n + 0.0722 * r),
100 * (0.0193 * e + 0.1192 * n + 0.9505 * r),
];
}),
(a.rgb.lab = function (t) {
var e = a.rgb.xyz(t),
n = e[0],
r = e[1],
i = e[2];
return (
(r /= 100),
(i /= 108.883),
(n =
(n /= 95.047) > 0.008856
? Math.pow(n, 1 / 3)
: 7.787 * n + 16 / 116),
[
116 *
(r = r > 0.008856 ? Math.pow(r, 1 / 3) : 7.787 * r + 16 / 116) -
16,
500 * (n - r),
200 *
(r -
(i =
i > 0.008856 ? Math.pow(i, 1 / 3) : 7.787 * i + 16 / 116)),
]
);
}),
(a.hsl.rgb = function (t) {
var e,
n,
r,
i,
o,
a,
s = t[0] / 360,
c = t[1] / 100,
u = t[2] / 100;
if (0 === c) return [(a = 255 * u), a, a];
for (
n = 2 * u - (r = u < 0.5 ? u * (1 + c) : u + c - u * c),
o = [0, 0, 0],
e = 0;
e < 3;
e++
)
(i = s + (1 / 3) * -(e - 1)) < 0 && i++,
i > 1 && i--,
(a =
6 * i < 1
? n + 6 * (r - n) * i
: 2 * i < 1
? r
: 3 * i < 2
? n + (r - n) * (2 / 3 - i) * 6
: n),
(o[e] = 255 * a);
return o;
}),
(a.hsl.hsv = function (t) {
var e = t[0],
n = t[1] / 100,
r = t[2] / 100,
i = n,
o = Math.max(r, 0.01);
return (
(n *= (r *= 2) <= 1 ? r : 2 - r),
(i *= o <= 1 ? o : 2 - o),
[
e,
100 * (0 === r ? (2 * i) / (o + i) : (2 * n) / (r + n)),
((r + n) / 2) * 100,
]
);
}),
(a.hsv.rgb = function (t) {
var e = t[0] / 60,
n = t[1] / 100,
r = t[2] / 100,
i = Math.floor(e) % 6,
o = e - Math.floor(e),
a = 255 * r * (1 - n),
s = 255 * r * (1 - n * o),
c = 255 * r * (1 - n * (1 - o));
switch (((r *= 255), i)) {
case 0:
return [r, c, a];
case 1:
return [s, r, a];
case 2:
return [a, r, c];
case 3:
return [a, s, r];
case 4:
return [c, a, r];
case 5:
return [r, a, s];
}
}),
(a.hsv.hsl = function (t) {
var e,
n,
r = t[0],
i = t[1] / 100,
o = t[2] / 100,
a = Math.max(o, 0.01),
s = (2 - i) * o;
return (
(n = i * a),
[
r,
100 * (n = (n /= (e = (2 - i) * a) <= 1 ? e : 2 - e) || 0),
100 * (s /= 2),
]
);
}),
(a.hwb.rgb = function (t) {
var e,
n,
r,
i,
o,
a,
s,
c = t[0] / 360,
u = t[1] / 100,
h = t[2] / 100,
l = u + h;
switch (
(l > 1 && ((u /= l), (h /= l)),
(r = 6 * c - (e = Math.floor(6 * c))),
0 != (1 & e) && (r = 1 - r),
(i = u + r * ((n = 1 - h) - u)),
e)
) {
default:
case 6:
case 0:
(o = n), (a = i), (s = u);
break;
case 1:
(o = i), (a = n), (s = u);
break;
case 2:
(o = u), (a = n), (s = i);
break;
case 3:
(o = u), (a = i), (s = n);
break;
case 4:
(o = i), (a = u), (s = n);
break;
case 5:
(o = n), (a = u), (s = i);
}
return [255 * o, 255 * a, 255 * s];
}),
(a.cmyk.rgb = function (t) {
var e = t[0] / 100,
n = t[1] / 100,
r = t[2] / 100,
i = t[3] / 100;
return [
255 * (1 - Math.min(1, e * (1 - i) + i)),
255 * (1 - Math.min(1, n * (1 - i) + i)),
255 * (1 - Math.min(1, r * (1 - i) + i)),
];
}),
(a.xyz.rgb = function (t) {
var e,
n,
r,
i = t[0] / 100,
o = t[1] / 100,
a = t[2] / 100;
return (
(n = -0.9689 * i + 1.8758 * o + 0.0415 * a),
(r = 0.0557 * i + -0.204 * o + 1.057 * a),
(e =
(e = 3.2406 * i + -1.5372 * o + -0.4986 * a) > 0.0031308
? 1.055 * Math.pow(e, 1 / 2.4) - 0.055
: 12.92 * e),
(n =
n > 0.0031308 ? 1.055 * Math.pow(n, 1 / 2.4) - 0.055 : 12.92 * n),
(r =
r > 0.0031308 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : 12.92 * r),
[
255 * (e = Math.min(Math.max(0, e), 1)),
255 * (n = Math.min(Math.max(0, n), 1)),
255 * (r = Math.min(Math.max(0, r), 1)),
]
);
}),
(a.xyz.lab = function (t) {
var e = t[0],
n = t[1],
r = t[2];
return (
(n /= 100),
(r /= 108.883),
(e =
(e /= 95.047) > 0.008856
? Math.pow(e, 1 / 3)
: 7.787 * e + 16 / 116),
[
116 *
(n = n > 0.008856 ? Math.pow(n, 1 / 3) : 7.787 * n + 16 / 116) -
16,
500 * (e - n),
200 *
(n -
(r =
r > 0.008856 ? Math.pow(r, 1 / 3) : 7.787 * r + 16 / 116)),
]
);
}),
(a.lab.xyz = function (t) {
var e,
n,
r,
i = t[0];
(e = t[1] / 500 + (n = (i + 16) / 116)), (r = n - t[2] / 200);
var o = Math.pow(n, 3),
a = Math.pow(e, 3),
s = Math.pow(r, 3);
return (
(n = o > 0.008856 ? o : (n - 16 / 116) / 7.787),
(e = a > 0.008856 ? a : (e - 16 / 116) / 7.787),
(r = s > 0.008856 ? s : (r - 16 / 116) / 7.787),
[(e *= 95.047), (n *= 100), (r *= 108.883)]
);
}),
(a.lab.lch = function (t) {
var e,
n = t[0],
r = t[1],
i = t[2];
return (
(e = (360 * Math.atan2(i, r)) / 2 / Math.PI) < 0 && (e += 360),
[n, Math.sqrt(r * r + i * i), e]
);
}),
(a.lch.lab = function (t) {
var e = t[0],
n = t[1],
r = (t[2] / 360) * 2 * Math.PI;
return [e, n * Math.cos(r), n * Math.sin(r)];
}),
(a.rgb.ansi16 = function (t) {
var e = t[0],
n = t[1],
r = t[2],
i = 1 in arguments ? arguments[1] : a.rgb.hsv(t)[2];
if (0 === (i = Math.round(i / 50))) return 30;
var o =
30 +
((Math.round(r / 255) << 2) |
(Math.round(n / 255) << 1) |
Math.round(e / 255));
return 2 === i && (o += 60), o;
}),
(a.hsv.ansi16 = function (t) {
return a.rgb.ansi16(a.hsv.rgb(t), t[2]);
}),
(a.rgb.ansi256 = function (t) {
var e = t[0],
n = t[1],
r = t[2];
return e === n && n === r
? e < 8
? 16
: e > 248
? 231
: Math.round(((e - 8) / 247) * 24) + 232
: 16 +
36 * Math.round((e / 255) * 5) +
6 * Math.round((n / 255) * 5) +
Math.round((r / 255) * 5);
}),
(a.ansi16.rgb = function (t) {
var e = t % 10;
if (0 === e || 7 === e)
return t > 50 && (e += 3.5), [(e = (e / 10.5) * 255), e, e];
var n = 0.5 * (1 + ~~(t > 50));
return [
(1 & e) * n * 255,
((e >> 1) & 1) * n * 255,
((e >> 2) & 1) * n * 255,
];
}),
(a.ansi256.rgb = function (t) {
return t >= 232
? [(n = 10 * (t - 232) + 8), n, n]
: ((t -= 16),
[
(Math.floor(t / 36) / 5) * 255,
(Math.floor((e = t % 36) / 6) / 5) * 255,
((e % 6) / 5) * 255,
]);
var e, n;
}),
(a.rgb.hex = function (t) {
var e = (
((255 & Math.round(t[0])) << 16) +
((255 & Math.round(t[1])) << 8) +
(255 & Math.round(t[2]))
)
.toString(16)
.toUpperCase();
return "000000".substring(e.length) + e;
}),
(a.hex.rgb = function (t) {
var e = t.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
if (!e) return [0, 0, 0];
var n = e[0];
3 === e[0].length &&
(n = n
.split("")
.map(function (t) {
return t + t;
})
.join(""));
var r = parseInt(n, 16);
return [(r >> 16) & 255, (r >> 8) & 255, 255 & r];
}),
(a.rgb.hcg = function (t) {
var e,
n = t[0] / 255,
r = t[1] / 255,
i = t[2] / 255,
o = Math.max(Math.max(n, r), i),
a = Math.min(Math.min(n, r), i),
s = o - a;
return (
(e =
s <= 0
? 0
: o === n
? ((r - i) / s) % 6
: o === r
? 2 + (i - n) / s
: 4 + (n - r) / s + 4),
(e /= 6),
[360 * (e %= 1), 100 * s, 100 * (s < 1 ? a / (1 - s) : 0)]
);
}),
(a.hsl.hcg = function (t) {
var e,
n = t[1] / 100,
r = t[2] / 100,
i = 0;
return (
(e = r < 0.5 ? 2 * n * r : 2 * n * (1 - r)) < 1 &&
(i = (r - 0.5 * e) / (1 - e)),
[t[0], 100 * e, 100 * i]
);
}),
(a.hsv.hcg = function (t) {
var e = t[1] / 100,
n = t[2] / 100,
r = e * n,
i = 0;
return r < 1 && (i = (n - r) / (1 - r)), [t[0], 100 * r, 100 * i];
}),
(a.hcg.rgb = function (t) {
var e = t[0] / 360,
n = t[1] / 100,
r = t[2] / 100;
if (0 === n) return [255 * r, 255 * r, 255 * r];
var i,
o = [0, 0, 0],
a = (e % 1) * 6,
s = a % 1,
c = 1 - s;
switch (Math.floor(a)) {
case 0:
(o[0] = 1), (o[1] = s), (o[2] = 0);
break;
case 1:
(o[0] = c), (o[1] = 1), (o[2] = 0);
break;
case 2:
(o[0] = 0), (o[1] = 1), (o[2] = s);
break;
case 3:
(o[0] = 0), (o[1] = c), (o[2] = 1);
break;
case 4:
(o[0] = s), (o[1] = 0), (o[2] = 1);
break;
default:
(o[0] = 1), (o[1] = 0), (o[2] = c);
}
return (
(i = (1 - n) * r),
[255 * (n * o[0] + i), 255 * (n * o[1] + i), 255 * (n * o[2] + i)]
);
}),
(a.hcg.hsv = function (t) {
var e = t[1] / 100,
n = e + (t[2] / 100) * (1 - e),
r = 0;
return n > 0 && (r = e / n), [t[0], 100 * r, 100 * n];
}),
(a.hcg.hsl = function (t) {
var e = t[1] / 100,
n = (t[2] / 100) * (1 - e) + 0.5 * e,
r = 0;
return (
n > 0 && n < 0.5
? (r = e / (2 * n))
: n >= 0.5 && n < 1 && (r = e / (2 * (1 - n))),
[t[0], 100 * r, 100 * n]
);
}),
(a.hcg.hwb = function (t) {
var e = t[1] / 100,
n = e + (t[2] / 100) * (1 - e);
return [t[0], 100 * (n - e), 100 * (1 - n)];
}),
(a.hwb.hcg = function (t) {
var e = t[1] / 100,
n = 1 - t[2] / 100,
r = n - e,
i = 0;
return r < 1 && (i = (n - r) / (1 - r)), [t[0], 100 * r, 100 * i];
}),
(a.apple.rgb = function (t) {
return [
(t[0] / 65535) * 255,
(t[1] / 65535) * 255,
(t[2] / 65535) * 255,
];
}),
(a.rgb.apple = function (t) {
return [
(t[0] / 255) * 65535,
(t[1] / 255) * 65535,
(t[2] / 255) * 65535,
];
}),
(a.gray.rgb = function (t) {
return [(t[0] / 100) * 255, (t[0] / 100) * 255, (t[0] / 100) * 255];
}),
(a.gray.hsl = a.gray.hsv =
function (t) {
return [0, 0, t[0]];
}),
(a.gray.hwb = function (t) {
return [0, 100, t[0]];
}),
(a.gray.cmyk = function (t) {
return [0, 0, 0, t[0]];
}),
(a.gray.lab = function (t) {
return [t[0], 0, 0];
}),
(a.gray.hex = function (t) {
var e = 255 & Math.round((t[0] / 100) * 255),
n = ((e << 16) + (e << 8) + e).toString(16).toUpperCase();
return "000000".substring(n.length) + n;
}),
(a.rgb.gray = function (t) {
return [((t[0] + t[1] + t[2]) / 3 / 255) * 100];
});
},
101: function (t, e) {},
102: function (t, e) {},
157: function (t, e, n) {
"use strict";
(function (t) {
n.d(e, "a", function () {
return f;
});
var r = function (t, e, n) {
if (n || 2 === arguments.length)
for (var r, i = 0, o = e.length; i < o; i++)
(!r && i in e) ||
(r || (r = Array.prototype.slice.call(e, 0, i)),
(r[i] = e[i]));
return t.concat(r || Array.prototype.slice.call(e));
},
i = function (t, e, n) {
(this.name = t),
(this.version = e),
(this.os = n),
(this.type = "browser");
},
o = function (e) {
(this.version = e),
(this.type = "node"),
(this.name = "node"),
(this.os = t.platform);
},
a = function (t, e, n, r) {
(this.name = t),
(this.version = e),
(this.os = n),
(this.bot = r),
(this.type = "bot-device");
},
s = function () {
(this.type = "bot"),
(this.bot = !0),
(this.name = "bot"),
(this.version = null),
(this.os = null);
},
c = function () {
(this.type = "react-native"),
(this.name = "react-native"),
(this.version = null),
(this.os = null);
},
u =
/(nuhk|curl|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask\ Jeeves\/Teoma|ia_archiver)/,
h = [
["aol", /AOLShield\/([0-9\._]+)/],
["edge", /Edge\/([0-9\._]+)/],
["edge-ios", /EdgiOS\/([0-9\._]+)/],
["yandexbrowser", /YaBrowser\/([0-9\._]+)/],
["kakaotalk", /KAKAOTALK\s([0-9\.]+)/],
["samsung", /SamsungBrowser\/([0-9\.]+)/],
["silk", /\bSilk\/([0-9._-]+)\b/],
["miui", /MiuiBrowser\/([0-9\.]+)$/],
["beaker", /BeakerBrowser\/([0-9\.]+)/],
["edge-chromium", /EdgA?\/([0-9\.]+)/],
[
"chromium-webview",
/(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/,
],
["chrome", /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
["phantomjs", /PhantomJS\/([0-9\.]+)(:?\s|$)/],
["crios", /CriOS\/([0-9\.]+)(:?\s|$)/],
["firefox", /Firefox\/([0-9\.]+)(?:\s|$)/],
["fxios", /FxiOS\/([0-9\.]+)/],
["opera-mini", /Opera Mini.*Version\/([0-9\.]+)/],
["opera", /Opera\/([0-9\.]+)(?:\s|$)/],
["opera", /OPR\/([0-9\.]+)(:?\s|$)/],
["pie", /^Microsoft Pocket Internet Explorer\/(\d+\.\d+)$/],
[
"pie",
/^Mozilla\/\d\.\d+\s\(compatible;\s(?:MSP?IE|MSInternet Explorer) (\d+\.\d+);.*Windows CE.*\)$/,
],
["netfront", /^Mozilla\/\d\.\d+.*NetFront\/(\d.\d)/],
["ie", /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
["ie", /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
["ie", /MSIE\s(7\.0)/],
["bb10", /BB10;\sTouch.*Version\/([0-9\.]+)/],
["android", /Android\s([0-9\.]+)/],
["ios", /Version\/([0-9\._]+).*Mobile.*Safari.*/],
["safari", /Version\/([0-9\._]+).*Safari/],
["facebook", /FB[AS]V\/([0-9\.]+)/],
["instagram", /Instagram\s([0-9\.]+)/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Mobile/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
["curl", /^curl\/([0-9\.]+)$/],
[
"searchbot",
/alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/,
],
],
l = [
["iOS", /iP(hone|od|ad)/],
["Android OS", /Android/],
["BlackBerry OS", /BlackBerry|BB10/],
["Windows Mobile", /IEMobile/],
["Amazon OS", /Kindle/],
["Windows 3.11", /Win16/],
["Windows 95", /(Windows 95)|(Win95)|(Windows_95)/],
["Windows 98", /(Windows 98)|(Win98)/],
["Windows 2000", /(Windows NT 5.0)|(Windows 2000)/],
["Windows XP", /(Windows NT 5.1)|(Windows XP)/],
["Windows Server 2003", /(Windows NT 5.2)/],
["Windows Vista", /(Windows NT 6.0)/],
["Windows 7", /(Windows NT 6.1)/],
["Windows 8", /(Windows NT 6.2)/],
["Windows 8.1", /(Windows NT 6.3)/],
["Windows 10", /(Windows NT 10.0)/],
["Windows ME", /Windows ME/],
[
"Windows CE",
/Windows CE|WinCE|Microsoft Pocket Internet Explorer/,
],
["Open BSD", /OpenBSD/],
["Sun OS", /SunOS/],
["Chrome OS", /CrOS/],
["Linux", /(Linux)|(X11)/],
["Mac OS", /(Mac_PowerPC)|(Macintosh)/],
["QNX", /QNX/],
["BeOS", /BeOS/],
["OS/2", /OS\/2/],
];
function f(e) {
return e
? p(e)
: "undefined" == typeof document &&
"undefined" != typeof navigator &&
"ReactNative" === navigator.product
? new c()
: "undefined" != typeof navigator
? p(navigator.userAgent)
: void 0 !== t && t.version
? new o(t.version.slice(1))
: null;
}
function d(t) {
return (
"" !== t &&
h.reduce(function (e, n) {
var r = n[0],
i = n[1];
if (e) return e;
var o = i.exec(t);
return !!o && [r, o];
}, !1)
);
}
function p(t) {
var e = d(t);
if (!e) return null;
var n = e[0],
o = e[1];
if ("searchbot" === n) return new s();
var c = o[1] && o[1].split(".").join("_").split("_").slice(0, 3);
c
? c.length < 3 &&
(c = r(
r([], c, !0),
(function (t) {
for (var e = [], n = 0; n < t; n++) e.push("0");
return e;
})(3 - c.length),
!0,
))
: (c = []);
var h = c.join("."),
f = (function (t) {
for (var e = 0, n = l.length; e < n; e++) {
var r = l[e],
i = r[0];
if (r[1].exec(t)) return i;
}
return null;
})(t),
p = u.exec(t);
return p && p[1] ? new a(n, h, f, p[1]) : new i(n, h, f);
}
}).call(this, n(178));
},
177: function (t, e, n) {
"use strict";
n.r(e),
function (r) {
var i = n(97),
o =
"undefined" != typeof globalThis
? globalThis
: "undefined" != typeof self
? self
: "undefined" != typeof window
? window
: void 0 !== r
? r
: void 0;
("object" == typeof exports && "object" == typeof t) ||
("function" == typeof define && n(195)) ||
"object" == typeof exports ||
Object.defineProperties(o, {
f6: {
get: function () {
return (
console.warn("废弃的特性: f6, 请使用 F6 代替 f6"), i.default
);
},
},
}),
(e.default = i.default);
}.call(this, n(77));
},
178: function (t, e) {
var n,
r,
i = (t.exports = {});
function o() {
throw new Error("setTimeout has not been defined");
}
function a() {
throw new Error("clearTimeout has not been defined");
}
function s(t) {
if (n === setTimeout) return setTimeout(t, 0);
if ((n === o || !n) && setTimeout)
return (n = setTimeout), setTimeout(t, 0);
try {
return n(t, 0);
} catch (e) {
try {
return n.call(null, t, 0);
} catch (e) {
return n.call(this, t, 0);
}
}
}
!(function () {
try {
n = "function" == typeof setTimeout ? setTimeout : o;
} catch (t) {
n = o;
}
try {
r = "function" == typeof clearTimeout ? clearTimeout : a;
} catch (t) {
r = a;
}
})();
var c,
u = [],
h = !1,
l = -1;
function f() {
h &&
c &&
((h = !1), c.length ? (u = c.concat(u)) : (l = -1), u.length && d());
}
function d() {
if (!h) {
var t = s(f);
h = !0;
for (var e = u.length; e; ) {
for (c = u, u = []; ++l < e; ) c && c[l].run();
(l = -1), (e = u.length);
}
(c = null),
(h = !1),
(function (t) {
if (r === clearTimeout) return clearTimeout(t);
if ((r === a || !r) && clearTimeout)
return (r = clearTimeout), clearTimeout(t);
try {
r(t);
} catch (e) {
try {
return r.call(null, t);
} catch (e) {
return r.call(this, t);
}
}
})(t);
}
}
function p(t, e) {
(this.fun = t), (this.array = e);
}
function g() {}
(i.nextTick = function (t) {
var e = new Array(arguments.length - 1);
if (arguments.length > 1)
for (var n = 1; n < arguments.length; n++) e[n - 1] = arguments[n];
u.push(new p(t, e)), 1 !== u.length || h || s(d);
}),
(p.prototype.run = function () {
this.fun.apply(null, this.array);
}),
(i.title = "browser"),
(i.browser = !0),
(i.env = {}),
(i.argv = []),
(i.version = ""),
(i.versions = {}),
(i.on = g),
(i.addListener = g),
(i.once = g),
(i.off = g),
(i.removeListener = g),
(i.removeAllListeners = g),
(i.emit = g),
(i.prependListener = g),
(i.prependOnceListener = g),
(i.listeners = function (t) {
return [];
}),
(i.binding = function (t) {
throw new Error("process.binding is not supported");
}),
(i.cwd = function () {
return "/";
}),
(i.chdir = function (t) {
throw new Error("process.chdir is not supported");
}),
(i.umask = function () {
return 0;
});
},
179: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isAllowCapture =
e.isParent =
e.upperFirst =
e.each =
e.mix =
e.isArray =
e.isObject =
e.isString =
e.isFunction =
e.isNil =
e.isBrowser =
e.removeFromArray =
void 0),
(e.removeFromArray = function (t, e) {
var n = t.indexOf(e);
-1 !== n && t.splice(n, 1);
}),
(e.isBrowser =
"undefined" != typeof window && void 0 !== window.document);
var r = n(0);
Object.defineProperty(e, "isNil", {
enumerable: !0,
get: function () {
return r.isNil;
},
}),
Object.defineProperty(e, "isFunction", {
enumerable: !0,
get: function () {
return r.isFunction;
},
}),
Object.defineProperty(e, "isString", {
enumerable: !0,
get: function () {
return r.isString;
},
}),
Object.defineProperty(e, "isObject", {
enumerable: !0,
get: function () {
return r.isObject;
},
}),
Object.defineProperty(e, "isArray", {
enumerable: !0,
get: function () {
return r.isArray;
},
}),
Object.defineProperty(e, "mix", {
enumerable: !0,
get: function () {
return r.mix;
},
}),
Object.defineProperty(e, "each", {
enumerable: !0,
get: function () {
return r.each;
},
}),
Object.defineProperty(e, "upperFirst", {
enumerable: !0,
get: function () {
return r.upperFirst;
},
}),
(e.isParent = function (t, e) {
if (t.isCanvas()) return !0;
for (var n = e.getParent(), r = !1; n; ) {
if (n === t) {
r = !0;
break;
}
n = n.getParent();
}
return r;
}),
(e.isAllowCapture = function (t) {
return t.cfg.visible && t.cfg.capture;
});
},
18: function (t, e, n) {
"use strict";
var r = n(75),
i = Object(r.getColorsWithSubjectColor)(
"rgb(95, 149, 255)",
"rgb(255, 255, 255)",
);
e.a = {
version: "0.0.16",
rootContainerClassName: "root-container",
uiContainerClassName: "ui-container",
waterContainerClassName: "water-container",
nodeContainerClassName: "node-container",
edgeContainerClassName: "edge-container",
comboContainerClassName: "combo-container",
delegateContainerClassName: "delegate-container",
defaultLoopPosition: "top",
nodeLabel: {
style: {
fill: "#000",
fontSize: 12,
textAlign: "center",
textBaseline: "middle",
},
offset: 4,
},
defaultNode: {
type: "circle",
style: { lineWidth: 1, stroke: i.mainStroke, fill: i.mainFill },
size: 20,
color: i.mainStroke,
linkPoints: {
size: 8,
lineWidth: 1,
fill: i.activeFill,
stroke: i.activeStroke,
},
},
nodeStateStyles: {
active: {
fill: i.activeFill,
stroke: i.activeStroke,
lineWidth: 2,
shadowColor: i.mainStroke,
shadowBlur: 10,
},
selected: {
fill: i.selectedFill,
stroke: i.selectedStroke,
lineWidth: 4,
shadowColor: i.selectedStroke,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
fill: i.highlightFill,
stroke: i.highlightStroke,
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: {
fill: i.inactiveFill,
stroke: i.inactiveStroke,
lineWidth: 1,
},
disable: {
fill: i.disableFill,
stroke: i.disableStroke,
lineWidth: 1,
},
},
edgeLabel: {
style: {
fill: "rgb(0, 0, 0)",
textAlign: "center",
textBaseline: "middle",
fontSize: 12,
},
},
defaultEdge: {
type: "line",
size: 1,
style: { stroke: i.edgeMainStroke, lineAppendWidth: 2 },
color: i.edgeMainStroke,
},
edgeStateStyles: {
active: { stroke: i.edgeActiveStroke, lineWidth: 1 },
selected: {
stroke: i.edgeSelectedStroke,
lineWidth: 2,
shadowColor: i.edgeSelectedStroke,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: i.edgeHighlightStroke,
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: { stroke: i.edgeInactiveStroke, lineWidth: 1 },
disable: { stroke: i.edgeDisableStroke, lineWidth: 1 },
},
comboLabel: {
style: { fill: "rgb(0, 0, 0)", textBaseline: "middle", fontSize: 12 },
refY: 10,
refX: 10,
},
defaultCombo: {
type: "circle",
style: {
fill: i.comboMainFill,
lineWidth: 1,
stroke: i.comboMainStroke,
r: 5,
width: 20,
height: 10,
},
size: [20, 5],
color: i.comboMainStroke,
padding: [25, 20, 15, 20],
},
comboStateStyles: {
active: {
stroke: i.comboActiveStroke,
lineWidth: 1,
fill: i.comboActiveFill,
},
selected: {
stroke: i.comboSelectedStroke,
lineWidth: 2,
fill: i.comboSelectedFill,
shadowColor: i.comboSelectedStroke,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: i.comboHighlightStroke,
lineWidth: 2,
fill: i.comboHighlightFill,
"text-shape": { fontWeight: 500 },
},
inactive: {
stroke: i.comboInactiveStroke,
fill: i.comboInactiveFill,
lineWidth: 1,
},
disable: {
stroke: i.comboDisableStroke,
fill: i.comboDisableFill,
lineWidth: 1,
},
},
delegateStyle: {
fill: "#F3F9FF",
fillOpacity: 0.5,
stroke: "#1890FF",
strokeOpacity: 0.9,
lineDash: [5, 5],
},
textWaterMarkerConfig: {
width: 150,
height: 100,
compatible: !1,
text: {
x: 0,
y: 60,
lineHeight: 20,
rotate: 20,
fontSize: 14,
fontFamily: "Microsoft YaHei",
fill: "rgba(0, 0, 0, 0.1)",
baseline: "Middle",
},
},
imageWaterMarkerConfig: {
image: { x: 0, y: 0, width: 30, height: 20, rotate: 0 },
},
waterMarkerImage:
"https://gw.alipayobjects.com/os/s/prod/antv/assets/image/logo-with-text-73b8a.svg",
};
},
180: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.getOffScreenContext = void 0);
var r = null;
e.getOffScreenContext = function () {
if (!r) {
var t = document.createElement("canvas");
(t.width = 1), (t.height = 1), (r = t.getContext("2d"));
}
return r;
};
},
181: function (t, e, n) {
"use strict";
var r = n(182),
i = n(183),
o = Object.hasOwnProperty,
a = {};
for (var s in r) o.call(r, s) && (a[r[s]] = s);
var c = (t.exports = { to: {}, get: {} });
function u(t, e, n) {
return Math.min(Math.max(e, t), n);
}
function h(t) {
var e = Math.round(t).toString(16).toUpperCase();
return e.length < 2 ? "0" + e : e;
}
(c.get = function (t) {
var e, n;
switch (t.substring(0, 3).toLowerCase()) {
case "hsl":
(e = c.get.hsl(t)), (n = "hsl");
break;
case "hwb":
(e = c.get.hwb(t)), (n = "hwb");
break;
default:
(e = c.get.rgb(t)), (n = "rgb");
}
return e ? { model: n, value: e } : null;
}),
(c.get.rgb = function (t) {
if (!t) return null;
var e,
n,
i,
a,
s = [0, 0, 0, 1];
if ((n = t.match(/^#([a-f0-9]{6})([a-f0-9]{2})?$/i))) {
for (a = n[2], n = n[1], i = 0; i < 3; i++)
(e = 2 * i), (s[i] = parseInt(n.slice(e, e + 2), 16));
a && (s[3] = parseInt(a, 16) / 255);
} else if ((n = t.match(/^#([a-f0-9]{3,4})$/i))) {
for (a = (n = n[1])[3], i = 0; i < 3; i++)
s[i] = parseInt(n[i] + n[i], 16);
a && (s[3] = parseInt(a + a, 16) / 255);
} else if (
(n = t.match(
/^rgba?\(\s*([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)(?=[\s,])\s*(?:,\s*)?([+-]?\d+)\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/,
))
) {
for (i = 0; i < 3; i++) s[i] = parseInt(n[i + 1], 0);
n[4] &&
(n[5]
? (s[3] = 0.01 * parseFloat(n[4]))
: (s[3] = parseFloat(n[4])));
} else {
if (
!(n = t.match(
/^rgba?\(\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*,?\s*([+-]?[\d\.]+)\%\s*(?:[,|\/]\s*([+-]?[\d\.]+)(%?)\s*)?\)$/,
))
)
return (n = t.match(/^(\w+)$/))
? "transparent" === n[1]
? [0, 0, 0, 0]
: o.call(r, n[1])
? (((s = r[n[1]])[3] = 1), s)
: null
: null;
for (i = 0; i < 3; i++)
s[i] = Math.round(2.55 * parseFloat(n[i + 1]));
n[4] &&
(n[5]
? (s[3] = 0.01 * parseFloat(n[4]))
: (s[3] = parseFloat(n[4])));
}
for (i = 0; i < 3; i++) s[i] = u(s[i], 0, 255);
return (s[3] = u(s[3], 0, 1)), s;
}),
(c.get.hsl = function (t) {
if (!t) return null;
var e,
n = t.match(
/^hsla?\(\s*([+-]?(?:\d{0,3}\.)?\d+)(?:deg)?\s*,?\s*([+-]?[\d\.]+)%\s*,?\s*([+-]?[\d\.]+)%\s*(?:[,|\/]\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/,
);
return n
? ((e = parseFloat(n[4])),
[
((parseFloat(n[1]) % 360) + 360) % 360,
u(parseFloat(n[2]), 0, 100),
u(parseFloat(n[3]), 0, 100),
u(isNaN(e) ? 1 : e, 0, 1),
])
: null;
}),
(c.get.hwb = function (t) {
if (!t) return null;
var e,
n = t.match(
/^hwb\(\s*([+-]?\d{0,3}(?:\.\d+)?)(?:deg)?\s*,\s*([+-]?[\d\.]+)%\s*,\s*([+-]?[\d\.]+)%\s*(?:,\s*([+-]?(?=\.\d|\d)(?:0|[1-9]\d*)?(?:\.\d*)?(?:[eE][+-]?\d+)?)\s*)?\)$/,
);
return n
? ((e = parseFloat(n[4])),
[
((parseFloat(n[1]) % 360) + 360) % 360,
u(parseFloat(n[2]), 0, 100),
u(parseFloat(n[3]), 0, 100),
u(isNaN(e) ? 1 : e, 0, 1),
])
: null;
}),
(c.to.hex = function () {
var t = i(arguments);
return (
"#" +
h(t[0]) +
h(t[1]) +
h(t[2]) +
(t[3] < 1 ? h(Math.round(255 * t[3])) : "")
);
}),
(c.to.rgb = function () {
var t = i(arguments);
return t.length < 4 || 1 === t[3]
? "rgb(" +
Math.round(t[0]) +
", " +
Math.round(t[1]) +
", " +
Math.round(t[2]) +
")"
: "rgba(" +
Math.round(t[0]) +
", " +
Math.round(t[1]) +
", " +
Math.round(t[2]) +
", " +
t[3] +
")";
}),
(c.to.rgb.percent = function () {
var t = i(arguments),
e = Math.round((t[0] / 255) * 100),
n = Math.round((t[1] / 255) * 100),
r = Math.round((t[2] / 255) * 100);
return t.length < 4 || 1 === t[3]
? "rgb(" + e + "%, " + n + "%, " + r + "%)"
: "rgba(" + e + "%, " + n + "%, " + r + "%, " + t[3] + ")";
}),
(c.to.hsl = function () {
var t = i(arguments);
return t.length < 4 || 1 === t[3]
? "hsl(" + t[0] + ", " + t[1] + "%, " + t[2] + "%)"
: "hsla(" + t[0] + ", " + t[1] + "%, " + t[2] + "%, " + t[3] + ")";
}),
(c.to.hwb = function () {
var t = i(arguments),
e = "";
return (
t.length >= 4 && 1 !== t[3] && (e = ", " + t[3]),
"hwb(" + t[0] + ", " + t[1] + "%, " + t[2] + "%" + e + ")"
);
}),
(c.to.keyword = function (t) {
return a[t.slice(0, 3)];
});
},
182: function (t, e, n) {
"use strict";
t.exports = {
aliceblue: [240, 248, 255],
antiquewhite: [250, 235, 215],
aqua: [0, 255, 255],
aquamarine: [127, 255, 212],
azure: [240, 255, 255],
beige: [245, 245, 220],
bisque: [255, 228, 196],
black: [0, 0, 0],
blanchedalmond: [255, 235, 205],
blue: [0, 0, 255],
blueviolet: [138, 43, 226],
brown: [165, 42, 42],
burlywood: [222, 184, 135],
cadetblue: [95, 158, 160],
chartreuse: [127, 255, 0],
chocolate: [210, 105, 30],
coral: [255, 127, 80],
cornflowerblue: [100, 149, 237],
cornsilk: [255, 248, 220],
crimson: [220, 20, 60],
cyan: [0, 255, 255],
darkblue: [0, 0, 139],
darkcyan: [0, 139, 139],
darkgoldenrod: [184, 134, 11],
darkgray: [169, 169, 169],
darkgreen: [0, 100, 0],
darkgrey: [169, 169, 169],
darkkhaki: [189, 183, 107],
darkmagenta: [139, 0, 139],
darkolivegreen: [85, 107, 47],
darkorange: [255, 140, 0],
darkorchid: [153, 50, 204],
darkred: [139, 0, 0],
darksalmon: [233, 150, 122],
darkseagreen: [143, 188, 143],
darkslateblue: [72, 61, 139],
darkslategray: [47, 79, 79],
darkslategrey: [47, 79, 79],
darkturquoise: [0, 206, 209],
darkviolet: [148, 0, 211],
deeppink: [255, 20, 147],
deepskyblue: [0, 191, 255],
dimgray: [105, 105, 105],
dimgrey: [105, 105, 105],
dodgerblue: [30, 144, 255],
firebrick: [178, 34, 34],
floralwhite: [255, 250, 240],
forestgreen: [34, 139, 34],
fuchsia: [255, 0, 255],
gainsboro: [220, 220, 220],
ghostwhite: [248, 248, 255],
gold: [255, 215, 0],
goldenrod: [218, 165, 32],
gray: [128, 128, 128],
green: [0, 128, 0],
greenyellow: [173, 255, 47],
grey: [128, 128, 128],
honeydew: [240, 255, 240],
hotpink: [255, 105, 180],
indianred: [205, 92, 92],
indigo: [75, 0, 130],
ivory: [255, 255, 240],
khaki: [240, 230, 140],
lavender: [230, 230, 250],
lavenderblush: [255, 240, 245],
lawngreen: [124, 252, 0],
lemonchiffon: [255, 250, 205],
lightblue: [173, 216, 230],
lightcoral: [240, 128, 128],
lightcyan: [224, 255, 255],
lightgoldenrodyellow: [250, 250, 210],
lightgray: [211, 211, 211],
lightgreen: [144, 238, 144],
lightgrey: [211, 211, 211],
lightpink: [255, 182, 193],
lightsalmon: [255, 160, 122],
lightseagreen: [32, 178, 170],
lightskyblue: [135, 206, 250],
lightslategray: [119, 136, 153],
lightslategrey: [119, 136, 153],
lightsteelblue: [176, 196, 222],
lightyellow: [255, 255, 224],
lime: [0, 255, 0],
limegreen: [50, 205, 50],
linen: [250, 240, 230],
magenta: [255, 0, 255],
maroon: [128, 0, 0],
mediumaquamarine: [102, 205, 170],
mediumblue: [0, 0, 205],
mediumorchid: [186, 85, 211],
mediumpurple: [147, 112, 219],
mediumseagreen: [60, 179, 113],
mediumslateblue: [123, 104, 238],
mediumspringgreen: [0, 250, 154],
mediumturquoise: [72, 209, 204],
mediumvioletred: [199, 21, 133],
midnightblue: [25, 25, 112],
mintcream: [245, 255, 250],
mistyrose: [255, 228, 225],
moccasin: [255, 228, 181],
navajowhite: [255, 222, 173],
navy: [0, 0, 128],
oldlace: [253, 245, 230],
olive: [128, 128, 0],
olivedrab: [107, 142, 35],
orange: [255, 165, 0],
orangered: [255, 69, 0],
orchid: [218, 112, 214],
palegoldenrod: [238, 232, 170],
palegreen: [152, 251, 152],
paleturquoise: [175, 238, 238],
palevioletred: [219, 112, 147],
papayawhip: [255, 239, 213],
peachpuff: [255, 218, 185],
peru: [205, 133, 63],
pink: [255, 192, 203],
plum: [221, 160, 221],
powderblue: [176, 224, 230],
purple: [128, 0, 128],
rebeccapurple: [102, 51, 153],
red: [255, 0, 0],
rosybrown: [188, 143, 143],
royalblue: [65, 105, 225],
saddlebrown: [139, 69, 19],
salmon: [250, 128, 114],
sandybrown: [244, 164, 96],
seagreen: [46, 139, 87],
seashell: [255, 245, 238],
sienna: [160, 82, 45],
silver: [192, 192, 192],
skyblue: [135, 206, 235],
slateblue: [106, 90, 205],
slategray: [112, 128, 144],
slategrey: [112, 128, 144],
snow: [255, 250, 250],
springgreen: [0, 255, 127],
steelblue: [70, 130, 180],
tan: [210, 180, 140],
teal: [0, 128, 128],
thistle: [216, 191, 216],
tomato: [255, 99, 71],
turquoise: [64, 224, 208],
violet: [238, 130, 238],
wheat: [245, 222, 179],
white: [255, 255, 255],
whitesmoke: [245, 245, 245],
yellow: [255, 255, 0],
yellowgreen: [154, 205, 50],
};
},
183: function (t, e, n) {
"use strict";
var r = n(184),
i = Array.prototype.concat,
o = Array.prototype.slice,
a = (t.exports = function (t) {
var e,
n,
a,
s = [];
for (e = 0, n = t.length; e < n; e++)
(a = t[e]), r(a) ? (s = i.call(s, o.call(a))) : s.push(a);
return s;
});
a.wrap = function (t) {
return function () {
return t(a(arguments));
};
};
},
184: function (t, e, n) {
"use strict";
t.exports = function (t) {
return (
!(!t || "string" == typeof t) &&
(t instanceof Array ||
Array.isArray(t) ||
(t.length >= 0 &&
(t.splice instanceof Function ||
(Object.getOwnPropertyDescriptor(t, t.length - 1) &&
"String" !== t.constructor.name))))
);
};
},
185: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function i(t) {
return (i =
"function" == typeof Symbol && "symbol" == r(Symbol.iterator)
? function (t) {
return r(t);
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: r(t);
})(t);
}
var o = n(100),
a = n(187),
s = {};
Object.keys(o).forEach(function (t) {
(s[t] = {}),
Object.defineProperty(s[t], "channels", { value: o[t].channels }),
Object.defineProperty(s[t], "labels", { value: o[t].labels });
var e = a(t);
Object.keys(e).forEach(function (n) {
var r = e[n];
(s[t][n] = (function (t) {
var e = function (e) {
if (null == e) return e;
arguments.length > 1 &&
(e = Array.prototype.slice.call(arguments));
var n,
r,
o = t(e);
if ("object" === i(o))
for (n = o.length, r = 0; r < n; r++) o[r] = Math.round(o[r]);
return o;
};
return "conversion" in t && (e.conversion = t.conversion), e;
})(r)),
(s[t][n].raw = (function (t) {
var e = function (e) {
return null == e
? e
: (arguments.length > 1 &&
(e = Array.prototype.slice.call(arguments)),
t(e));
};
return "conversion" in t && (e.conversion = t.conversion), e;
})(r));
});
}),
(t.exports = s);
},
186: function (t, e, n) {
"use strict";
t.exports = {
aliceblue: [240, 248, 255],
antiquewhite: [250, 235, 215],
aqua: [0, 255, 255],
aquamarine: [127, 255, 212],
azure: [240, 255, 255],
beige: [245, 245, 220],
bisque: [255, 228, 196],
black: [0, 0, 0],
blanchedalmond: [255, 235, 205],
blue: [0, 0, 255],
blueviolet: [138, 43, 226],
brown: [165, 42, 42],
burlywood: [222, 184, 135],
cadetblue: [95, 158, 160],
chartreuse: [127, 255, 0],
chocolate: [210, 105, 30],
coral: [255, 127, 80],
cornflowerblue: [100, 149, 237],
cornsilk: [255, 248, 220],
crimson: [220, 20, 60],
cyan: [0, 255, 255],
darkblue: [0, 0, 139],
darkcyan: [0, 139, 139],
darkgoldenrod: [184, 134, 11],
darkgray: [169, 169, 169],
darkgreen: [0, 100, 0],
darkgrey: [169, 169, 169],
darkkhaki: [189, 183, 107],
darkmagenta: [139, 0, 139],
darkolivegreen: [85, 107, 47],
darkorange: [255, 140, 0],
darkorchid: [153, 50, 204],
darkred: [139, 0, 0],
darksalmon: [233, 150, 122],
darkseagreen: [143, 188, 143],
darkslateblue: [72, 61, 139],
darkslategray: [47, 79, 79],
darkslategrey: [47, 79, 79],
darkturquoise: [0, 206, 209],
darkviolet: [148, 0, 211],
deeppink: [255, 20, 147],
deepskyblue: [0, 191, 255],
dimgray: [105, 105, 105],
dimgrey: [105, 105, 105],
dodgerblue: [30, 144, 255],
firebrick: [178, 34, 34],
floralwhite: [255, 250, 240],
forestgreen: [34, 139, 34],
fuchsia: [255, 0, 255],
gainsboro: [220, 220, 220],
ghostwhite: [248, 248, 255],
gold: [255, 215, 0],
goldenrod: [218, 165, 32],
gray: [128, 128, 128],
green: [0, 128, 0],
greenyellow: [173, 255, 47],
grey: [128, 128, 128],
honeydew: [240, 255, 240],
hotpink: [255, 105, 180],
indianred: [205, 92, 92],
indigo: [75, 0, 130],
ivory: [255, 255, 240],
khaki: [240, 230, 140],
lavender: [230, 230, 250],
lavenderblush: [255, 240, 245],
lawngreen: [124, 252, 0],
lemonchiffon: [255, 250, 205],
lightblue: [173, 216, 230],
lightcoral: [240, 128, 128],
lightcyan: [224, 255, 255],
lightgoldenrodyellow: [250, 250, 210],
lightgray: [211, 211, 211],
lightgreen: [144, 238, 144],
lightgrey: [211, 211, 211],
lightpink: [255, 182, 193],
lightsalmon: [255, 160, 122],
lightseagreen: [32, 178, 170],
lightskyblue: [135, 206, 250],
lightslategray: [119, 136, 153],
lightslategrey: [119, 136, 153],
lightsteelblue: [176, 196, 222],
lightyellow: [255, 255, 224],
lime: [0, 255, 0],
limegreen: [50, 205, 50],
linen: [250, 240, 230],
magenta: [255, 0, 255],
maroon: [128, 0, 0],
mediumaquamarine: [102, 205, 170],
mediumblue: [0, 0, 205],
mediumorchid: [186, 85, 211],
mediumpurple: [147, 112, 219],
mediumseagreen: [60, 179, 113],
mediumslateblue: [123, 104, 238],
mediumspringgreen: [0, 250, 154],
mediumturquoise: [72, 209, 204],
mediumvioletred: [199, 21, 133],
midnightblue: [25, 25, 112],
mintcream: [245, 255, 250],
mistyrose: [255, 228, 225],
moccasin: [255, 228, 181],
navajowhite: [255, 222, 173],
navy: [0, 0, 128],
oldlace: [253, 245, 230],
olive: [128, 128, 0],
olivedrab: [107, 142, 35],
orange: [255, 165, 0],
orangered: [255, 69, 0],
orchid: [218, 112, 214],
palegoldenrod: [238, 232, 170],
palegreen: [152, 251, 152],
paleturquoise: [175, 238, 238],
palevioletred: [219, 112, 147],
papayawhip: [255, 239, 213],
peachpuff: [255, 218, 185],
peru: [205, 133, 63],
pink: [255, 192, 203],
plum: [221, 160, 221],
powderblue: [176, 224, 230],
purple: [128, 0, 128],
rebeccapurple: [102, 51, 153],
red: [255, 0, 0],
rosybrown: [188, 143, 143],
royalblue: [65, 105, 225],
saddlebrown: [139, 69, 19],
salmon: [250, 128, 114],
sandybrown: [244, 164, 96],
seagreen: [46, 139, 87],
seashell: [255, 245, 238],
sienna: [160, 82, 45],
silver: [192, 192, 192],
skyblue: [135, 206, 235],
slateblue: [106, 90, 205],
slategray: [112, 128, 144],
slategrey: [112, 128, 144],
snow: [255, 250, 250],
springgreen: [0, 255, 127],
steelblue: [70, 130, 180],
tan: [210, 180, 140],
teal: [0, 128, 128],
thistle: [216, 191, 216],
tomato: [255, 99, 71],
turquoise: [64, 224, 208],
violet: [238, 130, 238],
wheat: [245, 222, 179],
white: [255, 255, 255],
whitesmoke: [245, 245, 245],
yellow: [255, 255, 0],
yellowgreen: [154, 205, 50],
};
},
187: function (t, e, n) {
"use strict";
var r = n(100);
function i(t) {
var e,
n,
i,
o,
a,
s,
c = (function () {
var t,
e,
n = {},
i = Object.keys(r);
for (t = i.length, e = 0; e < t; e++)
n[i[e]] = { distance: -1, parent: null };
return n;
})(),
u = [t];
for (c[t].distance = 0; u.length; )
for (
e = u.pop(), i = (n = Object.keys(r[e])).length, o = 0;
o < i;
o++
)
-1 === (s = c[(a = n[o])]).distance &&
((s.distance = c[e].distance + 1), (s.parent = e), u.unshift(a));
return c;
}
function o(t, e) {
return function (n) {
return e(t(n));
};
}
function a(t, e) {
for (
var n = [e[t].parent, t], i = r[e[t].parent][t], a = e[t].parent;
e[a].parent;
)
n.unshift(e[a].parent),
(i = o(r[e[a].parent][a], i)),
(a = e[a].parent);
return (i.conversion = n), i;
}
t.exports = function (t) {
var e,
n,
r,
o = i(t),
s = {},
c = Object.keys(o);
for (e = c.length, n = 0; n < e; n++)
null !== o[(r = c[n])].parent && (s[r] = a(r, o));
return s;
};
},
188: function (t, e, n) {
"use strict";
var r = Object.create
? function (t, e, n, r) {
void 0 === r && (r = n),
Object.defineProperty(t, r, {
enumerable: !0,
get: function () {
return e[n];
},
});
}
: function (t, e, n, r) {
void 0 === r && (r = n), (t[r] = e[n]);
},
i = function (t, e) {
for (var n in t)
"default" === n ||
Object.prototype.hasOwnProperty.call(e, n) ||
r(e, t, n);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
i(n(189), e),
i(n(190), e),
i(n(191), e),
i(n(192), e),
i(n(193), e),
i(n(194), e);
},
189: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.camelize = e.isString = void 0);
e.isString = function (t) {
return "string" == typeof t;
};
var r = /-(\w)/g;
e.camelize = (function (t) {
var e = Object.create(null);
return function (n) {
return e[n] || (e[n] = t(n));
};
})(function (t) {
return t.replace(r, function (t, e) {
return e ? e.toUpperCase() : "";
});
});
},
190: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isArray = void 0),
(e.isArray = Array.isArray);
},
191: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.toNumber = e.isNaN = e.isNumber = void 0);
e.isNumber = function (t) {
return "number" == typeof t;
};
e.isNaN = function (t) {
return Number.isNaN(Number(t));
};
e.toNumber = function (t) {
var n = parseFloat(t);
return e.isNaN(n) ? t : n;
};
},
192: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.traverseTreeUp =
e.scaleMatrix =
e.getAdjMatrix =
e.floydWarshall =
e.getDegree =
void 0);
e.getDegree = function (t, e, n) {
var r,
i = [];
for (r = 0; r < t; r++) i[r] = 0;
return n
? (n.forEach(function (t) {
t.source && (i[e[t.source]] += 1),
t.target && (i[e[t.target]] += 1);
}),
i)
: i;
};
e.floydWarshall = function (t) {
var e,
n = [],
r = t.length;
for (i = 0; i < r; i += 1)
for (n[i] = [], o = 0; o < r; o += 1)
i === o
? (n[i][o] = 0)
: 0 !== t[i][o] && t[i][o]
? (n[i][o] = t[i][o])
: (n[i][o] = 1 / 0);
for (e = 0; e < r; e += 1)
for (var i = 0; i < r; i += 1)
for (var o = 0; o < r; o += 1)
n[i][o] > n[i][e] + n[e][o] && (n[i][o] = n[i][e] + n[e][o]);
return n;
};
e.getAdjMatrix = function (t, e) {
var n = t.nodes,
r = t.edges,
i = [],
o = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
(o[t.id] = e), i.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
a = o[n],
s = o[r];
(i[a][s] = 1), e || (i[s][a] = 1);
}),
i
);
};
e.scaleMatrix = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * e);
}),
n.push(r);
}),
n
);
};
e.traverseTreeUp = function (t, e) {
"function" == typeof e &&
(function t(e, n) {
var r;
if (e && e.children)
for (r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return;
return !!n(e);
})(t, e);
};
},
193: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function i(t) {
return (i =
"function" == typeof Symbol && "symbol" == r(Symbol.iterator)
? function (t) {
return r(t);
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: r(t);
})(t);
}
var o = function () {
return (o =
Object.assign ||
function (t) {
var e, n, r;
for (n = 1, r = arguments.length; n < r; n++)
for (var i in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
return t;
}).apply(this, arguments);
};
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clone = e.isObject = void 0);
e.isObject = function (t) {
return null !== t && "object" === i(t);
};
e.clone = function (t) {
var n, r;
return null === t
? t
: t instanceof Date
? new Date(t.getTime())
: t instanceof Array
? ((n = []),
t.forEach(function (t) {
n.push(t);
}),
n.map(function (t) {
return e.clone(t);
}))
: "object" === i(t) && t !== {}
? ((r = o({}, t)),
Object.keys(r).forEach(function (t) {
r[t] = e.clone(r[t]);
}),
r)
: t;
};
},
194: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.isFunction = void 0);
e.isFunction = function (t) {
return "function" == typeof t;
};
},
195: function (t, e) {
(function (e) {
t.exports = e;
}).call(this, {});
},
2: function (t, e, n) {
"use strict";
n.d(e, "d", function () {
return Le;
}),
n.d(e, "g", function () {
return _e;
}),
n.d(e, "f", function () {
return De;
}),
n.d(e, "l", function () {
return We;
}),
n.d(e, "j", function () {
return Ve;
}),
n.d(e, "b", function () {
return we;
}),
n.d(e, "h", function () {
return Ye;
}),
n.d(e, "k", function () {
return qe;
}),
n.d(e, "i", function () {
return Ge;
}),
n.d(e, "c", function () {
return Xe;
}),
n.d(e, "a", function () {
return ze;
}),
n.d(e, "e", function () {
return He;
});
var r = {};
n.r(r),
n.d(r, "compare", function () {
return m;
}),
n.d(r, "getLineIntersect", function () {
return x;
}),
n.d(r, "getRectIntersectByPoint", function () {
return w;
}),
n.d(r, "getCircleIntersectByPoint", function () {
return S;
}),
n.d(r, "getEllipseIntersectByPoint", function () {
return O;
}),
n.d(r, "applyMatrix", function () {
return M;
}),
n.d(r, "invertMatrix", function () {
return k;
}),
n.d(r, "getCircleCenterByPoints", function () {
return C;
}),
n.d(r, "distance", function () {
return E;
}),
n.d(r, "scaleMatrix", function () {
return j;
}),
n.d(r, "floydWarshall", function () {
return P;
}),
n.d(r, "getAdjMatrix", function () {
return A;
}),
n.d(r, "translate", function () {
return I;
}),
n.d(r, "move", function () {
return T;
}),
n.d(r, "scale", function () {
return N;
}),
n.d(r, "rotate", function () {
return B;
}),
n.d(r, "getDegree", function () {
return L;
}),
n.d(r, "isPointInPolygon", function () {
return _;
}),
n.d(r, "intersectBBox", function () {
return R;
}),
n.d(r, "isPolygonsIntersect", function () {
return F;
}),
n.d(r, "Line", function () {
return Y;
}),
n.d(r, "getBBoxBoundLine", function () {
return X;
}),
n.d(r, "itemIntersectByLine", function () {
return W;
}),
n.d(r, "fractionToLine", function () {
return q;
}),
n.d(r, "getPointsCenter", function () {
return V;
}),
n.d(r, "squareDist", function () {
return G;
}),
n.d(r, "pointLineSquareDist", function () {
return H;
}),
n.d(r, "isPointsOverlap", function () {
return U;
}),
n.d(r, "pointRectSquareDist", function () {
return Z;
}),
n.d(r, "pointLineDistance", function () {
return K;
});
var i = {};
n.r(i),
n.d(i, "getBBox", function () {
return ut;
}),
n.d(i, "getLoopCfgs", function () {
return ht;
}),
n.d(i, "getLabelPosition", function () {
return lt;
}),
n.d(i, "traverseTree", function () {
return dt;
}),
n.d(i, "traverseTreeUp", function () {
return pt;
}),
n.d(i, "getLetterWidth", function () {
return gt;
}),
n.d(i, "getTextSize", function () {
return vt;
}),
n.d(i, "plainCombosToTrees", function () {
return yt;
}),
n.d(i, "reconstructTree", function () {
return mt;
}),
n.d(i, "getComboBBox", function () {
return bt;
}),
n.d(i, "shouldRefreshEdge", function () {
return xt;
}),
n.d(i, "cloneBesidesImg", function () {
return wt;
});
var o = {};
n.r(o),
n.d(o, "uniqueId", function () {
return Ct;
}),
n.d(o, "formatPadding", function () {
return Et;
}),
n.d(o, "cloneEvent", function () {
return jt;
}),
n.d(o, "isViewportChanged", function () {
return Pt;
}),
n.d(o, "isNaN", function () {
return At;
}),
n.d(o, "calculationItemsBBox", function () {
return It;
}),
n.d(o, "processParallelEdges", function () {
return Tt;
});
var a = {};
n.r(a),
n.d(a, "getSpline", function () {
return te;
}),
n.d(a, "getControlPoint", function () {
return ee;
}),
n.d(a, "pointsToPolygon", function () {
return ne;
}),
n.d(a, "pathToPoints", function () {
return re;
}),
n.d(a, "getClosedSpline", function () {
return ie;
}),
n.d(a, "roundedHull", function () {
return ce;
}),
n.d(a, "paddedHull", function () {
return ue;
});
var s = {};
n.r(s),
n.d(s, "defaultSubjectColors", function () {
return Re;
});
var c = n(0),
u = {
getDefaultCfg: function () {
return {};
},
getEvents: function () {
return {};
},
updateCfg: function (t) {
return Object.assign(this, t), !0;
},
shouldBegin: function () {
return !0;
},
shouldUpdate: function () {
return !0;
},
shouldEnd: function () {
return !0;
},
bind: function (t) {
var e = this.events;
(this.graph = t),
("drag-canvas" !== this.type &&
"brush-select" !== this.type &&
"lasso-select" !== this.type) ||
t.get("canvas").set("draggable", !0),
Object(c.each)(e, function (e, n) {
t.on(n, e);
});
},
unbind: function (t) {
var e = this.events;
("drag-canvas" !== this.type &&
"brush-select" !== this.type &&
"lasso-select" !== this.type) ||
t.get("canvas").set("draggable", !1),
Object(c.each)(e, function (e, n) {
t.off(n, e);
});
},
get: function (t) {
return this[t];
},
set: function (t, e) {
return (this[t] = e), this;
},
},
h = (function () {
function t() {}
return (
(t.registerBehavior = function (e, n) {
if (!n)
throw new Error(
"please specify handler for this behavior: ".concat(e),
);
var r = Object(c.clone)(u);
Object.assign(r, n);
var i = function (t) {
var e = this;
Object.assign(this, this.getDefaultCfg(), t);
var n = this.getEvents();
this.events = null;
var r = {};
n &&
(Object(c.each)(n, function (t, n) {
r[n] = Object(c.wrapBehavior)(e, t);
}),
(this.events = r));
};
(i.prototype = r), (t.types[e] = i);
}),
(t.hasBehavior = function (e) {
return !!t.types[e];
}),
(t.getBehavior = function (e) {
return t.types[e];
}),
(t.types = {}),
t
);
})(),
l = h,
f = n(1),
d = n(73),
p = n(76),
g = n(3),
v = n(27),
y = g.a.transform,
m = function (t) {
return function (e, n) {
return e[t] - n[t];
};
},
b = function (t, e, n) {
return t >= e && t <= n;
},
x = function (t, e, n, r) {
var i = n.x - t.x,
o = n.y - t.y,
a = e.x - t.x,
s = e.y - t.y,
c = r.x - n.x,
u = r.y - n.y,
h = a * u - s * c,
l = 1 / h;
if (h * h > 1e-4 * (a * a + s * s) * (c * c + u * u)) {
var f = (i * u - o * c) * l,
d = (i * s - o * a) * l;
return b(f, 0, 1) && b(d, 0, 1)
? { x: t.x + f * a, y: t.y + f * s }
: null;
}
return null;
},
w = function (t, e) {
var n = t.x,
r = t.y,
i = t.width,
o = t.height,
a = [],
s = { x: n + i / 2, y: r + o / 2 };
a.push({ x: n, y: r }),
a.push({ x: n + i, y: r }),
a.push({ x: n + i, y: r + o }),
a.push({ x: n, y: r + o }),
a.push({ x: n, y: r });
for (
var c = null, u = 1;
u < a.length && !(c = x(a[u - 1], a[u], s, e));
u++
);
return c;
},
S = function (t, e) {
var n = t.x,
r = t.y,
i = t.r,
o = e.x - n,
a = e.y - r;
if (Math.sqrt(o * o + a * a) < i) return null;
var s = Math.sign(o),
c = Math.sign(a),
u = Math.atan(a / o);
return {
x: n + Math.abs(i * Math.cos(u)) * s,
y: r + Math.abs(i * Math.sin(u)) * c,
};
},
O = function (t, e) {
var n = t.rx,
r = t.ry,
i = t.x,
o = t.y,
a = e.x - i,
s = e.y - o,
c = Math.atan2(s / r, a / n);
return (
c < 0 && (c += 2 * Math.PI),
{ x: i + n * Math.cos(c), y: o + r * Math.sin(c) }
);
},
M = function (t, e, n) {
void 0 === n && (n = 1);
var r = [t.x, t.y, n];
return (
(e && !isNaN(e[0])) || (e = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
g.d.transformMat3(r, r, e),
{ x: r[0], y: r[1] }
);
},
k = function (t, e, n) {
void 0 === n && (n = 1),
(e && !isNaN(e[0])) || (e = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = g.b.invert([1, 0, 0, 0, 1, 0, 0, 0, 1], e);
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var i = [t.x, t.y, n];
return g.d.transformMat3(i, i, r), { x: i[0], y: i[1] };
},
C = function (t, e, n) {
var r = t.x - e.x,
i = t.y - e.y,
o = t.x - n.x,
a = t.y - n.y,
s = (t.x * t.x - e.x * e.x - e.y * e.y + t.y * t.y) / 2,
c = (t.x * t.x - n.x * n.x - n.y * n.y + t.y * t.y) / 2,
u = i * o - r * a;
return { x: -(a * s - i * c) / u, y: -(r * c - o * s) / u };
},
E = function (t, e) {
var n = t.x - e.x,
r = t.y - e.y;
return Math.sqrt(n * n + r * r);
},
j = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * e);
}),
n.push(r);
}),
n
);
},
P = function (t) {
for (var e = [], n = t.length, r = 0; r < n; r += 1) {
e[r] = [];
for (var i = 0; i < n; i += 1)
r === i
? (e[r][i] = 0)
: 0 !== t[r][i] && t[r][i]
? (e[r][i] = t[r][i])
: (e[r][i] = 1 / 0);
}
for (var o = 0; o < n; o += 1)
for (r = 0; r < n; r += 1)
for (i = 0; i < n; i += 1)
e[r][i] > e[r][o] + e[o][i] && (e[r][i] = e[r][o] + e[o][i]);
return e;
},
A = function (t, e) {
var n = t.nodes,
r = t.edges,
i = [],
o = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
o[t.id] = e;
i.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
a = o[n],
s = o[r];
(i[a][s] = 1), e || (i[s][a] = 1);
}),
i
);
},
I = function (t, e) {
t.translate(e.x, e.y);
},
T = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = t.getCanvasBBox(),
i = e.x - r.minX,
o = e.y - r.minY,
a = y(n, [["t", i, o]]);
t.setMatrix(a);
},
N = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = e;
Object(c.isArray)(e) || (r = [e, e]),
Object(c.isArray)(e) && 1 === e.length && (r = [e[0], e[0]]),
(n = y(n, [["s", r[0], r[1]]])),
t.setMatrix(n);
},
B = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(n = y(n, [["r", e]])),
t.setMatrix(n);
},
L = function (t, e, n) {
for (var r = [], i = 0; i < t; i++) r[i] = 0;
return (
n.forEach(function (t) {
t.source && (r[e[t.source]] += 1),
t.target && (r[e[t.target]] += 1);
}),
r
);
};
function D(t, e, n) {
return (
(n[0] - t[0]) * (e[1] - t[1]) == (e[0] - t[0]) * (n[1] - t[1]) &&
Math.min(t[0], e[0]) <= n[0] &&
n[0] <= Math.max(t[0], e[0]) &&
Math.min(t[1], e[1]) <= n[1] &&
n[1] <= Math.max(t[1], e[1])
);
}
var _ = function (t, e, n) {
var r = !1,
i = t.length;
function o(t) {
return Math.abs(t) < 1e-6 ? 0 : t < 0 ? -1 : 1;
}
if (i <= 2) return !1;
for (var a = 0; a < i; a++) {
var s = t[a],
c = t[(a + 1) % i];
if (D(s, c, [e, n])) return !0;
o(s[1] - n) > 0 != o(c[1] - n) > 0 &&
o(e - ((n - s[1]) * (s[0] - c[0])) / (s[1] - c[1]) - s[0]) < 0 &&
(r = !r);
}
return r;
},
R = function (t, e) {
return !(
e.minX > t.maxX ||
e.maxX < t.minX ||
e.minY > t.maxY ||
e.maxY < t.minY
);
},
F = function (t, e) {
var n = function (t) {
var e = t.map(function (t) {
return t[0];
}),
n = t.map(function (t) {
return t[1];
});
return {
minX: Math.min.apply(null, e),
maxX: Math.max.apply(null, e),
minY: Math.min.apply(null, n),
maxY: Math.max.apply(null, n),
};
},
r = function (t) {
for (var e = [], n = t.length, r = 0; r < n - 1; r++) {
var i = t[r],
o = t[r + 1];
e.push({
from: { x: i[0], y: i[1] },
to: { x: o[0], y: o[1] },
});
}
if (e.length > 1) {
var a = t[0],
s = t[n - 1];
e.push({
from: { x: s[0], y: s[1] },
to: { x: a[0], y: a[1] },
});
}
return e;
};
if (t.length < 2 || e.length < 2) return !1;
var i = n(t),
o = n(e);
if (!R(i, o)) return !1;
var a = !1;
if (
(Object(c.each)(e, function (e) {
if (_(t, e[0], e[1])) return (a = !0), !1;
}),
a)
)
return !0;
if (
(Object(c.each)(t, function (t) {
if (_(e, t[0], t[1])) return (a = !0), !1;
}),
a)
)
return !0;
var s = r(t),
u = r(e),
h = !1;
return (
Object(c.each)(u, function (t) {
if (
(function (t, e) {
var n = !1;
return (
Object(c.each)(t, function (t) {
if (x(t.from, t.to, e.from, e.to)) return (n = !0), !1;
}),
n
);
})(s, t)
)
return (h = !0), !1;
}),
h
);
},
Y = (function () {
function t(t, e, n, r) {
(this.x1 = t), (this.y1 = e), (this.x2 = n), (this.y2 = r);
}
return (
(t.prototype.getBBox = function () {
var t = Math.min(this.x1, this.x2),
e = Math.min(this.y1, this.y2),
n = Math.max(this.x1, this.x2),
r = Math.max(this.y1, this.y2);
return {
x: t,
y: e,
minX: t,
minY: e,
maxX: n,
maxY: r,
width: n - t,
height: r - e,
};
}),
t
);
})(),
X = function (t, e) {
return {
top: [t.minX, t.minY, t.maxX, t.minY],
left: [t.minX, t.minY, t.minX, t.maxY],
bottom: [t.minX, t.maxY, t.maxX, t.maxY],
right: [t.maxX, t.minY, t.maxX, t.maxY],
}[e];
},
z = function (t, e) {
var n = (e.x2 - e.x1) * (t.y1 - e.y1) - (e.y2 - e.y1) * (t.x1 - e.x1),
r = (t.x2 - t.x1) * (t.y1 - e.y1) - (t.y2 - t.y1) * (t.x1 - e.x1),
i = (e.y2 - e.y1) * (t.x2 - t.x1) - (e.x2 - e.x1) * (t.y2 - t.y1);
if (i) {
var o = n / i,
a = r / i;
if (o >= 0 && o <= 1 && a >= 0 && a <= 1) return o;
}
return Number.POSITIVE_INFINITY;
},
W = function (t, e) {
for (
var n = ["top", "left", "bottom", "right"],
r = t.getBBox(),
i = 0,
o = [],
a = 0;
a < 4;
a++
) {
var s = X(r, n[a]),
c = s[0],
u = s[1],
h = s[2],
l = s[3];
(o[a] = x(
{ x: e.x1, y: e.y1 },
{ x: e.x2, y: e.y2 },
{ x: c, y: u },
{ x: h, y: l },
)),
o[a] && (i += 1);
}
return [o, i];
},
q = function (t, e) {
for (
var n = ["top", "left", "bottom", "right"],
r = t.getBBox(),
i = Number.POSITIVE_INFINITY,
o = 0,
a = 0;
a < 4;
a++
) {
var s = X(r, n[a]),
c = s[0],
u = s[1],
h = s[2],
l = s[3],
f = z(e, new Y(c, u, h, l));
(f = Math.abs(f - 0.5)) >= 0 &&
f <= 1 &&
((o += 1), (i = f < i ? f : i));
}
return 0 === o ? -1 : i;
},
V = function (t) {
var e = 0,
n = 0;
if (t.length > 0) {
for (var r = 0, i = t; r < i.length; r++) {
var o = i[r];
(e += o.x), (n += o.y);
}
(e /= t.length), (n /= t.length);
}
return { x: e, y: n };
},
G = function (t, e) {
return Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2);
},
H = function (t, e) {
var n,
r = e.x1,
i = e.y1,
o = e.x2 - r,
a = e.y2 - i,
s = t.x - r,
c = t.y - i,
u = s * o + c * a;
n =
u <= 0 || (u = (s = o - s) * o + (c = a - c) * a) <= 0
? 0
: (u * u) / (o * o + a * a);
var h = s * s + c * c - n;
return h < 0 && (h = 0), h;
},
U = function (t, e, n) {
return (
void 0 === n && (n = 0.001),
Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2) < Math.pow(n, 2)
);
},
Z = function (t, e) {
var n = t.x < e.x,
r = t.x > e.x + e.width,
i = t.y > e.y + e.height,
o = t.y < e.y;
if (!(n || r || i || o)) return 0;
if (i && !n && !r) return Math.pow(e.y + e.height - t.y, 2);
if (o && !n && !r) return Math.pow(t.y - e.y, 2);
if (n && !i && !o) return Math.pow(e.x - t.x, 2);
if (r && !i && !o) return Math.pow(e.x + e.width - t.x, 2);
var a = Math.min(Math.abs(e.x - t.x), Math.abs(e.x + e.width - t.x)),
s = Math.min(Math.abs(e.y - t.y), Math.abs(e.y + e.height - t.y));
return a * a + s * s;
},
K = function (t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = t[3],
a = e.x,
s = e.y,
c = [i - n, o - r];
if (g.c.exactEquals(c, [0, 0])) return NaN;
var u = [-c[1], c[0]];
g.c.normalize(u, u);
var h = [a - n, s - r];
return Math.abs(g.c.dot(h, u));
},
$ = "rgb(95, 149, 255)",
Q = "rgb(253, 253, 253)",
J = "rgb(247, 250, 255)",
tt = "rgb(224, 224, 224)",
et = "rgb(224, 224, 224)",
nt = {
version: "0.0.2",
rootContainerClassName: "root-container",
nodeContainerClassName: "node-container",
edgeContainerClassName: "edge-container",
comboContainerClassName: "combo-container",
delegateContainerClassName: "delegate-container",
defaultLoopPosition: "top",
nodeLabel: {
style: {
fill: "#000",
fontSize: 12,
textAlign: "center",
textBaseline: "middle",
},
offset: 4,
},
defaultNode: {
type: "circle",
style: { lineWidth: 1, stroke: $, fill: "rgb(239, 244, 255)" },
size: 20,
color: $,
linkPoints: { size: 8, lineWidth: 1, fill: J, stroke: $ },
},
nodeStateStyles: {
active: {
fill: J,
stroke: $,
lineWidth: 2,
shadowColor: $,
shadowBlur: 10,
},
selected: {
fill: "rgb(255, 255, 255)",
stroke: $,
lineWidth: 4,
shadowColor: $,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
fill: "rgb(223, 234, 255)",
stroke: "#4572d9",
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: {
fill: "rgb(247, 250, 255)",
stroke: "rgb(191, 213, 255)",
lineWidth: 1,
},
disable: {
fill: "rgb(250, 250, 250)",
stroke: "rgb(224, 224, 224)",
lineWidth: 1,
},
},
edgeLabel: {
style: {
fill: "rgb(0, 0, 0)",
textAlign: "center",
textBaseline: "middle",
fontSize: 12,
},
},
defaultEdge: {
type: "line",
size: 1,
style: { stroke: tt, lineAppendWidth: 2 },
color: tt,
},
edgeStateStyles: {
active: { stroke: $, lineWidth: 1 },
selected: {
stroke: $,
lineWidth: 2,
shadowColor: $,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: $,
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: { stroke: "rgb(234, 234, 234)", lineWidth: 1 },
disable: { stroke: "rgb(245, 245, 245)", lineWidth: 1 },
},
comboLabel: {
style: {
fill: "rgb(0, 0, 0)",
textBaseline: "middle",
fontSize: 12,
},
refY: 10,
refX: 10,
},
defaultCombo: {
type: "circle",
style: {
fill: Q,
lineWidth: 1,
stroke: et,
r: 5,
width: 20,
height: 10,
},
size: [20, 5],
color: et,
padding: [25, 20, 15, 20],
},
comboStateStyles: {
active: { stroke: $, lineWidth: 1, fill: "rgb(247, 250, 255)" },
selected: {
stroke: $,
lineWidth: 2,
fill: Q,
shadowColor: $,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: "#4572d9",
lineWidth: 2,
fill: Q,
"text-shape": { fontWeight: 500 },
},
inactive: { stroke: "rgb(224, 224, 224)", fill: Q, lineWidth: 1 },
disable: {
stroke: "rgb(234, 234, 234)",
fill: "rgb(250, 250, 250)",
lineWidth: 1,
},
},
delegateStyle: {
fill: "#F3F9FF",
fillOpacity: 0.5,
stroke: "#1890FF",
strokeOpacity: 0.9,
lineDash: [5, 5],
},
},
rt = {
" ": 0.3329986572265625,
a: 0.5589996337890625,
A: 0.6569992065429687,
b: 0.58599853515625,
B: 0.6769989013671875,
c: 0.5469985961914062,
C: 0.7279998779296875,
d: 0.58599853515625,
D: 0.705999755859375,
e: 0.554998779296875,
E: 0.63699951171875,
f: 0.37299957275390627,
F: 0.5769989013671875,
g: 0.5909988403320312,
G: 0.7479995727539063,
h: 0.555999755859375,
H: 0.7199996948242188,
i: 0.255999755859375,
I: 0.23699951171875,
j: 0.26699981689453123,
J: 0.5169998168945312,
k: 0.5289993286132812,
K: 0.6899993896484375,
l: 0.23499908447265624,
L: 0.5879989624023437,
m: 0.854998779296875,
M: 0.8819992065429687,
n: 0.5589996337890625,
N: 0.7189987182617188,
o: 0.58599853515625,
O: 0.7669998168945312,
p: 0.58599853515625,
P: 0.6419998168945312,
q: 0.58599853515625,
Q: 0.7669998168945312,
r: 0.3649993896484375,
R: 0.6759994506835938,
s: 0.504998779296875,
S: 0.6319992065429687,
t: 0.354998779296875,
T: 0.6189987182617187,
u: 0.5599990844726562,
U: 0.7139999389648437,
v: 0.48199920654296874,
V: 0.6389999389648438,
w: 0.754998779296875,
W: 0.929998779296875,
x: 0.5089996337890625,
X: 0.63699951171875,
y: 0.4959991455078125,
Y: 0.66199951171875,
z: 0.48699951171875,
Z: 0.6239990234375,
0: 0.6,
1: 0.40099945068359377,
2: 0.6,
3: 0.6,
4: 0.6,
5: 0.6,
6: 0.6,
7: 0.5469985961914062,
8: 0.6,
9: 0.6,
"[": 0.3329986572265625,
"]": 0.3329986572265625,
",": 0.26399993896484375,
".": 0.26399993896484375,
";": 0.26399993896484375,
":": 0.26399993896484375,
"{": 0.3329986572265625,
"}": 0.3329986572265625,
"\\": 0.5,
"|": 0.19499969482421875,
"=": 0.604998779296875,
"+": 0.604998779296875,
"-": 0.604998779296875,
_: 0.5,
"`": 0.3329986572265625,
" ~": 0.8329986572265625,
"!": 0.3329986572265625,
"@": 0.8579986572265625,
"#": 0.6,
$: 0.6,
"%": 0.9699996948242188,
"^": 0.517999267578125,
"&": 0.7259994506835937,
"*": 0.505999755859375,
"(": 0.3329986572265625,
")": 0.3329986572265625,
"<": 0.604998779296875,
">": 0.604998779296875,
"/": 0.5,
"?": 0.53699951171875,
},
it = Math.PI,
ot = Math.sin,
at = Math.cos,
st = ot(it / 8),
ct = at(it / 8),
ut = function (t, e) {
var n = t.getBBox(),
r = { x: n.minX, y: n.minY },
i = { x: n.maxX, y: n.maxY };
if (e) {
var o = e.getMatrix();
o || (o = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = M(r, o)),
(i = M(i, o));
}
var a = r.x,
s = r.y,
c = i.x,
u = i.y;
return {
x: a,
y: s,
minX: a,
minY: s,
maxX: c,
maxY: u,
width: c - a,
height: u - s,
};
},
ht = function (t) {
var e = t.sourceNode || t.targetNode,
n = e.get("group").getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = e.getKeyShape().getBBox(),
i = t.loopCfg || {},
o = i.dist || 2 * Math.max(r.width, r.height),
a = i.position || nt.defaultLoopPosition,
s = [n[6], n[7]],
c = [t.startPoint.x, t.startPoint.y],
u = [t.endPoint.x, t.endPoint.y],
h = r.height / 2,
l = r.height / 2,
f = h * st,
d = h * ct,
p = l * st,
v = l * ct;
if (c[0] === u[0] && c[1] === u[1]) {
switch (a) {
case "top":
(c = [s[0] - f, s[1] - d]), (u = [s[0] + p, s[1] - v]);
break;
case "top-right":
(h = r.height / 2),
(l = r.width / 2),
(c = [s[0] + (f = h * st), s[1] - (d = h * ct)]),
(u = [s[0] + (v = l * ct), s[1] - (p = l * st)]);
break;
case "right":
(h = r.width / 2),
(l = r.width / 2),
(c = [s[0] + (d = h * ct), s[1] - (f = h * st)]),
(u = [s[0] + (v = l * ct), s[1] + (p = l * st)]);
break;
case "bottom-right":
(h = r.width / 2),
(l = r.height / 2),
(c = [s[0] + (d = h * ct), s[1] + (f = h * st)]),
(u = [s[0] + (p = l * st), s[1] + (v = l * ct)]);
break;
case "bottom":
(h = r.height / 2),
(l = r.height / 2),
(c = [s[0] + (f = h * st), s[1] + (d = h * ct)]),
(u = [s[0] - (p = l * st), s[1] + (v = l * ct)]);
break;
case "bottom-left":
(h = r.height / 2),
(l = r.width / 2),
(c = [s[0] - (f = h * st), s[1] + (d = h * ct)]),
(u = [s[0] - (v = l * ct), s[1] + (p = l * st)]);
break;
case "left":
(h = r.width / 2),
(l = r.width / 2),
(c = [s[0] - (d = h * ct), s[1] + (f = h * st)]),
(u = [s[0] - (v = l * ct), s[1] - (p = l * st)]);
break;
case "top-left":
(h = r.width / 2),
(l = r.height / 2),
(c = [s[0] - (d = h * ct), s[1] - (f = h * st)]),
(u = [s[0] - (p = l * st), s[1] - (v = l * ct)]);
break;
default:
(h = r.width / 2),
(l = r.width / 2),
(c = [s[0] - (f = h * st), s[1] - (d = h * ct)]),
(u = [s[0] + (p = l * st), s[1] - (v = l * ct)]);
}
if (!1 === i.clockwise) {
var y = [c[0], c[1]];
(c = [u[0], u[1]]), (u = [y[0], y[1]]);
}
}
var m = [c[0] - s[0], c[1] - s[1]],
b = (h + o) / h,
x = (l + o) / l;
!1 === i.clockwise && ((b = (l + o) / l), (x = (h + o) / h));
var w = g.c.scale([0, 0], m, b),
S = [s[0] + w[0], s[1] + w[1]],
O = [u[0] - s[0], u[1] - s[1]],
M = g.c.scale([0, 0], O, x),
k = [s[0] + M[0], s[1] + M[1]];
return (
(t.startPoint = { x: c[0], y: c[1] }),
(t.endPoint = { x: u[0], y: u[1] }),
(t.controlPoints = [
{ x: S[0], y: S[1] },
{ x: k[0], y: k[1] },
]),
t
);
},
lt = function (t, e, n, r, i) {
var o = [],
a = t.getPoint(e);
if (null === a) return { x: 0, y: 0, angle: 0 };
if (e < 1e-4) o = t.getStartTangent().reverse();
else if (e > 0.9999) o = t.getEndTangent();
else {
var s = t.getPoint(e + 1e-4);
o.push([a.x, a.y]), o.push([s.x, s.y]);
}
var c = Math.atan2(o[1][1] - o[0][1], o[1][0] - o[0][0]);
if (
(c < 0 && (c += 2 * it),
n && ((a.x += at(c) * n), (a.y += ot(c) * n)),
r)
) {
var u = c - it / 2;
c > 0.5 * it && c < 1.5 * it && (u -= it),
(a.x += at(u) * r),
(a.y += ot(u) * r);
}
var h = { x: a.x, y: a.y, angle: c };
return i
? (c > 0.5 * it && c < 1.5 * it && (c -= it),
Object(f.a)({ rotate: c }, h))
: h;
},
ft = function t(e, n) {
if (!1 === n(e)) return !1;
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return !1;
return !0;
},
dt = function (t, e) {
"function" == typeof e && ft(t, e);
},
pt = function (t, e) {
"function" == typeof e &&
(function t(e, n) {
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return;
return !1 !== n(e);
})(t, e);
},
gt = function (t, e) {
return e * (rt[t] || 1);
},
vt = function (t, e) {
var n = 0,
r = new RegExp("[一-龥]+");
return (
t.split("").forEach(function (t) {
r.test(t) ? (n += e) : (n += gt(t, e));
}),
[n, e]
);
},
yt = function (t, e) {
var n = [],
r = {},
i = {};
t.forEach(function (t) {
i[t.id] = t;
}),
t.forEach(function (t, e) {
var o = Object(c.clone)(t);
(o.itemType = "combo"),
(o.children = void 0),
o.parentId === o.id
? (console.warn(
"The parentId for combo ".concat(
o.id,
" can not be the same as the combo's id",
),
),
delete o.parentId)
: o.parentId &&
!i[o.parentId] &&
(console.warn(
"The parent combo for combo ".concat(
o.id,
" does not exist!",
),
),
delete o.parentId);
var a = r[o.id];
if (a) {
if (
((o.children = a.children), (r[o.id] = o), !(a = o).parentId)
)
return void n.push(a);
var s = r[a.parentId];
if (s) s.children ? s.children.push(o) : (s.children = [o]);
else {
var u = { id: a.parentId, children: [a] };
(r[a.parentId] = u), (r[o.id] = o);
}
} else if (Object(c.isString)(t.parentId)) {
var h = r[t.parentId];
if (h)
h.children ? h.children.push(o) : (h.children = [o]),
(r[o.id] = o);
else {
var l = { id: t.parentId, children: [o] };
(r[l.id] = l), (r[o.id] = o);
}
} else n.push(o), (r[o.id] = o);
});
var o = {};
(e || []).forEach(function (t) {
o[t.id] = t;
var e = r[t.comboId];
if (e) {
var n = { id: t.id, comboId: t.comboId };
e.children ? e.children.push(n) : (e.children = [n]),
(n.itemType = "node"),
(r[t.id] = n);
}
});
var a = 0;
return (
n.forEach(function (t) {
(t.depth = a + 10),
ft(t, function (t) {
var e,
n = r[t.id].itemType;
(e = "node" === n ? r[t.comboId] : r[t.parentId]),
(t.depth = e && "node" === n ? a + 1 : a + 10),
a < t.depth && (a = t.depth);
var i = o[t.id];
return i && (i.depth = t.depth), !0;
});
}),
n
);
},
mt = function (t, e, n) {
var r,
i = t,
o = { root: { children: t } },
a = !1,
s = "root";
(t || []).forEach(function (t) {
if (!a)
return t.id === e
? ((r = t),
"combo" === t.itemType ? (r.parentId = n) : (r.comboId = n),
void (a = !0))
: void dt(t, function (t) {
return (
(o[t.id] = { children: t.children }),
(i = o[t.parentId || t.comboId || "root"].children),
!t ||
(!t.removed && e !== t.id) ||
!i ||
((s = t.parentId || t.comboId || "root"),
(r = t),
"combo" === t.itemType
? (r.parentId = n)
: (r.comboId = n),
(a = !0),
!1)
);
});
});
var c = (i = o[s].children) ? i.indexOf(r) : -1;
if (
(c > -1 && i.splice(c, 1),
a ||
((r = { id: e, itemType: "node", comboId: n }),
(o[e] = { children: void 0 })),
e)
) {
var u = !1;
if (n) {
var h = 0;
(t || []).forEach(function (t) {
u ||
dt(t, function (t) {
return (
n !== t.id ||
((u = !0),
t.children ? t.children.push(r) : (t.children = [r]),
(h = t.depth),
"node" === r.itemType
? (r.depth = h + 2)
: (r.depth = h + 1),
!1)
);
});
});
} else (n && u) || "node" === r.itemType || t.push(r);
var l = r.depth;
dt(r, function (t) {
return (
"node" === t.itemType ? (l += 2) : (l += 1), (t.depth = l), !0
);
});
}
return t;
},
bt = function (t, e) {
var n = {
minX: 1 / 0,
minY: 1 / 0,
maxX: -1 / 0,
maxY: -1 / 0,
x: void 0,
y: void 0,
width: void 0,
height: void 0,
centerX: void 0,
centerY: void 0,
};
return t && 0 !== t.length
? (t.forEach(function (t) {
var r = e.findById(t.id);
if (r && r.isVisible()) {
r.set("bboxCanvasCache", void 0);
var i = r.getCanvasBBox();
i.x && n.minX > i.minX && (n.minX = i.minX),
i.y && n.minY > i.minY && (n.minY = i.minY),
i.x && n.maxX < i.maxX && (n.maxX = i.maxX),
i.y && n.maxY < i.maxY && (n.maxY = i.maxY);
}
}),
(n.x = (n.minX + n.maxX) / 2),
(n.y = (n.minY + n.maxY) / 2),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
Object.keys(n).forEach(function (t) {
(n[t] !== 1 / 0 && n[t] !== -1 / 0) || (n[t] = void 0);
}),
n)
: n;
},
xt = function (t) {
var e =
Object(c.isNumber)(t.x) ||
Object(c.isNumber)(t.y) ||
t.type ||
t.anchorPoints ||
t.size;
return (
t.style &&
(e =
e ||
Object(c.isNumber)(t.style.r) ||
Object(c.isNumber)(t.style.width) ||
Object(c.isNumber)(t.style.height) ||
Object(c.isNumber)(t.style.rx) ||
Object(c.isNumber)(t.style.ry)),
e
);
},
wt = function (t) {
var e = {};
return (
Object.keys(t).forEach(function (n) {
var r = t[n];
if (Object(c.isObject)(r)) {
var i = {};
Object.keys(r).forEach(function (t) {
var e = r[t];
("img" !== t || Object(c.isString)(e)) &&
(i[t] = Object(c.clone)(e));
}),
(e[n] = i);
} else e[n] = Object(c.clone)(r);
}),
e
);
},
St = function (t) {
if (!t)
return console.error("G6 Error Tips: the data must be defined"), !1;
var e = t.nodes,
n = t.edges,
r = t.combos,
i = void 0 === r ? [] : r;
if (!e && !n) {
var o = !0;
return (
dt(t, function (t) {
return !!Object(c.isString)(t.id) || ((o = !1), !1);
}),
o
);
}
var a = (e || []).find(function (t) {
return !Object(c.isString)(t.id);
});
if (a)
return (
console.warn(
"G6 Warning Tips: missing 'id' property, or %c".concat(
a.id,
"%c is not a string.",
),
"font-size: 20px; color: red;",
"",
),
!1
);
var s = (e || []).map(function (t) {
return t.id;
}),
u = i.map(function (t) {
return t.id;
}),
h = Object(f.f)(Object(f.f)([], s, !0), u, !0),
l = (n || []).find(function (t) {
return !h.includes(t.source) || !h.includes(t.target);
});
return (
!l ||
(console.warn(
"G6 Warning Tips: The source %c"
.concat(l.source, "%c or the target %c")
.concat(
l.target,
"%c of the edge do not exist in the nodes or combos.",
),
"font-size: 20px; color: red;",
"",
"font-size: 20px; color: red;",
"",
),
!1)
);
},
Ot = (function () {
function t(t) {
(this.graph = t),
(this.destroyed = !1),
(this.modes = t.get("modes") || { default: [] }),
this.formatModes(),
(this.mode = t.get("defaultMode") || "default"),
(this.currentBehaves = []),
this.setMode(this.mode);
}
return (
(t.prototype.formatModes = function () {
var t = this.modes;
Object(c.each)(t, function (t) {
Object(c.each)(t, function (e, n) {
Object(c.isString)(e) && (t[n] = { type: e });
});
});
}),
(t.prototype.setBehaviors = function (t) {
var e,
n = this.graph,
r = this.modes[t],
i = [];
Object(c.each)(r || [], function (t) {
var r = h.getBehavior(t.type || t);
r && (e = new r(t)) && (e.bind(n), i.push(e));
}),
(this.currentBehaves = i);
}),
(t.mergeBehaviors = function (t, e) {
return (
Object(c.each)(e, function (e) {
t.indexOf(e) < 0 &&
(Object(c.isString)(e) && (e = { type: e }), t.push(e));
}),
t
);
}),
(t.filterBehaviors = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = "";
(r = Object(c.isString)(t) ? t : t.type),
e.indexOf(r) < 0 && n.push(t);
}),
n
);
}),
(t.prototype.setMode = function (t) {
var e = this.modes,
n = this.graph,
r = t;
e[r] &&
(n.emit("beforemodechange", { mode: t }),
Object(c.each)(this.currentBehaves, function (t) {
t.delegate && t.delegate.remove(), t.unbind(n);
}),
this.setBehaviors(r),
n.emit("aftermodechange", { mode: t }),
(this.mode = t));
}),
(t.prototype.getMode = function () {
return this.mode;
}),
(t.prototype.manipulateBehaviors = function (e, n, r) {
var i,
o = this;
if (((i = Object(c.isArray)(e) ? e : [e]), Object(c.isArray)(n)))
return (
Object(c.each)(n, function (e) {
o.modes[e]
? (o.modes[e] = r
? t.mergeBehaviors(o.modes[e] || [], i)
: t.filterBehaviors(o.modes[e] || [], i))
: r && (o.modes[e] = i);
}),
this
);
var a = n;
return (
n || (a = this.mode),
this.modes[a] || (r && (this.modes[a] = i)),
(this.modes[a] = r
? t.mergeBehaviors(this.modes[a] || [], i)
: t.filterBehaviors(this.modes[a] || [], i)),
this.setMode(this.mode),
this
);
}),
(t.prototype.updateBehavior = function (t, e, n) {
Object(c.isString)(t) && (t = { type: t });
var r = [];
if (n && n !== this.mode && "default" !== n) {
if (!(r = this.modes[n]) || !r.length)
return (
console.warn(
"Update behavior failed! There is no behaviors in this mode on the graph.",
),
this
);
var i = r.length;
for (a = 0; a < i; a++) {
if ((s = r[a]).type === t.type || s === t.type)
return (
s === t.type && (s = { type: s }),
Object.assign(s, e),
(r[a] = s),
this
);
a === i - 1 &&
console.warn(
"Update behavior failed! There is no such behavior in the mode",
);
}
} else {
if (!(r = this.currentBehaves) || !r.length)
return (
console.warn(
"Update behavior failed! There is no behaviors in this mode on the graph.",
),
this
);
for (var o = r.length, a = 0; a < o; a++) {
var s;
if ((s = r[a]).type === t.type) return s.updateCfg(e), this;
a === o - 1 &&
console.warn(
"Update behavior failed! There is no such behavior in the mode",
);
}
}
return this;
}),
(t.prototype.destroy = function () {
(this.graph = null),
(this.modes = null),
(this.currentBehaves = null),
(this.destroyed = !0);
}),
t
);
})(),
Mt = n(43),
kt = (function (t) {
function e(e, n) {
var r = t.call(this, e, n) || this;
return (
(r.item = n.item),
(r.canvasX = n.canvasX),
(r.canvasY = n.canvasY),
(r.detail = n.detail),
r
);
}
return Object(f.c)(e, t), e;
})(n(6).d),
Ct = function (t) {
return "".concat(t, "-").concat(Math.random()).concat(Date.now());
},
Et = function (t) {
var e = 0,
n = 0,
r = 0,
i = 0;
if (Object(c.isNumber)(t)) e = n = r = i = t;
else if (Object(c.isString)(t)) {
e = n = r = i = parseInt(t, 10);
} else
Object(c.isArray)(t) &&
((e = t[0]),
(r = Object(c.isNil)(t[1]) ? t[0] : t[1]),
(i = Object(c.isNil)(t[2]) ? t[0] : t[2]),
(n = Object(c.isNil)(t[3]) ? r : t[3]));
return [e, r, i, n];
},
jt = function (t) {
var e = new kt(t.type, t);
return (
(e.clientX = t.clientX),
(e.clientY = t.clientY),
(e.x = t.x),
(e.y = t.y),
(e.target = t.target),
(e.currentTarget = t.currentTarget),
(e.bubbles = !0),
(e.item = t.item),
e
);
},
Pt = function (t) {
if (!t) return !1;
for (var e = [1, 0, 0, 0, 1, 0, 0, 0, 1], n = 0; n < 9; n++)
if (t[n] !== e[n]) return !0;
return !1;
},
At = function (t) {
return Number.isNaN(Number(t));
},
It = function (t) {
for (
var e = 1 / 0, n = -1 / 0, r = 1 / 0, i = -1 / 0, o = 0;
o < t.length;
o++
) {
var a = t[o].getBBox(),
s = a.minX,
c = a.minY,
u = a.maxX,
h = a.maxY;
s < e && (e = s),
c < r && (r = c),
u > n && (n = u),
h > i && (i = h);
}
return {
x: Math.floor(e),
y: Math.floor(r),
width: Math.ceil(n) - Math.floor(e),
height: Math.ceil(i) - Math.floor(r),
minX: e,
minY: r,
maxX: n,
maxY: i,
};
},
Tt = function (t, e, n, r, i) {
void 0 === e && (e = 15),
void 0 === n && (n = "quadratic"),
void 0 === r && (r = void 0),
void 0 === i && (i = void 0);
for (
var o = t.length,
a = 2 * e,
s = [
"top",
"top-right",
"right",
"bottom-right",
"bottom",
"bottom-left",
"left",
"top-left",
],
c = {},
u = [],
h = {},
l = 0;
l < o;
l++
) {
var f = t[l],
d = f.source,
p = f.target,
g = "".concat(d, "-").concat(p);
if (!u[l]) {
c[g] || (c[g] = []), (u[l] = !0), c[g].push(f);
for (var v = 0; v < o; v++)
if (l !== v) {
var y = t[v],
m = y.source,
b = y.target;
u[v] ||
(d === b && p === m
? (c[g].push(y),
(u[v] = !0),
(h[
""
.concat(m, "|")
.concat(b, "|")
.concat(c[g].length - 1)
] = !0))
: d === m && p === b && (c[g].push(y), (u[v] = !0)));
}
}
}
for (var x in c)
for (var w = c[x], S = w.length, O = 0; O < S; O++) {
var M = w[O];
if (M.source !== M.target)
if (1 === S && r && M.source !== M.target) M.type = r;
else {
M.type = n;
var k =
(O % 2 == 0 ? 1 : -1) *
(h["".concat(M.source, "|").concat(M.target, "|").concat(O)]
? -1
: 1);
M.curveOffset =
S % 2 == 1
? k * Math.ceil(O / 2) * a
: k * (Math.floor(O / 2) * a + e);
}
else
i && (M.type = i),
(M.loopCfg = {
position: s[O % 8],
dist: 20 * Math.floor(O / 8) + 50,
});
}
return t;
},
Nt = (function () {
function t(t) {
(this.destroyed = !1), (this.graph = t), (this.destroyed = !1);
}
return (
(t.prototype.getViewCenter = function () {
var t = this.getFormatPadding(),
e = this.graph,
n = this.graph.get("width"),
r = e.get("height");
return {
x: (n - t[1] - t[3]) / 2 + t[3],
y: (r - t[0] - t[2]) / 2 + t[0],
};
}),
(t.prototype.fitCenter = function () {
var t = this.graph,
e = t.get("group");
e.resetMatrix();
var n = e.getCanvasBBox();
if (0 !== n.width && 0 !== n.height) {
var r = this.getViewCenter(),
i = n.x + n.width / 2,
o = n.y + n.height / 2;
t.translate(r.x - i, r.y - o);
}
}),
(t.prototype.fitView = function () {
var t = this.graph,
e = this.getFormatPadding(),
n = t.get("width"),
r = t.get("height"),
i = t.get("group");
i.resetMatrix();
var o = i.getCanvasBBox();
if (0 !== o.width && 0 !== o.height) {
var a = this.getViewCenter(),
s = o.x + o.width / 2,
c = o.y + o.height / 2;
t.translate(a.x - s, a.y - c);
var u = (n - e[1] - e[3]) / o.width,
h = (r - e[0] - e[2]) / o.height,
l = u;
u > h && (l = h), t.zoom(l, a);
}
}),
(t.prototype.getFormatPadding = function () {
var t = this.graph.get("fitViewPadding");
return Et(t);
}),
(t.prototype.focusPoint = function (t, e, n) {
var r = this,
i = this.getViewCenter(),
o = this.getPointByCanvas(i.x, i.y),
a = this.graph.get("group").getMatrix();
if ((a || (a = [1, 0, 0, 0, 1, 0, 0, 0, 1]), e)) {
var s = (o.x - t.x) * a[0],
c = (o.y - t.y) * a[4],
u = 0,
h = 0,
l = 0,
d = 0;
this.graph.get("canvas").animate(
function (t) {
(l = s * t),
(d = c * t),
r.graph.translate(l - u, d - h),
(u = l),
(h = d);
},
Object(f.a)({}, n),
);
} else
this.graph.translate((o.x - t.x) * a[0], (o.y - t.y) * a[4]);
}),
(t.prototype.getPointByCanvas = function (t, e) {
var n = this.graph.get("group").getMatrix();
return (
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]), k({ x: t, y: e }, n)
);
}),
(t.prototype.getPointByClient = function (t, e) {
var n = this.graph.get("canvas").getPointByClient(t, e);
return this.getPointByCanvas(n.x, n.y);
}),
(t.prototype.getClientByPoint = function (t, e) {
var n = this.graph.get("canvas"),
r = this.getCanvasByPoint(t, e),
i = n.getClientByPoint(r.x, r.y);
return { x: i.x, y: i.y };
}),
(t.prototype.getCanvasByPoint = function (t, e) {
var n = this.graph.get("group").getMatrix();
return (
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]), M({ x: t, y: e }, n)
);
}),
(t.prototype.focus = function (t, e, n) {
if ((Object(c.isString)(t) && (t = this.graph.findById(t)), t)) {
var r = 0,
i = 0;
if (t.getType && "edge" === t.getType()) {
var o = t.getSource().get("group").getMatrix(),
a = t.getTarget().get("group").getMatrix();
o && a
? ((r = (o[6] + a[6]) / 2), (i = (o[7] + a[7]) / 2))
: (o || a) &&
((r = o ? o[6] : a[6]), (i = o ? o[7] : a[7]));
} else {
var s = t.get("group").getMatrix();
s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = s[6]),
(i = s[7]);
}
this.focusPoint({ x: r, y: i }, e, n);
}
}),
(t.prototype.changeSize = function (t, e) {
var n = this.graph;
if (!Object(c.isNumber)(t) || !Object(c.isNumber)(e))
throw Error(
"invalid canvas width & height, please make sure width & height type is number",
);
n.set({ width: t, height: e }),
n.get("canvas").changeSize(t, e),
n.get("plugins").forEach(function (r) {
if (r.get("gridContainer")) {
var i = n.get("minZoom");
Object(Mt.b)(r.get("container"), {
width: "".concat(t, "px"),
height: "".concat(e, "px"),
}),
Object(Mt.b)(r.get("gridContainer"), {
width: "".concat(t / i, "px"),
height: "".concat(e / i, "px"),
left: 0,
top: 0,
});
}
});
}),
(t.prototype.destroy = function () {
(this.graph = null), (this.destroyed = !1);
}),
t
);
})();
function Bt(t) {
return (Bt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Lt(t) {
if ("string" != typeof t) return t;
var e = function (t) {
if ("string" != typeof t) return t;
try {
return JSON.parse(t.trim());
} catch (e) {
return t.trim();
}
},
n = e(t);
if ("string" != typeof n) return n;
for (
var r = function (t) {
return t[t.length - 1];
},
i = t.trim(),
o = [],
a = [],
s = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
return t.some(function (t) {
return r(a) === t;
});
},
c = null,
u = 0,
h = "";
u < i.length;
) {
var l = i[u],
f = s('"', "'");
if (f || l.trim()) {
var d = "\\" === i[u - 1],
p = s("}"),
g = s("]"),
v = s(","),
y = r(o);
if (f)
if (r(a) !== l || d) h += l;
else {
a.pop();
var m = e(h);
y.push(m), (c = m), (h = "");
}
else if (g && "," === l) h && (y.push(e(h)), (h = ""));
else if (p && ":" === l) a.push(","), h && (y.push(h), (h = ""));
else if (v && "," === l) h && (y.push(e(h)), (h = "")), a.pop();
else if ("}" === l && (p || v)) {
h && (y.push(e(h)), (h = "")), v && a.pop();
for (var b = {}, x = 1; x < y.length; x += 2) b[y[x - 1]] = y[x];
o.pop(), o.length && r(o).push(b), a.pop(), (c = b);
} else
"]" === l && g
? (h && (y.push(e(h)), (h = "")),
o.pop(),
o.length && r(o).push(y),
a.pop(),
(c = y))
: "{" === l
? (o.push([]), a.push("}"))
: "[" === l
? (o.push([]), a.push("]"))
: '"' === l
? a.push('"')
: "'" === l
? a.push("'")
: (h += l);
u += 1;
} else u += 1;
}
return c || h;
}
function Dt(t, e) {
var n;
void 0 === e && (e = { x: 0, y: 0 });
var r = Object(f.a)({ x: 0, y: 0, width: 0, height: 0 }, e);
if (null === (n = t.children) || void 0 === n ? void 0 : n.length) {
var i = t.attrs,
o = void 0 === i ? {} : i,
a = o.marginTop,
s = Object(f.a)({}, e);
a && (s.y += a);
for (var c = 0; c < t.children.length; c++) {
t.children[c].attrs.key = ""
.concat(o.key || "root", " -")
.concat(c, " ");
var u = Dt(t.children[c], s);
if (u.bbox) {
var h = u.bbox;
"inline" === u.attrs.next
? (s.x += u.bbox.width)
: (s.y += u.bbox.height),
h.width + h.x > r.width && (r.width = h.width + h.x),
h.height + h.y > r.height && (r.height = h.height + h.y);
}
}
}
return (
(t.bbox = (function (t, e, n) {
var r,
i,
o = t.attrs,
a = void 0 === o ? {} : o,
s = {
x: e.x || 0,
y: e.y || 0,
width: n.width || 0,
height: n.height || 0,
};
switch (t.type) {
case "maker":
case "circle":
a.r && ((i = 2 * a.r), (r = 2 * a.r));
break;
case "text":
a.text &&
((i = vt(a.text, a.fontSize || 12)[0]),
(r = 16),
(s.y += r),
(s.height = r),
(s.width = i),
(t.attrs = Object(f.a)({ fontSize: 12, fill: "#000" }, a)));
break;
default:
a.width && (i = a.width), a.height && (r = a.height);
}
return (
r >= 0 && (s.height = r),
i >= 0 && (s.width = i),
a.marginTop && (s.y += a.marginTop),
a.marginLeft && (s.x += a.marginLeft),
s
);
})(t, e, r)),
(t.attrs = Object(f.a)(Object(f.a)({}, t.attrs), t.bbox)),
t
);
}
function _t(t) {
var e = {},
n = function (e) {
var n = (function (t) {
return function (e) {
for (var n = t.length, r = [], i = 0, o = ""; i < n; )
if ("{" === t[i] && "{" === t[i + 1])
r.push(o), (o = ""), (i += 2);
else if ("}" === t[i] && "}" === t[i + 1]) {
if (r.length) {
var a = r.pop();
(o = Object(c.get)(
e,
o,
a.endsWith("=") ? '"{'.concat(o, '}"') : o,
)),
r.push(a + o);
}
(i += 2), (o = "");
} else (o += t[i]), (i += 1);
return (
r.push(o),
r
.map(function (t, e) {
return r[e - 1] && r[e - 1].endsWith("=")
? '"{'.concat(t, '}"')
: t;
})
.join("")
);
};
})("function" == typeof t ? t(e) : t)(e),
r = document.createElement("div");
r.innerHTML = n;
var i = Dt(
(function t(e, n) {
var r = {},
i = (e.getAttributeNames && e.getAttributeNames()) || [],
o =
e.children &&
Array.from(e.children).map(function (e) {
return t(e, n);
}),
a = {},
s = e.tagName ? e.tagName.toLowerCase() : "group";
return (
"text" === s && (r.text = e.innerText),
(a.type = s),
"img" === s && (a.type = "image"),
Array.from(i).forEach(function (t) {
var n = t.split("-").reduce(function (t, e) {
return t + e.charAt(0).toUpperCase() + e.slice(1);
}),
i = e.getAttribute(t);
try {
if ("style" === n || "attrs" === n) {
var o = Lt(i);
r = Object(f.a)(Object(f.a)({}, r), o);
} else a[n] = Lt(i);
} catch (t) {
if ("style" === n) throw t;
a[n] = i;
}
}),
(a.attrs = r),
n &&
n.style &&
a.name &&
"object" === Bt(n.style[a.name]) &&
(a.attrs = Object(f.a)(
Object(f.a)({}, a.attrs),
n.style[a.name],
)),
n &&
n.style &&
a.keyshape &&
(a.attrs = Object(f.a)(Object(f.a)({}, a.attrs), n.style)),
o.length && (a.children = o),
a
);
})(r.children[0], e),
);
return r.remove(), i;
};
return {
draw: function (t, r) {
var i = n(t),
o = r;
return (
(function t(e) {
var n = e.attrs,
i = void 0 === n ? {} : n,
a = e.bbox,
s = e.type,
c = e.children,
u = Object(f.e)(e, ["attrs", "bbox", "type", "children"]);
if ("group" !== e.type) {
var h = r.addShape(
e.type,
Object(f.a)(
{ attrs: i, origin: { bbox: a, type: s, children: c } },
u,
),
);
e.keyshape && (o = h);
}
e.children &&
e.children.forEach(function (e) {
return t(e);
});
})(i),
(e[t.id] = [i]),
o
);
},
update: function (t, r) {
e[t.id] || (e[t.id] = []);
var i = r.getContainer(),
o = i.get("children"),
a = n(t),
s = (function t(e, n) {
var r,
i,
o,
a,
s = (e || {}).type,
c = ((null == n ? void 0 : n.attrs) || {}).key;
if ((c && e && (e.attrs.key = c), !e && n))
return { action: "delete", val: n, type: s, key: c };
if (e && !n) return { action: "add", val: e, type: s };
if (!e && !n) return { action: "same", type: s };
var u = [];
if (
(null === (r = e.children) || void 0 === r
? void 0
: r.length) > 0 ||
(null === (i = n.children) || void 0 === i
? void 0
: i.length) > 0
)
for (
var h = Math.max(
null === (o = e.children) || void 0 === o
? void 0
: o.length,
null === (a = n.children) || void 0 === a
? void 0
: a.length,
),
l = n.children || [],
f = e.children || [],
d = 0;
d < h;
d += 1
)
u.push(t(f[d], l[d]));
var p = Object.keys(n.attrs),
g = Object.keys(e.attrs);
return n.type !== e.type
? {
action: "restructure",
nowTarget: e,
formerTarget: n,
key: c,
children: u,
}
: p
.filter(function (t) {
return "children" !== t;
})
.some(function (t) {
return e.attrs[t] !== n.attrs[t] || !g.includes(t);
})
? { action: "change", val: e, children: u, type: s, key: c }
: { action: "same", children: u, type: s, key: c };
})(a, e[t.id].pop()),
c = function t(e) {
var n;
"group" !== e.type && i.addShape(e.type, { attrs: e.attrs }),
(null === (n = e.children) || void 0 === n
? void 0
: n.length) &&
e.children.map(function (e) {
return t(e);
});
},
u = function t(e) {
var n,
r = o.find(function (t) {
return t.attrs.key === e.attrs.key;
});
r && i.removeChild(r),
(null === (n = e.children) || void 0 === n
? void 0
: n.length) &&
e.children.map(function (e) {
return t(e);
});
};
!(function t(e) {
var n = e.key;
if ("group" !== e.type) {
var i = o.find(function (t) {
return t.attrs.key === n;
});
switch (e.action) {
case "change":
if (i) {
var a = e.val.keyshape ? r.getOriginStyle() : {};
i.attr(Object(f.a)(Object(f.a)({}, a), e.val.attrs));
}
break;
case "add":
c(e.val);
break;
case "delete":
u(e.val);
break;
case "restructure":
u(e.formerTarget), c(e.nowTarget);
}
}
e.children &&
e.children.forEach(function (e) {
return t(e);
});
})(s),
e[t.id].push(a);
},
getAnchorPoints: function () {
return [
[0, 0.5],
[1, 0.5],
[0.5, 1],
[0.5, 0],
];
},
};
}
var Rt = {};
function Ft(t) {
return Rt[t] || (Rt[t] = Object(c.upperFirst)(t)), Rt[t];
}
var Yt = {
defaultShapeType: "defaultType",
className: null,
getShape: function (t) {
return (
this[t] || this[this.defaultShapeType] || this["simple-circle"]
);
},
draw: function (t, e, n) {
var r = this.getShape(t),
i = r.draw(e, n);
return r.afterDraw && r.afterDraw(e, n, i), i;
},
baseUpdate: function (t, e, n) {
var r = this.getShape(t);
r.update && r.update(e, n), r.afterUpdate && r.afterUpdate(e, n);
},
setState: function (t, e, n, r) {
this.getShape(t).setState(e, n, r);
},
shouldUpdate: function (t) {
return !!this.getShape(t).update;
},
getControlPoints: function (t, e) {
return this.getShape(t).getControlPoints(e);
},
getAnchorPoints: function (t, e) {
return this.getShape(t).getAnchorPoints(e);
},
},
Xt = {
options: {},
draw: function (t, e) {
return this.drawShape(t, e);
},
drawShape: function () {},
afterDraw: function () {},
afterUpdate: function () {},
setState: function () {},
getControlPoints: function (t) {
return t.controlPoints;
},
getAnchorPoints: function (t) {
var e = this.options.anchorPoints;
return t.anchorPoints || e;
},
},
zt = (function () {
function t() {}
return (
(t.registerFactory = function (e, n) {
var r = Ft(e),
i = Yt,
o = Object(f.a)(Object(f.a)({}, i), n);
return (t[r] = o), (o.className = r), o;
}),
(t.getFactory = function (e) {
return t[Ft(e)];
}),
(t.registerNode = function (e, n, r) {
var i,
o = t.Node;
if ("string" == typeof n || "function" == typeof n) {
var a = _t(n);
i = Object(f.a)(Object(f.a)({}, o.getShape("single-node")), a);
} else if (n.jsx) {
a = _t(n.jsx);
i = Object(f.a)(
Object(f.a)(Object(f.a)({}, o.getShape("single-node")), a),
n,
);
} else {
o.getShape(r);
var s = r ? o.getShape(r) : Xt;
i = Object(f.a)(Object(f.a)({}, s), n);
}
return (i.type = e), (i.itemType = "node"), (o[e] = i), i;
}),
(t.registerEdge = function (e, n, r) {
var i = t.Edge,
o = r ? i.getShape(r) : Xt,
a = Object(f.a)(Object(f.a)({}, o), n);
return (a.type = e), (a.itemType = "edge"), (i[e] = a), a;
}),
(t.registerCombo = function (e, n, r) {
var i = t.Combo,
o = r ? i.getShape(r) : Xt,
a = Object(f.a)(Object(f.a)({}, o), n);
return (a.type = e), (a.itemType = "combo"), (i[e] = a), a;
}),
t
);
})(),
Wt = zt;
zt.registerFactory("node", { defaultShapeType: "circle" }),
zt.registerFactory("edge", { defaultShapeType: "line" }),
zt.registerFactory("combo", { defaultShapeType: "circle" });
var qt = (function () {
function t(t) {
(this._cfg = {}), (this.destroyed = !1);
var e = {
id: void 0,
type: "item",
model: {},
group: void 0,
animate: !1,
visible: !0,
locked: !1,
event: !0,
keyShape: void 0,
states: [],
};
this._cfg = Object.assign(e, this.getDefaultCfg(), t);
var n = this.get("model"),
r = n.id,
i = this.get("type");
r || ((r = Ct(i)), (this.get("model").id = r)), this.set("id", r);
var o = t.group;
o && (o.set("item", this), o.set("id", r)),
this.init(),
this.draw();
var a = n.shape || n.type || ("edge" === i ? "line" : "circle"),
s = this.get("shapeFactory");
if (s && s[a]) {
var u = s[a].options;
if (u && u.stateStyles) {
var h = this.get("styles") || n.stateStyles;
(h = Object(c.deepMix)({}, u.stateStyles, h)),
this.set("styles", h);
}
}
}
return (
(t.prototype.calculateBBox = function () {
var t = this.get("keyShape"),
e = this.get("group"),
n = ut(t, e);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
n
);
}),
(t.prototype.calculateCanvasBBox = function () {
var t = this.get("keyShape"),
e = this.get("group"),
n = ut(t, e);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
n
);
}),
(t.prototype.drawInner = function () {
var t = this.get("shapeFactory"),
e = this.get("group"),
n = this.get("model");
e.clear();
var r = n.visible;
if ((void 0 === r || r || this.changeVisibility(r), t)) {
this.updatePosition(n);
var i = this.getShapeCfg(n),
o = i.type,
a = t.draw(o, i, e);
a &&
(this.set("keyShape", a),
a.set("isKeyShape", !0),
a.set("draggable", !0)),
this.setOriginStyle(),
this.set("currentShape", o),
this.restoreStates(t, o);
}
}),
(t.prototype.setOriginStyle = function () {
var t = this.get("group").get("children"),
e = this.getKeyShape(),
n = this,
r = e.get("name");
if (this.get("originStyle")) {
var i = this.getOriginStyle();
r && !i[r] && (i[r] = {});
var o = this.getCurrentStatesStyle();
Object(c.each)(t, function (t) {
var e = t.get("name"),
a = t.attr();
if (e && e !== r) {
var s = o[e];
i[e] || (i[e] = {}),
s
? Object.keys(a).forEach(function (t) {
var n = a[t];
n !== s[t] && (i[e][t] = n);
})
: (i[e] =
"image" !== t.get("type")
? Object(c.clone)(a)
: n.getShapeStyleByName(e));
} else {
var u = t.attr(),
h = Object(f.a)(Object(f.a)({}, o), o[r]);
Object.keys(u).forEach(function (t) {
var e = u[t];
h[t] !== e && (r ? (i[r][t] = e) : (i[t] = e));
});
}
}),
i.path && delete i.path,
i.matrix && delete i.matrix,
i.x && delete i.x,
i.y && delete i.y,
i[r] && i[r].x && delete i[r].x,
i[r] && i[r].y && delete i[r].y,
n.set("originStyle", i);
} else {
var a = {};
Object(c.each)(t, function (t) {
var e = t.get("type"),
i = t.get("name");
if (i && i !== r)
a[i] =
"image" !== e
? Object(c.clone)(t.attr())
: n.getShapeStyleByName(i);
else {
var o = n.getShapeStyleByName();
if (
(o.path && delete o.path, o.matrix && delete o.matrix, r)
)
if (i) a[r] = o;
else {
var s = Ct("shape");
t.set("name", s),
(a[s] =
"image" !== e
? Object(c.clone)(t.attr())
: n.getShapeStyleByName(i));
}
else Object.assign(a, o);
}
}),
n.set("originStyle", a);
}
}),
(t.prototype.restoreStates = function (t, e) {
var n = this,
r = n.get("states");
Object(c.each)(r, function (r) {
t.setState(e, r, !0, n);
});
}),
(t.prototype.init = function () {
var t = Wt.getFactory(this.get("type"));
this.set("shapeFactory", t);
}),
(t.prototype.get = function (t) {
return this._cfg[t];
}),
(t.prototype.set = function (t, e) {
Object(c.isPlainObject)(t)
? (this._cfg = Object(f.a)(Object(f.a)({}, this._cfg), t))
: (this._cfg[t] = e);
}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.clearCache = function () {
this.set("bboxCache", null), this.set("bboxCanvasCache", null);
}),
(t.prototype.beforeDraw = function () {}),
(t.prototype.afterDraw = function () {}),
(t.prototype.afterUpdate = function () {}),
(t.prototype.draw = function () {
this.beforeDraw(), this.drawInner(), this.afterDraw();
}),
(t.prototype.getShapeStyleByName = function (t) {
var e,
n = this.get("group");
if (
(e = t
? n.find(function (e) {
return e.get("name") === t;
})
: this.getKeyShape())
) {
var r = {};
return (
Object(c.each)(e.attr(), function (t, e) {
"img" !== e && (r[e] = t);
}),
r
);
}
return {};
}),
(t.prototype.getShapeCfg = function (t) {
var e = this.get("styles");
if (e) {
var n = t;
return (n.style = Object(f.a)(Object(f.a)({}, e), t.style)), n;
}
return t;
}),
(t.prototype.getStateStyle = function (t) {
var e = this.get("styles");
return e && e[t];
}),
(t.prototype.getOriginStyle = function () {
return this.get("originStyle");
}),
(t.prototype.getCurrentStatesStyle = function () {
var t = this,
e = {},
n = t.getStates();
return n && n.length
? (Object(c.each)(t.getStates(), function (n) {
e = Object.assign(e, t.getStateStyle(n));
}),
e)
: this.getOriginStyle();
}),
(t.prototype.setState = function (t, e) {
var n = this.get("states"),
r = this.get("shapeFactory"),
i = t,
o = t;
Object(c.isString)(e) &&
((i = "".concat(t, ":").concat(e)), (o = "".concat(t, ":")));
var a = n;
if (Object(c.isBoolean)(e)) {
var s = n.indexOf(o);
if (e) {
if (s > -1) return;
n.push(i);
} else s > -1 && n.splice(s, 1);
} else if (Object(c.isString)(e)) {
var u = n.filter(function (t) {
return t.includes(o);
});
u.length > 0 && this.clearStates(u),
(a = a.filter(function (t) {
return !t.includes(o);
})).push(i),
this.set("states", a);
}
if (r) {
var h = this.get("model").type;
r.setState(h, t, e, this);
}
}),
(t.prototype.clearStates = function (t) {
var e = this,
n = e.getStates(),
r = e.get("shapeFactory"),
i = e.get("model").type;
t || (t = n), Object(c.isString)(t) && (t = [t]);
var o = n.filter(function (e) {
return -1 === t.indexOf(e);
});
e.set("states", o),
t.forEach(function (t) {
r.setState(i, t, !1, e);
});
}),
(t.prototype.getContainer = function () {
return this.get("group");
}),
(t.prototype.getKeyShape = function () {
return this.get("keyShape");
}),
(t.prototype.getModel = function () {
return this.get("model");
}),
(t.prototype.getType = function () {
return this.get("type");
}),
(t.prototype.getID = function () {
return this.get("id");
}),
(t.prototype.isItem = function () {
return !0;
}),
(t.prototype.getStates = function () {
return this.get("states");
}),
(t.prototype.hasState = function (t) {
return this.getStates().indexOf(t) >= 0;
}),
(t.prototype.refresh = function () {
var t = this.get("model");
this.updatePosition(t),
this.updateShape(),
this.afterUpdate(),
this.clearCache();
}),
(t.prototype.isOnlyMove = function (t) {
return !1;
}),
(t.prototype.update = function (t, e) {
void 0 === e && (e = !1);
var n = this.get("model"),
r = n.visible,
i = t.visible;
r !== i && void 0 !== i && this.changeVisibility(i);
var o = n.x,
a = n.y;
(t.x = isNaN(t.x) ? n.x : t.x), (t.y = isNaN(t.y) ? n.y : t.y);
var s = this.get("styles");
if (t.stateStyles) {
var u = t.stateStyles;
Object(c.mix)(s, u), delete t.stateStyles;
}
Object.assign(n, t),
e
? this.updatePosition(t)
: ((o === t.x && a === t.y) || this.updatePosition(t),
this.updateShape()),
this.afterUpdate(),
this.clearCache();
}),
(t.prototype.updateShape = function () {
var t = this.get("shapeFactory"),
e = this.get("model"),
n = e.type;
if (t.shouldUpdate(n) && n === this.get("currentShape")) {
var r = this.getShapeCfg(e);
t.baseUpdate(n, r, this), this.setOriginStyle();
} else this.draw();
this.restoreStates(t, n);
}),
(t.prototype.updatePosition = function (t) {
var e = this.get("model"),
n = Object(c.isNil)(t.x) ? e.x : t.x,
r = Object(c.isNil)(t.y) ? e.y : t.y,
i = this.get("group");
if (Object(c.isNil)(n) || Object(c.isNil)(r)) return !1;
(e.x = n), (e.y = r);
var o = i.getMatrix();
return (
(!o || o[6] !== n || o[7] !== r) &&
(i.resetMatrix(), I(i, { x: n, y: r }), this.clearCache(), !0)
);
}),
(t.prototype.getBBox = function () {
var t = this.get("bboxCache");
return (
t || ((t = this.calculateBBox()), this.set("bboxCache", t)), t
);
}),
(t.prototype.getCanvasBBox = function () {
var t = this.get("bboxCanvasCache");
return (
t ||
((t = this.calculateCanvasBBox()),
this.set("bboxCanvasCache", t)),
t
);
}),
(t.prototype.toFront = function () {
this.get("group").toFront();
}),
(t.prototype.toBack = function () {
this.get("group").toBack();
}),
(t.prototype.show = function () {
this.changeVisibility(!0);
}),
(t.prototype.hide = function () {
this.changeVisibility(!1);
}),
(t.prototype.changeVisibility = function (t) {
var e = this.get("group");
t ? e.show() : e.hide(), this.set("visible", t);
}),
(t.prototype.isVisible = function () {
return this.get("visible");
}),
(t.prototype.enableCapture = function (t) {
var e = this.get("group");
e && e.set("capture", t);
}),
(t.prototype.destroy = function () {
if (!this.destroyed) {
var t = this.get("animate"),
e = this.get("group");
t && e.stopAnimate(),
this.clearCache(),
e.remove(),
(this._cfg = null),
(this.destroyed = !0);
}
}),
t
);
})(),
Vt = { source: "start", target: "end" },
Gt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(f.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return {
type: "edge",
sourceNode: null,
targetNode: null,
startPoint: null,
endPoint: null,
linkCenter: !1,
};
}),
(e.prototype.setEnd = function (t, e) {
var n = Vt[t] + "Point",
r = t + "Node",
i = this.get(r);
i && !i.destroyed && i.removeEdge(this),
Object(c.isPlainObject)(e)
? (this.set(n, e), this.set(r, null))
: (e.addEdge(this), this.set(r, e), this.set(n, null));
}),
(e.prototype.getLinkPoint = function (t, e, n) {
var r = Vt[t] + "Point",
i = t + "Node",
o = this.get(r);
if (!o) {
var a = this.get(i),
s = t + "Anchor",
u = this.getPrePoint(t, n),
h = e[s];
Object(c.isNil)(h) || (o = a.getLinkPointByAnchor(h)),
(o = o || a.getLinkPoint(u)),
Object(c.isNil)(o.index) ||
this.set("".concat(t, "AnchorIndex"), o.index);
}
return o;
}),
(e.prototype.getPrePoint = function (t, e) {
if (e && e.length) return e["source" === t ? 0 : e.length - 1];
var n = "source" === t ? "target" : "source";
return this.getEndPoint(n);
}),
(e.prototype.getEndPoint = function (t) {
var e = t + "Node",
n = Vt[t] + "Point",
r = this.get(e);
return r ? r.get("model") : this.get(n);
}),
(e.prototype.getControlPointsByCenter = function (t) {
var e = this.getEndPoint("source"),
n = this.getEndPoint("target"),
r = this.get("shapeFactory"),
i = t.type;
return r.getControlPoints(i, { startPoint: e, endPoint: n });
}),
(e.prototype.getEndCenter = function (t) {
var e = t + "Node",
n = Vt[t] + "Point",
r = this.get(e);
if (r) {
var i = r.getBBox();
return { x: i.centerX, y: i.centerY };
}
return this.get(n);
}),
(e.prototype.init = function () {
t.prototype.init.call(this),
this.setSource(this.get("source")),
this.setTarget(this.get("target"));
}),
(e.prototype.getShapeCfg = function (e) {
var n = this.get("linkCenter"),
r = t.prototype.getShapeCfg.call(this, e);
if (n)
(r.startPoint = this.getEndCenter("source")),
(r.endPoint = this.getEndCenter("target"));
else {
var i = r.controlPoints || this.getControlPointsByCenter(r);
(r.startPoint = this.getLinkPoint("source", e, i)),
(r.endPoint = this.getLinkPoint("target", e, i));
}
return (
(r.sourceNode = this.get("sourceNode")),
(r.targetNode = this.get("targetNode")),
r
);
}),
(e.prototype.getModel = function () {
var t = this.get("model"),
e = this.get("source".concat("Node")),
n = this.get("target".concat("Node"));
return (
e
? delete t["source".concat("Node")]
: (t.source = this.get("start".concat("Point"))),
n
? delete t["target".concat("Node")]
: (t.target = this.get("end".concat("Point"))),
Object(c.isString)(t.source) ||
Object(c.isPlainObject)(t.source) ||
(t.source = t.source.getID()),
Object(c.isString)(t.target) ||
Object(c.isPlainObject)(t.target) ||
(t.target = t.target.getID()),
t
);
}),
(e.prototype.setSource = function (t) {
this.setEnd("source", t), this.set("source", t);
}),
(e.prototype.setTarget = function (t) {
this.setEnd("target", t), this.set("target", t);
}),
(e.prototype.getSource = function () {
return this.get("source");
}),
(e.prototype.getTarget = function () {
return this.get("target");
}),
(e.prototype.updatePosition = function () {
return !1;
}),
(e.prototype.update = function (t, e) {
void 0 === e && (e = !1);
var n = this.get("model"),
r = n.visible,
i = t.visible;
r !== i && void 0 !== i && this.changeVisibility(i);
var o = this.get("styles");
if (t.stateStyles) {
var a = t.stateStyles;
Object(c.mix)(o, a), delete t.stateStyles;
}
Object.assign(n, t),
this.updateShape(),
this.afterUpdate(),
this.clearCache();
}),
(e.prototype.destroy = function () {
var e = this.get("source".concat("Node")),
n = this.get("target".concat("Node"));
e && !e.destroyed && e.removeEdge(this),
n && !n.destroyed && n.removeEdge(this),
t.prototype.destroy.call(this);
}),
e
);
})(qt),
Ht = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(f.c)(e, t),
(e.prototype.getNearestPoint = function (t, e) {
for (
var n = 0, r = t[0], i = E(t[0], e), o = 0;
o < t.length;
o++
) {
var a = t[o],
s = E(a, e);
s < i && ((r = a), (i = s), (n = o));
}
return (r.anchorIndex = n), r;
}),
(e.prototype.getDefaultCfg = function () {
return { type: "node", edges: [] };
}),
(e.prototype.getEdges = function () {
return this.get("edges");
}),
(e.prototype.getInEdges = function () {
var t = this;
return this.get("edges").filter(function (e) {
return e.get("target") === t;
});
}),
(e.prototype.getOutEdges = function () {
var t = this;
return this.get("edges").filter(function (e) {
return e.get("source") === t;
});
}),
(e.prototype.getNeighbors = function (t) {
var e = this,
n = this.get("edges");
if ("target" === t) {
return n
.filter(function (t) {
return t.getSource() === e;
})
.map(function (t) {
return t.getTarget();
});
}
if ("source" === t) {
return n
.filter(function (t) {
return t.getTarget() === e;
})
.map(function (t) {
return t.getSource();
});
}
return n.map(function (t) {
return t.getSource() === e ? t.getTarget() : t.getSource();
});
}),
(e.prototype.getLinkPointByAnchor = function (t) {
return this.getAnchorPoints()[t];
}),
(e.prototype.getLinkPoint = function (t) {
var e,
n,
r = this.get("keyShape").get("type"),
i = this.get("type"),
o = this.getBBox();
"combo" === i
? ((e = o.centerX || (o.maxX + o.minX) / 2),
(n = o.centerY || (o.maxY + o.minY) / 2))
: ((e = o.centerX), (n = o.centerY));
var a,
s = this.getAnchorPoints();
switch (r) {
case "circle":
a = S({ x: e, y: n, r: o.width / 2 }, t);
break;
case "ellipse":
a = O({ x: e, y: n, rx: o.width / 2, ry: o.height / 2 }, t);
break;
default:
a = w(o, t);
}
var c = a;
return (
s.length && (c || (c = t), (c = this.getNearestPoint(s, c))),
c || (c = { x: e, y: n }),
c
);
}),
(e.prototype.getAnchorPoints = function () {
var t = this.get("anchorPointsCache");
if (!t) {
t = [];
var e = this.get("shapeFactory"),
n = this.getBBox(),
r = this.get("model"),
i = this.getShapeCfg(r),
o = r.type,
a = e.getAnchorPoints(o, i) || [];
Object(c.each)(a, function (e, r) {
var i = {
x: n.minX + e[0] * n.width,
y: n.minY + e[1] * n.height,
anchorIndex: r,
};
t.push(i);
}),
this.set("anchorPointsCache", t);
}
return t;
}),
(e.prototype.addEdge = function (t) {
this.get("edges").push(t);
}),
(e.prototype.lock = function () {
this.set("locked", !0);
}),
(e.prototype.unlock = function () {
this.set("locked", !1);
}),
(e.prototype.hasLocked = function () {
return this.get("locked");
}),
(e.prototype.removeEdge = function (t) {
var e = this.getEdges(),
n = e.indexOf(t);
n > -1 && e.splice(n, 1);
}),
(e.prototype.clearCache = function () {
this.set("bboxCache", null), this.set("anchorPointsCache", null);
}),
(e.prototype.isOnlyMove = function (t) {
if (!t) return !1;
var e = !Object(c.isNil)(t.x),
n = !Object(c.isNil)(t.y),
r = Object.keys(t);
return (1 === r.length && (e || n)) || (2 === r.length && e && n);
}),
e
);
})(qt),
Ut = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(f.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return { type: "combo", nodes: [], edges: [], combos: [] };
}),
(e.prototype.getShapeCfg = function (t) {
var e = this.get("styles"),
n = this.get("bbox");
if (e && n) {
var r = t,
i = {
r:
Math.hypot(n.height, n.width) / 2 ||
nt.defaultCombo.size[0] / 2,
width: n.width || nt.defaultCombo.size[0],
height: n.height || nt.defaultCombo.size[1],
};
r.style = Object(f.a)(
Object(f.a)(Object(f.a)({}, e), t.style),
i,
);
var o = t.padding || nt.defaultCombo.padding;
return (
Object(c.isNumber)(o)
? ((i.r += o), (i.width += 2 * o), (i.height += 2 * o))
: ((i.r += o[0]),
(i.width += o[1] + o[3] || 2 * o[1]),
(i.height += o[0] + o[2] || 2 * o[0])),
this.set("sizeCache", i),
r
);
}
return t;
}),
(e.prototype.calculateCanvasBBox = function () {
if (!this.destroyed) {
var t = this.get("keyShape"),
e = this.get("group"),
n = ut(t, e);
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2);
var r = this.get("sizeCache"),
i = this.get("bboxCache") || {},
o = i.x,
a = i.x;
if (r)
(r.width = Math.max(r.width, n.width)),
(r.height = Math.max(r.height, n.height)),
"circle" === t.get("type")
? ((n.width = 2 * r.r), (n.height = 2 * r.r))
: ((n.width = r.width), (n.height = r.height)),
(n.minX = n.centerX - n.width / 2),
(n.minY = n.centerY - n.height / 2),
(n.maxX = n.centerX + n.width / 2),
(n.maxY = n.centerY + n.height / 2);
else
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.x === o && n.y === a) ||
this.set("anchorPointsCache", null),
n
);
}
}),
(e.prototype.getChildren = function () {
return { nodes: this.getNodes(), combos: this.getCombos() };
}),
(e.prototype.getNodes = function () {
return this.get("nodes");
}),
(e.prototype.getCombos = function () {
return this.get("combos");
}),
(e.prototype.addChild = function (t) {
switch (t.getType()) {
case "node":
this.addNode(t);
break;
case "combo":
this.addCombo(t);
break;
default:
return (
console.warn(
"Only node or combo items are allowed to be added into a combo",
),
!1
);
}
return !0;
}),
(e.prototype.addCombo = function (t) {
return this.get("combos").push(t), !0;
}),
(e.prototype.addNode = function (t) {
return this.get("nodes").push(t), !0;
}),
(e.prototype.removeChild = function (t) {
switch (t.getType()) {
case "node":
this.removeNode(t);
break;
case "combo":
this.removeCombo(t);
break;
default:
return (
console.warn(
"Only node or combo items are allowed to be added into a combo",
),
!1
);
}
return !0;
}),
(e.prototype.removeCombo = function (t) {
if (t) {
var e = this.getCombos(),
n = e.indexOf(t);
return n > -1 && (e.splice(n, 1), !0);
}
}),
(e.prototype.removeNode = function (t) {
if (t) {
var e = this.getNodes(),
n = e.indexOf(t);
return n > -1 && (e.splice(n, 1), !0);
}
}),
(e.prototype.isOnlyMove = function (t) {
return !1;
}),
(e.prototype.getBBox = function () {
return (
this.set("bboxCanvasCache", null), this.calculateCanvasBBox()
);
}),
(e.prototype.clearCache = function () {
this.set("bboxCache", null),
this.set("bboxCanvasCache", null),
this.set("anchorPointsCache", null);
}),
(e.prototype.destroy = function () {
if (!this.destroyed) {
var t = this.get("animate"),
e = this.get("group");
t && e.stopAnimate(),
this.clearCache(),
this.set("sizeCache", null),
this.set("bbox", null),
e.remove(),
(this._cfg = null),
(this.destroyed = !0);
}
}),
e
);
})(Ht),
Zt = (function () {
function t(t) {
(this.graph = t), (this.destroyed = !1);
}
return (
(t.prototype.addItem = function (t, e) {
var n = this.graph,
r = "vedge" === t ? "edge" : t,
i = n.get("".concat(r, "Group")) || n.get("group"),
o = Object(c.upperFirst)(r),
a = null,
s = n.get(r + Object(c.upperFirst)("stateStyles")) || {},
u = n.get("default" + o);
e.stateStyles && (s = e.stateStyles),
u &&
Object(c.each)(u, function (t, n) {
Object(c.isObject)(t) && !Object(c.isArray)(t)
? (e[n] = Object(c.deepMix)({}, t, e[n]))
: Object(c.isArray)(t)
? (e[n] = e[n] || Object(c.clone)(u[n]))
: (e[n] = e[n] || u[n]);
});
var h = n.get(r + "Mapper");
if (h) {
var l = h(e);
l.stateStyles && ((s = l.stateStyles), delete l.stateStyles),
Object(c.each)(l, function (t, n) {
Object(c.isObject)(t) && !Object(c.isArray)(t)
? (e[n] = Object(c.deepMix)({}, e[n], t))
: (e[n] = l[n] || e[n]);
});
}
if (
(n.emit("beforeadditem", { type: t, model: e }),
"edge" === t || "vedge" === t)
) {
var f = void 0,
d = void 0;
if (
((f = e.source),
(d = e.target),
f && Object(c.isString)(f) && (f = n.findById(f)),
d && Object(c.isString)(d) && (d = n.findById(d)),
!f || !d)
)
return void console.warn(
"The source or target node of edge ".concat(
e.id,
" does not exist!",
),
);
f.getType && "combo" === f.getType() && (e.isComboEdge = !0),
d.getType && "combo" === d.getType() && (e.isComboEdge = !0),
(a = new Gt({
model: e,
source: f,
target: d,
styles: s,
linkCenter: n.get("linkCenter"),
group: i.addGroup(),
}));
} else if ("node" === t)
a = new Ht({ model: e, styles: s, group: i.addGroup() });
else if ("combo" === t) {
var p = e.children,
g = bt(p, n);
isNaN(g.x)
? isNaN(e.x) && (e.x = 100 * Math.random())
: (e.x = g.x),
isNaN(g.y)
? isNaN(e.y) && (e.y = 100 * Math.random())
: (e.y = g.y);
var v = i.addGroup();
v.setZIndex(e.depth);
var y = (a = new Ut({
model: e,
styles: s,
bbox: e.collapsed ? bt([], n) : g,
group: v,
})).getModel();
(p || []).forEach(function (t) {
var e = n.findById(t.id);
a.addChild(e), (t.depth = y.depth + 2);
}),
e.collapsed &&
setTimeout(function () {
n.collapseCombo(a);
}, 16);
}
if (a)
return (
n.get("".concat(t, "s")).push(a),
(n.get("itemMap")[a.get("id")] = a),
n.emit("afteradditem", { item: a, model: e }),
a
);
}),
(t.prototype.updateItem = function (t, e) {
var n,
r,
i = this.graph;
if (
(Object(c.isString)(t) && (t = i.findById(t)),
t && !t.destroyed)
) {
var o = "";
t.getType && (o = t.getType());
var a = i.get(o + "Mapper"),
s = t.getModel(),
u = t.isOnlyMove(e);
if (a) {
var h = a(Object(c.deepMix)({}, s, e)),
l = Object(c.deepMix)({}, s, h, e);
h.stateStyles &&
(t.set("styles", l.stateStyles), delete l.stateStyles),
Object(c.each)(l, function (t, n) {
e[n] = t;
});
} else
Object(c.each)(e, function (t, n) {
s[n] &&
Object(c.isObject)(t) &&
!Object(c.isArray)(t) &&
(e[n] = Object(f.a)(Object(f.a)({}, s[n]), e[n]));
});
if (
(i.emit("beforeupdateitem", { item: t, cfg: e }),
"edge" === o)
) {
if (e.source) {
var d = e.source;
Object(c.isString)(d) && (d = i.findById(d)),
t.setSource(d);
}
if (e.target) {
var p = e.target;
Object(c.isString)(p) && (p = i.findById(p)),
t.setTarget(p);
}
t.update(e);
}
if ("node" === o || "combo" === o) {
t.update(e, u);
var g = t.getEdges(),
v = xt(e);
if (v && "node" === o)
Object(c.each)(g, function (t) {
t.refresh();
});
else if (v && "combo" === o) {
var y = t.get("shapeFactory"),
m = s.type || "circle";
(
void 0 === s.animate || void 0 === e.animate
? null ===
(r =
null === (n = y[m]) || void 0 === n
? void 0
: n.options) || void 0 === r
? void 0
: r.animate
: s.animate || e.animate
)
? setTimeout(function () {
if (t && !t.destroyed) {
var e = t.getKeyShape();
e &&
!e.destroyed &&
Object(c.each)(g, function (t) {
t && !t.destroyed && t.refresh();
});
}
}, 201)
: Object(c.each)(g, function (t) {
t.refresh();
});
}
}
i.emit("afterupdateitem", { item: t, cfg: e });
}
}),
(t.prototype.updateCombo = function (t, e) {
var n,
r,
i = this,
o = this.graph;
if (
(Object(c.isString)(t) && (t = o.findById(t)),
t && !t.destroyed)
) {
var a = t.getModel(),
s = bt(a.collapsed ? [] : e, o);
t.set("bbox", s), t.update({ x: s.x, y: s.y });
var u = t.get("shapeFactory"),
h = a.type || "circle";
(
void 0 === a.animate
? null ===
(r =
null === (n = u[h]) || void 0 === n
? void 0
: n.options) || void 0 === r
? void 0
: r.animate
: a.animate
)
? setTimeout(function () {
if (t && !t.destroyed) {
var e = t.getKeyShape();
e &&
!e.destroyed &&
(t.getShapeCfg(a), i.updateComboEdges(t));
}
}, 201)
: this.updateComboEdges(t);
}
}),
(t.prototype.updateComboEdges = function (t) {
for (var e = t.getEdges() || [], n = 0; n < e.length; n++) {
var r = e[n];
if (r && !r.destroyed) {
var i = r.get("shapeFactory"),
o = r.getShapeCfg(r.getModel()),
a = r.getContainer();
a.clear();
var s = i.draw(o.type, o, a);
r.set("keyShape", s),
s.set("isKeyShape", !0),
s.set("draggable", !0),
r.setOriginStyle();
}
}
}),
(t.prototype.collapseCombo = function (t) {
var e = this.graph;
Object(c.isString)(t) && (t = e.findById(t));
var n = t.getChildren();
n.nodes.forEach(function (t) {
e.hideItem(t);
}),
n.combos.forEach(function (t) {
e.hideItem(t);
});
}),
(t.prototype.expandCombo = function (t) {
var e = this.graph;
Object(c.isString)(t) && (t = e.findById(t));
var n = t.getChildren();
n.nodes.forEach(function (t) {
e.showItem(t);
}),
n.combos.forEach(function (t) {
t.getModel().collapsed ? t.show() : e.showItem(t);
});
}),
(t.prototype.removeItem = function (t) {
var e = this,
n = this.graph;
if (
(Object(c.isString)(t) && (t = n.findById(t)),
t && !t.destroyed)
) {
var r = Object(c.clone)(t.getModel());
n.emit("beforeremoveitem", { item: r });
var i = "";
t.getType && (i = t.getType());
var o = n.get("".concat(i, "s")),
a = o.indexOf(t);
if ((a > -1 && o.splice(a, 1), "edge" === i)) {
var s = n.get("v".concat(i, "s")),
u = s.indexOf(t);
u > -1 && s.splice(u, 1);
}
var h = t.get("id");
delete n.get("itemMap")[h];
var l = n.get("comboTrees"),
f = t.get("id");
if ("node" === i) {
var d = t.getModel().comboId;
if (l && d) {
var p = l,
g = !1;
l.forEach(function (t) {
g ||
dt(t, function (t) {
if (t.id === f && p) {
var e = p.indexOf(t);
return p.splice(e, 1), (g = !0), !1;
}
return (p = t.children), !0;
});
});
}
for (var v = (x = t.getEdges()).length - 1; v >= 0; v--)
n.removeItem(x[v], !1);
d && n.updateCombo(d);
} else if ("combo" === i) {
var y,
m = t.getModel().parentId,
b = !1;
(l || []).forEach(function (t) {
b ||
dt(t, function (t) {
return t.id !== f || ((y = t), (b = !0), !1);
});
}),
(y.removed = !0),
y &&
y.children &&
y.children.forEach(function (t) {
e.removeItem(t.id);
});
var x;
for (v = (x = t.getEdges()).length; v >= 0; v--)
n.removeItem(x[v], !1);
m && n.updateCombo(m);
}
t.destroy(), n.emit("afterremoveitem", { item: r });
}
}),
(t.prototype.setItemState = function (t, e, n) {
var r = this.graph,
i = e;
Object(c.isString)(n) && (i = "".concat(e, ":").concat(n)),
(t.hasState(i) === n && n) ||
(Object(c.isString)(n) && t.hasState(i)) ||
(r.emit("beforeitemstatechange", {
item: t,
state: i,
enabled: n,
}),
t.setState(e, n),
r.autoPaint(),
r.emit("afteritemstatechange", {
item: t,
state: i,
enabled: n,
}));
}),
(t.prototype.priorityState = function (t, e) {
var n = this.graph,
r = t;
Object(c.isString)(t) && (r = n.findById(t)),
this.setItemState(r, e, !1),
this.setItemState(r, e, !0);
}),
(t.prototype.clearItemStates = function (t, e) {
var n = this.graph;
Object(c.isString)(t) && (t = n.findById(t)),
n.emit("beforeitemstatesclear", { item: t, states: e }),
t.clearStates(e),
n.emit("afteritemstatesclear", { item: t, states: e });
}),
(t.prototype.refreshItem = function (t) {
var e = this.graph;
Object(c.isString)(t) && (t = e.findById(t)),
e.emit("beforeitemrefresh", { item: t }),
t.refresh(),
e.emit("afteritemrefresh", { item: t });
}),
(t.prototype.addCombos = function (t, e) {
var n = this,
r = this.graph;
(t || []).forEach(function (t) {
pt(t, function (t) {
var r;
return (
e.forEach(function (e) {
e.id === t.id &&
((e.children = t.children),
(e.depth = t.depth),
(r = e));
}),
r && n.addItem("combo", r),
!0
);
});
});
var i = r.get("comboGroup");
i && i.sort();
}),
(t.prototype.changeItemVisibility = function (t, e) {
var n = this,
r = this.graph;
if ((Object(c.isString)(t) && (t = r.findById(t)), t)) {
if (
(r.emit("beforeitemvisibilitychange", {
item: t,
visible: e,
}),
t.changeVisibility(e),
t.getType && "node" === t.getType())
) {
var i = t.getEdges();
Object(c.each)(i, function (t) {
(!e ||
(t.get("source").isVisible() &&
t.get("target").isVisible())) &&
n.changeItemVisibility(t, e);
});
} else if (t.getType && "combo" === t.getType()) {
var o = r.get("comboTrees"),
a = t.get("id"),
s = [],
u = !1;
(o || []).forEach(function (t) {
u ||
(t.children &&
0 !== t.children.length &&
dt(t, function (t) {
return t.id !== a || ((s = t.children), (u = !0), !1);
}));
}),
s &&
(!e || (e && !t.getModel().collapsed)) &&
s.forEach(function (t) {
var i = r.findById(t.id);
n.changeItemVisibility(i, e);
});
i = t.getEdges();
Object(c.each)(i, function (t) {
(!e ||
(t.get("source").isVisible() &&
t.get("target").isVisible())) &&
n.changeItemVisibility(t, e);
});
}
return (
r.emit("afteritemvisibilitychange", { item: t, visible: e }),
t
);
}
console.warn("The item to be shown or hidden does not exist!");
}),
(t.prototype.destroy = function () {
(this.graph = null), (this.destroyed = !0);
}),
t
);
})(),
Kt = null,
$t = (function () {
function t(t) {
(this.graph = t),
(this.cachedStates = { enabled: {}, disabled: {} }),
(this.destroyed = !1);
}
return (
(t.checkCache = function (t, e, n) {
if (n[e]) {
var r = n[e].indexOf(t);
r >= 0 && n[e].splice(r, 1);
}
}),
(t.cacheState = function (t, e, n) {
n[e] || (n[e] = []), n[e].push(t);
}),
(t.prototype.updateState = function (e, n, r) {
var i = this,
o = t.checkCache,
a = t.cacheState;
if (!e.destroyed) {
var s = this.cachedStates,
c = s.enabled,
u = s.disabled;
r ? (o(e, n, u), a(e, n, c)) : (o(e, n, c), a(e, n, u)),
Kt && clearTimeout(Kt),
(Kt = setTimeout(function () {
(Kt = null), i.updateGraphStates();
}, 16));
}
}),
(t.prototype.updateStates = function (t, e, n) {
var r = this;
Object(c.isString)(e)
? this.updateState(t, e, n)
: e.forEach(function (e) {
r.updateState(t, e, n);
});
}),
(t.prototype.updateGraphStates = function () {
var t = this.graph.get("states"),
e = this.cachedStates;
Object(c.each)(e.disabled, function (e, n) {
t[n] &&
(t[n] = t[n].filter(function (t) {
return e.indexOf(t) < 0 && !e.destroyed;
}));
}),
Object(c.each)(e.enabled, function (e, n) {
if (t[n]) {
var r = {};
t[n].forEach(function (t) {
t.destroyed || (r[t.get("id")] = !0);
}),
e.forEach(function (e) {
if (!e.destroyed) {
var i = e.get("id");
r[i] || ((r[i] = !0), t[n].push(e));
}
});
} else t[n] = e;
}),
this.graph.emit("graphstatechange", { states: t }),
(this.cachedStates = { enabled: {}, disabled: {} });
}),
(t.prototype.destroy = function () {
(this.graph = null),
(this.cachedStates = null),
Kt && clearTimeout(Kt),
(Kt = null),
(this.destroyed = !0);
}),
t
);
})(),
Qt = n(22),
Jt = function (t, e) {
return t && e
? t.replace(/\\?\{([^{}]+)\}/g, function (t, n) {
if ("\\" === t.charAt(0)) return t.slice(1);
var r = e[n];
return 0 === r && (r = "0"), r || "";
})
: t;
},
te = function (t) {
var e = [];
if (t.length < 2)
throw new Error(
"point length must largn than 2, now it's ".concat(t.length),
);
for (var n = 0, r = t; n < r.length; n++) {
var i = r[n],
o = i.x,
a = i.y;
e.push(o), e.push(a);
}
var s = Object(Qt.a)(e);
return s.unshift(["M", t[0].x, t[0].y]), s;
},
ee = function (t, e, n, r) {
void 0 === n && (n = 0), void 0 === r && (r = 0);
var i = { x: (1 - n) * t.x + n * e.x, y: (1 - n) * t.y + n * e.y },
o = [0, 0];
g.c.normalize(o, [e.x - t.x, e.y - t.y]),
(o && (o[0] || o[1])) || (o = [0, 0]);
var a = [-o[1] * r, o[0] * r];
return (i.x += a[0]), (i.y += a[1]), i;
},
ne = function (t, e) {
var n = t.length;
if (!n) return "";
for (var r = "", i = 0; i < n; i++) {
var o = t[i];
r += Jt(0 === i ? "M{x} {y}" : "L{x} {y}", o);
}
return e && (r += "Z"), r;
},
re = function (t) {
var e = [];
return (
t.forEach(function (t) {
if ("A" !== t[0])
for (var n = 1; n < t.length; n += 2) e.push([t[n], t[n + 1]]);
else {
var r = t.length;
e.push([t[r - 2], t[r - 1]]);
}
}),
e
);
},
ie = function (t) {
if (t.length < 2)
throw new Error(
"point length must largn than 2, now it's ".concat(t.length),
);
var e = t[0],
n = t[1],
r = t[t.length - 1],
i = t[t.length - 2];
t.unshift(r), t.unshift(i), t.push(e), t.push(n);
for (var o = [], a = 1; a < t.length - 2; a += 1) {
var s = t[a - 1].x,
c = t[a - 1].y,
u = t[a].x,
h = t[a].y,
l = t[a + 1].x,
f = t[a + 1].y,
d = u + (l - s) / 6,
p = h + (f - c) / 6,
g = l - ((a !== t.length - 2 ? t[a + 2].x : l) - u) / 6,
v = f - ((a !== t.length - 2 ? t[a + 2].y : f) - h) / 6;
o.push(["C", d, p, g, v, l, f]);
}
return o.unshift(["M", r.x, r.y]), o;
},
oe = function (t, e) {
return g.c.scale([0, 0], g.c.normalize([0, 0], t), e);
},
ae = function (t, e) {
var n = [t[1] - e[1], e[0] - t[0]],
r = Math.sqrt(n[0] * n[0] + n[1] * n[1]);
if (0 === r) throw new Error("p0 should not be equal to p1");
return [n[0] / r, n[1] / r];
},
se = function (t, e) {
return [e[0] - t[0], e[1] - t[1]];
};
function ce(t, e) {
if (!t || t.length < 1) return "";
if (1 === t.length)
return (function (t) {
var n = [t[0][0], t[0][1] - e],
r = [t[0][0], t[0][1] + e];
return "M "
.concat(n, " A ")
.concat(e, ",")
.concat(e, ",0,0,0,")
.concat(r, " A ")
.concat(e, ",")
.concat(e, ",0,0,0,")
.concat(n);
})(t);
if (2 === t.length)
return (function (t) {
var n = g.c.scale([0, 0], ae(t[0], t[1]), e),
r = g.c.scale([0, 0], n, -1),
i = g.c.add([0, 0], t[0], n),
o = g.c.add([0, 0], t[1], n),
a = g.c.add([0, 0], t[1], r),
s = g.c.add([0, 0], t[0], r);
return "M "
.concat(i, " L ")
.concat(o, " A ")
.concat([e, e, "0,0,0", a].join(","), " L ")
.concat(s, " A ")
.concat([e, e, "0,0,0", i].join(","));
})(t);
for (var n = new Array(t.length), r = 0; r < n.length; ++r) {
var i = 0 === r ? t[t.length - 1] : t[r - 1],
o = t[r],
a = g.c.scale([0, 0], ae(i, o), e);
n[r] = [g.c.add([0, 0], i, a), g.c.add([0, 0], o, a)];
}
var s = "A ".concat([e, e, "0,0,0,"].join(","));
return (n = n.map(function (t, e) {
var r = "";
return (
0 === e && (r = "M ".concat(n[n.length - 1][1], " ")),
(r += "".concat(s + t[0], " L ").concat(t[1]))
);
})).join(" ");
}
function ue(t, e) {
var n,
r,
i,
o = t.length;
if (!t || o < 1) return "";
if (1 === o)
return (
(r = [(n = t)[0][0], n[0][1] - e]),
(i = [n[0][0], n[0][1] + e]),
"M "
.concat(r, " A ")
.concat([e, e, "0,0,0", i].join(","), " A ")
.concat([e, e, "0,0,0", r].join(","))
);
if (2 === o)
return (function (t) {
var n = se(t[0], t[1]),
r = oe(n, e),
i = g.c.add([0, 0], t[0], g.c.scale([0, 0], r, -1)),
o = g.c.add([0, 0], t[1], r),
a = 1.2 * e,
s = oe(g.c.normalize([0, 0], n), a),
c = g.c.scale([0, 0], s, -1),
u = g.c.add([0, 0], i, c),
h = g.c.add([0, 0], o, c),
l = g.c.add([0, 0], i, s);
return "M "
.concat(i, " C ")
.concat([u, h, o].join(","), " S ")
.concat([l, i].join(","), " Z");
})(t);
for (
var a = t.map(function (e, n) {
var r = t[(n + 1) % o];
return { p: e, v: g.c.normalize([0, 0], se(e, r)) };
}),
s = 0;
s < a.length;
++s
) {
var c = s > 0 ? s - 1 : o - 1,
u = g.c.normalize(
[0, 0],
g.c.add([0, 0], a[c].v, g.c.scale([0, 0], a[s].v, -1)),
);
a[s].p = g.c.add([0, 0], a[s].p, g.c.scale([0, 0], u, e));
}
return a.map(function (t) {
var e = t.p;
return { x: e[0], y: e[1] };
});
}
var he = function (t, e, n) {
return (t.y - n.y) * (e.x - n.x) - (t.x - n.x) * (e.y - n.y);
},
le = function (t) {
var e = t.map(function (t) {
return { x: t.getModel().x, y: t.getModel().y };
});
if (
(e.sort(function (t, e) {
return t.x === e.x ? t.y - e.y : t.x - e.x;
}),
1 === e.length)
)
return e;
for (var n = [], r = 0; r < e.length; r++) {
for (
;
n.length >= 2 && he(n[n.length - 2], n[n.length - 1], e[r]) <= 0;
)
n.pop();
n.push(e[r]);
}
var i = [];
for (r = e.length - 1; r >= 0; r--) {
for (
;
i.length >= 2 && he(i[i.length - 2], i[i.length - 1], e[r]) <= 0;
)
i.pop();
i.push(e[r]);
}
return i.pop(), n.pop(), n.concat(i);
},
fe = {
maxRoutingIterations: 100,
maxMarchingIterations: 100,
pixelGroupSize: 2,
edgeR0: 10,
edgeR1: 10,
nodeR0: 5,
nodeR1: 10,
morphBuffer: 5,
threshold: 0.001,
skip: 16,
nodeInfluenceFactor: 1,
edgeInfluenceFactor: 1,
negativeNodeInfluenceFactor: -0.5,
};
function de(t, e, n) {
var r = !1,
i = function (t, n) {
return e.cells[t + n * e.width];
},
o = function (t, e) {
var r = 0;
return (
i(t - 1, e - 1) >= n && (r += 1),
i(t, e - 1) > n && (r += 2),
i(t - 1, e) > n && (r += 4),
i(t, e) > n && (r += 8),
r
);
},
a = function (n, r) {
for (var i, a, s = n, c = r, u = 0; u < e.width * e.height; u++) {
if (
((i = s),
(a = c),
t.findIndex(function (t) {
return t.x === s && t.y === c;
}) > -1)
) {
if (t[0].x === s && t[0].y === c) return !0;
} else t.push({ x: s, y: c });
var h = o(s, c);
switch (h) {
case -1:
return console.warn("Marched out of bounds"), !0;
case 0:
case 3:
case 2:
case 7:
s++;
break;
case 12:
case 14:
case 4:
s--;
break;
case 6:
0 === i && (-1 === a ? (s -= 1) : (s += 1));
break;
case 1:
case 13:
case 5:
c--;
break;
case 9:
1 === i && (0 === a ? (c -= 1) : (c += 1));
break;
case 10:
case 8:
case 11:
c++;
break;
default:
return (
console.warn("Marching squares invalid state: ".concat(h)),
!0
);
}
}
};
this.march = function () {
for (var t = 0; t < e.width && !r; t += 1)
for (var s = 0; s < e.height && !r; s += 1)
i(t, s) > n && 15 !== o(t, s) && (r = a(t, s));
return r;
};
}
var pe = function (t, e) {
var n = Number.POSITIVE_INFINITY,
r = null;
return (
t.forEach(function (t) {
var i = q(t, e);
i >= 0 && i < n && ((r = t), (n = i));
}),
r
);
};
function ge(t, e, n, r, i) {
var o = (function (t, e, n) {
var r = null,
i = Number.POSITIVE_INFINITY;
return (
e.forEach(function (e) {
var o = { x: t.getModel().x, y: t.getModel().y },
a = { x: e.getModel().x, y: e.getModel().y },
s = G(o, a),
c = new Y(o.x, o.y, a.x, a.y),
u = n.reduce(function (t, e) {
return q(e, c) > 0 ? t + 1 : t;
}, 0);
s * Math.pow(u + 1, 2) < i &&
((r = e), (i = s * Math.pow(u + 1, 2)));
}),
r
);
})(t, n, e);
if (null === o) return [];
return (function (t) {
for (var n = []; t.length > 0; ) {
var r = t.pop();
if (0 === t.length) {
n.push(r);
break;
}
var i = t.pop(),
o = new Y(r.x1, r.y1, i.x2, i.y2);
pe(e, o) ? (n.push(r), t.push(i)) : t.push(o);
}
return n;
})(
(function (t, e, n, r) {
var i = [],
o = [];
o.push(t);
for (
var a = !0,
s = 0,
c = function (t, e) {
var n = !1;
return (
e.forEach(function (e) {
n ||
((U(t, { x: e.x1, y: e.y1 }) ||
U(t, { x: e.x2, y: e.y2 })) &&
(n = !0));
}),
n
);
},
u = function (t, e) {
for (var n = 0, r = e; n < r.length; n++) {
var i = r[n].getBBox(),
o = [
[i.x, i.y],
[i.x + i.width, i.y],
[i.x, i.y + i.height],
[i.x + i.width, i.y + i.height],
];
if (_(o, t.x, t.y)) return !0;
}
return !1;
};
a && s < n;
) {
a = !1;
for (
var h = function () {
var t = o.pop(),
n = pe(e, t);
if (n) {
var h = W(n, t),
l = h[0];
if (2 === h[1]) {
var f = function (s) {
for (
var h = r,
f = me(n, h, l, s),
d = c(f, o) || c(f, i),
p = u(f, e);
!d && p && h >= 1;
)
(f = me(n, (h /= 1.5), l, s)),
(d = c(f, o) || c(f, i)),
(p = u(f, e));
!f ||
d ||
(s && p) ||
(o.push(new Y(t.x1, t.y1, f.x, f.y)),
o.push(new Y(f.x, f.y, t.x2, t.y2)),
(a = !0));
};
f(!0), a || f(!1);
}
}
a || i.push(t), (s += 1);
};
!a && o.length;
)
h();
}
for (; o.length; ) i.push(o.pop());
return i;
})(
new Y(
t.getModel().x,
t.getModel().y,
o.getModel().x,
o.getModel().y,
),
e,
r,
i,
),
);
}
var ve = function (t, e, n) {
var r = Object.assign(fe, n),
i = V(
t.map(function (t) {
return { x: t.getModel().x, y: t.getModel().y };
}),
);
t = t.sort(function (t, e) {
return (
G({ x: t.getModel().x, y: t.getModel().y }, i) -
G({ x: e.getModel().x, y: e.getModel().y }, i)
);
});
var o = [],
a = [];
t.forEach(function (t) {
ge(t, e, o, r.maxRoutingIterations, r.morphBuffer).forEach(
function (t) {
a.push(t);
},
),
o.push(t);
});
for (
var s,
c,
u,
h,
l,
f = (function (t, e, n) {
var r = {
minX: Number.POSITIVE_INFINITY,
minY: Number.POSITIVE_INFINITY,
maxX: Number.NEGATIVE_INFINITY,
maxY: Number.NEGATIVE_INFINITY,
width: 0,
height: 0,
x: 0,
y: 0,
},
i = [];
t.forEach(function (t) {
i.push(t.getBBox());
}),
e.forEach(function (t) {
i.push(t.getBBox());
});
for (var o = 0, a = i; o < a.length; o++) {
var s = a[o];
(r.minX = (s.minX < r.minX ? s.minX : r.minX) - n),
(r.minY = (s.minY < r.minY ? s.minY : r.minY) - n),
(r.maxX = (s.maxX > r.maxX ? s.maxX : r.maxX) + n),
(r.maxY = (s.maxY > r.maxY ? s.maxY : r.maxY) + n);
}
return (
(r.width = r.maxX - r.minX),
(r.height = r.maxY - r.minY),
(r.x = r.minX),
(r.y = r.minY),
r
);
})(t, a, r.nodeR0),
d =
((s = f.width),
(c = f.height),
(u = r.pixelGroupSize),
(h = Math.ceil(s / u)),
(l = Math.ceil(c / u)),
{
cells: new Float32Array(Math.max(0, h * l)).fill(0),
width: h,
height: l,
}),
p = [],
g = [],
v = 0;
v < r.maxMarchingIterations;
v++
)
if (
(ye(t, e, a, f, d, r),
(g = []),
new de((p = []), d, r.threshold).march())
) {
var y = p.map(function (t) {
return {
x: Math.round(t.x * r.pixelGroupSize + f.minX),
y: Math.round(t.y * r.pixelGroupSize + f.minY),
};
});
if (y) {
var m = y.length;
if (r.skip > 1)
for (m = Math.floor(y.length / r.skip); m < 3 && r.skip > 1; )
(r.skip -= 1), (m = Math.floor(y.length / r.skip));
for (var b = 0, x = 0; x < m; x += 1, b += r.skip)
g.push({ x: y[b].x, y: y[b].y });
}
if (
g &&
(function () {
for (var e = 0, n = t; e < n.length; e++) {
var r = n[e],
i = g.map(function (t) {
return [t.x, t.y];
});
if (!_(i, r.getBBox().centerX, r.getBBox().centerY))
return !1;
}
return !0;
})()
)
return g;
if (((r.threshold *= 0.9), v <= 0.5 * r.maxMarchingIterations))
(r.memberInfluenceFactor *= 1.2), (r.edgeInfluenceFactor *= 1.2);
else {
if (!(0 !== r.nonMemberInfluenceFactor && e.length > 0)) break;
r.nonMemberInfluenceFactor *= 0.8;
}
}
return g;
};
function ye(t, e, n, r, i, o) {
function a(t, e) {
var n = Math.floor((t - e) / o.pixelGroupSize);
return n < 0 ? 0 : n;
}
function s(t, e) {
return t * o.pixelGroupSize + e;
}
var c = (o.nodeR0 - o.nodeR1) * (o.nodeR0 - o.nodeR1),
u = (o.edgeR0 - o.edgeR1) * (o.edgeR0 - o.edgeR1),
h = function (t, e) {
return [
Math.min(a(t.minX, e + r.minX), i.width),
Math.min(a(t.minY, e + r.minY), i.height),
Math.min(a(t.maxX, -e + r.minX), i.width),
Math.min(a(t.maxY, -e + r.minY), i.height),
];
},
l = function (t, e) {
for (
var n = t.getBBox(),
a = h(n, o.nodeR1),
c = a[0],
u = a[1],
l = a[2],
f = a[3],
d = u;
d < f;
d += 1
)
for (var p = c; p < l; p += 1)
if (!(e < 0 && i[p + d * i.width] <= 0)) {
var g = s(p, r.minX),
v = s(d, r.minY),
y = Z(
{ x: g, y: v },
{
x: n.minX,
y: n.minY,
width: n.width,
height: n.height,
},
);
if (y < Math.pow(o.nodeR1, 2)) {
var m = Math.sqrt(y) - o.nodeR1;
i.cells[p + d * i.width] += e * m * m;
}
}
};
o.nodeInfluenceFactor &&
t.forEach(function (t) {
l(t, o.nodeInfluenceFactor / c);
}),
o.edgeInfluenceFactor &&
n.forEach(function (t) {
!(function (t, e) {
for (
var n = t.getBBox(),
a = h(n, o.edgeR1),
c = a[0],
u = a[1],
l = a[2],
f = a[3],
d = u;
d < f;
d += 1
)
for (var p = c; p < l; p += 1)
if (!(e < 0 && i.cells[p + d * i.width] <= 0)) {
var g = s(p, r.minX),
v = s(d, r.minY),
y = H({ x: g, y: v }, t);
if (y < Math.pow(o.edgeR1, 2)) {
var m = Math.sqrt(y) - o.edgeR1;
i.cells[p + d * i.width] += e * m * m;
}
}
})(t, o.edgeInfluenceFactor / u);
}),
o.negativeNodeInfluenceFactor &&
e.forEach(function (t) {
l(t, o.negativeNodeInfluenceFactor / c);
});
}
function me(t, e, n, r) {
var i = t.getBBox(),
o = n[0],
a = n[1],
s = n[2],
c = n[3],
u = {
topLeft: { x: i.minX - e, y: i.minY - e },
topRight: { x: i.maxX + e, y: i.minY - e },
bottomLeft: { x: i.minX - e, y: i.maxY + e },
bottomRight: { x: i.maxX + e, y: i.maxY + e },
},
h = i.height * i.width;
function l(t, e) {
return i.width * (0.5 * (t.y - i.minY + (e.y - i.minY)));
}
if (a)
return o
? r
? u.topLeft
: u.bottomRight
: s
? r
? u.bottomLeft
: u.topRight
: l(a, c) < 0.5 * h
? a.y > c.y
? r
? u.topLeft
: u.bottomRight
: r
? u.topRight
: u.bottomLeft
: a.y < c.y
? r
? u.bottomLeft
: u.topRight
: r
? u.bottomRight
: u.topLeft;
if (c) {
if (o) return r ? u.topRight : u.bottomLeft;
if (s) return r ? u.bottomRight : u.topLeft;
}
return l(o, s) < 0.5 * h
? o.x > s.x
? r
? u.topLeft
: u.bottomRight
: r
? u.bottomLeft
: u.topRight
: o.x < s.x
? r
? u.topRight
: u.bottomLeft
: r
? u.bottomRight
: u.topLeft;
}
var be = (function () {
function t(t, e) {
(this.cfg = Object(c.deepMix)(this.getDefaultCfg(), e)),
(this.graph = t),
(this.id = this.cfg.id),
(this.group = this.cfg.group),
(this.members = this.cfg.members.map(function (e) {
return Object(c.isString)(e) ? t.findById(e) : e;
})),
(this.nonMembers = this.cfg.nonMembers.map(function (e) {
return Object(c.isString)(e) ? t.findById(e) : e;
})),
this.setPadding(),
this.setType(),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}
return (
(t.prototype.getDefaultCfg = function () {
return {
id: "g6-hull",
type: "round-convex",
members: [],
nonMembers: [],
style: { fill: "lightblue", stroke: "blue", opacity: 0.2 },
padding: 10,
};
}),
(t.prototype.setPadding = function () {
var t =
this.members.length &&
this.members[0].getKeyShape().getCanvasBBox().width / 2;
(this.padding =
this.cfg.padding > 0 ? this.cfg.padding + t : 10 + t),
(this.cfg.bubbleCfg = {
nodeR0: this.padding - t,
nodeR1: this.padding - t,
morphBuffer: this.padding - t,
});
}),
(t.prototype.setType = function () {
(this.type = this.cfg.type),
this.members.length < 3 && (this.type = "round-convex"),
"round-convex" !== this.type &&
"smooth-convex" !== this.type &&
"bubble" !== this.type &&
(console.warn(
"The hull type should be either round-convex, smooth-convex or bubble, round-convex is used by default.",
),
(this.type = "round-convex"));
}),
(t.prototype.calcPath = function (t, e) {
var n, r, i;
switch (this.type) {
case "round-convex":
(i = ce(
(n = le(t)).map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = Object(Qt.b)(i));
break;
case "smooth-convex":
2 === (n = le(t)).length
? ((i = ce(
n.map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = Object(Qt.b)(i)))
: n.length > 2 &&
((i = ue(
n.map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = ie(i)));
break;
case "bubble":
r = (n = ve(t, e, this.cfg.bubbleCfg)).length >= 2 && ie(n);
}
return r;
}),
(t.prototype.render = function () {
this.group.addShape("path", {
attrs: Object(f.a)({ path: this.path }, this.cfg.style),
id: this.id,
name: this.cfg.id,
}),
this.group.toBack();
}),
(t.prototype.addMember = function (t) {
if (t) {
Object(c.isString)(t) && (t = this.graph.findById(t)),
this.members.push(t);
var e = this.nonMembers.indexOf(t);
return (
e > -1 && this.nonMembers.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0
);
}
}),
(t.prototype.addNonMember = function (t) {
if (t) {
Object(c.isString)(t) && (t = this.graph.findById(t)),
this.nonMembers.push(t);
var e = this.members.indexOf(t);
return (
e > -1 && this.members.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0
);
}
}),
(t.prototype.removeMember = function (t) {
if (t) {
Object(c.isString)(t) && (t = this.graph.findById(t));
var e = this.members.indexOf(t);
return (
e > -1 &&
(this.members.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0)
);
}
}),
(t.prototype.removeNonMember = function (t) {
if (t) {
Object(c.isString)(t) && (t = this.graph.findById(t));
var e = this.nonMembers.indexOf(t);
return (
e > -1 &&
(this.nonMembers.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0)
);
}
}),
(t.prototype.updateData = function (t, e) {
var n = this;
this.group.findById(this.id).remove(),
t &&
(this.members = t.map(function (t) {
return Object(c.isString)(t) ? n.graph.findById(t) : t;
})),
e &&
(this.nonMembers = e.map(function (t) {
return Object(c.isString)(t) ? n.graph.findById(t) : t;
})),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}),
(t.prototype.updateStyle = function (t) {
this.group.findById(this.id).attr(Object(f.a)({}, t));
}),
(t.prototype.updateCfg = function (t) {
var e = this;
(this.cfg = Object(c.deepMix)(this.cfg, t)),
(this.id = this.cfg.id),
(this.group = this.cfg.group),
t.members &&
(this.members = this.cfg.members.map(function (t) {
return Object(c.isString)(t) ? e.graph.findById(t) : t;
})),
t.nonMembers &&
(this.nonMembers = this.cfg.nonMembers.map(function (t) {
return Object(c.isString)(t) ? e.graph.findById(t) : t;
})),
this.setPadding(),
this.setType(),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}),
(t.prototype.contain = function (t) {
var e,
n,
r = this,
i = (e = Object(c.isString)(t)
? this.graph.findById(t)
: t).getKeyShape();
if ("path" === e.get("type")) n = re(i.attr("path"));
else {
var o = i.getCanvasBBox();
n = [
[o.minX, o.minY],
[o.maxX, o.minY],
[o.maxX, o.maxY],
[o.minX, o.maxY],
];
}
return (
(n = n.map(function (t) {
var e = r.graph.getPointByCanvas(t[0], t[1]);
return [e.x, e.y];
})),
F(n, re(this.path))
);
}),
(t.prototype.destroy = function () {
this.group.remove(), (this.cfg = null);
}),
t
);
})(),
xe = g.a.transform,
we = (function (t) {
function e(e) {
var n = t.call(this) || this;
return (
(n.cfg = Object(c.deepMix)(n.getDefaultCfg(), e)),
n.init(),
(n.animating = !1),
(n.destroyed = !1),
n.cfg.enabledStack &&
((n.undoStack = new v.Stack(n.cfg.maxStep)),
(n.redoStack = new v.Stack(n.cfg.maxStep))),
n
);
}
return (
Object(f.c)(e, t),
(e.prototype.init = function () {
this.initCanvas();
var t = new Nt(this),
e = new Ot(this),
n = new Zt(this),
r = new $t(this);
this.set({
viewController: t,
modeController: e,
itemController: n,
stateController: r,
}),
this.initLayoutController(),
this.initEventController(),
this.initGroups(),
this.initPlugins(),
(this.timeIndex = Object(p.requestAnimationFrame)(
this.onTick.bind(this),
));
}),
(e.prototype.initGroups = function () {
var t = this.get("canvas"),
e = this.get("canvas").get("el").id,
n = t.addGroup({
id: "".concat(e, "-root"),
className: nt.rootContainerClassName,
});
if (this.get("groupByTypes")) {
var r = n.addGroup({
id: "".concat(e, "-edge"),
className: nt.edgeContainerClassName,
}),
i = n.addGroup({
id: "".concat(e, "-node"),
className: nt.nodeContainerClassName,
}),
o = n.addGroup({
id: "".concat(e, "-combo"),
className: nt.comboContainerClassName,
});
o.toBack(),
this.set({ nodeGroup: i, edgeGroup: r, comboGroup: o });
}
var a = n.addGroup({
id: "".concat(e, "-delegate"),
className: nt.delegateContainerClassName,
});
this.set({ delegateGroup: a }), this.set("group", n);
}),
(e.prototype.getDefaultCfg = function () {
return {
container: void 0,
width: void 0,
height: void 0,
renderer: "canvas",
modes: {},
plugins: [],
data: {},
fitViewPadding: 10,
minZoom: 0.2,
maxZoom: 10,
event: !0,
groupByTypes: !0,
directed: !1,
autoPaint: !0,
nodes: [],
edges: [],
combos: [],
vedges: [],
itemMap: {},
linkCenter: !1,
defaultNode: {},
defaultEdge: {},
nodeStateStyles: {},
edgeStateStyles: {},
states: {},
animate: !1,
animateCfg: {
onFrame: void 0,
duration: 500,
easing: "easeLinear",
},
callback: void 0,
enabledStack: !1,
maxStep: 10,
tooltips: [],
};
}),
(e.prototype.set = function (t, e) {
return (
Object(c.isPlainObject)(t)
? (this.cfg = Object(f.a)(Object(f.a)({}, this.cfg), t))
: (this.cfg[t] = e),
this
);
}),
(e.prototype.get = function (t) {
return this.cfg[t];
}),
(e.prototype.getGroup = function () {
return this.get("group");
}),
(e.prototype.getContainer = function () {
return this.get("container");
}),
(e.prototype.getMinZoom = function () {
return this.get("minZoom");
}),
(e.prototype.setMinZoom = function (t) {
return this.set("minZoom", t);
}),
(e.prototype.getMaxZoom = function () {
return this.get("maxZoom");
}),
(e.prototype.setMaxZoom = function (t) {
return this.set("maxZoom", t);
}),
(e.prototype.getWidth = function () {
return this.get("width");
}),
(e.prototype.getHeight = function () {
return this.get("height");
}),
(e.prototype.clearItemStates = function (t, e) {
Object(c.isString)(t) && (t = this.findById(t));
var n = this.get("itemController");
e || (e = t.get("states")),
n.clearItemStates(t, e),
this.get("stateController").updateStates(t, e, !1);
}),
(e.prototype.node = function (t) {
"function" == typeof t && this.set("nodeMapper", t);
}),
(e.prototype.edge = function (t) {
"function" == typeof t && this.set("edgeMapper", t);
}),
(e.prototype.combo = function (t) {
"function" == typeof t && this.set("comboMapper", t);
}),
(e.prototype.findById = function (t) {
return this.get("itemMap")[t];
}),
(e.prototype.find = function (t, e) {
var n,
r = this.get("".concat(t, "s"));
return (
Object(c.each)(r, function (t, r) {
if (e(t, r)) return (n = t);
}),
n
);
}),
(e.prototype.findAll = function (t, e) {
var n = [];
return (
Object(c.each)(this.get("".concat(t, "s")), function (t, r) {
e(t, r) && n.push(t);
}),
n
);
}),
(e.prototype.findAllByState = function (t, e) {
return this.findAll(t, function (t) {
return t.hasState(e);
});
}),
(e.prototype.translate = function (t, e) {
var n = this.get("group"),
r = Object(c.clone)(n.getMatrix());
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = xe(r, [["t", t, e]])),
n.setMatrix(r),
this.emit("viewportchange", {
action: "translate",
matrix: n.getMatrix(),
}),
this.autoPaint();
}),
(e.prototype.moveTo = function (t, e) {
var n = this.get("group");
T(n, { x: t, y: e }),
this.emit("viewportchange", {
action: "move",
matrix: n.getMatrix(),
});
}),
(e.prototype.fitView = function (t) {
t && this.set("fitViewPadding", t),
this.get("viewController").fitView(),
this.autoPaint();
}),
(e.prototype.fitCenter = function () {
this.get("viewController").fitCenter(), this.autoPaint();
}),
(e.prototype.addBehaviors = function (t, e) {
return (
this.get("modeController").manipulateBehaviors(t, e, !0), this
);
}),
(e.prototype.removeBehaviors = function (t, e) {
return (
this.get("modeController").manipulateBehaviors(t, e, !1), this
);
}),
(e.prototype.updateBehavior = function (t, e, n) {
return this.get("modeController").updateBehavior(t, e, n), this;
}),
(e.prototype.zoom = function (t, e) {
var n = this.get("group"),
r = Object(c.clone)(n.getMatrix()),
i = this.get("minZoom"),
o = this.get("maxZoom");
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = xe(
r,
e
? [
["t", -e.x, -e.y],
["s", t, t],
["t", e.x, e.y],
]
: [["s", t, t]],
)),
(i && r[0] < i) ||
(o && r[0] > o) ||
(n.setMatrix(r),
this.emit("viewportchange", { action: "zoom", matrix: r }),
this.autoPaint());
}),
(e.prototype.zoomTo = function (t, e) {
var n = t / this.getZoom();
this.zoom(n, e);
}),
(e.prototype.focusItem = function (t, e, n) {
var r = this.get("viewController"),
i = !1;
e ? (i = !0) : void 0 === e && (i = this.get("animate"));
var o = {};
n ? (o = n) : void 0 === n && (o = this.get("animateCfg")),
r.focus(t, i, o),
this.autoPaint();
}),
(e.prototype.autoPaint = function () {
this.get("autoPaint") && this.paint();
}),
(e.prototype.paint = function () {
this.emit("beforepaint"),
this.get("canvas").draw(),
this.emit("afterpaint");
}),
(e.prototype.getPointByClient = function (t, e) {
return this.get("viewController").getPointByClient(t, e);
}),
(e.prototype.getClientByPoint = function (t, e) {
return this.get("viewController").getClientByPoint(t, e);
}),
(e.prototype.getPointByCanvas = function (t, e) {
return this.get("viewController").getPointByCanvas(t, e);
}),
(e.prototype.getCanvasByPoint = function (t, e) {
return this.get("viewController").getCanvasByPoint(t, e);
}),
(e.prototype.getGraphCenterPoint = function () {
var t = this.get("group").getCanvasBBox();
return { x: (t.minX + t.maxX) / 2, y: (t.minY + t.maxY) / 2 };
}),
(e.prototype.getViewPortCenterPoint = function () {
return this.getPointByCanvas(
this.get("width") / 2,
this.get("height") / 2,
);
}),
(e.prototype.showItem = function (t, e) {
void 0 === e && (e = !0);
var n = this.get("itemController").changeItemVisibility(t, !0);
if (e && this.get("enabledStack")) {
var r = n.getID(),
i = {},
o = {};
switch (n.getType()) {
case "node":
(i.nodes = [{ id: r, visible: !1 }]),
(o.nodes = [{ id: r, visible: !0 }]);
break;
case "edge":
(i.nodes = [{ id: r, visible: !1 }]),
(o.edges = [{ id: r, visible: !0 }]);
break;
case "combo":
(i.nodes = [{ id: r, visible: !1 }]),
(o.combos = [{ id: r, visible: !0 }]);
}
this.pushStack("visible", { before: i, after: o });
}
}),
(e.prototype.hideItem = function (t, e) {
void 0 === e && (e = !0);
var n = this.get("itemController").changeItemVisibility(t, !1);
if (e && this.get("enabledStack")) {
var r = n.getID(),
i = {},
o = {};
switch (n.getType()) {
case "node":
(i.nodes = [{ id: r, visible: !0 }]),
(o.nodes = [{ id: r, visible: !1 }]);
break;
case "edge":
(i.nodes = [{ id: r, visible: !0 }]),
(o.edges = [{ id: r, visible: !1 }]);
break;
case "combo":
(i.nodes = [{ id: r, visible: !0 }]),
(o.combos = [{ id: r, visible: !1 }]);
}
this.pushStack("visible", { before: i, after: o });
}
}),
(e.prototype.refreshItem = function (t) {
this.get("itemController").refreshItem(t);
}),
(e.prototype.setAutoPaint = function (t) {
this.set("autoPaint", t), this.get("canvas").set("autoDraw", t);
}),
(e.prototype.remove = function (t, e) {
void 0 === e && (e = !0), this.removeItem(t, e);
}),
(e.prototype.removeItem = function (t, e) {
void 0 === e && (e = !0);
var n = t;
if (
(Object(c.isString)(t) && (n = this.findById(t)),
!n && Object(c.isString)(t))
)
console.warn("The item to be removed does not exist!");
else if (n) {
var r = "";
if (
(n.getType && (r = n.getType()),
e && this.get("enabledStack"))
) {
var i = Object(f.a)(Object(f.a)({}, n.getModel()), {
itemType: r,
}),
o = {};
switch (r) {
case "node":
(o.nodes = [i]), (o.edges = []);
for (var a = n.getEdges(), s = a.length - 1; s >= 0; s--)
o.edges.push(
Object(f.a)(Object(f.a)({}, a[s].getModel()), {
itemType: "edge",
}),
);
break;
case "edge":
o.edges = [i];
break;
case "combo":
o.combos = [i];
}
this.pushStack("delete", { before: o, after: {} });
}
if ("node" === r)
n.getModel().comboId && this.updateComboTree(n);
if ((this.get("itemController").removeItem(n), "combo" === r)) {
var u = mt(this.get("comboTrees"));
this.set("comboTrees", u);
}
}
}),
(e.prototype.addItem = function (t, e, n, r) {
void 0 === n && (n = !0), void 0 === r && (r = !0);
var i = this.get("comboSorted");
this.set("comboSorted", i && !r);
var o = this.get("itemController");
if (
!(function (t, e) {
if ("node" === t || "combo" === t) {
if (e.id && !Object(c.isString)(e.id))
return (
console.warn(
"G6 Warning Tips: missing 'id' property, or the 'id' %c".concat(
e.id,
"%c is not a string.",
),
"font-size: 20px; color: red;",
"",
),
!1
);
} else if (!("edge" !== t || (e.source && e.target)))
return (
console.warn(
"G6 Warning Tips: missing 'source' or 'target' for the edge.",
),
!1
);
return !0;
})(t, e)
)
return !1;
if (!e.id || !this.findById(e.id)) {
var a,
s = this.get("comboTrees");
if ((s || (s = []), "combo" === t)) {
var u = this.get("itemMap"),
h = !1;
if (
(s.forEach(function (n) {
h ||
pt(n, function (n) {
if (e.parentId === n.id) {
h = !0;
var r = Object(f.a)(
{ id: e.id, depth: n.depth + 2 },
e,
);
n.children
? n.children.push(r)
: (n.children = [r]),
(e.depth = r.depth),
(a = o.addItem(t, e));
}
var i = u[n.id];
return (
h &&
i &&
i.getType &&
"combo" === i.getType() &&
o.updateCombo(i, n.children),
!0
);
});
}),
!h)
) {
var l = Object(f.a)({ id: e.id, depth: 0 }, e);
(e.depth = l.depth), s.push(l), (a = o.addItem(t, e));
}
this.set("comboTrees", s);
} else if ("node" === t && Object(c.isString)(e.comboId) && s) {
var d;
(d = this.findById(e.comboId)) &&
d.getType &&
"combo" !== d.getType() &&
console.warn(
"'".concat(
e.comboId,
"' is not a id of a combo in the graph, the node will be added without combo.",
),
),
(a = o.addItem(t, e));
var p = this.get("itemMap"),
g = !1,
v = !1;
(s || []).forEach(function (t) {
v ||
g ||
pt(t, function (t) {
if (t.id === e.id) return (v = !0), !1;
if (e.comboId === t.id && !v) {
g = !0;
var n = Object(c.clone)(e);
(n.itemType = "node"),
t.children
? t.children.push(n)
: (t.children = [n]),
(n.depth = t.depth + 1);
}
return (
g &&
p[t.id].getType &&
"combo" === p[t.id].getType() &&
o.updateCombo(p[t.id], t.children),
!0
);
});
});
} else a = o.addItem(t, e);
if (
("node" === t && e.comboId) ||
("combo" === t && e.parentId)
)
(d = this.findById(e.comboId || e.parentId)) &&
d.getType &&
"combo" === d.getType() &&
d.addChild(a);
var y = this.get("combos");
if (
(y && y.length > 0 && this.sortCombos(),
this.autoPaint(),
n && this.get("enabledStack"))
) {
var m = Object(f.a)(Object(f.a)({}, a.getModel()), {
itemType: t,
}),
b = {};
switch (t) {
case "node":
b.nodes = [m];
break;
case "edge":
b.edges = [m];
break;
case "combo":
b.combos = [m];
}
this.pushStack("add", { before: {}, after: b });
}
return a;
}
console.warn(
"This item exists already. Be sure the id %c".concat(
e.id,
"%c is unique.",
),
"font-size: 20px; color: red;",
"",
);
}),
(e.prototype.add = function (t, e, n, r) {
return (
void 0 === n && (n = !0),
void 0 === r && (r = !0),
this.addItem(t, e, n, r)
);
}),
(e.prototype.updateItem = function (t, e, n) {
var r = this;
void 0 === n && (n = !0);
var i,
o = this.get("itemController");
i = Object(c.isString)(t) ? this.findById(t) : t;
var a = Object(c.clone)(i.getModel()),
s = "";
i.getType && (s = i.getType());
var u = Object(f.f)([], i.getStates(), !0);
if (
("combo" === s &&
Object(c.each)(u, function (t) {
return r.setItemState(i, t, !1);
}),
o.updateItem(i, e),
"combo" === s &&
Object(c.each)(u, function (t) {
return r.setItemState(i, t, !0);
}),
n && this.get("enabledStack"))
) {
var h = { nodes: [], edges: [], combos: [] },
l = { nodes: [], edges: [], combos: [] },
d = Object(f.a)({ id: a.id }, e);
switch (s) {
case "node":
h.nodes.push(a), l.nodes.push(d);
break;
case "edge":
h.edges.push(a), l.edges.push(d);
break;
case "combo":
h.combos.push(a), l.combos.push(d);
}
"node" === s && h.nodes.push(a),
this.pushStack("update", { before: h, after: l });
}
}),
(e.prototype.update = function (t, e, n) {
void 0 === n && (n = !0), this.updateItem(t, e, n);
}),
(e.prototype.setItemState = function (t, e, n) {
Object(c.isString)(t) && (t = this.findById(t)),
this.get("itemController").setItemState(t, e, n);
var r = this.get("stateController");
Object(c.isString)(n)
? r.updateState(t, "".concat(e, ":").concat(n), !0)
: r.updateState(t, e, n);
}),
(e.prototype.priorityState = function (t, e) {
this.get("itemController").priorityState(t, e);
}),
(e.prototype.data = function (t) {
St(t), this.set("data", t);
}),
(e.prototype.render = function () {
var t = this;
this.set("comboSorted", !1);
var e = this.get("data");
if ((this.get("enabledStack") && this.clearStack(), !e))
throw new Error("data must be defined first");
var n = e.nodes,
r = void 0 === n ? [] : n,
i = e.edges,
o = void 0 === i ? [] : i,
a = e.combos,
s = void 0 === a ? [] : a;
if (
(this.clear(!0),
this.emit("beforerender"),
Object(c.each)(r, function (e) {
t.add("node", e, !1, !1);
}),
s && 0 !== s.length)
) {
var u = yt(s, r);
this.set("comboTrees", u), t.addCombos(s);
}
Object(c.each)(o, function (e) {
t.add("edge", e, !1, !1);
});
var h = t.get("animate");
(t.get("fitView") || t.get("fitCenter")) && t.set("animate", !1);
var l = t.get("layoutController");
if (l) {
if (
(l.layout(function () {
t.get("fitView")
? t.fitView()
: t.get("fitCenter") && t.fitCenter();
t.autoPaint(),
t.emit("afterrender"),
(t.get("fitView") || t.get("fitCenter")) &&
t.set("animate", h);
}),
this.refreshPositions(),
this.destroyed)
)
return;
} else
t.get("fitView") && t.fitView(),
t.get("fitCenter") && t.fitCenter(),
t.emit("afterrender"),
t.set("animate", h);
this.get("groupByTypes") ||
(s && 0 !== s.length
? this.sortCombos()
: e.nodes && e.edges && e.nodes.length < e.edges.length
? this.getNodes().forEach(function (t) {
t.toFront();
})
: this.getEdges().forEach(function (t) {
t.toBack();
}));
this.get("enabledStack") && this.pushStack("render");
}),
(e.prototype.read = function (t) {
this.data(t), this.render();
}),
(e.prototype.diffItems = function (t, e, n) {
var r,
i = this,
o = this.get("itemMap");
Object(c.each)(n, function (n) {
if ((r = o[n.id])) {
if (i.get("animate") && "node" === t) {
var a = r.getContainer().getMatrix();
a || (a = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
r.set("originAttrs", { x: a[6], y: a[7] });
}
i.updateItem(r, n, !1);
} else r = i.addItem(t, n, !1);
r && e["".concat(t, "s")].push(r);
});
}),
(e.prototype.changeData = function (t, e) {
void 0 === e && (e = !0);
var n = this;
if (!St(t)) return this;
e &&
this.get("enabledStack") &&
this.pushStack("changedata", { before: n.save(), after: t }),
this.set("comboSorted", !1),
this.removeHulls(),
this.getNodes().map(function (t) {
return n.clearItemStates(t);
}),
this.getEdges().map(function (t) {
return n.clearItemStates(t);
});
var r = this.get("canvas"),
i = r.get("localRefresh");
r.set("localRefresh", !1),
n.get("data") || (n.data(t), n.render());
var o = this.get("itemMap"),
a = { nodes: [], edges: [] },
s = t.combos;
if (s) {
var u = yt(s, t.nodes);
this.set("comboTrees", u);
}
this.diffItems("node", a, t.nodes),
Object(c.each)(o, function (t, e) {
(o[e].getModel().depth = 0),
(t.getType && "edge" === t.getType()) ||
(t.getType && "combo" === t.getType()
? (delete o[e], t.destroy())
: a.nodes.indexOf(t) < 0 &&
(delete o[e], n.remove(t, !1)));
});
for (var h = this.getCombos(), l = h.length - 1; l >= 0; l--)
h[l].destroyed && h.splice(l, 1);
s &&
(n.addCombos(s), this.get("groupByTypes") || this.sortCombos()),
this.diffItems("edge", a, t.edges),
Object(c.each)(o, function (t, e) {
(!t.getType ||
("node" !== t.getType() && "combo" !== t.getType())) &&
a.edges.indexOf(t) < 0 &&
(delete o[e], n.remove(t, !1));
}),
this.set({ nodes: a.nodes, edges: a.edges });
var f = this.get("layoutController");
return (
f &&
(f.changeData(),
n.get("animate") && !f.getLayoutType()
? n.positionsAnimate()
: n.autoPaint()),
setTimeout(function () {
r.set("localRefresh", i);
}, 16),
this
);
}),
(e.prototype.addCombos = function (t) {
var e = this.get("comboTrees");
this.get("itemController").addCombos(e, t);
}),
(e.prototype.createCombo = function (t, e) {
var n = this;
this.set("comboSorted", !1);
var r,
i = "";
if (t) {
if (Object(c.isString)(t)) (i = t), (r = { id: t });
else {
if (!(i = t.id))
return void console.warn(
"Create combo failed. Please assign a unique string id for the adding combo.",
);
r = t;
}
var o = e.map(function (t) {
var e = n.findById(t),
r = e.getModel(),
o = "";
e.getType && (o = e.getType());
var a = { id: e.getID(), itemType: o };
return (
"combo" === o
? ((a.parentId = i), (r.parentId = i))
: "node" === o && ((a.comboId = i), (r.comboId = i)),
a
);
});
(r.children = o),
this.addItem("combo", r, !1),
this.set("comboSorted", !1);
var a = this.get("comboTrees");
(a || []).forEach(function (t) {
pt(t, function (t) {
return (
t.id !== i ||
((t.itemType = "combo"), (t.children = o), !1)
);
});
}),
a && this.sortCombos();
}
}),
(e.prototype.uncombo = function (t) {
var e = this,
n = t;
if (
(Object(c.isString)(t) && (n = this.findById(t)),
!n || (n.getType && "combo" !== n.getType()))
)
console.warn("The item is not a combo!");
else {
var r = n.getModel().parentId,
i = this.get("comboTrees");
i || (i = []);
var o,
a = this.get("itemMap"),
s = n.get("id"),
u = [],
h = this.get("combos"),
l = this.findById(r);
if (
(i.forEach(function (i) {
o ||
pt(i, function (i) {
if (i.id === s) {
(o = i),
n.getEdges().forEach(function (t) {
e.removeItem(t, !1);
});
var c = h.indexOf(t);
h.splice(c, 1), delete a[s], n.destroy();
}
return (
!r ||
!o ||
i.id !== r ||
(l.removeCombo(n),
-1 !== (c = (u = i.children).indexOf(o)) &&
u.splice(c, 1),
o.children.forEach(function (t) {
var n = e.findById(t.id),
i = n.getModel();
n.getType && "combo" === n.getType()
? ((t.parentId = r),
delete t.comboId,
(i.parentId = r),
delete i.comboId)
: n.getType &&
"node" === n.getType() &&
((t.comboId = r), (i.comboId = r)),
l.addChild(n),
u.push(t);
}),
!1)
);
});
}),
!r && o)
) {
var f = i.indexOf(o);
i.splice(f, 1),
o.children.forEach(function (t) {
t.parentId = void 0;
var n = e.findById(t.id).getModel();
delete n.parentId,
delete n.comboId,
"node" !== t.itemType && i.push(t);
});
}
}
}),
(e.prototype.updateCombos = function () {
var t = this,
e = this.get("comboTrees"),
n = this.get("itemController"),
r = this.get("itemMap");
(e || []).forEach(function (e) {
pt(e, function (e) {
if (!e) return !0;
var i = r[e.id];
if (i && i.getType && "combo" === i.getType()) {
var o = Object(f.f)([], i.getStates(), !0);
Object(c.each)(o, function (e) {
return t.setItemState(i, e, !1);
}),
n.updateCombo(i, e.children),
Object(c.each)(o, function (e) {
return t.setItemState(i, e, !0);
});
}
return !0;
});
}),
this.sortCombos();
}),
(e.prototype.updateCombo = function (t) {
var e,
n = this,
r = t;
if (
(Object(c.isString)(t) && (r = this.findById(t)),
!r || (r.getType && "combo" !== r.getType()))
)
console.warn("The item to be updated is not a combo!");
else {
e = r.get("id");
var i = this.get("comboTrees"),
o = this.get("itemController"),
a = this.get("itemMap");
(i || []).forEach(function (t) {
pt(t, function (t) {
if (!t) return !0;
var r = a[t.id];
if (
e === t.id &&
r &&
r.getType &&
"combo" === r.getType()
) {
var i = Object(f.f)([], r.getStates(), !0);
Object(c.each)(i, function (t) {
r.getStateStyle(t) && n.setItemState(r, t, !1);
}),
o.updateCombo(r, t.children),
Object(c.each)(i, function (t) {
r.getStateStyle(t) && n.setItemState(r, t, !0);
}),
e && (e = t.parentId);
}
return !0;
});
});
}
}),
(e.prototype.updateComboTree = function (t, e, n) {
void 0 === n && (n = !0);
var r;
this.set("comboSorted", !1);
var i,
o = (r = Object(c.isString)(t)
? this.findById(t)
: t).getModel(),
a = o.comboId || o.parentId,
s = "";
if ((r.getType && (s = r.getType()), e && "combo" === s)) {
var u,
h = this.get("comboTrees"),
l = !0;
if (
((h || []).forEach(function (t) {
u ||
dt(t, function (t) {
if (!u) return t.id === r.getID() && (u = t), !0;
});
}),
dt(u, function (t) {
return t.id !== e || ((l = !1), !1);
}),
!l)
)
return void console.warn(
"Failed to update the combo tree! The parentId points to a descendant of the combo!",
);
}
if (n && this.get("enabledStack")) {
var f = {},
d = {};
"combo" === s
? ((f.combos = [{ id: o.id, parentId: o.parentId }]),
(d.combos = [{ id: o.id, parentId: e }]))
: "node" === s &&
((f.nodes = [{ id: o.id, parentId: o.comboId }]),
(d.nodes = [{ id: o.id, parentId: e }])),
this.pushStack("updateComboTree", { before: f, after: d });
}
if (o.parentId || o.comboId) {
var p = this.findById(o.parentId || o.comboId);
p && p.removeChild(r);
}
("combo" === s
? (o.parentId = e)
: "node" === s && (o.comboId = e),
e) &&
(i = this.findById(e)) &&
i.addChild(r);
a && (i = this.findById(a)) && i.removeChild(r);
var g = mt(this.get("comboTrees"), o.id, e);
this.set("comboTrees", g), this.updateCombos();
}),
(e.prototype.save = function () {
var t = [],
e = [],
n = [];
return (
Object(c.each)(this.get("nodes"), function (e) {
t.push(e.getModel());
}),
Object(c.each)(this.get("edges"), function (t) {
e.push(t.getModel());
}),
Object(c.each)(this.get("combos"), function (t) {
n.push(t.getModel());
}),
{ nodes: t, edges: e, combos: n }
);
}),
(e.prototype.changeSize = function (t, e) {
return this.get("viewController").changeSize(t, e), this;
}),
(e.prototype.refresh = function () {
if ((this.emit("beforegraphrefresh"), this.get("animate")))
this.positionsAnimate();
else {
var t = this.get("nodes"),
e = this.get("edges"),
n = this.get("edges");
Object(c.each)(t, function (t) {
t.refresh();
}),
Object(c.each)(e, function (t) {
t.refresh();
}),
Object(c.each)(n, function (t) {
t.refresh();
});
}
this.emit("aftergraphrefresh"), this.autoPaint();
}),
(e.prototype.getNodes = function () {
return this.get("nodes");
}),
(e.prototype.getEdges = function () {
return this.get("edges");
}),
(e.prototype.getCombos = function () {
return this.get("combos");
}),
(e.prototype.getComboChildren = function (t) {
if (
(Object(c.isString)(t) && (t = this.findById(t)),
t && (!t.getType || "combo" === t.getType()))
)
return t.getChildren();
console.warn("The combo does not exist!");
}),
(e.prototype.positionsAnimate = function () {
var t = this;
t.emit("beforeanimate");
var e = t.get("animateCfg"),
n = e.onFrame,
r = t.getNodes(),
i = r.map(function (t) {
var e = t.getModel();
return { id: e.id, x: e.x, y: e.y };
});
t.isAnimating() && t.stopAnimate(),
t.get("canvas").animate(
function (e) {
Object(c.each)(i, function (r) {
var i = t.findById(r.id);
if (i && !i.destroyed) {
var o = i.get("originAttrs"),
a = i.get("model");
if (!o) {
var s = i.getContainer().getMatrix();
s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(o = { x: s[6], y: s[7] }),
i.set("originAttrs", o);
}
if (n) {
var c = n(i, e, r, o);
i.set("model", Object.assign(a, c));
} else
(a.x = o.x + (r.x - o.x) * e),
(a.y = o.y + (r.y - o.y) * e);
}
}),
t.refreshPositions();
},
{
duration: e.duration,
easing: e.easing,
callback: function () {
Object(c.each)(r, function (t) {
t.set("originAttrs", null);
}),
e.callback && e.callback(),
t.emit("afteranimate"),
(t.animating = !1);
},
},
);
}),
(e.prototype.refreshPositions = function () {
this.emit("beforegraphrefreshposition");
var t,
e = this.get("nodes"),
n = this.get("edges"),
r = this.get("vedges"),
i = this.get("combos"),
o = {};
Object(c.each)(e, function (e) {
t = e.getModel();
var n = e.get("originAttrs");
if (!n || t.x !== n.x || t.y !== n.y) {
var r = e.updatePosition({ x: t.x, y: t.y });
(o[t.id] = r),
t.comboId && (o[t.comboId] = o[t.comboId] || r);
}
}),
i && 0 !== i.length && this.updateCombos(),
Object(c.each)(n, function (t) {
var e = t.getSource().getModel(),
n = t.getTarget();
if (!Object(c.isPlainObject)(n)) {
var r = n.getModel();
(o[e.id] || o[r.id] || t.getModel().isComboEdge) &&
t.refresh();
}
}),
Object(c.each)(r, function (t) {
t.refresh();
}),
this.emit("aftergraphrefreshposition"),
this.autoPaint();
}),
(e.prototype.stopAnimate = function () {
this.get("canvas").stopAnimate();
}),
(e.prototype.isAnimating = function () {
return this.animating;
}),
(e.prototype.getZoom = function () {
var t = this.get("group").getMatrix();
return t ? t[0] : 1;
}),
(e.prototype.getCurrentMode = function () {
return this.get("modeController").getMode();
}),
(e.prototype.setMode = function (t) {
return this.get("modeController").setMode(t), this;
}),
(e.prototype.clear = function (t) {
return (
void 0 === t && (t = !1),
this.get("canvas").clear(),
this.initGroups(),
this.set({
itemMap: {},
nodes: [],
edges: [],
groups: [],
combos: [],
comboTrees: [],
}),
t || this.emit("afterrender"),
this
);
}),
(e.prototype.updateLayout = function (t) {
var e = this.get("layoutController");
Object(c.isString)(t) && (t = { type: t });
var n = this.get("layout"),
r = {};
Object.assign(r, n, t),
this.set("layout", r),
e.isLayoutTypeSame(r) && r.gpuEnabled === n.gpuEnabled
? e.updateLayoutCfg(r)
: e.changeLayout(r);
}),
(e.prototype.destroyLayout = function () {
this.get("layoutController").destroyLayout();
}),
(e.prototype.layout = function () {
var t = this.get("layoutController"),
e = this.get("layout");
e &&
t &&
(e.workerEnabled
? t.layout()
: t.layoutMethod
? t.relayout(!0)
: t.layout());
}),
(e.prototype.collapseCombo = function (t) {
var e = this;
if ((Object(c.isString)(t) && (t = this.findById(t)), t)) {
this.emit("beforecollapseexpandcombo", {
action: "expand",
item: t,
});
var n = t.getModel();
this.get("itemController").collapseCombo(t), (n.collapsed = !0);
var r = this.getEdges().concat(this.get("vedges")),
i = [],
o = [],
a = this.get("comboTrees"),
s = !1;
(a || []).forEach(function (t) {
s ||
dt(t, function (t) {
if (s && t.depth <= n.depth) return !1;
if ((n.id === t.id && (s = !0), s)) {
var r = e.findById(t.id);
r &&
r.getType &&
"combo" === r.getType() &&
((i = i.concat(r.getNodes())),
(o = o.concat(r.getCombos())));
}
return !0;
});
});
var u = {},
h = [];
r.forEach(function (t) {
if (!t.isVisible() || t.getModel().isVEdge) {
var r = t.getSource(),
a = t.getTarget();
if (
((i.includes(r) || o.includes(r)) &&
!i.includes(a) &&
!o.includes(a)) ||
r.getModel().id === n.id
) {
if ((f = t.getModel()).isVEdge)
return void e.removeItem(t, !1);
for (var s = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(s.parentId || s.comboId)) ||
(!s.parentId && !s.comboId)
)
return;
s = a.getModel();
}
var c = s.id;
if (u["".concat(n.id, "-").concat(c)])
return void (u["".concat(n.id, "-").concat(c)] +=
f.size || 1);
var l = e.addItem(
"vedge",
{ source: n.id, target: c, isVEdge: !0 },
!1,
);
(u["".concat(n.id, "-").concat(c)] = f.size || 1),
h.push(l);
} else if (
(!i.includes(r) &&
!o.includes(r) &&
(i.includes(a) || o.includes(a))) ||
a.getModel().id === n.id
) {
var f;
if ((f = t.getModel()).isVEdge)
return void e.removeItem(t, !1);
for (var d = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(d.parentId || d.comboId)) ||
(!d.parentId && !d.comboId)
)
return;
d = r.getModel();
}
var p = d.id;
if (u["".concat(p, "-").concat(n.id)])
return void (u["".concat(p, "-").concat(n.id)] +=
f.size || 1);
l = e.addItem(
"vedge",
{ target: n.id, source: p, isVEdge: !0 },
!1,
);
(u["".concat(p, "-").concat(n.id)] = f.size || 1),
h.push(l);
}
}
}),
h.forEach(function (t) {
var n = t.getModel();
e.updateItem(
t,
{ size: u["".concat(n.source, "-").concat(n.target)] },
!1,
);
}),
this.emit("aftercollapseexpandcombo", {
action: "collapse",
item: t,
});
} else console.warn("The combo to be collapsed does not exist!");
}),
(e.prototype.expandCombo = function (t) {
var e = this;
if (
(Object(c.isString)(t) && (t = this.findById(t)),
!t || (t.getType && "combo" !== t.getType()))
)
console.warn("The combo to be collapsed does not exist!");
else {
this.emit("beforecollapseexpandcombo", {
action: "expand",
item: t,
});
var n = t.getModel();
this.get("itemController").expandCombo(t), (n.collapsed = !1);
var r = this.getEdges().concat(this.get("vedges")),
i = [],
o = [],
a = this.get("comboTrees"),
s = !1;
(a || []).forEach(function (t) {
s ||
dt(t, function (t) {
if (s && t.depth <= n.depth) return !1;
if ((n.id === t.id && (s = !0), s)) {
var r = e.findById(t.id);
r &&
r.getType &&
"combo" === r.getType() &&
((i = i.concat(r.getNodes())),
(o = o.concat(r.getCombos())));
}
return !0;
});
});
var u = {},
h = {};
r.forEach(function (t) {
if (!t.isVisible() || t.getModel().isVEdge) {
var r = t.getSource(),
a = t.getTarget(),
s = r.get("id"),
c = a.get("id");
if (
((i.includes(r) || o.includes(r)) &&
!i.includes(a) &&
!o.includes(a)) ||
s === n.id
) {
if (t.getModel().isVEdge) return void e.removeItem(t, !1);
for (var l = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(l.comboId || l.parentId)) ||
(!l.parentId && !l.comboId)
)
return;
l = a.getModel();
}
c = l.id;
for (var f = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(f.comboId || f.parentId)) ||
(!f.parentId && !f.comboId)
)
return;
if (f.comboId === n.id || f.parentId === n.id) break;
f = r.getModel();
}
if (((s = f.id), c)) {
var d = "".concat(s, "-").concat(c);
if (u[d])
return (
(u[d] += t.getModel().size || 1),
void e.updateItem(h[d], { size: u[d] }, !1)
);
var p = e.addItem(
"vedge",
{ source: s, target: c, isVEdge: !0 },
!1,
);
(u[d] = t.getModel().size || 1), (h[d] = p);
}
} else if (
(!i.includes(r) &&
!o.includes(r) &&
(i.includes(a) || o.includes(a))) ||
c === n.id
) {
if (t.getModel().isVEdge) return void e.removeItem(t, !1);
for (f = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(f.comboId || f.parentId)) ||
(!f.parentId && !f.comboId)
)
return;
f = r.getModel();
}
s = f.id;
for (l = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(l.comboId || l.parentId)) ||
(!l.parentId && !l.comboId)
)
return;
if (l.comboId === n.id || l.parentId === n.id) break;
l = a.getModel();
}
if (((c = l.id), s)) {
d = "".concat(s, "-").concat(c);
if (u[d])
return (
(u[d] += t.getModel().size || 1),
void e.updateItem(h[d], { size: u[d] }, !1)
);
p = e.addItem(
"vedge",
{ target: c, source: s, isVEdge: !0 },
!1,
);
(u[d] = t.getModel().size || 1), (h[d] = p);
}
} else
(i.includes(r) || o.includes(r)) &&
(i.includes(a) || o.includes(a)) &&
r.isVisible() &&
a.isVisible() &&
t.show();
}
}),
this.emit("aftercollapseexpandcombo", {
action: "expand",
item: t,
});
}
}),
(e.prototype.collapseExpandCombo = function (t) {
if (
(Object(c.isString)(t) && (t = this.findById(t)),
t && (!t.getType || "combo" === t.getType()))
) {
for (var e = t.getModel(), n = this.findById(e.parentId); n; ) {
var r = n.getModel();
if (r.collapsed)
return (
console.warn(
"Fail to expand the combo since it's ancestor combo is collapsed.",
),
void (n = void 0)
);
n = this.findById(r.parentId);
}
e.collapsed ? this.expandCombo(t) : this.collapseCombo(t),
this.updateCombo(t);
}
}),
(e.prototype.sortCombos = function () {
var t = this;
if (!this.get("comboSorted")) {
this.set("comboSorted", !0);
var e = [],
n = {};
(this.get("comboTrees") || []).forEach(function (t) {
dt(t, function (t) {
return (
e[t.depth]
? e[t.depth].push(t.id)
: (e[t.depth] = [t.id]),
(n[t.id] = t.depth),
!0
);
});
}),
(this.getEdges().concat(this.get("vedges")) || []).forEach(
function (t) {
var r = t.getModel(),
i = n[r.source] || 0,
o = n[r.target] || 0,
a = Math.max(i, o);
e[a] ? e[a].push(r.id) : (e[a] = [r.id]);
},
),
e.forEach(function (e) {
if (e && e.length)
for (var n = e.length - 1; n >= 0; n--) {
var r = t.findById(e[n]);
r && r.toFront();
}
});
}
}),
(e.prototype.getNeighbors = function (t, e) {
var n = t;
return (
Object(c.isString)(t) && (n = this.findById(t)),
n.getNeighbors(e)
);
}),
(e.prototype.getNodeDegree = function (t, e, n) {
void 0 === e && (e = void 0), void 0 === n && (n = !1);
var r = t;
Object(c.isString)(t) && (r = this.findById(t));
var i = this.get("degrees");
(i && !n) ||
((i = Object(v.getDegree)(this.save())),
this.set("degrees", i));
var o = i[r.getID()],
a = 0;
if (!o) return 0;
switch (e) {
case "in":
a = o.inDegree;
break;
case "out":
a = o.outDegree;
break;
case "all":
a = o;
break;
default:
a = o.degree;
}
return a;
}),
(e.prototype.getUndoStack = function () {
return this.undoStack;
}),
(e.prototype.getRedoStack = function () {
return this.redoStack;
}),
(e.prototype.getStackData = function () {
return this.get("enabledStack")
? {
undoStack: this.undoStack.toArray(),
redoStack: this.redoStack.toArray(),
}
: null;
}),
(e.prototype.clearStack = function () {
this.get("enabledStack") &&
(this.undoStack.clear(), this.redoStack.clear());
}),
(e.prototype.pushStack = function (t, e, n) {
if (
(void 0 === t && (t = "update"),
void 0 === n && (n = "undo"),
this.get("enabledStack"))
) {
var r = e
? Object(c.clone)(e)
: { before: {}, after: Object(c.clone)(this.save()) };
"redo" === n
? this.redoStack.push({ action: t, data: r })
: this.undoStack.push({ action: t, data: r }),
this.emit("stackchange", {
undoStack: this.undoStack,
redoStack: this.redoStack,
});
} else
console.warn(
"请先启用 undo & redo 功能，在实例化 Graph 时候配置 enabledStack: true !",
);
}),
(e.prototype.getAdjMatrix = function (t, e) {
void 0 === t && (t = !0),
void 0 === e && (e = this.get("directed"));
var n = this.get("adjMatrix");
return (
(n && t) ||
((n = Object(v.getAdjMatrix)(this.save(), e)),
this.set("adjMatrix", n)),
n
);
}),
(e.prototype.getShortestPathMatrix = function (t, e) {
void 0 === t && (t = !0),
void 0 === e && (e = this.get("directed"));
var n = this.get("adjMatrix"),
r = this.get("shortestPathMatrix");
return (
(n && t) ||
((n = Object(v.getAdjMatrix)(this.save(), e)),
this.set("adjMatrix", n)),
(r && t) ||
((r = Object(v.floydWarshall)(this.save(), e)),
this.set("shortestPathMatrix", r)),
r
);
}),
(e.prototype.on = function (e, n, r) {
return t.prototype.on.call(this, e, n, r);
}),
(e.prototype.destroy = function () {
this.clear(),
Object(p.clearAnimationFrame)(this.timeIndex),
this.clearStack(),
this.get("itemController").destroy(),
this.get("modeController").destroy(),
this.get("viewController").destroy(),
this.get("stateController").destroy(),
this.get("canvas").destroy(),
(this.cfg = null),
(this.destroyed = !0),
(this.redoStack = null),
(this.undoStack = null);
}),
(e.prototype.createHull = function (t) {
if (t.members && !(t.members.length < 1)) {
var e = this.get("hullGroup"),
n = this.get("hullMap");
if (
(n || ((n = {}), this.set("hullMap", n)),
(e && !e.get("destroyed")) ||
((e = this.get("group").addGroup({
id: "hullGroup",
})).toBack(),
this.set("hullGroup", e)),
n[t.id])
)
return console.warn("Existed hull id."), n[t.id];
var r = e.addGroup({ id: "".concat(t.id, "-container") }),
i = new be(
this,
Object(f.a)(Object(f.a)({}, t), { group: r }),
);
return (n[i.id] = i), i;
}
console.warn("Create hull failed! The members is empty.");
}),
(e.prototype.getHulls = function () {
return this.get("hullMap");
}),
(e.prototype.getHullById = function (t) {
return this.get("hullMap")[t];
}),
(e.prototype.removeHull = function (t) {
var e;
(e = Object(c.isString)(t) ? this.getHullById(t) : t),
delete this.get("hullMap")[e.id],
e.destroy();
}),
(e.prototype.removeHulls = function () {
var t = this.getHulls();
t &&
Object.keys(t).length &&
(Object.keys(t).forEach(function (e) {
t[e].destroy();
}),
this.set("hullMap", {}));
}),
(e.prototype.onTick = function (t) {
var e = this.get("layoutController");
e &&
(e.onTick(t),
(this.timeIndex = Object(p.requestAnimationFrame)(
this.onTick.bind(this),
)));
}),
e
);
})(d.a);
function Se(t) {
return (Se =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var Oe = g.a.transform,
Me = ["startArrow", "endArrow"],
ke = {
lineWidth: 1,
stroke: void 0,
fill: void 0,
lineAppendWidth: 1,
opacity: void 0,
strokeOpacity: void 0,
fillOpacity: void 0,
x: 0,
y: 0,
r: 10,
width: 20,
height: 20,
shadowColor: void 0,
shadowBlur: 0,
shadowOffsetX: 0,
shadowOffsetY: 0,
},
Ce = {
edge: {
lineWidth: 1,
stroke: "#000",
lineDash: void 0,
startArrow: !1,
endArrow: !1,
opacity: void 0,
strokeOpacity: void 0,
fillOpacity: void 0,
shadowColor: void 0,
shadowBlur: 0,
shadowOffsetX: 0,
shadowOffsetY: 0,
},
node: ke,
combo: ke,
},
Ee = {
options: {},
itemType: "",
type: "",
getCustomConfig: function (t) {
return {};
},
getOptions: function (t) {
return Object(c.deepMix)(
{
labelCfg: {
style: {
fontFamily:
("undefined" != typeof window &&
window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif",
},
},
descriptionCfg: {
style: {
fontFamily:
("undefined" != typeof window &&
window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif",
},
},
},
this.options,
this.getCustomConfig(t) || {},
t,
);
},
draw: function (t, e) {
var n = this.drawShape(t, e);
(n.set("className", this.itemType + "-shape"), t.label) &&
this.drawLabel(t, e).set("className", this.itemType + "-label");
return n;
},
afterDraw: function (t, e, n) {},
drawShape: function (t, e) {
return null;
},
drawLabel: function (t, e) {
var n = this.getOptions(t).labelCfg || {},
r = this.getLabelStyle(t, n, e),
i = r.rotate;
delete r.rotate;
var o = e.addShape("text", {
attrs: r,
draggable: !0,
className: "text-shape",
name: "text-shape",
});
if (i) {
var a = o.getBBox(),
s = o.getMatrix();
if ((s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]), r.rotateCenter))
switch (r.rotateCenter) {
case "center":
s = Oe(s, [
["t", -a.width / 2, -a.height / 2],
["r", i],
["t", a.width / 2, a.height / 2],
]);
break;
case "lefttop":
s = Oe(s, [
["t", -r.x, -r.y],
["r", i],
["t", r.x, r.y],
]);
break;
case "leftcenter":
s = Oe(s, [
["t", -r.x, -r.y - a.height / 2],
["r", i],
["t", r.x, r.y + a.height / 2],
]);
break;
default:
s = Oe(s, [
["t", -a.width / 2, -a.height / 2],
["r", i],
["t", a.width / 2, a.height / 2],
]);
}
else
s = Oe(s, [
["t", -r.x, -r.y - a.height / 2],
["r", i],
["t", r.x, r.y + a.height / 2],
]);
o.setMatrix(s);
}
if (r.background) {
var c = this.drawLabelBg(t, e, o),
u = this.itemType + "-label-bg";
c.set("classname", u), o.toFront();
}
return o;
},
drawLabelBg: function (t, e, n) {
var r = this.options.labelCfg,
i = Object(c.mix)({}, r, t.labelCfg),
o = this.getLabelBgStyleByPosition(n, t, i, e);
return e.addShape("rect", { name: "text-bg-shape", attrs: o });
},
getLabelStyleByPosition: function (t, e, n) {
return { text: t.label };
},
getLabelBgStyleByPosition: function (t, e, n, r) {
return {};
},
getLabelStyle: function (t, e, n) {
var r = this.getLabelStyleByPosition(t, e, n),
i = "".concat(this.itemType, "Label"),
o = nt[i] ? nt[i].style : null;
return Object(f.a)(Object(f.a)(Object(f.a)({}, o), r), e.style);
},
getShapeStyle: function (t) {
return t.style;
},
update: function (t, e) {
this.updateShapeStyle(t, e), this.updateLabel(t, e);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = e.getKeyShape(),
i = Object(c.mix)({}, r.attr(), t.style),
o = function (t) {
var e,
o = i[t];
if (Object(c.isPlainObject)(o)) {
var a = n.find(function (e) {
return e.get("name") === t;
});
a && a.attr(o);
} else r.attr((((e = {})[t] = o), e));
};
for (var a in i) o(a);
},
updateLabel: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).labelCfg,
i = this.itemType + "-label",
o = n.find(function (t) {
return t.get("className") === i;
}),
a = this.itemType + "-label-bg",
s = n.find(function (t) {
return t.get("classname") === a;
});
if (t.label || "" === t.label)
if (o) {
var u = {};
e.getModel && (u = e.getModel().labelCfg);
var h = Object(c.deepMix)({}, r, u, t.labelCfg),
l = this.getLabelStyleByPosition(t, h, n),
d = t.labelCfg ? t.labelCfg.style : void 0,
p = h.style && h.style.background,
g = Object(f.a)(Object(f.a)(Object(f.a)({}, o.attr()), l), d),
v = g.rotate;
if ((delete g.rotate, v)) {
var y = [1, 0, 0, 0, 1, 0, 0, 0, 1];
(y = Oe(y, [
["t", -g.x, -g.y],
["r", v],
["t", g.x, g.y],
])),
o.resetMatrix(),
o.attr(Object(f.a)(Object(f.a)({}, g), { matrix: y }));
} else o.resetMatrix(), o.attr(g);
if (s)
if (g.background) {
var m = this.getLabelBgStyleByPosition(o, t, h, n),
b = Object(f.a)(Object(f.a)({}, m), p);
if ((s.resetMatrix(), v)) {
var x = [1, 0, 0, 0, 1, 0, 0, 0, 1];
(x = Oe(x, [
["t", -b.x, -b.y],
["r", v],
["t", b.x, b.y],
])),
(b.matrix = x);
}
s.attr(b);
} else n.removeChild(s);
else
g.background &&
((s = this.drawLabelBg(t, n, o)).set("classname", a),
o.toFront());
} else {
this.drawLabel(t, n).set("className", i);
}
},
afterUpdate: function (t, e) {},
setState: function (t, e, n) {
var r,
i,
o = n.get("keyShape");
if (o && !o.destroyed) {
var a = n.getType(),
s = Object(c.isBoolean)(e) ? t : "".concat(t, ":").concat(e),
u = this.getStateStyle(s, n),
h = n.getStateStyle(s);
if (h || u) {
var l = Object(c.mix)({}, h || u),
f = n.getContainer(),
d = { x: 1, y: 1, cx: 1, cy: 1 };
if (
("combo" === a && ((d.r = 1), (d.width = 1), (d.height = 1)),
e)
) {
var p = function (t) {
var e,
n = l[t];
if (Object(c.isPlainObject)(n) && !Me.includes(t)) {
var r = f.find(function (e) {
return e.get("name") === t;
});
r && r.attr(n);
} else o.attr((((e = {})[t] = n), e));
};
for (var g in l) p(g);
} else {
var v = wt(n.getCurrentStatesStyle()),
y = n.getModel(),
m = Object(c.mix)({}, y.style, wt(n.getOriginStyle())),
b = o.get("name"),
x = o.attr(),
w = {};
Object.keys(x).forEach(function (t) {
if ("img" !== t) {
var e = x[t];
e && "object" === Se(e)
? (w[t] = Object(c.clone)(e))
: (w[t] = e);
}
});
var S = {},
O = function (t) {
var e = l[t];
if (Object(c.isPlainObject)(e) && !Me.includes(t)) {
var n = f.find(function (e) {
return e.get("name") === t;
});
if (n) {
var r = Object(c.clone)(n.attr());
Object(c.each)(e, function (e, i) {
if (t === b && w[i] && !d[i]) {
delete w[i];
var s = m[t][i] || Ce[a][i];
o.attr(i, s);
} else if (r[i] || 0 === r[i]) {
delete r[i];
var c = m[t][i] || Ce[a][i];
n.attr(i, c);
}
}),
(S[t] = r);
}
} else if (w[t] && !d[t]) {
delete w[t];
var i = m[t] || (m[b] ? m[b][t] : void 0) || Ce[a][t];
o.attr(t, i);
}
};
for (var M in l) O(M);
for (var g in (b ? (S[b] = w) : Object(c.mix)(S, w), v))
if (!d[g]) {
var k = v[g];
(Object(c.isPlainObject)(k) && !Me.includes(g)) ||
(b
? (Object(c.mix)(m[b], (((i = {})[g] = k), i)),
delete m[g])
: Object(c.mix)(m, (((r = {})[g] = k), r)),
delete v[g]);
}
var C = {};
Object(c.deepMix)(C, m, S, v);
var E = !1,
j = function (t) {
var e,
n,
r = C[t];
if (Object(c.isPlainObject)(r) && !Me.includes(t)) {
var i = f.find(function (e) {
return e.get("name") === t;
});
i &&
(t === b &&
("combo" === a &&
(delete r.r, delete r.width, delete r.height),
(E = !0)),
i.attr(r));
} else if (!E) {
var s = r || Ce[a][t];
"combo" === a
? b || o.attr((((e = {})[t] = s), e))
: o.attr((((n = {})[t] = s), n));
}
};
for (var P in C) j(P);
}
}
}
},
getStateStyle: function (t, e) {
var n = e.getModel(),
r = e.getType(),
i = this.getOptions(n),
o = i.stateStyles,
a = i.style,
s = void 0 === a ? {} : a,
u = n.stateStyles ? n.stateStyles[t] : o && o[t];
return "combo" === r ? Object(c.clone)(u) : Object(c.mix)({}, s, u);
},
getControlPoints: function (t) {
return t.controlPoints;
},
getAnchorPoints: function (t) {
return this.getOptions(t).anchorPoints;
},
},
je = {
itemType: "node",
shapeType: "single-node",
labelPosition: "center",
offset: nt.nodeLabel.offset,
getSize: function (t) {
var e = t.size || this.getOptions({}).size || nt.defaultNode.size;
return (
Object(c.isArray)(e) && 1 === e.length && (e = [e[0], e[0]]),
Object(c.isArray)(e) || (e = [e, e]),
e
);
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition;
if ("center" === n) return { x: 0, y: 0, text: t.label };
var r = e.offset;
Object(c.isNil)(r) && (r = this.offset);
var i,
o = this.getSize(t),
a = o[0],
s = o[1];
switch (n) {
case "top":
i = { x: 0, y: 0 - s / 2 - r, textBaseline: "bottom" };
break;
case "bottom":
i = { x: 0, y: s / 2 + r, textBaseline: "top" };
break;
case "left":
i = { x: 0 - a / 2 - r, y: 0, textAlign: "right" };
break;
default:
i = { x: a / 2 + r, y: 0, textAlign: "left" };
}
return (i.text = t.label), i;
},
getLabelBgStyleByPosition: function (t, e, n, r) {
if (!t) return {};
var i = t.getBBox(),
o = n.style && n.style.background;
if (!o) return {};
var a,
s = Et(o.padding),
u = i.width + s[1] + s[3],
h = i.height + s[0] + s[2],
l = n.offset;
return (
Object(c.isNil)(l) && (l = this.offset),
(a = { x: i.minX - s[3], y: i.minY - s[0] }),
(a = Object(f.a)(Object(f.a)(Object(f.a)({}, a), o), {
width: u,
height: h,
}))
);
},
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
return e.addShape(n, {
attrs: r,
draggable: !0,
name: "node-shape",
});
},
updateLinkPoints: function (t, e) {
var n,
r = this.getOptions(t).linkPoints,
i = e.find(function (t) {
return "link-point-left" === t.get("className");
}),
o = e.find(function (t) {
return "link-point-right" === t.get("className");
}),
a = e.find(function (t) {
return "link-point-top" === t.get("className");
}),
s = e.find(function (t) {
return "link-point-bottom" === t.get("className");
});
i && (n = i.attr()),
o && !n && (n = o.attr()),
a && !n && (n = a.attr()),
s && !n && (n = s.attr()),
n || (n = r);
var u = Object(c.mix)({}, n, t.linkPoints),
h = u.fill,
l = u.stroke,
d = u.lineWidth,
p = u.size / 2;
p || (p = u.r);
var g = t.linkPoints
? t.linkPoints
: { left: void 0, right: void 0, top: void 0, bottom: void 0 },
v = g.left,
y = g.right,
m = g.top,
b = g.bottom,
x = this.getSize(t),
w = x[0],
S = x[1],
O = { r: p, fill: h, stroke: l, lineWidth: d };
i
? v || void 0 === v
? i.attr(Object(f.a)(Object(f.a)({}, O), { x: -w / 2, y: 0 }))
: i.remove()
: v &&
e.addShape("circle", {
attrs: Object(f.a)(Object(f.a)({}, O), { x: -w / 2, y: 0 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
o
? (y || void 0 === y || o.remove(),
o.attr(Object(f.a)(Object(f.a)({}, O), { x: w / 2, y: 0 })))
: y &&
e.addShape("circle", {
attrs: Object(f.a)(Object(f.a)({}, O), { x: w / 2, y: 0 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a
? (m || void 0 === m || a.remove(),
a.attr(Object(f.a)(Object(f.a)({}, O), { x: 0, y: -S / 2 })))
: m &&
e.addShape("circle", {
attrs: Object(f.a)(Object(f.a)({}, O), { x: 0, y: -S / 2 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
s
? b || void 0 === b
? s.attr(Object(f.a)(Object(f.a)({}, O), { x: 0, y: S / 2 }))
: s.remove()
: b &&
e.addShape("circle", {
attrs: Object(f.a)(Object(f.a)({}, O), { x: 0, y: S / 2 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
updateShape: function (t, e, n, r) {
e.get("keyShape").attr(Object(f.a)({}, n)),
this.updateLabel(t, e),
r && this.updateIcon(t, e);
},
updateIcon: function (t, e) {
var n = this,
r = e.getContainer(),
i = this.getOptions(t).icon,
o = (t.icon ? t.icon : { show: void 0 }).show,
a = r.find(function (t) {
return t.get("className") === "".concat(n.type, "-icon");
});
if (a)
if (o || void 0 === o) {
var s = Object(c.mix)({}, a.attr(), i),
u = s.width,
h = s.height;
a.attr(
Object(f.a)(Object(f.a)({}, s), { x: -u / 2, y: -h / 2 }),
);
} else a.remove();
else if (o) {
(u = i.width), (h = i.height);
r.addShape("image", {
attrs: Object(f.a)(Object(f.a)({}, i), {
x: -u / 2,
y: -h / 2,
}),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
});
var l = r.find(function (t) {
return "node-label" === t.get("className");
});
l && l.toFront();
}
},
},
Pe = Object(f.a)(Object(f.a)({}, Ee), je);
Wt.registerNode("single-node", Pe);
var Ae = {
itemType: "edge",
labelPosition: "center",
refX: 0,
refY: 0,
labelAutoRotate: !1,
options: {
size: nt.defaultEdge.size,
style: {
x: 0,
y: 0,
stroke: nt.defaultEdge.style.stroke,
lineAppendWidth: nt.defaultEdge.style.lineAppendWidth,
},
labelCfg: {
style: {
fill: nt.edgeLabel.style.fill,
fontSize: nt.edgeLabel.style.fontSize,
},
},
stateStyles: Object(f.a)({}, nt.edgeStateStyles),
},
getPath: function (t) {
var e = [];
return (
Object(c.each)(t, function (t, n) {
0 === n ? e.push(["M", t.x, t.y]) : e.push(["L", t.x, t.y]);
}),
e
);
},
getShapeStyle: function (t) {
var e = this.options.style,
n = { stroke: t.color },
r = Object(c.mix)({}, e, n, t.style),
i = t.size || nt.defaultEdge.size,
o = (t = this.getPathPoints(t)).startPoint,
a = t.endPoint,
s = this.getControlPoints(t),
u = [o];
s && (u = u.concat(s)), u.push(a);
var h = this.getPath(u);
return Object(c.mix)(
{},
nt.defaultEdge.style,
{ stroke: nt.defaultEdge.color, lineWidth: i, path: h },
r,
);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = { stroke: t.color },
i =
n.find(function (t) {
return "edge-shape" === t.get("className");
}) || e.getKeyShape(),
o = t.size,
a = (t = this.getPathPoints(t)).startPoint,
s = t.endPoint,
u = this.getControlPoints(t),
h = [a];
u && (h = h.concat(u)), h.push(s);
var l = i.attr(),
f = Object(c.mix)({}, r, l, t.style),
d = t.sourceNode,
p = t.targetNode,
g = { radius: f.radius };
u ||
(g = {
source: d,
target: p,
offset: f.offset,
radius: f.radius,
}),
l.endArrow &&
!1 === f.endArrow &&
(t.style.endArrow = { path: "" }),
l.startArrow &&
!1 === f.startArrow &&
(t.style.startArrow = { path: "" });
var v = this.getPath(h, g),
y = Object(c.mix)(
r,
i.attr(),
{ lineWidth: o, path: v },
t.style,
);
i && i.attr(y);
},
getLabelStyleByPosition: function (t, e, n) {
var r,
i = e.position || this.labelPosition,
o = {},
a =
n &&
n.find(function (t) {
return "edge-shape" === t.get("className");
});
r = "start" === i ? 0 : "end" === i ? 1 : 0.5;
var s,
u = e.refX || this.refX,
h = e.refY || this.refY;
if (
t.startPoint.x === t.endPoint.x &&
t.startPoint.y === t.endPoint.y
)
return (
(o.x = t.startPoint.x + u),
(o.y = t.startPoint.y + h),
(o.text = t.label),
o
);
s = Object(c.isNil)(e.autoRotate)
? this.labelAutoRotate
: e.autoRotate;
var l = lt(a, r, u, h, s);
return (
(o.x = l.x),
(o.y = l.y),
(o.rotate = l.rotate),
(o.textAlign = this._getTextAlign(i, l.angle)),
(o.text = t.label),
o
);
},
getLabelBgStyleByPosition: function (t, e, n, r) {
if (!t) return {};
var i = t.getBBox(),
o = n.style && n.style.background;
if (!o) return {};
var a,
s = o.padding,
u = i.width + s[1] + s[3],
h = i.height + s[0] + s[2],
l = n.position || this.labelPosition,
d = Object(f.a)(Object(f.a)({}, o), {
width: u,
height: h,
x: i.minX - s[2],
y: i.minY - s[0],
rotate: 0,
});
a = Object(c.isNil)(n.autoRotate)
? this.labelAutoRotate
: n.autoRotate;
var p,
g =
r &&
r.find(function (t) {
return "edge-shape" === t.get("className");
});
p = "start" === l ? 0 : "end" === l ? 1 : 0.5;
var v = n.refX || this.refX,
y = n.refY || this.refY;
if (
e.startPoint.x === e.endPoint.x &&
e.startPoint.y === e.endPoint.y
)
return (
(d.x = e.startPoint.x + v - u / 2),
(d.y = e.startPoint.y + y - h / 2),
d
);
var m = lt(g, p, v - u / 2, y + h / 2, a),
b = m.angle;
return (
b > 0.5 * Math.PI &&
b < 1.5 * Math.PI &&
(m = lt(g, p, v + u / 2, y + h / 2, a)),
a && ((d.x = m.x), (d.y = m.y)),
(d.rotate = m.rotate),
d
);
},
_getTextAlign: function (t, e) {
var n = "center";
return e
? ((e %= 2 * Math.PI),
"center" !== t &&
(n =
(e >= 0 && e <= Math.PI / 2) ||
(e >= 1.5 * Math.PI && e < 2 * Math.PI)
? t
: (function (t) {
var e = t;
return (
"start" === t
? (e = "end")
: "end" === t && (e = "start"),
e
);
})(t)),
n)
: t;
},
getControlPoints: function (t) {
return t.controlPoints;
},
getPathPoints: function (t) {
return t;
},
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("path", {
className: "edge-shape",
name: "edge-shape",
attrs: n,
});
},
drawLabel: function (t, e) {
var n,
r = this.options.labelCfg;
n =
("undefined" != typeof window &&
void 0 !== window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif";
var i = Object(c.deepMix)({ fontFamily: n }, r, t.labelCfg),
o = this.getLabelStyle(t, i, e),
a = o.rotate;
delete o.rotate;
var s = e.addShape("text", { attrs: o, name: "text-shape" });
if ((a && s.rotateAtStart(a), o.background)) {
var u = this.drawLabelBg(t, e, s),
h = this.itemType + "-label-bg";
u.set("classname", h), s.toFront();
}
return s;
},
drawLabelBg: function (t, e, n) {
var r = this.options.labelCfg,
i = Object(c.deepMix)({}, r, t.labelCfg),
o = this.getLabelStyle(t, i, e).rotate,
a = this.getLabelBgStyleByPosition(n, t, i, e);
delete a.rotate;
var s = e.addShape("rect", { name: "text-bg-shape", attrs: a });
return o && s.rotateAtStart(o), s;
},
},
Ie = Object(f.a)(Object(f.a)({}, Ee), Ae);
Wt.registerEdge("single-edge", Ie),
Wt.registerEdge(
"line",
{ getControlPoints: function () {} },
"single-edge",
),
Wt.registerEdge(
"spline",
{
getPath: function (t) {
return te(t);
},
},
"single-edge",
),
Wt.registerEdge(
"arc",
{
curveOffset: 20,
clockwise: 1,
getControlPoints: function (t) {
var e,
n,
r = t.startPoint,
i = t.endPoint,
o = (r.x + i.x) / 2,
a = (r.y + i.y) / 2;
if (void 0 !== t.controlPoints) {
if (
((n = t.controlPoints[0]),
(e = C(r, n, i)),
r.x <= i.x && r.y > i.y
? (this.clockwise = e.x > n.x ? 0 : 1)
: r.x <= i.x && r.y < i.y
? (this.clockwise = e.x > n.x ? 1 : 0)
: r.x > i.x && r.y <= i.y
? (this.clockwise = e.y < n.y ? 0 : 1)
: (this.clockwise = e.y < n.y ? 1 : 0),
(n.x - r.x) / (n.y - r.y) == (i.x - r.x) / (i.y - r.y))
)
return [];
} else {
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
Object(c.isArray)(t.curveOffset) &&
(t.curveOffset = t.curveOffset[0]),
t.curveOffset < 0
? (this.clockwise = 0)
: (this.clockwise = 1);
var s = { x: i.x - r.x, y: i.y - r.y },
u = Math.atan2(s.y, s.x);
(n = {
x: t.curveOffset * Math.cos(-Math.PI / 2 + u) + o,
y: t.curveOffset * Math.sin(-Math.PI / 2 + u) + a,
}),
(e = C(r, n, i));
}
var h = E(r, e);
return [{ x: h, y: h }];
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
2 === t.length
? e.push(["L", t[1].x, t[1].y])
: e.push([
"A",
t[1].x,
t[1].y,
0,
0,
this.clockwise,
t[2].x,
t[2].y,
]),
e
);
},
},
"single-edge",
),
Wt.registerEdge(
"quadratic",
{
curvePosition: 0.5,
curveOffset: -20,
getControlPoints: function (t) {
var e = t.controlPoints;
if (!e || !e.length) {
var n = t.startPoint,
r = t.endPoint;
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
Object(c.isArray)(this.curveOffset) &&
(t.curveOffset = t.curveOffset[0]),
Object(c.isArray)(this.curvePosition) &&
(t.curvePosition = t.curveOffset[0]),
(e = [ee(n, r, t.curvePosition, t.curveOffset)]);
}
return e;
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
e.push(["Q", t[1].x, t[1].y, t[2].x, t[2].y]),
e
);
},
},
"single-edge",
),
Wt.registerEdge(
"cubic",
{
curvePosition: [0.5, 0.5],
curveOffset: [-20, 20],
getControlPoints: function (t) {
var e = t.controlPoints;
if (
(void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
Object(c.isNumber)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(c.isNumber)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]),
!e || !e.length || e.length < 2)
) {
var n = t.startPoint,
r = t.endPoint;
e = [
ee(n, r, t.curvePosition[0], t.curveOffset[0]),
ee(n, r, t.curvePosition[1], t.curveOffset[1]),
];
}
return e;
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
e.push(["C", t[1].x, t[1].y, t[2].x, t[2].y, t[3].x, t[3].y]),
e
);
},
},
"single-edge",
),
Wt.registerEdge(
"cubic-vertical",
{
curvePosition: [0.5, 0.5],
minCurveOffset: [0, 0],
curveOffset: void 0,
getControlPoints: function (t) {
var e = t.startPoint,
n = t.endPoint;
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.minCurveOffset &&
(t.minCurveOffset = this.minCurveOffset),
Object(c.isNumber)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(c.isNumber)(t.minCurveOffset) &&
(t.minCurveOffset = [t.minCurveOffset, -t.minCurveOffset]),
Object(c.isNumber)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]);
var r = n.y - e.y,
i = [0, 0];
return (
t.curveOffset
? (i = t.curveOffset)
: Math.abs(r) < Math.abs(t.minCurveOffset[0]) &&
(i = t.minCurveOffset),
[
{ x: e.x, y: e.y + r * this.curvePosition[0] + i[0] },
{ x: n.x, y: n.y - r * this.curvePosition[1] + i[1] },
]
);
},
},
"cubic",
),
Wt.registerEdge(
"cubic-horizontal",
{
curvePosition: [0.5, 0.5],
minCurveOffset: [0, 0],
curveOffset: void 0,
getControlPoints: function (t) {
var e = t.startPoint,
n = t.endPoint;
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.minCurveOffset &&
(t.minCurveOffset = this.minCurveOffset),
Object(c.isNumber)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(c.isNumber)(t.minCurveOffset) &&
(t.minCurveOffset = [t.minCurveOffset, -t.minCurveOffset]),
Object(c.isNumber)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]);
var r = n.x - e.x,
i = [0, 0];
return (
t.curveOffset
? (i = t.curveOffset)
: Math.abs(r) < Math.abs(t.minCurveOffset[0]) &&
(i = t.minCurveOffset),
[
{ x: e.x + r * this.curvePosition[0] + i[0], y: e.y },
{ x: n.x - r * this.curvePosition[1] + i[1], y: n.y },
]
);
},
},
"cubic",
),
Wt.registerEdge(
"loop",
{
getPathPoints: function (t) {
return ht(t);
},
getControlPoints: function (t) {
return t.controlPoints;
},
afterDraw: function (t) {
t.controlPoints = void 0;
},
afterUpdate: function (t) {
t.controlPoints = void 0;
},
},
"cubic",
);
var Te = {
itemType: "combo",
shapeType: "single-combo",
labelPosition: "top",
refX: nt.comboLabel.refX,
refY: nt.comboLabel.refY,
options: {
style: {
stroke: nt.defaultCombo.style.stroke,
fill: nt.defaultCombo.style.fill,
lineWidth: nt.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: nt.comboLabel.style.fill,
fontSize: nt.comboLabel.style.fontSize,
},
},
stateStyles: Object(f.a)({}, nt.comboStateStyles),
},
getSize: function (t) {
var e = Object(c.clone)(
t.size || this.options.size || nt.defaultCombo.size,
);
return (
Object(c.isArray)(e) && 1 === e.length && (e = [e[0], e[0]]),
Object(c.isArray)(e) || (e = [e, e]),
e
);
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition,
r = t.style,
i = t.padding || this.options.padding;
Object(c.isArray)(i) && (i = i[0]);
var o = e.refX,
a = e.refY;
Object(c.isNil)(o) && (o = this.refX),
Object(c.isNil)(a) && (a = this.refY);
var s,
u = this.getSize(t),
h = (Math.max(r.r, u[0] / 2) || u[0] / 2) + i;
switch (n) {
case "top":
s = {
x: 0,
y: -h - a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "bottom":
s = {
x: 0,
y: h + a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "left":
s = { x: -h + o, y: 0, textAlign: "left" };
break;
case "center":
s = { x: 0, y: 0, text: t.label, textAlign: "center" };
break;
default:
s = { x: h + o, y: 0, textAlign: "right" };
}
return (s.text = t.label), s;
},
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
return e.addShape(n, {
attrs: r,
draggable: !0,
name: "combo-shape",
});
},
updateShape: function (t, e, n) {
var r = e.get("keyShape");
(void 0 === t.animate ? this.options.animate : t.animate) &&
r.animate
? r.animate(n, { duration: 200, easing: "easeLinear" })
: r.attr(Object(f.a)({}, n)),
this.updateLabel(t, e);
},
},
Ne = Object(f.a)(Object(f.a)({}, Ee), Te);
Wt.registerCombo("single-combo", Ne),
Wt.registerCombo(
"circle",
{
options: {
size: [nt.defaultCombo.size[0], nt.defaultCombo.size[0]],
padding: nt.defaultCombo.padding[0],
animate: !0,
style: {
stroke: nt.defaultCombo.style.stroke,
fill: nt.defaultCombo.style.fill,
lineWidth: nt.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: nt.comboLabel.style.fill,
fontSize: nt.comboLabel.style.fontSize,
},
refX: 0,
refY: 0,
},
stateStyles: Object(f.a)({}, nt.comboStateStyles),
},
shapeType: "circle",
labelPosition: "top",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return (
delete n.height,
delete n.width,
e.addShape("circle", {
attrs: n,
className: "circle-combo",
name: "circle-combo",
draggable: !0,
})
);
},
getShapeStyle: function (t) {
var e = this.options.style,
n = t.padding || this.options.padding;
Object(c.isArray)(n) && (n = n[0]);
var r,
i = { stroke: t.color },
o = Object(c.mix)({}, e, i, t.style);
if (t.fixSize)
r = Object(c.isNumber)(t.fixSize) ? t.fixSize : t.fixSize[0];
else {
var a = this.getSize(t);
r =
!Object(c.isNumber)(o.r) || isNaN(o.r)
? a[0] / 2 || nt.defaultCombo.style.r
: Math.max(o.r, a[0] / 2) || a[0] / 2;
}
o.r = r + n;
var s = Object(f.a)({ x: 0, y: 0 }, o);
return t.style ? (t.style.r = r) : (t.style = { r: r }), s;
},
update: function (t, e) {
var n = this.getSize(t),
r = t.padding || this.options.padding;
Object(c.isArray)(r) && (r = r[0]);
var i,
o = Object(c.clone)(t.style);
(i = t.fixSize
? Object(c.isNumber)(t.fixSize)
? t.fixSize
: t.fixSize[0]
: Math.max(o.r, n[0] / 2) || n[0] / 2),
(o.r = i + r);
var a = e.get("sizeCache");
a && (a.r = o.r);
var s = { stroke: t.color },
u = e.get("keyShape"),
h = Object(c.mix)({}, u.attr(), s, o);
t.style ? (t.style.r = i) : (t.style = { r: i }),
this.updateShape(t, e, h, !0);
},
},
"single-combo",
),
Wt.registerCombo(
"rect",
{
options: {
size: [40, 5],
padding: [25, 20, 15, 20],
animate: !0,
style: {
radius: 0,
stroke: nt.defaultCombo.style.stroke,
fill: nt.defaultCombo.style.fill,
lineWidth: nt.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: nt.comboLabel.style.fill,
fontSize: nt.comboLabel.style.fontSize,
},
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
stateStyles: Object(f.a)({}, nt.comboStateStyles),
},
shapeType: "rect",
labelPosition: "top",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("rect", {
attrs: n,
className: "rect-combo",
name: "rect-combo",
draggable: !0,
});
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition,
r = t.style,
i = t.padding || this.options.padding;
Object(c.isNumber)(i) && (i = [i, i, i, i]);
var o = e.refX,
a = e.refY;
Object(c.isNil)(o) && (o = this.refX),
Object(c.isNil)(a) && (a = this.refY);
var s,
u = r.width / 2 + i[3],
h = r.height / 2 + i[0];
switch (n) {
case "top":
s = {
x: 0 - u + o,
y: 0 - h + a,
textBaseline: "top",
textAlign: "left",
};
break;
case "bottom":
s = {
x: 0,
y: h + a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "left":
s = { x: 0 - u + a, y: 0, textAlign: "left" };
break;
case "center":
s = { x: 0, y: 0, text: t.label, textAlign: "center" };
break;
default:
s = { x: u + o, y: 0, textAlign: "right" };
}
return (s.text = t.label), s;
},
getShapeStyle: function (t) {
var e = this.options.style,
n = t.padding || this.options.padding;
Object(c.isNumber)(n) && (n = [n, n, n, n]);
var r,
i,
o = { stroke: t.color },
a = Object(c.mix)({}, e, o, t.style),
s = this.getSize(t),
u =
t.collapsed && t.fixCollapseSize
? t.fixCollapseSize
: t.fixSize;
u
? Object(c.isNumber)(u)
? ((r = u), (i = u))
: ((r = u[0]), (i = u[1]))
: ((r =
!Object(c.isNumber)(a.width) || isNaN(a.width)
? s[0] || nt.defaultCombo.style.width
: Math.max(a.width, s[0]) || s[0]),
(i =
!Object(c.isNumber)(a.height) || isNaN(a.height)
? s[1] || nt.defaultCombo.style.height
: Math.max(a.height, s[1]) || s[1]));
var h = -r / 2 - n[3],
l = -i / 2 - n[0];
(a.width = r + n[1] + n[3]), (a.height = i + n[0] + n[2]);
var d = Object(f.a)({ x: h, y: l }, a);
return (
t.style
? ((t.style.width = r), (t.style.height = i))
: (t.style = { width: r, height: i }),
d
);
},
update: function (t, e) {
var n = this.getSize(t),
r = t.padding || this.options.padding;
Object(c.isNumber)(r) && (r = [r, r, r, r]);
var i,
o,
a = Object(c.clone)(t.style),
s =
t.collapsed && t.fixCollapseSize
? t.fixCollapseSize
: t.fixSize;
s
? Object(c.isNumber)(s)
? ((i = s), (o = s))
: ((i = s[0]), (o = s[1]))
: ((i = Math.max(a.width, n[0]) || n[0]),
(o = Math.max(a.height, n[1]) || n[1])),
(a.width = i + r[1] + r[3]),
(a.height = o + r[0] + r[2]);
var u = e.get("sizeCache");
u && ((u.width = a.width), (u.height = a.height)),
(a.x = -i / 2 - r[3]),
(a.y = -o / 2 - r[0]);
var h = { stroke: t.color },
l = e.get("keyShape"),
f = Object(c.mix)({}, l.attr(), h, a);
t.style
? ((t.style.width = i), (t.style.height = o))
: (t.style = { width: i, height: o }),
this.updateShape(t, e, f, !1);
},
updateShape: function (t, e, n) {
var r = e.get("keyShape");
(void 0 === t.animate ? this.options.animate : t.animate) &&
r.animate
? r.animate(n, { duration: 200, easing: "easeLinear" })
: r.attr(Object(f.a)({}, n)),
this.updateLabel(t, e);
},
},
"single-combo",
),
Wt.registerNode(
"simple-circle",
{
options: {
size: nt.defaultNode.size,
style: {
x: 0,
y: 0,
stroke: nt.defaultNode.style.stroke,
fill: nt.defaultNode.style.fill,
lineWidth: nt.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: nt.nodeLabel.style.fill,
fontSize: nt.nodeLabel.style.fontSize,
},
},
stateStyles: Object(f.a)({}, nt.nodeStateStyles),
},
shapeType: "simple-circle",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("circle", {
attrs: n,
className: "".concat(this.type, "-keyShape"),
draggable: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
r = Object(c.deepMix)({}, e, n),
i = this.getSize(t)[0] / 2;
return Object(f.a)({ x: 0, y: 0, r: i }, r);
},
update: function (t, e) {
var n = this.getSize(t),
r = { stroke: t.color, r: n[0] / 2 },
i = e.get("keyShape"),
o = Object(c.deepMix)({}, i.attr(), r, t.style);
this.updateShape(t, e, o, !0);
},
},
"single-node",
),
Wt.registerNode(
"simple-rect",
{
options: {
size: [100, 30],
style: {
radius: 0,
stroke: nt.defaultNode.style.stroke,
fill: nt.defaultNode.style.fill,
lineWidth: nt.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: nt.nodeLabel.style.fill,
fontSize: nt.nodeLabel.style.fontSize,
},
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
stateStyles: Object(f.a)({}, nt.nodeStateStyles),
},
shapeType: "simple-rect",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("rect", {
attrs: n,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
r = Object(c.mix)({}, e, n),
i = this.getSize(t),
o = r.width || i[0],
a = r.height || i[1];
return Object(f.a)(
{ x: -o / 2, y: -a / 2, width: o, height: a },
r,
);
},
update: function (t, e) {
e.getContainer();
var n = this.getOptions({}).style,
r = this.getSize(t),
i = e.get("keyShape");
t.size ||
((r[0] = i.attr("width") || n.width),
(r[1] = i.attr("height") || n.height));
var o = {
stroke: t.color,
x: -r[0] / 2,
y: -r[1] / 2,
width: r[0],
height: r[1],
},
a = Object(c.mix)({}, n, i.attr(), o);
(a = Object(c.mix)(a, t.style)), this.updateShape(t, e, a, !1);
},
},
"single-node",
),
Wt.registerNode(
"image",
{
options: {
img: "https://gw.alipayobjects.com/mdn/rms_f8c6a0/afts/img/A*eD7nT6tmYgAAAAAAAAAAAABkARQnAQ",
size: 200,
clipCfg: {
show: !1,
type: "circle",
r: 50,
rx: 50,
ry: 35,
width: 50,
height: 35,
points: [
[30, 12],
[12, 30],
[30, 48],
[48, 30],
],
path: [
["M", 25, 25],
["L", 50, 25],
["A", 12.5, 12.5, 0, 1, 1, 50, 50],
["A", 12.5, 12.5, 0, 1, 0, 50, 50],
["L", 25, 75],
["Z"],
],
x: 0,
y: 0,
},
},
shapeType: "image",
labelPosition: "bottom",
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
delete r.fill;
var i = e.addShape(n, {
attrs: r,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
});
return this.drawClip(t, i), i;
},
drawClip: function (t, e) {
var n = this.getOptions(t).clipCfg;
if (n.show) {
var r = n.type,
i = n.x,
o = n.y,
a = n.style;
if ("circle" === r) {
var s = n.r;
e.setClip({
type: "circle",
attrs: Object(f.a)({ r: s, x: i, y: o }, a),
});
} else if ("rect" === r) {
var c = n.width,
u = n.height,
h = i - c / 2,
l = o - u / 2;
e.setClip({
type: "rect",
attrs: Object(f.a)({ x: h, y: l, width: c, height: u }, a),
});
} else if ("ellipse" === r) {
var d = n.rx,
p = n.ry;
e.setClip({
type: "ellipse",
attrs: Object(f.a)({ x: i, y: o, rx: d, ry: p }, a),
});
} else if ("polygon" === r) {
var g = n.points;
e.setClip({
type: "polygon",
attrs: Object(f.a)({ points: g }, a),
});
} else if ("path" === r) {
var v = n.path;
e.setClip({
type: "path",
attrs: Object(f.a)({ path: v }, a),
});
}
}
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = this.getSize(t),
r = this.getOptions(t).img,
i = n[0],
o = n[1];
return (
e && ((i = e.width || n[0]), (o = e.height || n[1])),
Object(f.a)(
{ x: -i / 2, y: -o / 2, width: i, height: o, img: r },
e,
)
);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = "".concat(this.itemType, "-shape"),
i =
n.find(function (t) {
return t.get("className") === r;
}) || e.getKeyShape(),
o = this.getShapeStyle(t);
i && i.attr(o);
},
},
"single-node",
);
var Be,
Le = {
triangle: function (t, e, n) {
void 0 === t && (t = 10),
void 0 === e && (e = 15),
void 0 === n && (n = 0);
var r = 2 * n;
return "M "
.concat(r, ",0 L ")
.concat(r + e, ",-")
.concat(t / 2, " L ")
.concat(r + e, ",")
.concat(t / 2, " Z");
},
vee: function (t, e, n) {
void 0 === t && (t = 15),
void 0 === e && (e = 20),
void 0 === n && (n = 0);
var r = 2 * n;
return "M "
.concat(r, ",0 L ")
.concat(r + e, ",-")
.concat(t / 2, "\n L ")
.concat(r + (2 * e) / 3, ",0 L ")
.concat(r + e, ",")
.concat(t / 2, " Z");
},
circle: function (t, e) {
return (
void 0 === t && (t = 5),
void 0 === e && (e = 0),
"M "
.concat(2 * e, ", 0\n a ")
.concat(t, ",")
.concat(t, " 0 1,0 ")
.concat(2 * t, ",0\n a ")
.concat(t, ",")
.concat(t, " 0 1,0 ")
.concat(2 * -t, ",0")
);
},
rect: function (t, e, n) {
void 0 === t && (t = 10),
void 0 === e && (e = 10),
void 0 === n && (n = 0);
var r = 2 * n;
return "M "
.concat(r, ",")
.concat(-t / 2, " \n L ")
.concat(r + e, ",")
.concat(-t / 2, " \n L ")
.concat(r + e, ",")
.concat(t / 2, " \n L ")
.concat(r, ",")
.concat(t / 2, " Z");
},
diamond: function (t, e, n) {
void 0 === t && (t = 15),
void 0 === e && (e = 15),
void 0 === n && (n = 0);
var r = 2 * n;
return "M "
.concat(r, ",0 \n L ")
.concat(r + e / 2, ",")
.concat(-t / 2, " \n L ")
.concat(r + e, ",0 \n L ")
.concat(r + e / 2, ",")
.concat(t / 2, " Z");
},
triangleRect: function (t, e, n, r, i, o) {
void 0 === t && (t = 15),
void 0 === e && (e = 15),
void 0 === n && (n = 15),
void 0 === r && (r = 3),
void 0 === i && (i = 5),
void 0 === o && (o = 0);
var a = 2 * o,
s = a + e + i;
return "M "
.concat(a, ",0 L ")
.concat(a + e, ",-")
.concat(t / 2, " L ")
.concat(a + e, ",")
.concat(t / 2, " Z\n M ")
.concat(s, ", -")
.concat(n / 2, "\n L ")
.concat(s + r, " -")
.concat(n / 2, "\n L ")
.concat(s + r, " ")
.concat(n / 2, "\n L ")
.concat(s, " ")
.concat(n / 2, "\n Z");
},
},
De = {
collapse: function (t, e, n) {
return [
["M", t - n, e],
["a", n, n, 0, 1, 0, 2 * n, 0],
["a", n, n, 0, 1, 0, 2 * -n, 0],
["M", t - n + 4, e],
["L", t + n - 4, e],
];
},
expand: function (t, e, n) {
return [
["M", t - n, e],
["a", n, n, 0, 1, 0, 2 * n, 0],
["a", n, n, 0, 1, 0, 2 * -n, 0],
["M", t - n + 4, e],
["L", t - n + 2 * n - 4, e],
["M", t - n + n, e - n + 4],
["L", t, e + n - 4],
];
},
upTriangle: function (t, e, n) {
var r = n * Math.cos(Math.PI / 6),
i = n * Math.sin(Math.PI / 6);
return [
["M", t - r, e + i],
["L", t + r, e + i],
["L", t, e - n],
["Z"],
];
},
downTriangle: function (t, e, n) {
var r = n * Math.cos(Math.PI / 6),
i = n * Math.sin(Math.PI / 6);
return [
["M", t - r, e - i],
["L", t + r, e - i],
["L", t, e + n],
["Z"],
];
},
},
_e = Wt,
Re = [
"#5F95FF",
"#61DDAA",
"#65789B",
"#F6BD16",
"#7262FD",
"#78D3F8",
"#9661BC",
"#F6903D",
"#008685",
"#F08BB4",
],
Fe = g.a.transform,
Ye = Object(f.a)(
Object(f.a)(
Object(f.a)(Object(f.a)(Object(f.a)(Object(f.a)({}, o), i), a), r),
s,
),
{ transform: Fe, mat3: g.b },
),
Xe = (function () {
function t(t) {
(this.graph = t),
(this.layoutCfg = t.get("layout") || {}),
(this.layoutType = this.getLayoutType()),
(this.layoutMethods = []),
this.initLayout();
}
return (
(t.prototype.initLayout = function () {}),
(t.prototype.getLayoutType = function () {
return this.getLayoutCfgType(this.layoutCfg);
}),
(t.prototype.getLayoutCfgType = function (t) {
var e = t.type;
if (e) return e;
var n = t.pipes;
return Array.isArray(n)
? n.map(function (t) {
return (null == t ? void 0 : t.type) || "";
})
: null;
}),
(t.prototype.isLayoutTypeSame = function (t) {
var e = this.getLayoutCfgType(t);
return Array.isArray(this.layoutType)
? this.layoutType.every(function (t, n) {
return t === e[n];
})
: (null == t ? void 0 : t.type) === this.layoutType;
}),
(t.prototype.refreshLayout = function () {
var t = this.graph;
t &&
(t.get("animate")
? t.positionsAnimate()
: t.refreshPositions());
}),
(t.prototype.changeLayout = function (t) {
(this.layoutCfg = t), this.destoryLayoutMethods(), this.layout();
}),
(t.prototype.changeData = function () {
this.destoryLayoutMethods(), this.layout();
}),
(t.prototype.destoryLayoutMethods = function () {
var t = this.layoutMethods;
null == t ||
t.forEach(function (t) {
t.destroy();
}),
(this.layoutMethods = []);
}),
(t.prototype.destroyLayout = function () {
var t = this.graph;
this.destoryLayoutMethods(),
t.set("layout", void 0),
(this.layoutCfg = void 0),
(this.layoutType = void 0),
(this.layoutMethods = void 0);
}),
(t.prototype.setDataFromGraph = function () {
for (
var t = [],
e = [],
n = [],
r = [],
i = [],
o = [],
a = this.graph.getNodes(),
s = this.graph.getEdges(),
c = this.graph.getCombos(),
u = a.length,
h = 0;
h < u;
h++
) {
var l = a[h];
if (l && !l.destroyed) {
var f = l.getModel();
l.isVisible() ? t.push(f) : e.push(f);
}
}
var d = s.length;
for (h = 0; h < d; h++) {
var p = s[h];
if (p && !p.destroyed) {
f = p.getModel();
p.isVisible()
? f.isComboEdge
? i.push(f)
: n.push(f)
: r.push(f);
}
}
var g = c.length;
for (h = 0; h < g; h++) {
var v = c[h];
if (!v.destroyed) {
f = v.getModel();
v.isVisible() ? o.push(f) : r.push(f);
}
}
return {
nodes: t,
hiddenNodes: e,
edges: n,
hiddenEdges: r,
combos: o,
hiddenCombos: [],
comboEdges: i,
};
}),
(t.prototype.reLayoutMethod = function (t, e) {
var n = this;
return new Promise(function (r, i) {
var o = n.graph,
a = null == e ? void 0 : e.type;
(e.onLayoutEnd = function () {
o.emit("aftersublayout", { type: a }), r();
}),
t.init(n.data),
"force" === a && ((t.ticking = !1), t.forceSimulation.stop()),
o.emit("beforesublayout", { type: a }),
t.execute(),
t.isCustomLayout && e.onLayoutEnd && e.onLayoutEnd();
});
}),
(t.prototype.relayout = function (t) {
var e = this,
n = this.graph,
r = this.layoutMethods,
i = this.layoutCfg;
if (t) {
this.data = this.setDataFromGraph();
var o = this.data.nodes;
if (!o) return !1;
this.initPositions(i.center, o);
}
n.emit("beforelayout");
var a = Promise.resolve();
null == r ||
r.forEach(function (t, n) {
var r = i[n];
a = a.then(function () {
return e.reLayoutMethod(t, r);
});
}),
a
.then(function () {
i.onAllLayoutEnd && i.onAllLayoutEnd();
})
.catch(function (t) {
console.warn("relayout failed", t);
});
}),
(t.prototype.filterLayoutData = function (t, e) {
var n,
r,
i = t.nodes,
o = t.edges,
a = Object(f.e)(t, ["nodes", "edges"]);
if (!i) return t;
if (
((n = Object(c.isFunction)(null == e ? void 0 : e.nodesFilter)
? e.nodesFilter
: function () {
return !0;
}),
Object(c.isFunction)(null == e ? void 0 : e.edgesFilter))
)
r = e.edgesFilter;
else {
var s = i.reduce(function (t, e) {
return (t[e.id] = !0), t;
}, {});
r = function (t) {
return s[t.source] && s[t.target];
};
}
return Object(f.a)({ nodes: i.filter(n), edges: o.filter(r) }, a);
}),
(t.prototype.getLayoutBBox = function (t) {
var e = this.graph,
n = Object(c.groupBy)(e.getNodes(), function (t) {
return t.getModel().layoutOrder;
}),
r = Object.values(n).map(function (t) {
var e = It(t);
return (e.size = [e.width, e.height]), e;
});
return {
groupNodes: Object.values(Object(c.groupBy)(t, "layoutOrder")),
layoutNodes: r,
};
}),
(t.prototype.layoutAnimate = function () {}),
(t.prototype.moveToZero = function () {
var t = this.graph.get("data").nodes;
if (void 0 !== t[0].x && null !== t[0].x && !At(t[0].x)) {
for (var e = [0, 0], n = t.length, r = 0; r < n; r++) {
var i = t[r];
(e[0] += i.x), (e[1] += i.y);
}
(e[0] /= t.length), (e[1] /= t.length);
for (r = 0; r < n; r++) {
((i = t[r]).x -= e[0]), (i.y -= e[1]);
}
}
}),
(t.prototype.initPositions = function (t, e) {
var n = this.graph;
if (!e) return !1;
var r = e ? e.length : 0;
if (r) {
var i = 0.85 * n.get("width"),
o = 0.85 * n.get("height"),
a = Math.ceil(Math.sqrt(r) * (i / o)),
s = i / (a - 1),
c = o / (Math.ceil(r / a) - 1);
(isFinite(s) && s) || (s = 0), (isFinite(c) && s) || (c = 0);
for (
var u = t[0] - i / 2, h = t[1] - o / 2, l = !0, f = 0;
f < r;
f++
) {
var d = e[f];
At(d.x) && ((l = !1), (d.x = (f % a) * s + u)),
At(d.y) && ((l = !1), (d.y = Math.floor(f / a) * c + h));
}
return l;
}
}),
(t.prototype.destroy = function () {
(this.graph = null),
this.destoryLayoutMethods(),
(this.destroyed = !0);
}),
(t.prototype.onTick = function (t) {
var e;
null === (e = this.layoutMethods) ||
void 0 === e ||
e.forEach(function (e) {
var n;
null === (n = null == e ? void 0 : e.onTick) ||
void 0 === n ||
n.call(e, t);
});
}),
t
);
})(),
ze = function (t) {
(this.graph = t), (this.destroyed = !1), this.initEvents();
};
!(function (t) {
(t.CLICK = "click"),
(t.DBLCLICK = "dblclick"),
(t.TAP = "tap"),
(t.DBLTAP = "dbltap"),
(t.DRAGSTART = "dragstart"),
(t.DRAGEND = "dragend"),
(t.DRAG = "drag"),
(t.DRAGENTER = "dragenter"),
(t.DRAGLEAVE = "dragleave"),
(t.DRAGOVER = "dragover"),
(t.DRAGOUT = "dragout"),
(t.DDROP = "drop"),
(t.PINCHSTART = "pinchstart"),
(t.PINCHMOVE = "pinchmove"),
(t.PANSTART = "panstart"),
(t.PANMOVE = "panmove"),
(t.PANEND = "panend"),
(t.PRESS = "press"),
(t.ACTION_END = "actionend"),
(t.TOUCHSTART = "touchstart"),
(t.TOUCHMOVE = "touchmove"),
(t.TOUCHEND = "touchend"),
(t.CANVAS_TOUCHSTART = "canvas:touchstart"),
(t.CANVAS_TOUCHMOVE = "canvas:touchmove"),
(t.CANVAS_TOUCHEND = "canvas:touchend"),
(t.NODE_TOUCHSTART = "node:touchstart"),
(t.NODE_TOUCHMOVE = "node:touchmove"),
(t.NODE_TOUCHEND = "node:touchend"),
(t.COMBO_TOUCHSTART = "combo:touchstart"),
(t.COMBO_TOUCHMOVE = "combo:touchmove"),
(t.COMBO_TOUCHEND = "combo:touchend"),
(t.EDGE_TOUCHSTART = "edge:touchstart"),
(t.EDGE_TOUCHMOVE = "edge:touchmove"),
(t.EDGE_TOUCHEND = "edge:touchend"),
(t.NODE_CLICK = "node:click"),
(t.NODE_DBLCLICK = "node:dblclick"),
(t.NODE_DROP = "node:drop"),
(t.NODE_DRAGOVER = "node:dragover"),
(t.NODE_DRAGENTER = "node:dragenter"),
(t.NODE_DRAGLEAVE = "node:dragleave"),
(t.NODE_DRAGSTART = "node:dragstart"),
(t.NODE_DRAG = "node:drag"),
(t.NODE_DRAGEND = "node:dragend"),
(t.NODE_TAP = "node:tap"),
(t.NODE_DBLTAP = "node:dbltap"),
(t.NODE_PANSTART = "node:panstart"),
(t.NODE_PANMOVE = "node:panmove"),
(t.NODE_PANEND = "node:panend"),
(t.NODE_PRESS = "node:press"),
(t.COMBO_CLICK = "combo:click"),
(t.COMBO_DBLCLICK = "combo:dblclick"),
(t.COMBO_DROP = "combo:drop"),
(t.COMBO_DRAGOVER = "combo:dragover"),
(t.COMBO_DRAGENTER = "combo:dragenter"),
(t.COMBO_DRAGLEAVE = "combo:dragleave"),
(t.COMBO_DRAGSTART = "combo:dragstart"),
(t.COMBO_DRAG = "combo:drag"),
(t.COMBO_DRAGEND = "combo:dragend"),
(t.COMBO_TAP = "combo:tap"),
(t.COMBO_DBLTAP = "combo:dbltap"),
(t.COMBO_PANSTART = "combo:panstart"),
(t.COMBO_PANMOVE = "combo:panmove"),
(t.COMBO_PANEND = "combo:panend"),
(t.COMBO_PRESS = "combo:press"),
(t.EDGE_CLICK = "edge:click"),
(t.EDGE_DBLCLICK = "edge:dblclick"),
(t.EDGE_DROP = "edge:drop"),
(t.EDGE_DRAGOVER = "edge:dragover"),
(t.EDGE_DRAGENTER = "edge:dragenter"),
(t.EDGE_DRAGLEAVE = "edge:dragleave"),
(t.EDGE_TAP = "edge:tap"),
(t.EDGE_DBLTAP = "edge:dbltap"),
(t.EDGE_PRESS = "edge:press"),
(t.CANVAS_CLICK = "canvas:click"),
(t.CANVAS_DBLCLICK = "canvas:dblclick"),
(t.CANVAS_DROP = "canvas:drop"),
(t.CANVAS_DRAGENTER = "canvas:dragenter"),
(t.CANVAS_DRAGLEAVE = "canvas:dragleave"),
(t.CANVAS_DRAGSTART = "canvas:dragstart"),
(t.CANVAS_DRAG = "canvas:drag"),
(t.CANVAS_DRAGEND = "canvas:dragend"),
(t.CANVAS_TAP = "canvas:tap"),
(t.CANVAS_DBLTAP = "canvas:dbltap"),
(t.CANVAS_PANSTART = "canvas:panstart"),
(t.CANVAS_PANMOVE = "canvas:panmove"),
(t.CANVAS_PANEND = "canvas:panend"),
(t.CANVAS_PRESS = "canvas:press"),
(t.BEFORERENDER = "beforerender"),
(t.AFTERRENDER = "afterrender"),
(t.BEFOREADDITEM = "beforeadditem"),
(t.AFTERADDITEM = "afteradditem"),
(t.BEFOREREMOVEITEM = "beforeremoveitem"),
(t.AFTERREMOVEITEM = "afterremoveitem"),
(t.BEFOREUPDATEITEM = "beforeupdateitem"),
(t.AFTERUPDATEITEM = "afterupdateitem"),
(t.BEFOREITEMVISIBILITYCHANGE = "beforeitemvisibilitychange"),
(t.AFTERITEMVISIBILITYCHANGE = "afteritemvisibilitychange"),
(t.BEFOREITEMSTATECHANGE = "beforeitemstatechange"),
(t.AFTERITEMSTATECHANGE = "afteritemstatechange"),
(t.BEFOREITEMREFRESH = "beforeitemrefresh"),
(t.AFTERITEMREFRESH = "afteritemrefresh"),
(t.BEFOREITEMSTATESCLEAR = "beforeitemstatesclear"),
(t.AFTERITEMSTATESCLEAR = "afteritemstatesclear"),
(t.BEFOREMODECHANGE = "beforemodechange"),
(t.AFTERMODECHANGE = "aftermodechange"),
(t.BEFORELAYOUT = "beforelayout"),
(t.AFTERLAYOUT = "afterlayout"),
(t.BEFORECREATEEDGE = "beforecreateedge"),
(t.AFTERCREATEEDGE = "aftercreateedge"),
(t.BEFOREGRAPHREFRESHPOSITION = "beforegraphrefreshposition"),
(t.AFTERGRAPHREFRESHPOSITION = "aftergraphrefreshposition"),
(t.BEFOREGRAPHREFRESH = "beforegraphrefresh"),
(t.AFTERGRAPHREFRESH = "aftergraphrefresh"),
(t.BEFOREANIMATE = "beforeanimate"),
(t.AFTERANIMATE = "afteranimate"),
(t.BEFOREPAINT = "beforepaint"),
(t.AFTERPAINT = "afterpaint"),
(t.BEFORECOLLAPSEEXPANDCOMBO = "beforecollapseexpandcombo"),
(t.AFTERCOLLAPSEEXPANDCOMBO = "aftercollapseexpandcombo"),
(t.GRAPHSTATECHANGE = "graphstatechange"),
(t.AFTERACTIVATERELATIONS = "afteractivaterelations"),
(t.NODESELECTCHANGE = "nodeselectchange"),
(t.TOOLTIPCHANGE = "tooltipchange"),
(t.WHEELZOOM = "wheelzoom"),
(t.VIEWPORTCHANGE = "viewportchange"),
(t.DRAGNODEEND = "dragnodeend"),
(t.STACKCHANGE = "stackchange");
})(Be || (Be = {}));
var We = _e.registerNode,
qe = _e.registerEdge,
Ve = _e.registerCombo,
Ge = l.registerBehavior,
He = nt;
_e.registerNode, _e.registerEdge, _e.registerCombo, l.registerBehavior;
},
22: function (t, e, n) {
"use strict";
n.d(e, "a", function () {
return c;
}),
n.d(e, "b", function () {
return f;
}),
n.d(e, "c", function () {
return g;
}),
n.d(e, "d", function () {
return S;
});
var r = n(0),
i = /[MLHVQTCSAZ]([^MLHVQTCSAZ]*)/gi,
o = /[^\s\,]+/gi;
var a = function (t) {
var e = t || [];
return Object(r.isArray)(e)
? e
: Object(r.isString)(e)
? ((e = e.match(i)),
Object(r.each)(e, function (t, n) {
if ((t = t.match(o))[0].length > 1) {
var i = t[0].charAt(0);
t.splice(1, 0, t[0].substr(1)), (t[0] = i);
}
Object(r.each)(t, function (e, n) {
isNaN(e) || (t[n] = +e);
}),
(e[n] = t);
}),
e)
: void 0;
},
s = n(4);
var c = function (t, e, n) {
void 0 === e && (e = !1),
void 0 === n &&
(n = [
[0, 0],
[1, 1],
]);
for (var r = !!e, i = [], o = 0, a = t.length; o < a; o += 2)
i.push([t[o], t[o + 1]]);
var c,
u,
h,
l = (function (t, e, n, r) {
var i,
o,
a,
c,
u,
h,
l,
f = [],
d = !!r;
if (d) {
(a = r[0]), (c = r[1]);
for (var p = 0, g = t.length; p < g; p += 1) {
var v = t[p];
(a = s.b.min([0, 0], a, v)), (c = s.b.max([0, 0], c, v));
}
}
p = 0;
for (var y = t.length; p < y; p += 1) {
v = t[p];
if (0 !== p || n)
if (p !== y - 1 || n) {
(i = t[[p ? p - 1 : y - 1, p - 1][n ? 0 : 1]]),
(o = t[n ? (p + 1) % y : p + 1]);
var m = [0, 0];
(m = s.b.sub(m, o, i)), (m = s.b.scale(m, m, e));
var b = s.b.distance(v, i),
x = s.b.distance(v, o),
w = b + x;
0 !== w && ((b /= w), (x /= w));
var S = s.b.scale([0, 0], m, -b),
O = s.b.scale([0, 0], m, x);
(h = s.b.add([0, 0], v, S)),
(u = s.b.add([0, 0], v, O)),
(u = s.b.min([0, 0], u, s.b.max([0, 0], o, v))),
(u = s.b.max([0, 0], u, s.b.min([0, 0], o, v))),
(S = s.b.sub([0, 0], u, v)),
(S = s.b.scale([0, 0], S, -b / x)),
(h = s.b.add([0, 0], v, S)),
(h = s.b.min([0, 0], h, s.b.max([0, 0], i, v))),
(h = s.b.max([0, 0], h, s.b.min([0, 0], i, v))),
(O = s.b.sub([0, 0], v, h)),
(O = s.b.scale([0, 0], O, x / b)),
(u = s.b.add([0, 0], v, O)),
d &&
((h = s.b.max([0, 0], h, a)),
(h = s.b.min([0, 0], h, c)),
(u = s.b.max([0, 0], u, a)),
(u = s.b.min([0, 0], u, c))),
f.push(l),
f.push(h),
(l = u);
} else (h = v), f.push(l), f.push(h);
else l = v;
}
return n && f.push(f.shift()), f;
})(i, 0.4, r, n),
f = i.length,
d = [];
for (o = 0; o < f - 1; o += 1)
(c = l[2 * o]),
(u = l[2 * o + 1]),
(h = i[o + 1]),
d.push(["C", c[0], c[1], u[0], u[1], h[0], h[1]]);
return (
r &&
((c = l[f]),
(u = l[f + 1]),
(h = i[0]),
d.push(["C", c[0], c[1], u[0], u[1], h[0], h[1]])),
d
);
};
var u = "\t\n\v\f\r \u2028\u2029",
h = new RegExp(
"([a-z])[" +
u +
",]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[" +
u +
"]*,?[" +
u +
"]*)+)",
"ig",
),
l = new RegExp(
"(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[" + u + "]*,?[" + u + "]*",
"ig",
);
function f(t) {
if (!t) return null;
if (Object(r.isArray)(t)) return t;
var e = {
a: 7,
c: 6,
o: 2,
h: 1,
l: 2,
m: 2,
r: 4,
q: 4,
s: 4,
t: 2,
v: 1,
u: 3,
z: 0,
},
n = [];
return (
String(t).replace(h, function (t, r, i) {
var o = [],
a = r.toLowerCase();
if (
(i.replace(l, function (t, e) {
e && o.push(+e);
}),
"m" === a &&
o.length > 2 &&
(n.push([r].concat(o.splice(0, 2))),
(a = "l"),
(r = "m" === r ? "l" : "L")),
"o" === a && 1 === o.length && n.push([r, o[0]]),
"r" === a)
)
n.push([r].concat(o));
else
for (
;
o.length >= e[a] &&
(n.push([r].concat(o.splice(0, e[a]))), e[a]);
);
return "";
}),
n
);
}
var d = /[a-z]/;
function p(t, e) {
return [e[0] + (e[0] - t[0]), e[1] + (e[1] - t[1])];
}
function g(t) {
var e = f(t);
if (!e || !e.length) return [["M", 0, 0]];
for (var n = !1, r = 0; r < e.length; r++) {
var i = e[r][0];
if (d.test(i) || ["V", "H", "T", "S"].indexOf(i) >= 0) {
n = !0;
break;
}
}
if (!n) return e;
var o = [],
a = 0,
s = 0,
c = 0,
u = 0,
h = 0,
l = e[0];
("M" !== l[0] && "m" !== l[0]) ||
((c = a = +l[1]), (u = s = +l[2]), h++, (o[0] = ["M", a, s]));
r = h;
for (var g = e.length; r < g; r++) {
var v = e[r],
y = o[r - 1],
m = [],
b = (i = v[0]).toUpperCase();
if (i !== b)
switch (((m[0] = b), b)) {
case "A":
(m[1] = v[1]),
(m[2] = v[2]),
(m[3] = v[3]),
(m[4] = v[4]),
(m[5] = v[5]),
(m[6] = +v[6] + a),
(m[7] = +v[7] + s);
break;
case "V":
m[1] = +v[1] + s;
break;
case "H":
m[1] = +v[1] + a;
break;
case "M":
(c = +v[1] + a), (u = +v[2] + s), (m[1] = c), (m[2] = u);
break;
default:
for (var x = 1, w = v.length; x < w; x++)
m[x] = +v[x] + (x % 2 ? a : s);
}
else m = e[r];
switch (b) {
case "Z":
(a = +c), (s = +u);
break;
case "H":
m = ["L", (a = m[1]), s];
break;
case "V":
m = ["L", a, (s = m[1])];
break;
case "T":
(a = m[1]), (s = m[2]);
var S = p([y[1], y[2]], [y[3], y[4]]);
m = ["Q", S[0], S[1], a, s];
break;
case "S":
(a = m[m.length - 2]), (s = m[m.length - 1]);
var O = y.length,
M = p([y[O - 4], y[O - 3]], [y[O - 2], y[O - 1]]);
m = ["C", M[0], M[1], m[1], m[2], a, s];
break;
case "M":
(c = m[m.length - 2]), (u = m[m.length - 1]);
break;
default:
(a = m[m.length - 2]), (s = m[m.length - 1]);
}
o.push(m);
}
return o;
}
Math.PI;
function v(t) {
return Math.sqrt(t[0] * t[0] + t[1] * t[1]);
}
function y(t, e) {
return v(t) * v(e) ? (t[0] * e[0] + t[1] * e[1]) / (v(t) * v(e)) : 1;
}
function m(t, e) {
return (t[0] * e[1] < t[1] * e[0] ? -1 : 1) * Math.acos(y(t, e));
}
function b(t, e) {
return t[0] === e[0] && t[1] === e[1];
}
function x(t, e) {
var n = e[1],
i = e[2],
o = Object(r.mod)(Object(r.toRadian)(e[3]), 2 * Math.PI),
a = e[4],
s = e[5],
c = t[0],
u = t[1],
h = e[6],
l = e[7],
f = (Math.cos(o) * (c - h)) / 2 + (Math.sin(o) * (u - l)) / 2,
d = (-1 * Math.sin(o) * (c - h)) / 2 + (Math.cos(o) * (u - l)) / 2,
p = (f * f) / (n * n) + (d * d) / (i * i);
p > 1 && ((n *= Math.sqrt(p)), (i *= Math.sqrt(p)));
var g = n * n * (d * d) + i * i * (f * f),
v = g ? Math.sqrt((n * n * (i * i) - g) / g) : 1;
a === s && (v *= -1), isNaN(v) && (v = 0);
var x = i ? (v * n * d) / i : 0,
w = n ? (v * -i * f) / n : 0,
S = (c + h) / 2 + Math.cos(o) * x - Math.sin(o) * w,
O = (u + l) / 2 + Math.sin(o) * x + Math.cos(o) * w,
M = [(f - x) / n, (d - w) / i],
k = [(-1 * f - x) / n, (-1 * d - w) / i],
C = m([1, 0], M),
E = m(M, k);
return (
y(M, k) <= -1 && (E = Math.PI),
y(M, k) >= 1 && (E = 0),
0 === s && E > 0 && (E -= 2 * Math.PI),
1 === s && E < 0 && (E += 2 * Math.PI),
{
cx: S,
cy: O,
rx: b(t, [h, l]) ? 0 : n,
ry: b(t, [h, l]) ? 0 : i,
startAngle: C,
endAngle: C + E,
xRotation: o,
arcFlag: a,
sweepFlag: s,
}
);
}
function w(t, e) {
return [e[0] + (e[0] - t[0]), e[1] + (e[1] - t[1])];
}
function S(t) {
for (
var e = [],
n = null,
r = null,
i = null,
o = 0,
s = (t = a(t)).length,
c = 0;
c < s;
c++
) {
var u = t[c];
r = t[c + 1];
var h = u[0],
l = {
command: h,
prePoint: n,
params: u,
startTangent: null,
endTangent: null,
};
switch (h) {
case "M":
(i = [u[1], u[2]]), (o = c);
break;
case "A":
var f = x(n, u);
l.arcParams = f;
}
if ("Z" === h) (n = i), (r = t[o + 1]);
else {
var d = u.length;
n = [u[d - 2], u[d - 1]];
}
r && "Z" === r[0] && ((r = t[o]), e[o] && (e[o].prePoint = n)),
(l.currentPoint = n),
e[o] && b(n, e[o].currentPoint) && (e[o].prePoint = l.prePoint);
var p = r ? [r[r.length - 2], r[r.length - 1]] : null;
l.nextPoint = p;
var g = l.prePoint;
if (["L", "H", "V"].includes(h))
(l.startTangent = [g[0] - n[0], g[1] - n[1]]),
(l.endTangent = [n[0] - g[0], n[1] - g[1]]);
else if ("Q" === h) {
var v = [u[1], u[2]];
(l.startTangent = [g[0] - v[0], g[1] - v[1]]),
(l.endTangent = [n[0] - v[0], n[1] - v[1]]);
} else if ("T" === h) {
v = w((S = e[c - 1]).currentPoint, g);
"Q" === S.command
? ((l.command = "Q"),
(l.startTangent = [g[0] - v[0], g[1] - v[1]]),
(l.endTangent = [n[0] - v[0], n[1] - v[1]]))
: ((l.command = "TL"),
(l.startTangent = [g[0] - n[0], g[1] - n[1]]),
(l.endTangent = [n[0] - g[0], n[1] - g[1]]));
} else if ("C" === h) {
var y = [u[1], u[2]],
m = [u[3], u[4]];
(l.startTangent = [g[0] - y[0], g[1] - y[1]]),
(l.endTangent = [n[0] - m[0], n[1] - m[1]]),
0 === l.startTangent[0] &&
0 === l.startTangent[1] &&
(l.startTangent = [y[0] - m[0], y[1] - m[1]]),
0 === l.endTangent[0] &&
0 === l.endTangent[1] &&
(l.endTangent = [m[0] - y[0], m[1] - y[1]]);
} else if ("S" === h) {
var S;
(y = w((S = e[c - 1]).currentPoint, g)), (m = [u[1], u[2]]);
"C" === S.command
? ((l.command = "C"),
(l.startTangent = [g[0] - y[0], g[1] - y[1]]),
(l.endTangent = [n[0] - m[0], n[1] - m[1]]))
: ((l.command = "SQ"),
(l.startTangent = [g[0] - m[0], g[1] - m[1]]),
(l.endTangent = [n[0] - m[0], n[1] - m[1]]));
} else if ("A" === h) {
var O = 0.001,
M = l.arcParams || {},
k = M.cx,
C = void 0 === k ? 0 : k,
E = M.cy,
j = void 0 === E ? 0 : E,
P = M.rx,
A = void 0 === P ? 0 : P,
I = M.ry,
T = void 0 === I ? 0 : I,
N = M.sweepFlag,
B = void 0 === N ? 0 : N,
L = M.startAngle,
D = void 0 === L ? 0 : L,
_ = M.endAngle,
R = void 0 === _ ? 0 : _;
0 === B && (O *= -1);
var F = A * Math.cos(D - O) + C,
Y = T * Math.sin(D - O) + j;
l.startTangent = [F - i[0], Y - i[1]];
var X = A * Math.cos(D + R + O) + C,
z = T * Math.sin(D + R - O) + j;
l.endTangent = [g[0] - X, g[1] - z];
}
e.push(l);
}
return e;
}
},
26: function (t, e, n) {
"use strict";
var r = n(78);
n.d(e, "a", function () {
return r.Layout;
}),
n.d(e, "b", function () {
return r.Layouts;
});
var i = n(51);
n.d(e, "c", function () {
return i.registerLayout;
}),
n.d(e, "d", function () {
return i.unRegisterLayout;
});
var o = n(52);
Object(i.registerLayout)("random", o.RandomLayout);
},
27: function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "getAdjMatrix", function () {
return r;
}),
n.d(e, "breadthFirstSearch", function () {
return l;
}),
n.d(e, "connectedComponent", function () {
return d;
}),
n.d(e, "getDegree", function () {
return g;
}),
n.d(e, "getInDegree", function () {
return v;
}),
n.d(e, "getOutDegree", function () {
return y;
}),
n.d(e, "detectCycle", function () {
return S;
}),
n.d(e, "detectDirectedCycle", function () {
return mt;
}),
n.d(e, "detectAllCycles", function () {
return w;
}),
n.d(e, "detectAllDirectedCycle", function () {
return x;
}),
n.d(e, "detectAllUndirectedCycle", function () {
return b;
}),
n.d(e, "depthFirstSearch", function () {
return m;
}),
n.d(e, "dijkstra", function () {
return k;
}),
n.d(e, "findAllPath", function () {
return P;
}),
n.d(e, "findShortestPath", function () {
return j;
}),
n.d(e, "floydWarshall", function () {
return A;
}),
n.d(e, "labelPropagation", function () {
return I;
}),
n.d(e, "louvain", function () {
return F;
}),
n.d(e, "iLouvain", function () {
return Y;
}),
n.d(e, "kCore", function () {
return X;
}),
n.d(e, "kMeans", function () {
return W;
}),
n.d(e, "cosineSimilarity", function () {
return q;
}),
n.d(e, "nodesCosineSimilarity", function () {
return V;
}),
n.d(e, "minimumSpanningTree", function () {
return $;
}),
n.d(e, "pageRank", function () {
return Q;
}),
n.d(e, "getNeighbors", function () {
return c;
}),
n.d(e, "Stack", function () {
return yt;
}),
n.d(e, "GADDI", function () {
return vt;
});
var r = function (t, e) {
var n = t.nodes,
r = t.edges,
i = [],
o = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
o[t.id] = e;
i.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
a = o[n],
s = o[r];
(!a && 0 !== a) ||
(!s && 0 !== s) ||
((i[a][s] = 1), e || (i[s][a] = 1));
}),
i
);
},
i = function (t, e) {
return t === e;
},
o = (function () {
function t(t, e) {
void 0 === e && (e = null), (this.value = t), (this.next = e);
}
return (
(t.prototype.toString = function (t) {
return t ? t(this.value) : "".concat(this.value);
}),
t
);
})(),
a = (function () {
function t(t) {
void 0 === t && (t = i),
(this.head = null),
(this.tail = null),
(this.compare = t);
}
return (
(t.prototype.prepend = function (t) {
var e = new o(t, this.head);
return (this.head = e), this.tail || (this.tail = e), this;
}),
(t.prototype.append = function (t) {
var e = new o(t);
return this.head
? ((this.tail.next = e), (this.tail = e), this)
: ((this.head = e), (this.tail = e), this);
}),
(t.prototype.delete = function (t) {
if (!this.head) return null;
for (
var e = null;
this.head && this.compare(this.head.value, t);
)
(e = this.head), (this.head = this.head.next);
var n = this.head;
if (null !== n)
for (; n.next; )
this.compare(n.next.value, t)
? ((e = n.next), (n.next = n.next.next))
: (n = n.next);
return this.compare(this.tail.value, t) && (this.tail = n), e;
}),
(t.prototype.find = function (t) {
var e = t.value,
n = void 0 === e ? void 0 : e,
r = t.callback,
i = void 0 === r ? void 0 : r;
if (!this.head) return null;
for (var o = this.head; o; ) {
if (i && i(o.value)) return o;
if (void 0 !== n && this.compare(o.value, n)) return o;
o = o.next;
}
return null;
}),
(t.prototype.deleteTail = function () {
var t = this.tail;
if (this.head === this.tail)
return (this.head = null), (this.tail = null), t;
for (var e = this.head; e.next; )
e.next.next ? (e = e.next) : (e.next = null);
return (this.tail = e), t;
}),
(t.prototype.deleteHead = function () {
if (!this.head) return null;
var t = this.head;
return (
this.head.next
? (this.head = this.head.next)
: ((this.head = null), (this.tail = null)),
t
);
}),
(t.prototype.fromArray = function (t) {
var e = this;
return (
t.forEach(function (t) {
return e.append(t);
}),
this
);
}),
(t.prototype.toArray = function () {
for (var t = [], e = this.head; e; ) t.push(e), (e = e.next);
return t;
}),
(t.prototype.reverse = function () {
for (var t = this.head, e = null, n = null; t; )
(n = t.next), (t.next = e), (e = t), (t = n);
(this.tail = this.head), (this.head = e);
}),
(t.prototype.toString = function (t) {
return (
void 0 === t && (t = void 0),
this.toArray()
.map(function (e) {
return e.toString(t);
})
.toString()
);
}),
t
);
})(),
s = (function () {
function t() {
this.linkedList = new a();
}
return (
(t.prototype.isEmpty = function () {
return !this.linkedList.head;
}),
(t.prototype.peek = function () {
return this.linkedList.head ? this.linkedList.head.value : null;
}),
(t.prototype.enqueue = function (t) {
this.linkedList.append(t);
}),
(t.prototype.dequeue = function () {
var t = this.linkedList.deleteHead();
return t ? t.value : null;
}),
(t.prototype.toString = function (t) {
return this.linkedList.toString(t);
}),
t
);
})(),
c = function (t, e, n) {
void 0 === e && (e = []);
var r = e.filter(function (e) {
return e.source === t || e.target === t;
});
if ("target" === n) {
return r
.filter(function (e) {
return e.source === t;
})
.map(function (t) {
return t.target;
});
}
if ("source" === n) {
return r
.filter(function (e) {
return e.target === t;
})
.map(function (t) {
return t.source;
});
}
return r.map(function (e) {
return e.source === t ? e.target : e.source;
});
},
u = function (t, e) {
return e.filter(function (e) {
return e.source === t || e.target === t;
});
},
h = function (t) {
void 0 === t && (t = 0);
var e = "".concat(Math.random()).split(".")[1].substr(0, 5),
n = "".concat(Math.random()).split(".")[1].substr(0, 5);
return "".concat(t, "-").concat(e).concat(n);
};
var l = function (t, e, n, r) {
void 0 === r && (r = !0);
var i = (function (t) {
void 0 === t && (t = {});
var e,
n = t,
r = function () {},
i =
((e = {}),
function (t) {
var n = t.next;
return !e[n] && ((e[n] = !0), !0);
});
return (
(n.allowTraversal = t.allowTraversal || i),
(n.enter = t.enter || r),
(n.leave = t.leave || r),
n
);
})(n),
o = new s(),
a = t.edges,
u = void 0 === a ? [] : a;
o.enqueue(e);
for (
var h = "",
l = function () {
var t = o.dequeue();
i.enter({ current: t, previous: h }),
c(t, u, r ? "target" : void 0).forEach(function (e) {
i.allowTraversal({ previous: h, current: t, next: e }) &&
o.enqueue(e);
}),
i.leave({ current: t, previous: h }),
(h = t);
};
!o.isEmpty();
)
l();
},
f = function (t) {
for (
var e = t.nodes,
n = void 0 === e ? [] : e,
r = t.edges,
i = void 0 === r ? [] : r,
o = [],
a = {},
s = {},
u = {},
h = [],
l = 0,
f = function t(e) {
(s[e.id] = l),
(u[e.id] = l),
(l += 1),
o.push(e),
(a[e.id] = !0);
for (
var r = c(e.id, i, "target").filter(function (t) {
return (
n
.map(function (t) {
return t.id;
})
.indexOf(t) > -1
);
}),
f = function (i) {
var o = r[i];
if (s[o] || 0 === s[o])
a[o] && (u[e.id] = Math.min(u[e.id], s[o]));
else {
var c = n.filter(function (t) {
return t.id === o;
});
c.length > 0 && t(c[0]),
(u[e.id] = Math.min(u[e.id], u[o]));
}
},
d = 0;
d < r.length;
d++
)
f(d);
if (u[e.id] === s[e.id]) {
for (var p = []; o.length > 0; ) {
var g = o.pop();
if (((a[g.id] = !1), p.push(g), g === e)) break;
}
p.length > 0 && h.push(p);
}
},
d = 0,
p = n;
d < p.length;
d++
) {
var g = p[d];
s[g.id] || 0 === s[g.id] || f(g);
}
return h;
};
function d(t, e) {
return e
? f(t)
: (function (t) {
for (
var e = t.nodes,
n = void 0 === e ? [] : e,
r = t.edges,
i = void 0 === r ? [] : r,
o = [],
a = {},
s = [],
u = function t(e) {
s.push(e), (a[e.id] = !0);
for (
var r = c(e.id, i),
o = function (e) {
var i = r[e];
if (!a[i]) {
var o = n.filter(function (t) {
return t.id === i;
});
o.length > 0 && t(o[0]);
}
},
u = 0;
u < r.length;
++u
)
o(u);
},
h = 0;
h < n.length;
h++
) {
var l = n[h];
if (!a[l.id]) {
u(l);
for (var f = []; s.length > 0; ) f.push(s.pop());
o.push(f);
}
}
return o;
})(t);
}
var p = function (t) {
var e = {},
n = t.nodes,
r = void 0 === n ? [] : n,
i = t.edges,
o = void 0 === i ? [] : i;
return (
r.forEach(function (t) {
e[t.id] = { degree: 0, inDegree: 0, outDegree: 0 };
}),
o.forEach(function (t) {
e[t.source].degree++,
e[t.source].outDegree++,
e[t.target].degree++,
e[t.target].inDegree++;
}),
e
);
},
g = p,
v = function (t, e) {
return p(t)[e] ? p(t)[e].inDegree : 0;
},
y = function (t, e) {
return p(t)[e] ? p(t)[e].outDegree : 0;
};
function m(t, e, n) {
!(function t(e, n, r, i) {
i.enter({ current: n, previous: r });
var o = e.edges;
c(n, void 0 === o ? [] : o, "target").forEach(function (o) {
i.allowTraversal({ previous: r, current: n, next: o }) &&
t(e, o, n, i);
}),
i.leave({ current: n, previous: r });
})(
t,
e,
"",
(function (t) {
void 0 === t && (t = {});
var e,
n = t,
r = function () {},
i =
((e = {}),
function (t) {
var n = t.next;
return !e[n] && ((e[n] = !0), !0);
});
return (
(n.allowTraversal = t.allowTraversal || i),
(n.enter = t.enter || r),
(n.leave = t.leave || r),
n
);
})(n),
);
}
var b = function (t, e, n) {
var r, i;
void 0 === n && (n = !0);
for (var o = [], a = 0, s = d(t, !1); a < s.length; a++) {
var u = s[a];
if (u.length)
for (
var h = u[0],
l = h.id,
f = [h],
p = (((r = {})[l] = h), r),
g = (((i = {})[l] = new Set()), i);
f.length > 0;
)
for (
var v = f.pop(),
y = v.id,
m = c(y, t.edges),
b = function (r) {
var i,
a = m[r],
s = t.nodes.find(function (t) {
return t.id === a;
});
if (a === y) o.push((((i = {})[a] = v), i));
else if ((a in g)) {
if (!g[y].has(s)) {
for (
var c = !0, u = [s, v], h = p[y];
g[a].size &&
!g[a].has(h) &&
(u.push(h), h !== p[h.id]);
)
h = p[h.id];
if (
(u.push(h),
e && n
? ((c = !1),
u.findIndex(function (t) {
return e.indexOf(t.id) > -1;
}) > -1 && (c = !0))
: e &&
!n &&
u.findIndex(function (t) {
return e.indexOf(t.id) > -1;
}) > -1 &&
(c = !1),
c)
) {
for (var l = {}, d = 1; d < u.length; d += 1)
l[u[d - 1].id] = u[d];
u.length && (l[u[u.length - 1].id] = u[0]),
o.push(l);
}
g[a].add(v);
}
} else (p[a] = v), f.push(s), (g[a] = new Set([v]));
},
x = 0;
x < m.length;
x += 1
)
b(x);
}
return o;
},
x = function (t, e, n) {
void 0 === n && (n = !0);
for (
var r = [],
i = new Set(),
o = [],
a = [],
s = {},
u = {},
h = function t(c, u, h) {
var l = !1;
if (e && !1 === n && e.indexOf(c.id) > -1) return l;
r.push(c), i.add(c);
for (var f = h[c.id], d = 0; d < f.length; d += 1) {
if ((v = s[f[d]]) === u) {
for (var p = {}, g = 1; g < r.length; g += 1)
p[r[g - 1].id] = r[g];
r.length && (p[r[r.length - 1].id] = r[0]),
a.push(p),
(l = !0);
} else i.has(v) || (t(v, u, h) && (l = !0));
}
if (l)
!(function (t) {
for (var e = [t]; e.length > 0; ) {
var n = e.pop();
i.has(n) &&
(i.delete(n),
o[n.id].forEach(function (t) {
e.push(t);
}),
o[n.id].clear());
}
})(c);
else
for (d = 0; d < f.length; d += 1) {
var v = s[f[d]];
o[v.id].has(c) || o[v.id].add(c);
}
return r.pop(), l;
},
l = t.nodes,
d = void 0 === l ? [] : l,
p = 0;
p < d.length;
p += 1
) {
var g = d[p],
v = g.id;
(u[v] = p), (s[p] = g);
}
if (e && n) {
var y = function (t) {
var n = e[t];
(u[d[t].id] = u[n]),
(u[n] = 0),
(s[0] = d.find(function (t) {
return t.id === n;
})),
(s[u[d[t].id]] = d[t]);
};
for (p = 0; p < e.length; p++) y(p);
}
for (
var m = function (r) {
for (var i, o, s = 1 / 0, h = 0; h < r.length; h += 1)
for (var l = r[h], f = 0; f < l.length; f++) {
var d = u[l[f].id];
d < s && ((s = d), (o = h));
}
var p = r[o],
g = [];
for (h = 0; h < p.length; h += 1) {
var v = p[h];
g[v.id] = [];
for (
var y = 0,
m = c(v.id, t.edges, "target").filter(function (t) {
return (
p
.map(function (t) {
return t.id;
})
.indexOf(t) > -1
);
});
y < m.length;
y++
) {
var b = m[y];
b !== v.id || (!1 === n && e.indexOf(v.id) > -1)
? g[v.id].push(u[b])
: a.push((((i = {})[v.id] = v), i));
}
}
return { component: p, adjList: g, minIdx: s };
},
b = 0;
b < d.length;
) {
var x = d.filter(function (t) {
return u[t.id] >= b;
}),
w = f({ nodes: x, edges: t.edges }).filter(function (t) {
return t.length > 1;
});
if (0 === w.length) break;
var S = m(w),
O = S.minIdx,
M = S.adjList,
k = S.component;
if (!(k.length > 1)) break;
k.forEach(function (t) {
o[t.id] = new Set();
});
var C = s[O];
if (e && n && -1 === e.indexOf(C.id)) return a;
h(C, C, M), (b = O + 1);
}
return a;
},
w = function (t, e, n, r) {
return void 0 === r && (r = !0), e ? x(t, n, r) : b(t, n, r);
},
S = function (t) {
var e = null,
n = t.nodes,
r = {},
i = {},
o = {},
a = {};
(void 0 === n ? [] : n).forEach(function (t) {
i[t.id] = t;
});
for (
var s = {
enter: function (t) {
var n = t.current,
a = t.previous;
if (o[n]) {
e = {};
for (var s = n, c = a; c !== n; )
(e[s] = c), (s = c), (c = r[c]);
e[s] = c;
} else (o[n] = n), delete i[n], (r[n] = a);
},
leave: function (t) {
var e = t.current;
(a[e] = e), delete o[e];
},
allowTraversal: function (t) {
var n = t.next;
return !e && !a[n];
},
};
Object.keys(i).length;
) {
m(t, Object.keys(i)[0], s);
}
return e;
},
O = n(1),
M = n(0),
k = function (t, e, n, r) {
var i = t.nodes,
o = void 0 === i ? [] : i,
a = t.edges,
s = void 0 === a ? [] : a,
c = [],
h = {},
l = {},
f = {};
o.forEach(function (t, n) {
var r = t.id;
c.push(r), (l[r] = 1 / 0), r === e && (l[r] = 0);
});
for (
var d = o.length,
p = function (t) {
var e = (function (t, e, n) {
for (var r, i = 1 / 0, o = 0; o < e.length; o++) {
var a = e[o].id;
!n[a] && t[a] <= i && ((i = t[a]), (r = e[o]));
}
return r;
})(l, o, h),
i = e.id;
if (((h[i] = !0), l[i] === 1 / 0)) return "continue";
(n
? (function (t, e) {
return e.filter(function (e) {
return e.source === t;
});
})(i, s)
: u(i, s)
).forEach(function (t) {
var n = t.target,
o = t.source,
a = n === i ? o : n,
s = r && t[r] ? t[r] : 1;
l[a] > l[e.id] + s
? ((l[a] = l[e.id] + s), (f[a] = [e.id]))
: l[a] === l[e.id] + s && f[a].push(e.id);
});
},
g = 0;
g < d;
g++
)
p();
f[e] = [e];
var v = {};
for (var y in l) l[y] !== 1 / 0 && C(e, y, f, v);
var m = {};
for (var y in v) m[y] = v[y][0];
return { length: l, path: m, allPath: v };
};
function C(t, e, n, r) {
if (t === e) return [t];
if (r[e]) return r[e];
for (var i = [], o = 0, a = n[e]; o < a.length; o++) {
var s = C(t, a[o], n, r);
if (!s) return;
for (var c = 0, u = s; c < u.length; c++) {
var h = u[c];
Object(M.isArray)(h)
? i.push(Object(O.f)(Object(O.f)([], h, !0), [e], !1))
: i.push([h, e]);
}
}
return (r[e] = i), r[e];
}
var E,
j = function (t, e, n, r, i) {
var o = k(t, e, r, i),
a = o.length,
s = o.path,
c = o.allPath;
return { length: a[n], path: s[n], allPath: c[n] };
},
P = function (t, e, n, r) {
var i;
if (e === n) return [[e]];
var o = t.edges,
a = void 0 === o ? [] : o,
s = [e],
u = (((i = {})[e] = !0), i),
h = [],
l = [],
f = r ? c(e, a, "target") : c(e, a);
for (h.push(f); s.length > 0 && h.length > 0; ) {
var d = h[h.length - 1];
if (d.length) {
var p = d.shift();
if (
(p &&
(s.push(p),
(u[p] = !0),
(f = r ? c(p, a, "target") : c(p, a)),
h.push(
f.filter(function (t) {
return !u[t];
}),
)),
s[s.length - 1] === n)
) {
var g = s.map(function (t) {
return t;
});
l.push(g);
v = s.pop();
(u[v] = !1), h.pop();
}
} else {
var v = s.pop();
(u[v] = !1), h.pop();
}
}
return l;
},
A = function (t, e) {
for (var n = r(t, e), i = [], o = n.length, a = 0; a < o; a += 1) {
i[a] = [];
for (var s = 0; s < o; s += 1)
a === s
? (i[a][s] = 0)
: 0 !== n[a][s] && n[a][s]
? (i[a][s] = n[a][s])
: (i[a][s] = 1 / 0);
}
for (var c = 0; c < o; c += 1)
for (a = 0; a < o; a += 1)
for (s = 0; s < o; s += 1)
i[a][s] > i[a][c] + i[c][s] && (i[a][s] = i[a][c] + i[c][s]);
return i;
},
I = function (t, e, n, i) {
void 0 === e && (e = !1),
void 0 === n && (n = "weight"),
void 0 === i && (i = 1e3);
var o = t.nodes,
a = void 0 === o ? [] : o,
s = t.edges,
c = void 0 === s ? [] : s,
u = {},
l = {};
a.forEach(function (t, e) {
var n = h();
(t.clusterId = n),
(u[n] = { id: n, nodes: [t] }),
(l[t.id] = { node: t, idx: e });
});
var f = r(t, e),
d = [],
p = {};
f.forEach(function (t, e) {
var n = 0,
r = a[e].id;
(p[r] = {}),
t.forEach(function (t, e) {
if (t) {
n += t;
var i = a[e].id;
p[r][i] = t;
}
}),
d.push(n);
});
for (
var g = 0,
v = function () {
var t = !1;
if (
(a.forEach(function (e) {
var n = {};
Object.keys(p[e.id]).forEach(function (t) {
var r = p[e.id][t],
i = l[t].node.clusterId;
n[i] || (n[i] = 0), (n[i] += r);
});
var r = -1 / 0,
i = [];
if (
(Object.keys(n).forEach(function (t) {
r < n[t]
? ((r = n[t]), (i = [t]))
: r === n[t] && i.push(t);
}),
1 !== i.length || i[0] !== e.clusterId)
) {
var o = i.indexOf(e.clusterId);
if ((o >= 0 && i.splice(o, 1), i && i.length)) {
t = !0;
var a = u[e.clusterId],
s = a.nodes.indexOf(e);
a.nodes.splice(s, 1);
var c = Math.floor(Math.random() * i.length),
h = u[i[c]];
h.nodes.push(e), (e.clusterId = h.id);
}
}
}),
!t)
)
return "break";
g++;
};
g < i;
) {
if ("break" === v()) break;
}
Object.keys(u).forEach(function (t) {
var e = u[t];
(e.nodes && e.nodes.length) || delete u[t];
});
var y = [],
m = {};
c.forEach(function (t) {
var e = t.source,
r = t.target,
i = t[n] || 1,
o = l[e].node.clusterId,
a = l[r].node.clusterId,
s = "".concat(o, "---").concat(a);
if (m[s]) (m[s].weight += i), m[s].count++;
else {
var c = { source: o, target: a, weight: i, count: 1 };
(m[s] = c), y.push(c);
}
});
var b = [];
return (
Object.keys(u).forEach(function (t) {
b.push(u[t]);
}),
{ clusters: b, clusterEdges: y }
);
},
T = (function () {
function t(t) {
this.arr = t;
}
return (
(t.prototype.getArr = function () {
return this.arr || [];
}),
(t.prototype.add = function (e) {
var n,
r = e.arr;
if (
!(null === (n = this.arr) || void 0 === n ? void 0 : n.length)
)
return new t(r);
if (!(null == r ? void 0 : r.length)) return new t(this.arr);
if (this.arr.length === r.length) {
var i = [];
for (var o in this.arr) i[o] = this.arr[o] + r[o];
return new t(i);
}
}),
(t.prototype.subtract = function (e) {
var n,
r = e.arr;
if (
!(null === (n = this.arr) || void 0 === n ? void 0 : n.length)
)
return new t(r);
if (!(null == r ? void 0 : r.length)) return new t(this.arr);
if (this.arr.length === r.length) {
var i = [];
for (var o in this.arr) i[o] = this.arr[o] - r[o];
return new t(i);
}
}),
(t.prototype.avg = function (e) {
var n = [];
if (0 !== e) for (var r in this.arr) n[r] = this.arr[r] / e;
return new t(n);
}),
(t.prototype.negate = function () {
var e = [];
for (var n in this.arr) e[n] = -this.arr[n];
return new t(e);
}),
(t.prototype.squareEuclideanDistance = function (t) {
var e,
n = t.arr;
if (
!(null === (e = this.arr) || void 0 === e
? void 0
: e.length) ||
!(null == n ? void 0 : n.length)
)
return 0;
if (this.arr.length === n.length) {
var r = 0;
for (var i in this.arr)
r += Math.pow(this.arr[i] - t.arr[i], 2);
return r;
}
}),
(t.prototype.euclideanDistance = function (t) {
var e,
n = t.arr;
if (
!(null === (e = this.arr) || void 0 === e
? void 0
: e.length) ||
!(null == n ? void 0 : n.length)
)
return 0;
if (this.arr.length === n.length) {
var r = 0;
for (var i in this.arr)
r += Math.pow(this.arr[i] - t.arr[i], 2);
return Math.sqrt(r);
}
console.error("The two vectors are unequal in length.");
}),
(t.prototype.normalize = function () {
var e = [],
n = Object(M.clone)(this.arr);
n.sort(function (t, e) {
return t - e;
});
var r = n[n.length - 1],
i = n[0];
for (var o in this.arr) e[o] = (this.arr[o] - i) / (r - i);
return new t(e);
}),
(t.prototype.norm2 = function () {
var t;
if (
!(null === (t = this.arr) || void 0 === t ? void 0 : t.length)
)
return 0;
var e = 0;
for (var n in this.arr) e += Math.pow(this.arr[n], 2);
return Math.sqrt(e);
}),
(t.prototype.dot = function (t) {
var e,
n = t.arr;
if (
!(null === (e = this.arr) || void 0 === e
? void 0
: e.length) ||
!(null == n ? void 0 : n.length)
)
return 0;
if (this.arr.length === n.length) {
var r = 0;
for (var i in this.arr) r += this.arr[i] * t.arr[i];
return r;
}
console.error("The two vectors are unequal in length.");
}),
(t.prototype.equal = function (t) {
var e,
n = t.arr;
if (
(null === (e = this.arr) || void 0 === e
? void 0
: e.length) !== (null == n ? void 0 : n.length)
)
return !1;
for (var r in this.arr) if (this.arr[r] !== n[r]) return !1;
return !0;
}),
t
);
})(),
N = function (t, e) {
void 0 === e && (e = void 0);
var n = [];
return (
t.forEach(function (t) {
void 0 === e && n.push(t), void 0 !== t[e] && n.push(t[e]);
}),
n
);
};
!(function (t) {
t.EuclideanDistance = "euclideanDistance";
})(E || (E = {}));
var B = function (t, e, n) {
var r = [];
(null == e ? void 0 : e.length)
? (r = e)
: (t.forEach(function (t) {
r = r.concat(Object.keys(t));
}),
(r = Object(M.uniq)(r)));
var i = {};
return (
r.forEach(function (e) {
var r = [];
t.forEach(function (t) {
void 0 !== t[e] && "" !== t[e] && r.push(t[e]);
}),
r.length &&
!(null == n ? void 0 : n.includes(e)) &&
(i[e] = Object(M.uniq)(r));
}),
i
);
},
L = function (t, e, n) {
var r = B(t, e, n),
i = [];
return Object.keys(r).length
? (t.forEach(function (t, e) {
var n = [];
if (1 === Object.keys(r).length) {
var o = Object.keys(r)[0];
r[o].every(function (t) {
return !isNaN(Number(t));
}) && (n = [t[o]]);
} else
Object.keys(r).forEach(function (e) {
for (
var i = t[e],
o = r[e],
a = o.findIndex(function (t) {
return i === t;
}),
s = [],
c = 0;
c < o.length;
c++
)
c === a ? s.push(1) : s.push(0);
n = n.concat(s);
});
i[e] = n;
}),
i)
: i;
},
D = function (t, e, n, r) {
void 0 === n && (n = E.EuclideanDistance);
var i = 0;
switch (n) {
case E.EuclideanDistance:
i = new T(t).euclideanDistance(new T(e));
}
return i;
},
_ = function (t, e, n, r) {
for (var i = e.length, o = 2 * r, a = 0, s = 0; s < i; s++)
for (var c = t[s].clusterId, u = 0; u < i; u++) {
if (c === t[u].clusterId)
a += (e[s][u] || 0) - ((n[s] || 0) * (n[u] || 0)) / o;
}
return (a *= 1 / o);
},
R = function (t, e) {
void 0 === t && (t = []);
for (var n = t.length, r = new T([]), i = 0; i < n; i++)
r = r.add(new T(e[i]));
var o = r.avg(n);
o.normalize();
var a = 0;
for (i = 0; i < n; i++) {
a += (c = new T(e[i])).squareEuclideanDistance(o);
}
var s = [];
t.forEach(function () {
s.push([]);
});
for (i = 0; i < n; i++) {
var c = new T(e[i]);
t[i].clusterInertial = 0;
for (var u = 0; u < n; u++)
if (i !== u) {
var h = new T(e[u]);
(s[i][u] = c.squareEuclideanDistance(h)),
(t[i].clusterInertial += s[i][u]);
} else s[i][u] = 0;
}
var l = 0,
f = 2 * n * a;
for (i = 0; i < n; i++) {
var d = t[i].clusterId;
for (u = 0; u < n; u++) {
var p = t[u].clusterId;
if (i !== u && d === p)
l +=
(t[i].clusterInertial * t[u].clusterInertial) /
Math.pow(f, 2) -
s[i][u] / f;
}
}
return Number(l.toFixed(4));
},
F = function (t, e, n, i, o, a, s, c, u) {
void 0 === e && (e = !1),
void 0 === n && (n = "weight"),
void 0 === i && (i = 1e-4),
void 0 === o && (o = !1),
void 0 === a && (a = void 0),
void 0 === s && (s = []),
void 0 === c && (c = ["id"]),
void 0 === u && (u = 1);
var h = t.nodes,
l = void 0 === h ? [] : h,
f = t.edges,
d = void 0 === f ? [] : f,
p = [];
if (o) {
l.forEach(function (t, e) {
(t.properties = t.properties || {}), (t.originIndex = e);
});
var g = [];
l.every(function (t) {
return t.hasOwnProperty("nodeType");
}) &&
((g = Array.from(
new Set(
l.map(function (t) {
return t.nodeType;
}),
),
)),
l.forEach(function (t) {
t.properties.nodeType = g.findIndex(function (e) {
return e === t.nodeType;
});
}));
var v = N(l, a);
p = L(v, s, c);
}
var y = 1,
m = {},
b = {};
l.forEach(function (t, e) {
var n = String(y++);
(t.clusterId = n),
(m[n] = { id: n, nodes: [t] }),
(b[t.id] = { node: t, idx: e });
});
var x = r(t, e),
w = [],
S = {},
O = 0;
x.forEach(function (t, e) {
var n = 0,
r = l[e].id;
(S[r] = {}),
t.forEach(function (t, e) {
if (t) {
n += t;
var i = l[e].id;
(S[r][i] = t), (O += t);
}
}),
w.push(n);
}),
(O /= 2);
for (var k = 1 / 0, C = 1 / 0, E = 0, j = [], P = {}; ; ) {
(k =
o &&
l.every(function (t) {
return t.hasOwnProperty("properties");
})
? _(l, x, w, O) + R(l, p) * u
: _(l, x, w, O)),
0 === E && ((C = k), (j = l), (P = m));
var A = k > 0 && k > C && k - C < i;
if (
(k > C &&
((j = l.map(function (t) {
return { node: t, clusterId: t.clusterId };
})),
(P = Object(M.clone)(m)),
(C = k)),
A || E > 100)
)
break;
E++,
Object.keys(m).forEach(function (t) {
var e = 0;
d.forEach(function (r) {
var i = r.source,
o = r.target,
a = b[i].node.clusterId,
s = b[o].node.clusterId;
((a === t && s !== t) || (s === t && a !== t)) &&
(e += r[n] || 1);
}),
(m[t].sumTot = e);
}),
l.forEach(function (t, e) {
var r,
i = m[t.clusterId],
a = 0,
s = w[e] / (2 * O),
c = 0,
h = i.nodes;
h.forEach(function (t) {
var n = b[t.id].idx;
c += x[e][n] || 0;
});
var l = c - i.sumTot * s,
f = h.filter(function (e) {
return e.id !== t.id;
}),
g = [];
f.forEach(function (t, e) {
g[e] = p[t.originIndex];
});
var v = R(f, p) * u,
y = S[t.id];
if (
(Object.keys(y).forEach(function (n) {
var i = b[n].node.clusterId;
if (i !== t.clusterId) {
var c = m[i],
h = c.nodes;
if (h && h.length) {
var f = 0;
h.forEach(function (t) {
var n = b[t.id].idx;
f += x[e][n] || 0;
});
var d = f - c.sumTot * s,
g = h.concat([t]),
y = [];
g.forEach(function (t, e) {
y[e] = p[t.originIndex];
});
var w = R(g, p) * u,
S = d - l;
o && (S = d + w - (l + v)), S > a && ((a = S), (r = c));
}
}
}),
a > 0)
) {
r.nodes.push(t);
var M = t.clusterId;
t.clusterId = r.id;
var k = i.nodes.indexOf(t);
i.nodes.splice(k, 1);
var C = 0,
E = 0;
d.forEach(function (t) {
var e = t.source,
i = t.target,
o = b[e].node.clusterId,
a = b[i].node.clusterId;
((o === r.id && a !== r.id) ||
(a === r.id && o !== r.id)) &&
(C += t[n] || 1),
((o === M && a !== M) || (a === M && o !== M)) &&
(E += t[n] || 1);
}),
(r.sumTot = C),
(i.sumTot = E);
}
});
}
var I = {},
T = 0;
Object.keys(P).forEach(function (t) {
var e = P[t];
if (e.nodes && e.nodes.length) {
var n = String(T + 1);
n !== t &&
((e.id = n),
(e.nodes = e.nodes.map(function (t) {
return { id: t.id, clusterId: n };
})),
(P[n] = e),
(I[t] = n),
delete P[t],
T++);
} else delete P[t];
}),
j.forEach(function (t) {
var e = t.node,
n = t.clusterId;
(e.clusterId = n),
e.clusterId && I[e.clusterId] && (e.clusterId = I[e.clusterId]);
});
var B = [],
D = {};
d.forEach(function (t) {
var e = t.source,
r = t.target,
i = t[n] || 1,
o = b[e].node.clusterId,
a = b[r].node.clusterId,
s = "".concat(o, "---").concat(a);
if (D[s]) (D[s].weight += i), D[s].count++;
else {
var c = { source: o, target: a, weight: i, count: 1 };
(D[s] = c), B.push(c);
}
});
var F = [];
return (
Object.keys(P).forEach(function (t) {
F.push(P[t]);
}),
{ clusters: F, clusterEdges: B }
);
},
Y = function (t, e, n, r, i, o, a, s) {
return (
void 0 === e && (e = !1),
void 0 === n && (n = "weight"),
void 0 === r && (r = 1e-4),
void 0 === i && (i = void 0),
void 0 === o && (o = []),
void 0 === a && (a = ["id"]),
void 0 === s && (s = 1),
F(t, e, n, r, !0, i, o, a, s)
);
},
X = function (t, e) {
var n;
void 0 === e && (e = 1);
for (
var r = Object(M.clone)(t),
i = r.nodes,
o = void 0 === i ? [] : i,
a = r.edges,
s = void 0 === a ? [] : a,
c = function () {
var t = g({ nodes: o, edges: s }),
r = Object.keys(t);
r.sort(function (e, n) {
var r, i;
return (
(null === (r = t[e]) || void 0 === r ? void 0 : r.degree) -
(null === (i = t[n]) || void 0 === i ? void 0 : i.degree)
);
});
var i = r[0];
if (
!o.length ||
(null === (n = t[i]) || void 0 === n ? void 0 : n.degree) >= e
)
return "break";
var a = o.findIndex(function (t) {
return t.id === i;
});
o.splice(a, 1),
(s = s.filter(function (t) {
return !(t.source === i || t.target === i);
}));
};
;
) {
if ("break" === c()) break;
}
return { nodes: o, edges: s };
},
z = function (t, e, n) {
var r = [];
switch (t) {
case E.EuclideanDistance:
r = e[n];
break;
default:
r = [];
}
return r;
},
W = function (t, e, n, r, i, o) {
void 0 === e && (e = 3),
void 0 === n && (n = void 0),
void 0 === r && (r = []),
void 0 === i && (i = ["id"]),
void 0 === o && (o = E.EuclideanDistance);
var a = t.nodes,
s = void 0 === a ? [] : a,
c = t.edges,
u = void 0 === c ? [] : c,
h = { clusters: [{ id: "0", nodes: s }], clusterEdges: [] };
if (
o === E.EuclideanDistance &&
!s.every(function (t) {
return t.hasOwnProperty(n);
})
)
return h;
var l = [],
f = [];
if (
(o === E.EuclideanDistance && ((l = N(s, n)), (f = L(l, r, i))),
!f.length)
)
return h;
for (
var d = Object(M.uniq)(
f.map(function (t) {
return t.join("");
}),
),
p = Math.min(e, s.length, d.length),
g = 0;
g < s.length;
g++
)
s[g].originIndex = g;
var v = [],
y = [],
m = [];
for (g = 0; g < p; g++)
if (0 === g) {
var b = Math.floor(Math.random() * s.length);
switch (o) {
case E.EuclideanDistance:
v[g] = f[b];
break;
default:
v[g] = [];
}
y.push(b), (m[g] = [s[b]]), (s[b].clusterId = String(g));
} else {
for (
var x = -1 / 0,
w = 0,
S = function (t) {
if (!y.includes(t)) {
for (var e = 0, n = 0; n < v.length; n++) {
var r = 0;
switch (o) {
case E.EuclideanDistance:
r = D(f[s[t].originIndex], v[n], o);
}
e += r;
}
var i = e / v.length;
i > x &&
!v.find(function (e) {
return Object(M.isEqual)(
e,
z(o, f, s[t].originIndex),
);
}) &&
((x = i), (w = t));
}
},
O = 0;
O < s.length;
O++
)
S(O);
(v[g] = z(o, f, w)),
y.push(w),
(m[g] = [s[w]]),
(s[w].clusterId = String(g));
}
for (var k = 0; ; ) {
for (g = 0; g < s.length; g++) {
var C = 0,
j = 1 / 0;
if (0 !== k || !y.includes(g)) {
for (var P = 0; P < v.length; P++) {
var A = 0;
switch (o) {
case E.EuclideanDistance:
A = D(f[g], v[P], o);
}
A < j && ((j = A), (C = P));
}
if (void 0 !== s[g].clusterId)
for (
var I = m[Number(s[g].clusterId)].length - 1;
I >= 0;
I--
)
m[Number(s[g].clusterId)][I].id === s[g].id &&
m[Number(s[g].clusterId)].splice(I, 1);
(s[g].clusterId = String(C)), m[C].push(s[g]);
}
}
var B = !1;
for (g = 0; g < m.length; g++) {
var _ = m[g],
R = new T([]);
for (P = 0; P < _.length; P++)
R = R.add(new T(f[_[P].originIndex]));
var F = R.avg(_.length);
F.equal(new T(v[g])) || ((B = !0), (v[g] = F.getArr()));
}
if (
(k++,
(s.every(function (t) {
return void 0 !== t.clusterId;
}) &&
B) ||
k >= 1e3)
)
break;
}
var Y = [],
X = {};
return (
u.forEach(function (t) {
var e,
n,
r = t.source,
i = t.target,
o =
null ===
(e = s.find(function (t) {
return t.id === r;
})) || void 0 === e
? void 0
: e.clusterId,
a =
null ===
(n = s.find(function (t) {
return t.id === i;
})) || void 0 === n
? void 0
: n.clusterId,
c = "".concat(o, "---").concat(a);
if (X[c]) X[c].count++;
else {
var u = { source: o, target: a, count: 1 };
(X[c] = u), Y.push(u);
}
}),
{ clusters: m, clusterEdges: Y }
);
},
q = function (t, e) {
var n = new T(e),
r = n.norm2(),
i = new T(t),
o = i.norm2(),
a = n.dot(i),
s = r * o,
c = s ? a / s : 0;
return c;
},
V = function (t, e, n, r, i) {
void 0 === t && (t = []),
void 0 === n && (n = void 0),
void 0 === r && (r = []),
void 0 === i && (i = []);
var o = Object(M.clone)(
t.filter(function (t) {
return t.id !== e.id;
}),
),
a = t.findIndex(function (t) {
return t.id === e.id;
}),
s = N(t, n),
c = L(s, r, i),
u = c[a],
h = [];
return (
o.forEach(function (t, n) {
if (t.id !== e.id) {
var r = c[n],
i = q(r, u);
h.push(i), (t.cosineSimilarity = i);
}
}),
o.sort(function (t, e) {
return e.cosineSimilarity - t.cosineSimilarity;
}),
{ allCosineSimilarity: h, similarNodes: o }
);
},
G = (function () {
function t(t) {
(this.count = t.length), (this.parent = {});
for (var e = 0, n = t; e < n.length; e++) {
var r = n[e];
this.parent[r] = r;
}
}
return (
(t.prototype.find = function (t) {
for (; this.parent[t] !== t; ) t = this.parent[t];
return t;
}),
(t.prototype.union = function (t, e) {
var n = this.find(t),
r = this.find(e);
n !== r &&
(n < r
? (this.parent[e] !== e && this.union(this.parent[e], t),
(this.parent[e] = this.parent[t]))
: (this.parent[t] !== t && this.union(this.parent[t], e),
(this.parent[t] = this.parent[e])));
}),
(t.prototype.connected = function (t, e) {
return this.find(t) === this.find(e);
}),
t
);
})(),
H = function (t, e) {
return t - e;
},
U = (function () {
function t(t) {
void 0 === t && (t = H), (this.compareFn = t), (this.list = []);
}
return (
(t.prototype.getLeft = function (t) {
return 2 * t + 1;
}),
(t.prototype.getRight = function (t) {
return 2 * t + 2;
}),
(t.prototype.getParent = function (t) {
return 0 === t ? null : Math.floor((t - 1) / 2);
}),
(t.prototype.isEmpty = function () {
return this.list.length <= 0;
}),
(t.prototype.top = function () {
return this.isEmpty() ? void 0 : this.list[0];
}),
(t.prototype.delMin = function () {
var t = this.top(),
e = this.list.pop();
return (
this.list.length > 0 && ((this.list[0] = e), this.moveDown(0)),
t
);
}),
(t.prototype.insert = function (t) {
if (null !== t) {
this.list.push(t);
var e = this.list.length - 1;
return this.moveUp(e), !0;
}
return !1;
}),
(t.prototype.moveUp = function (t) {
for (
var e = this.getParent(t);
t && t > 0 && this.compareFn(this.list[e], this.list[t]) > 0;
) {
var n = this.list[e];
(this.list[e] = this.list[t]),
(this.list[t] = n),
(t = e),
(e = this.getParent(t));
}
}),
(t.prototype.moveDown = function (t) {
var e,
n = t,
r = this.getLeft(t),
i = this.getRight(t),
o = this.list.length;
null !== r &&
r < o &&
this.compareFn(this.list[n], this.list[r]) > 0
? (n = r)
: null !== i &&
i < o &&
this.compareFn(this.list[n], this.list[i]) > 0 &&
(n = i),
t !== n &&
((e = [this.list[n], this.list[t]]),
(this.list[t] = e[0]),
(this.list[n] = e[1]),
this.moveDown(n));
}),
t
);
})(),
Z = function (t, e) {
var n = [],
r = t.nodes,
i = void 0 === r ? [] : r,
o = t.edges,
a = void 0 === o ? [] : o;
if (0 === i.length) return n;
var s = i[0],
c = new Set();
c.add(s);
var h = new U(function (t, n) {
return e ? t.weight - n.weight : 0;
});
for (
u(s.id, a).forEach(function (t) {
h.insert(t);
});
!h.isEmpty();
) {
var l = h.delMin(),
f = l.source,
d = l.target;
(c.has(f) && c.has(d)) ||
(n.push(l),
c.has(f) ||
(c.add(f),
u(f, a).forEach(function (t) {
h.insert(t);
})),
c.has(d) ||
(c.add(d),
u(d, a).forEach(function (t) {
h.insert(t);
})));
}
return n;
},
K = function (t, e) {
var n = [],
r = t.nodes,
i = void 0 === r ? [] : r,
o = t.edges,
a = void 0 === o ? [] : o;
if (0 === i.length) return n;
var s = a.map(function (t) {
return t;
});
e &&
s.sort(function (t, e) {
return t.weight - e.weight;
});
for (
var c = new G(
i.map(function (t) {
return t.id;
}),
);
s.length > 0;
) {
var u = s.shift(),
h = u.source,
l = u.target;
c.connected(h, l) || (n.push(u), c.union(h, l));
}
return n;
},
$ = function (t, e, n) {
return n ? { prim: Z, kruskal: K }[n](t, e) : K(t, e);
},
Q = function (t, e, n) {
"number" != typeof e && (e = 1e-6),
"number" != typeof n && (n = 0.85);
for (
var r,
i = 1,
o = 0,
a = 1e3,
s = t.nodes,
u = void 0 === s ? [] : s,
h = t.edges,
l = void 0 === h ? [] : h,
f = u.length,
d = {},
p = {},
v = 0;
v < f;
++v
) {
(d[(m = (O = u[v]).id)] = 1 / f), (p[m] = 1 / f);
}
for (var y = g(t); a > 0 && i > e; ) {
o = 0;
for (v = 0; v < f; ++v) {
var m = (O = u[v]).id;
if (((r = 0), 0 === y[O.id].inDegree)) d[m] = 0;
else {
for (var b = c(m, l, "source"), x = 0; x < b.length; ++x) {
var w = b[x],
S = y[w].outDegree;
S > 0 && (r += p[w] / S);
}
(d[m] = n * r), (o += d[m]);
}
}
(o = (1 - o) / f), (i = 0);
for (v = 0; v < f; ++v) {
var O;
(r = d[(m = (O = u[v]).id)] + o),
(i += Math.abs(r - p[m])),
(p[m] = r);
}
a -= 1;
}
return p;
},
J = function (t, e, n, r) {
void 0 === t && (t = -1),
void 0 === e && (e = -1),
void 0 === n && (n = -1),
void 0 === r && (r = "-1"),
(this.id = t),
(this.from = e),
(this.to = n),
(this.label = r);
},
tt = (function () {
function t(t, e) {
void 0 === t && (t = -1),
void 0 === e && (e = "-1"),
(this.id = t),
(this.label = e),
(this.edges = []),
(this.edgeMap = {});
}
return (
(t.prototype.addEdge = function (t) {
this.edges.push(t), (this.edgeMap[t.id] = t);
}),
t
);
})(),
et = (function () {
function t(t, e, n) {
void 0 === t && (t = -1),
void 0 === e && (e = !0),
void 0 === n && (n = !1),
(this.id = t),
(this.edgeIdAutoIncrease = e),
(this.edges = []),
(this.nodes = []),
(this.nodeMap = {}),
(this.edgeMap = {}),
(this.nodeLabelMap = {}),
(this.edgeLabelMap = {}),
(this.counter = 0),
(this.directed = n);
}
return (
(t.prototype.getNodeNum = function () {
return this.nodes.length;
}),
(t.prototype.addNode = function (t, e) {
if (!this.nodeMap[t]) {
var n = new tt(t, e);
this.nodes.push(n),
(this.nodeMap[t] = n),
this.nodeLabelMap[e] || (this.nodeLabelMap[e] = []),
this.nodeLabelMap[e].push(t);
}
}),
(t.prototype.addEdge = function (t, e, n, r) {
if (
((this.edgeIdAutoIncrease || void 0 === t) &&
(t = this.counter++),
!(
this.nodeMap[e] &&
this.nodeMap[n] &&
this.nodeMap[n].edgeMap[t]
))
) {
var i = new J(t, e, n, r);
if (
(this.edges.push(i),
(this.edgeMap[t] = i),
this.nodeMap[e].addEdge(i),
this.edgeLabelMap[r] || (this.edgeLabelMap[r] = []),
this.edgeLabelMap[r].push(i),
!this.directed)
) {
var o = new J(t, n, e, r);
this.nodeMap[n].addEdge(o), this.edgeLabelMap[r].push(o);
}
}
}),
t
);
})(),
nt = (function () {
function t(t, e, n, r, i) {
(this.fromNode = t),
(this.toNode = e),
(this.nodeEdgeNodeLabel = {
nodeLabel1: n || "-1",
edgeLabel: r || "-1",
nodeLabel2: i || "-1",
});
}
return (
(t.prototype.equalTo = function (t) {
return (
this.fromNode === t.formNode &&
this.toNode === t.toNode &&
this.nodeEdgeNodeLabel === t.nodeEdgeNodeLabel
);
}),
(t.prototype.notEqualTo = function (t) {
return !this.equalTo(t);
}),
t
);
})(),
rt = (function () {
function t() {
(this.rmpath = []), (this.dfsEdgeList = []);
}
return (
(t.prototype.equalTo = function (t) {
var e = this.dfsEdgeList.length;
if (e !== t.length) return !1;
for (var n = 0; n < e; n++)
if (this.dfsEdgeList[n] !== t[n]) return !1;
return !0;
}),
(t.prototype.notEqualTo = function (t) {
return !this.equalTo(t);
}),
(t.prototype.pushBack = function (t, e, n, r, i) {
return (
this.dfsEdgeList.push(new nt(t, e, n, r, i)), this.dfsEdgeList
);
}),
(t.prototype.toGraph = function (t, e) {
void 0 === t && (t = -1), void 0 === e && (e = !1);
var n = new et(t, !0, e);
return (
this.dfsEdgeList.forEach(function (t) {
var e = t.fromNode,
r = t.toNode,
i = t.nodeEdgeNodeLabel,
o = i.nodeLabel1,
a = i.edgeLabel,
s = i.nodeLabel2;
"-1" !== o && n.addNode(e, o),
"-1" !== s && n.addNode(r, s),
"-1" !== o && s !== o && n.addEdge(void 0, e, r, a);
}),
n
);
}),
(t.prototype.buildRmpath = function () {
this.rmpath = [];
for (
var t = void 0, e = this.dfsEdgeList.length - 1;
e >= 0;
e--
) {
var n = this.dfsEdgeList[e],
r = n.fromNode,
i = n.toNode;
r < i &&
(void 0 === t || i === t) &&
(this.rmpath.push(e), (t = r));
}
return this.rmpath;
}),
(t.prototype.getNodeNum = function () {
var t = {};
return (
this.dfsEdgeList.forEach(function (e) {
t[e.fromNode] || (t[e.fromNode] = !0),
t[e.toNode] || (t[e.toNode] = !0);
}),
Object.keys(t).length
);
}),
t
);
})(),
it = (function () {
function t(t) {
if (
((this.his = {}),
(this.nodesUsed = {}),
(this.edgesUsed = {}),
(this.edges = []),
t)
) {
for (; t; ) {
var e = t.edge;
this.edges.push(e),
(this.nodesUsed[e.from] = 1),
(this.nodesUsed[e.to] = 1),
(this.edgesUsed[e.id] = 1),
(t = t.preNode);
}
this.edges = this.edges.reverse();
}
}
return (
(t.prototype.hasNode = function (t) {
return 1 === this.nodesUsed[t.id];
}),
(t.prototype.hasEdge = function (t) {
return 1 === this.edgesUsed[t.id];
}),
t
);
})(),
ot = (function () {
function t(t) {
var e = t.graphs,
n = t.minSupport,
r = void 0 === n ? 2 : n,
i = t.minNodeNum,
o = void 0 === i ? 1 : i,
a = t.maxNodeNum,
s = void 0 === a ? 4 : a,
c = t.top,
u = void 0 === c ? 10 : c,
h = t.directed,
l = void 0 !== h && h,
f = t.verbose,
d = void 0 !== f && f;
(this.graphs = e),
(this.dfsCode = new rt()),
(this.support = 0),
(this.frequentSize1Subgraphs = []),
(this.frequentSubgraphs = []),
(this.minSupport = r),
(this.top = u),
(this.directed = l),
(this.counter = 0),
(this.maxNodeNum = s),
(this.minNodeNum = o),
(this.verbose = d),
this.maxNodeNum < this.minNodeNum &&
(this.maxNodeNum = this.minNodeNum),
(this.reportDF = []);
}
return (
(t.prototype.findForwardRootEdges = function (t, e) {
var n = this,
r = [],
i = t.nodeMap;
return (
e.edges.forEach(function (t) {
(n.directed || e.label <= i[t.to].label) && r.push(t);
}),
r
);
}),
(t.prototype.findBackwardEdge = function (t, e, n, r) {
if (!this.directed && e === n) return null;
for (
var i = t.nodeMap, o = i[n.to].edges, a = o.length, s = 0;
s < a;
s++
) {
var c = o[s];
if (!r.hasEdge(c) && c.to === e.from)
if (this.directed) {
if (
i[e.from].label < i[n.to].label ||
(i[e.from].label === i[n.to].label && e.label <= c.label)
)
return c;
} else if (
e.label < c.label ||
(e.label === c.label && i[e.to].label <= i[n.to].label)
)
return c;
}
return null;
}),
(t.prototype.findForwardPureEdges = function (t, e, n, r) {
for (
var i = [],
o = e.to,
a = t.nodeMap[o].edges,
s = a.length,
c = 0;
c < s;
c++
) {
var u = a[c],
h = t.nodeMap[u.to];
n <= h.label && !r.hasNode(h) && i.push(u);
}
return i;
}),
(t.prototype.findForwardRmpathEdges = function (t, e, n, r) {
for (
var i = [],
o = t.nodeMap,
a = o[e.to].label,
s = o[e.from].edges,
c = s.length,
u = 0;
u < c;
u++
) {
var h = s[u],
l = o[h.to].label;
e.to === h.to ||
n > l ||
r.hasNode(o[h.to]) ||
((e.label < h.label || (e.label === h.label && a <= l)) &&
i.push(h));
}
return i;
}),
(t.prototype.getSupport = function (t) {
var e = {};
return (
t.forEach(function (t) {
e[t.graphId] || (e[t.graphId] = !0);
}),
Object.keys(e).length
);
}),
(t.prototype.findMinLabel = function (t) {
var e = void 0;
return (
Object.keys(t).forEach(function (n) {
var r = t[n],
i = r.nodeLabel1,
o = r.edgeLabel,
a = r.nodeLabel2;
e
? (i < e.nodeLabel1 ||
(i === e.nodeLabel1 && o < e.edgeLabel) ||
(i === e.nodeLabel1 &&
o === e.edgeLabel &&
a < e.nodeLabel2)) &&
(e = { nodeLabel1: i, edgeLabel: o, nodeLabel2: a })
: (e = { nodeLabel1: i, edgeLabel: o, nodeLabel2: a });
}),
e
);
}),
(t.prototype.isMin = function () {
var t = this,
e = this.dfsCode;
if (
(this.verbose && console.log("isMin checking", e),
1 === e.dfsEdgeList.length)
)
return !0;
var n = this.directed,
r = e.toGraph(-1, n),
i = r.nodeMap,
o = new rt(),
a = {};
r.nodes.forEach(function (e) {
t.findForwardRootEdges(r, e).forEach(function (t) {
var n = i[t.to],
o = ""
.concat(e.label, "-")
.concat(t.label, "-")
.concat(n.label);
a[o] ||
(a[o] = {
projected: [],
nodeLabel1: e.label,
edgeLabel: t.label,
nodeLabel2: n.label,
});
var s = { graphId: r.id, edge: t, preNode: null };
a[o].projected.push(s);
});
});
var s = this.findMinLabel(a);
if (s) {
o.dfsEdgeList.push(
new nt(0, 1, s.nodeLabel1, s.edgeLabel, s.nodeLabel2),
);
var c = ""
.concat(s.nodeLabel1, "-")
.concat(s.edgeLabel, "-")
.concat(s.nodeLabel2);
return (function a(s) {
for (
var c = o.buildRmpath(),
u = o.dfsEdgeList[0].nodeEdgeNodeLabel.nodeLabel1,
h = o.dfsEdgeList[c[0]].toNode,
l = {},
f = !1,
d = 0,
p = n ? -1 : 0,
g = function (e) {
if (f) return "break";
s.forEach(function (n) {
var i = new it(n),
a = t.findBackwardEdge(
r,
i.edges[c[e]],
i.edges[c[0]],
i,
);
a &&
(l[a.label] ||
(l[a.label] = {
projected: [],
edgeLabel: a.label,
}),
l[a.label].projected.push({
graphId: r.id,
edge: l,
preNode: n,
}),
(d = o.dfsEdgeList[c[e]].fromNode),
(f = !0));
});
},
v = c.length - 1;
v > p;
v--
) {
if ("break" === g(v)) break;
}
if (f) {
var y = t.findMinLabel(l);
o.dfsEdgeList.push(new nt(h, d, "-1", y.edgeLabel, "-1"));
var m = o.dfsEdgeList.length - 1;
return (
t.dfsCode.dfsEdgeList[m] === o.dfsEdgeList[m] &&
a(l[y.edgeLabel].projected)
);
}
var b = {};
f = !1;
var x = 0;
s.forEach(function (e) {
var n = new it(e),
o = t.findForwardPureEdges(r, n.edges[c[0]], u, n);
o.length > 0 &&
((f = !0),
(x = h),
o.forEach(function (t) {
var n = "".concat(t.label, "-").concat(i[t.to].label);
b[n] ||
(b[n] = {
projected: [],
edgeLabel: t.label,
nodeLabel2: i[t.to].label,
}),
b[n].projected.push({
graphId: r.id,
edge: t,
preNode: e,
});
}));
});
var w = c.length,
S = function (e) {
if (f) return "break";
var n = c[e];
s.forEach(function (e) {
var a = new it(e),
s = t.findForwardRmpathEdges(r, a.edges[n], u, a);
s.length > 0 &&
((f = !0),
(x = o.dfsEdgeList[n].fromNode),
s.forEach(function (t) {
var n = ""
.concat(t.label, "-")
.concat(i[t.to].label);
b[n] ||
(b[n] = {
projected: [],
edgeLabel: t.label,
nodeLabel2: i[t.to].label,
}),
b[n].projected.push({
graphId: r.id,
edge: t,
preNode: e,
});
}));
});
};
for (v = 0; v < w; v++) {
if ("break" === S(v)) break;
}
if (!f) return !0;
var O = t.findMinLabel(b);
o.dfsEdgeList.push(
new nt(x, h + 1, "-1", O.edgeLabel, O.nodeLabel2),
);
var M = o.dfsEdgeList.length - 1;
return (
e.dfsEdgeList[M] === o.dfsEdgeList[M] &&
a(
b["".concat(O.edgeLabel, "-").concat(O.nodeLabel2)]
.projected,
)
);
})(a[c].projected);
}
}),
(t.prototype.report = function () {
if (!(this.dfsCode.getNodeNum() < this.minNodeNum)) {
this.counter++;
var t = this.dfsCode.toGraph(this.counter, this.directed);
this.frequentSubgraphs.push(Object(M.clone)(t));
}
}),
(t.prototype.subGraphMining = function (t) {
var e = this;
if (!(this.getSupport(t) < this.minSupport) && this.isMin()) {
this.report();
var n = this.dfsCode.getNodeNum(),
r = this.dfsCode.buildRmpath(),
i = this.dfsCode.dfsEdgeList[r[0]].toNode,
o = this.dfsCode.dfsEdgeList[0].nodeEdgeNodeLabel.nodeLabel1,
a = {},
s = {};
t.forEach(function (t) {
for (
var c = e.graphs[t.graphId],
u = c.nodeMap,
h = new it(t),
l = r.length - 1;
l >= 0;
l--
) {
var f = e.findBackwardEdge(
c,
h.edges[r[l]],
h.edges[r[0]],
h,
);
if (f) {
var d = ""
.concat(e.dfsCode.dfsEdgeList[r[l]].fromNode, "-")
.concat(f.label);
s[d] ||
(s[d] = {
projected: [],
toNodeId: e.dfsCode.dfsEdgeList[r[l]].fromNode,
edgeLabel: f.label,
}),
s[d].projected.push({
graphId: t.graphId,
edge: f,
preNode: t,
});
}
}
if (!(n >= e.maxNodeNum)) {
e.findForwardPureEdges(c, h.edges[r[0]], o, h).forEach(
function (e) {
var n = ""
.concat(i, "-")
.concat(e.label, "-")
.concat(u[e.to].label);
a[n] ||
(a[n] = {
projected: [],
fromNodeId: i,
edgeLabel: e.label,
nodeLabel2: u[e.to].label,
}),
a[n].projected.push({
graphId: t.graphId,
edge: e,
preNode: t,
});
},
);
var p = function (n) {
e.findForwardRmpathEdges(c, h.edges[r[n]], o, h).forEach(
function (i) {
var o = ""
.concat(e.dfsCode.dfsEdgeList[r[n]].fromNode, "-")
.concat(i.label, "-")
.concat(u[i.to].label);
a[o] ||
(a[o] = {
projected: [],
fromNodeId: e.dfsCode.dfsEdgeList[r[n]].fromNode,
edgeLabel: i.label,
nodeLabel2: u[i.to].label,
}),
a[o].projected.push({
graphId: t.graphId,
edge: i,
preNode: t,
});
},
);
};
for (l = 0; l < r.length; l++) p(l);
}
}),
Object.keys(s).forEach(function (t) {
var n = s[t],
r = n.toNodeId,
o = n.edgeLabel;
e.dfsCode.dfsEdgeList.push(new nt(i, r, "-1", o, "-1")),
e.subGraphMining(s[t].projected),
e.dfsCode.dfsEdgeList.pop();
}),
Object.keys(a).forEach(function (t) {
var n = a[t],
r = n.fromNodeId,
o = n.edgeLabel,
s = n.nodeLabel2;
e.dfsCode.dfsEdgeList.push(new nt(r, i + 1, "-1", o, s)),
e.subGraphMining(a[t].projected),
e.dfsCode.dfsEdgeList.pop();
});
}
}),
(t.prototype.generate1EdgeFrequentSubGraphs = function () {
var t = this.graphs,
e = this.directed,
n = this.minSupport,
r = this.frequentSize1Subgraphs,
i = {},
o = {},
a = {},
s = {};
return (
Object.keys(t).forEach(function (n) {
var r = t[n],
c = r.nodeMap;
r.nodes.forEach(function (t, r) {
var u = t.label,
h = "".concat(n, "-").concat(u);
if (!a[h]) {
var l = i[u] || 0;
l++, (i[u] = l);
}
(a[h] = { graphKey: n, label: u }),
t.edges.forEach(function (t) {
var r = u,
i = c[t.to].label;
if (!e && r > i) {
var a = i;
(i = r), (r = a);
}
var h = t.label,
l = ""
.concat(n, "-")
.concat(r, "-")
.concat(h, "-")
.concat(i),
f = "".concat(r, "-").concat(h, "-").concat(i);
if (!o[f]) {
var d = o[f] || 0;
d++, (o[f] = d);
}
s[l] = {
graphId: n,
nodeLabel1: r,
edgeLabel: h,
nodeLabel2: i,
};
});
});
}),
Object.keys(i).forEach(function (t) {
if (!(i[t] < n)) {
var e = { nodes: [], edges: [] };
e.nodes.push({ id: "0", label: t }), r.push(e);
}
}),
r
);
}),
(t.prototype.run = function () {
var t = this;
if (
((this.frequentSize1Subgraphs =
this.generate1EdgeFrequentSubGraphs()),
!(this.maxNodeNum < 2))
) {
var e = this.graphs,
n = (this.directed, {});
Object.keys(e).forEach(function (r) {
var i = e[r],
o = i.nodeMap;
i.nodes.forEach(function (e) {
t.findForwardRootEdges(i, e).forEach(function (t) {
var i = o[t.to],
a = ""
.concat(e.label, "-")
.concat(t.label, "-")
.concat(i.label);
n[a] ||
(n[a] = {
projected: [],
nodeLabel1: e.label,
edgeLabel: t.label,
nodeLabel2: i.label,
});
var s = { graphId: r, edge: t, preNode: null };
n[a].projected.push(s);
});
});
}),
Object.keys(n).forEach(function (e) {
var r = n[e],
i = r.projected,
o = r.nodeLabel1,
a = r.edgeLabel,
s = r.nodeLabel2;
t.dfsCode.dfsEdgeList.push(new nt(0, 1, o, a, s)),
t.subGraphMining(i),
t.dfsCode.dfsEdgeList.pop();
});
}
}),
t
);
})(),
at = function (t) {
var e = t.graphs,
n = t.directed,
r = void 0 !== n && n,
i = t.nodeLabelProp,
o = void 0 === i ? "cluster" : i,
a = t.edgeLabelProp,
s = void 0 === a ? "cluster" : a,
c = (function (t, e, n, r) {
var i = {};
return (
Object.keys(t).forEach(function (o, a) {
var s = t[o],
c = new et(a, !0, e),
u = {};
s.nodes.forEach(function (t, e) {
c.addNode(e, t[n]), (u[t.id] = e);
}),
s.edges.forEach(function (t, e) {
var n = u[t.source],
i = u[t.target];
c.addEdge(-1, n, i, t[r]);
}),
c && c.getNodeNum() && (i[c.id] = c);
}),
i
);
})(e, r, o, s),
u = t.minSupport,
h = t.maxNodeNum,
l = t.minNodeNum,
f = t.verbose,
d = t.top,
p = new ot({
graphs: c,
minSupport: u,
maxNodeNum: h,
minNodeNum: l,
top: d,
verbose: f,
directed: r,
});
return (
p.run(),
(function (t, e, n) {
var r = [];
return (
t.forEach(function (t) {
var i = { nodes: [], edges: [] };
t.nodes.forEach(function (t) {
var n;
i.nodes.push(
(((n = { id: "".concat(t.id) })[e] = t.label), n),
);
}),
t.edges.forEach(function (t) {
var e;
i.edges.push(
(((e = {
source: "".concat(t.from),
target: "".concat(t.to),
})[n] = t.label),
e),
);
}),
r.push(i);
}),
r
);
})(p.frequentSubgraphs, o, s)
);
},
st = function (t, e, n, r) {
void 0 === n && (n = "cluster"), void 0 === r && (r = 2);
var i = [],
o = t.nodes;
return (
e.forEach(function (t, e) {
i.push(ct(o, t, e, n, r));
}),
i
);
},
ct = function (t, e, n, r, i) {
var o = [n],
a = [],
s = {};
return (
e.forEach(function (e, c) {
if (e <= i && n !== c) {
o.push(c), a.push(t[c]);
var u = t[c][r];
s[u]
? (s[u].count++, s[u].dists.push(e))
: (s[u] = { count: 1, dists: [e] });
}
}),
Object.keys(s).forEach(function (t) {
s[t].dists = s[t].dists.sort(function (t, e) {
return t - e;
});
}),
{
nodeIdx: n,
nodeId: t[n].id,
nodeIdxs: o,
neighbors: a,
neighborNum: o.length - 1,
nodeLabelCountMap: s,
}
);
},
ut = function (t, e, n, r) {
var i = n.nodes;
return (
r || (r = {}),
Object.keys(t).forEach(function (o) {
var a, s;
if (!r || !r[o]) {
r[o] = { nodes: [], edges: [] };
var c = t[o],
u =
null === (a = e[c.start]) || void 0 === a
? void 0
: a.nodeIdxs,
h =
null === (s = e[c.end]) || void 0 === s
? void 0
: s.nodeIdxs;
if (u && h) {
var l = new Set(h),
f = u.filter(function (t) {
return l.has(t);
});
if (f && f.length) {
for (var d = {}, p = f.length, g = 0; g < p; g++) {
var v = i[f[g]];
r[o].nodes.push(v), (d[v.id] = !0);
}
n.edges.forEach(function (t) {
d[t.source] && d[t.target] && r[o].edges.push(t);
});
}
}
}
}),
r
);
},
ht = function (t, e, n, r) {
var i,
o,
a = {};
t.nodes.forEach(function (t) {
a[t.id] = t;
});
var s = 0;
return !(null === (i = null == e ? void 0 : e.edges) || void 0 === i
? void 0
: i.length) ||
(null === (o = null == e ? void 0 : e.nodes) || void 0 === o
? void 0
: o.length) < 2
? 0
: (t.edges.forEach(function (t) {
var i = a[t.source][n],
o = a[t.target][n],
c = null == e ? void 0 : e.nodes[0][n],
u = null == e ? void 0 : e.nodes[1][n],
h = null == e ? void 0 : e.edges[0][r];
t[r] === h &&
((i === c && o === u) || (i === u && o === c)) &&
s++;
}),
s);
},
lt = function (t, e) {
var n = {},
r = {};
return (
t.forEach(function (t, i) {
n[t.id] = {
idx: i,
node: t,
degree: 0,
inDegree: 0,
outDegree: 0,
};
var o = t[e];
r[o] || (r[o] = []), r[o].push(t);
}),
{ nodeMap: n, nodeLabelMap: r }
);
},
ft = function (t, e, n) {
var r = {},
i = {};
return (
t.forEach(function (t, o) {
r["".concat(h)] = { idx: o, edge: t };
var a = t[e];
i[a] || (i[a] = []), i[a].push(t);
var s = n[t.source];
s && (s.degree++, s.outDegree++);
var c = n[t.target];
c && (c.degree++, c.inDegree++);
}),
{ edgeMap: r, edgeLabelMap: i }
);
},
dt = function (t, e, n) {
var r = e.length,
i = {};
return (
e.forEach(function (e, o) {
for (var a = n ? 0 : o + 1, s = t[o].id, c = a; c < r; c++)
if (o !== c) {
var u = t[c].id,
h = e[c];
(i["".concat(s, "-").concat(u)] = h),
n || (i["".concat(u, "-").concat(s)] = h);
}
}),
i
);
},
pt = function (t, e, n, r, i, o, a, s, c, u, h) {
var l,
f = "".concat(e.id, "-").concat(n.id);
if (u && u[f]) return u[f];
var d = h ? h[f] : void 0;
if (!d) {
var p =
(((l = {})[f] = {
start: r[e.id].idx,
end: r[n.id].idx,
distance: i,
}),
l);
d = (h = ut(p, o, t, h))[f];
}
return ht(d, a, s, c);
},
gt = function (t, e, n, r) {
var i,
o,
a,
s = null === (i = t[e]) || void 0 === i ? void 0 : i.degree,
c = null === (o = t[e]) || void 0 === o ? void 0 : o.inDegree,
u = null === (a = t[e]) || void 0 === a ? void 0 : a.outDegree;
return (
void 0 === t[e] &&
((s = 1 / 0),
(c = 1 / 0),
(u = 1 / 0),
r[e].forEach(function (t) {
var e = n[t.id].degree;
s > e && (s = e);
var r = n[t.id].inDegree;
c > r && (c = r);
var i = n[t.id].outDegree;
u > i && (u = i);
}),
(t[e] = { degree: s, inDegree: c, outDegree: u })),
{
minPatternNodeLabelDegree: s,
minPatternNodeLabelInDegree: c,
minPatternNodeLabelOutDegree: u,
}
);
},
vt = function (t, e, n, r, i, o, a) {
var s;
if (
(void 0 === n && (n = !1),
void 0 === o && (o = "cluster"),
void 0 === a && (a = "cluster"),
t && t.nodes)
) {
var c = t.nodes.length;
if (c) {
var u = A(t, n),
h = A(e, n),
l = dt(t.nodes, u, n),
f = dt(e.nodes, h, n),
d = lt(t.nodes, o),
p = d.nodeMap,
g = d.nodeLabelMap,
v = lt(e.nodes, o),
y = v.nodeMap,
m = v.nodeLabelMap;
ft(t.edges, a, p);
var b = ft(e.edges, a, y).edgeLabelMap,
x = [];
null == h ||
h.forEach(function (t) {
x = x.concat(t);
}),
i ||
(i = Math.max.apply(
Math,
Object(O.f)(Object(O.f)([], x, !1), [2], !1),
)),
r || (r = i);
var w = st(t, u, o, r),
S = st(e, h, o, r),
M = (function (t, e, n, r, i) {
var o = Math.ceil(n / e),
a = {},
s = 0;
return (
r.forEach(function (t, r) {
for (
var c = 0, u = 0, h = t.nodeIdxs, l = t.neighborNum - 1;
c < o;
) {
for (
var f = h[1 + Math.floor(Math.random() * l)], d = 0;
(a["".concat(r, "-").concat(f)] ||
a["".concat(f, "-").concat(r)]) &&
((f = Math.floor(Math.random() * e)), !(++d > 2 * e));
);
if (
d < 2 * e &&
((a["".concat(r, "-").concat(f)] = {
start: r,
end: f,
distance: i[r][f],
}),
c++,
++s >= n)
)
return a;
if (++u > 2 * e) break;
}
c < o && (o = (o + (o - c)) / (e - r - 1));
}),
a
);
})(0, c, Math.min(100, (c * (c - 1)) / 2), w, u),
C = ut(M, w, t),
E = at({
graphs: C,
nodeLabelProp: o,
edgeLabelProp: a,
minSupport: 1,
minNodeNum: 1,
maxNodeNum: 4,
directed: n,
}).slice(0, 10),
j = E.length,
P = [];
E.forEach(function (t, e) {
(P[e] = {}),
Object.keys(C).forEach(function (n) {
var r = C[n],
i = ht(r, t, o, a);
P[e][n] = i;
});
});
var I = (function (t, e, n) {
for (
var r = 1 / 0,
i = 0,
o = function (e) {
var n = t[e],
o = Object.keys(n).sort(function (t, e) {
return n[t] - n[e];
}),
a = [];
o.forEach(function (t, e) {
a[e % 10] ||
(a[e % 10] = {
graphs: [],
totalCount: 0,
aveCount: 0,
}),
a[e % 10].graphs.push(t),
(a[e % 10].totalCount += n[t]);
});
var s = 0,
c = [];
a.forEach(function (t) {
var e = t.totalCount / t.graphs.length;
(t.aveCount = e), c.push(e);
var r = 0,
i = t.length;
t.graphs.forEach(function (e, i) {
var o = n[e];
t.graphs.forEach(function (t, e) {
i !== e && (r += Math.abs(o - n[t]));
});
}),
(s += r /= (i * (i - 1)) / 2);
}),
(s /= a.length);
var u = 0;
c.forEach(function (t, e) {
c.forEach(function (n, r) {
e !== r && (u += Math.abs(t - n));
}),
(u /= (c.length * (c.length - 1)) / 2);
});
var h = u - s;
r < h && ((r = h), (i = e));
},
a = 0;
a < e;
a++
)
o(a);
return { structure: n[i], structureCountMap: t[i] };
})(P, j, E),
T = I.structure,
N = I.structureCountMap,
B = e.nodes[0],
L = [],
D = null === (s = e.nodes[0]) || void 0 === s ? void 0 : s[o],
_ = -1 / 0;
e.nodes.forEach(function (t) {
var e = t[o],
n = g[e];
(null == n ? void 0 : n.length) > _ &&
((_ = n.length), (L = n), (D = e), (B = t));
});
var R = {},
F = {},
Y = {},
X = {},
z = {},
W = {};
Object.keys(m).forEach(function (r, i) {
(z[r] = []), n && (W[r] = []);
var s = -1 / 0,
c = m[r],
u = {};
c.forEach(function (t) {
var e = f["".concat(B.id, "-").concat(t.id)];
if (
(e && z[r].push(e),
s < e && (s = e),
(u["".concat(B.id, "-").concat(t.id)] = {
start: 0,
end: y[t.id].idx,
distance: e,
}),
n)
) {
var i = f["".concat(t.id, "-").concat(B.id)];
i && W[r].push(i);
}
}),
(z[r] = z[r].sort(function (t, e) {
return t - e;
})),
n &&
(W[r] = W[r].sort(function (t, e) {
return t - e;
})),
(F = ut(u, S, e, F));
var h = [];
if (
(Object.keys(u).forEach(function (t) {
if (Y[t]) h.push(Y[t]);
else {
var e = F[t];
(Y[t] = ht(e, T, o, a)), h.push(Y[t]);
}
}),
(h = h.sort(function (t, e) {
return e - t;
})),
(X["".concat(B.id, "-").concat(r)] = h),
r !== D)
)
for (
var d = function (e) {
var n = L[e],
i = w[p[n.id].idx],
s = i.nodeLabelCountMap[r],
c = m[r].length;
if (!s || s.count < c)
return L.splice(e, 1), "continue";
for (var u = !1, f = 0; f < c; f++)
if (s.dists[f] > z[r][f]) {
u = !0;
break;
}
if (u) return L.splice(e, 1), "continue";
var d = {};
i.neighbors.forEach(function (t) {
var e = l["".concat(n.id, "-").concat(t.id)];
d["".concat(n.id, "-").concat(t.id)] = {
start: p[n.id].idx,
end: p[t.id].idx,
distance: e,
};
}),
(C = ut(d, w, t, C));
var g = [];
Object.keys(d).forEach(function (t) {
if (N[t]) g.push(N[t]);
else {
var e = C[t];
(N[t] = ht(e, T, o, a)), g.push(N[t]);
}
}),
(g = g.sort(function (t, e) {
return e - t;
}));
var v = !1;
for (f = 0; f < c; f++)
if (g[f] < h[f]) {
v = !0;
break;
}
return v ? (L.splice(e, 1), "continue") : void 0;
},
g = ((null == L ? void 0 : L.length) || 0) - 1;
g >= 0;
g--
)
d(g);
});
var q = [];
null == L ||
L.forEach(function (r) {
for (
var s = p[r.id].idx,
c = ct(t.nodes, u[s], s, o, i).neighbors,
h = !1,
f = c.length - 1;
f >= 0;
f--
) {
if (c.length + 1 < e.nodes.length) return void (h = !0);
var d = c[f],
g = d[o];
if (m[g] && m[g].length)
if (z[g] && z[g].length) {
var v = "".concat(r.id, "-").concat(d.id),
b = l[v],
x = z[g].length - 1;
if (b > z[g][x]) c.splice(f, 1);
else {
if (n) {
var S = "".concat(d.id, "-").concat(r.id),
O = l[S];
if (((x = W[g].length - 1), O > W[g][x])) {
c.splice(f, 1);
continue;
}
}
var M = N[v]
? N[v]
: pt(t, r, d, p, b, w, T, o, a, N, C),
k = "".concat(B.id, "-").concat(g);
if (M < X[k][X[k].length - 1]) c.splice(f, 1);
else {
var E = gt(R, g, y, m),
j = E.minPatternNodeLabelDegree;
E.minPatternNodeLabelInDegree,
E.minPatternNodeLabelOutDegree;
p[d.id].degree < j && c.splice(f, 1);
}
}
} else c.splice(f, 1);
else c.splice(f, 1);
}
h || q.push({ nodes: [r].concat(c) });
});
var V = k(e, B.id, !1).length,
G = {};
n
? (Object.keys(V).forEach(function (t) {
var e = y[t].node[o];
G[e] ? G[e].push(V[t]) : (G[e] = [V[t]]);
}),
Object.keys(G).forEach(function (t) {
G[t].sort(function (t, e) {
return t - e;
});
}))
: (G = z);
for (
var H = function (r) {
var i = q[r],
s = i.nodes[0],
c = {},
u = {};
i.nodes.forEach(function (t, e) {
u[t.id] = {
idx: e,
node: t,
degree: 0,
inDegree: 0,
outDegree: 0,
};
var n = t[o];
c[n] ? c[n]++ : (c[n] = 1);
});
var h = [],
l = {};
t.edges.forEach(function (t) {
u[t.source] &&
u[t.target] &&
(h.push(t),
l[t[a]] ? l[t[a]]++ : (l[t[a]] = 1),
u[t.source].degree++,
u[t.target].degree++,
u[t.source].outDegree++,
u[t.target].inDegree++);
});
for (
var f = Object.keys(b).length, d = !1, g = 0;
g < f;
g++
) {
var v = Object.keys(b)[g];
if (!l[v] || l[v] < b[v].length) {
d = !0;
break;
}
}
if (d) return q.splice(r, 1), "continue";
var x = h.length;
if (x < e.edges.length) return q.splice(r, 1), "break";
var w = !1,
S = function (t) {
var e = h[t],
r = e[a],
i = b[r];
if (!i || !i.length)
return (
l[r]--,
i && l[r] < i.length
? ((w = !0), "break")
: (h.splice(t, 1),
u[e.source].degree--,
u[e.target].degree--,
u[e.source].outDegree--,
u[e.target].inDegree--,
"continue")
);
var s = u[e.source].node[o],
c = u[e.target].node[o],
f = !1;
return (
i.forEach(function (t) {
var e = y[t.source].node,
r = y[t.target].node;
e[o] === s && r[o] === c && (f = !0),
n || e[o] !== c || r[o] !== s || (f = !0);
}),
f
? void 0
: (l[r]--,
i && l[r] < i.length
? ((w = !0), "break")
: (h.splice(t, 1),
u[e.source].degree--,
u[e.target].degree--,
u[e.source].outDegree--,
u[e.target].inDegree--,
"continue"))
);
};
for (g = x - 1; g >= 0; g--) {
if ("break" === S(g)) break;
}
if (w) return q.splice(r, 1), "continue";
i.edges = h;
var O = k(i, i.nodes[0].id, !1).length;
if (
(Object.keys(O)
.reverse()
.forEach(function (t) {
if (t !== i.nodes[0].id && !w) {
if (O[t] === 1 / 0) {
var e = u[t].node[o];
if ((c[e]--, c[e] < m[e].length))
return void (w = !0);
var n = i.nodes.indexOf(u[t].node);
return i.nodes.splice(n, 1), void (u[t] = void 0);
}
var r = p[t].node[o];
if (
!G[r] ||
!G[r].length ||
O[t] > G[r][G[r].length - 1]
) {
e = u[t].node[o];
if ((c[e]--, c[e] < m[e].length))
return void (w = !0);
n = i.nodes.indexOf(u[t].node);
i.nodes.splice(n, 1), (u[t] = void 0);
}
}
}),
w)
)
return q.splice(r, 1), "continue";
for (var M = !0, C = 0; M && !w; ) {
if (
((M = !1),
n
? u[s.id].degree < y[B.id].degree ||
u[s.id].inDegree < y[B.id].inDegree ||
u[s.id].outDegree < y[B.id].outDegree
: u[s.id].degree < y[B.id].degree)
) {
w = !0;
break;
}
if (c[s[o]] < m[s[o]].length) {
w = !0;
break;
}
for (var E = i.nodes.length - 1; E >= 0; E--) {
var j = i.nodes[E],
P = u[j.id].degree,
A = u[j.id].inDegree,
I = u[j.id].outDegree,
T = j[o],
N = gt(R, T, y, m),
L = N.minPatternNodeLabelDegree,
D = N.minPatternNodeLabelInDegree,
_ = N.minPatternNodeLabelOutDegree;
if (n ? P < L || A < D || I < _ : P < L) {
if ((c[j[o]]--, c[j[o]] < m[j[o]].length)) {
w = !0;
break;
}
i.nodes.splice(E, 1), (u[j.id] = void 0), (M = !0);
}
}
if (w || (!M && 0 !== C)) break;
for (var F = (x = h.length) - 1; F >= 0; F--) {
var Y = h[F];
if (!u[Y.source] || !u[Y.target]) {
h.splice(F, 1);
var X = Y[a];
if (
(l[X]--,
u[Y.source] &&
(u[Y.source].degree--, u[Y.source].outDegree--),
u[Y.target] &&
(u[Y.target].degree--, u[Y.target].inDegree--),
b[X] && l[X] < b[X].length)
) {
w = !0;
break;
}
M = !0;
}
}
C++;
}
return w ||
w ||
i.nodes.length < e.nodes.length ||
h.length < e.edges.length
? (q.splice(r, 1), "continue")
: void 0;
},
U = q.length - 1;
U >= 0;
U--
) {
if ("break" === H(U)) break;
}
var Z = q.length,
K = function (t) {
var e = q[t],
n = {};
e.edges.forEach(function (t) {
var e = ""
.concat(t.source, "-")
.concat(t.target, "-")
.concat(t.label);
n[e] ? n[e]++ : (n[e] = 1);
});
for (
var r = function (t) {
var e = q[t],
r = {};
e.edges.forEach(function (t) {
var e = ""
.concat(t.source, "-")
.concat(t.target, "-")
.concat(t.label);
r[e] ? r[e]++ : (r[e] = 1);
});
var i = !0;
Object.keys(r).length !== Object.keys(n).length
? (i = !1)
: Object.keys(n).forEach(function (t) {
r[t] !== n[t] && (i = !1);
}),
i && q.splice(t, 1);
},
i = Z - 1;
i > t;
i--
)
r(i);
Z = q.length;
};
for (U = 0; U <= Z - 1; U++) K(U);
return q;
}
}
},
yt = (function () {
function t(t) {
void 0 === t && (t = 10),
(this.linkedList = new a()),
(this.maxStep = t);
}
return (
Object.defineProperty(t.prototype, "length", {
get: function () {
return this.linkedList.toArray().length;
},
enumerable: !1,
configurable: !0,
}),
(t.prototype.isEmpty = function () {
return !this.linkedList.head;
}),
(t.prototype.isMaxStack = function () {
return this.toArray().length >= this.maxStep;
}),
(t.prototype.peek = function () {
return this.isEmpty() ? null : this.linkedList.head.value;
}),
(t.prototype.push = function (t) {
this.linkedList.prepend(t),
this.length > this.maxStep && this.linkedList.deleteTail();
}),
(t.prototype.pop = function () {
var t = this.linkedList.deleteHead();
return t ? t.value : null;
}),
(t.prototype.toArray = function () {
return this.linkedList.toArray().map(function (t) {
return t.value;
});
}),
(t.prototype.clear = function () {
for (; !this.isEmpty(); ) this.pop();
}),
t
);
})(),
mt = S;
e.default = {
getAdjMatrix: r,
breadthFirstSearch: l,
connectedComponent: d,
getDegree: g,
getInDegree: v,
getOutDegree: y,
detectCycle: S,
detectDirectedCycle: mt,
detectAllCycles: w,
detectAllDirectedCycle: x,
detectAllUndirectedCycle: b,
depthFirstSearch: m,
dijkstra: k,
findAllPath: P,
findShortestPath: j,
floydWarshall: A,
labelPropagation: I,
louvain: F,
iLouvain: Y,
kCore: X,
kMeans: W,
cosineSimilarity: q,
nodesCosineSimilarity: V,
minimumSpanningTree: $,
pageRank: Q,
getNeighbors: c,
Stack: yt,
GADDI: vt,
};
},
3: function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return i.a;
}),
n.d(e, "c", function () {
return i.b;
}),
n.d(e, "d", function () {
return i.c;
}),
n.d(e, "a", function () {
return r;
});
var r = {};
n.r(r),
n.d(r, "leftTranslate", function () {
return o;
}),
n.d(r, "leftRotate", function () {
return a;
}),
n.d(r, "leftScale", function () {
return s;
}),
n.d(r, "transform", function () {
return c;
}),
n.d(r, "direction", function () {
return u;
}),
n.d(r, "angleTo", function () {
return h;
}),
n.d(r, "vertical", function () {
return l;
});
var i = n(4);
function o(t, e, n) {
var r = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return i.a.fromTranslation(r, n), i.a.multiply(t, r, e);
}
function a(t, e, n) {
var r = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return i.a.fromRotation(r, n), i.a.multiply(t, r, e);
}
function s(t, e, n) {
var r = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return i.a.fromScaling(r, n), i.a.multiply(t, r, e);
}
function c(t, e) {
for (
var n,
r,
c,
u = t ? [].concat(t) : [1, 0, 0, 0, 1, 0, 0, 0, 1],
h = 0,
l = e.length;
h < l;
h++
) {
var f = e[h];
switch (f[0]) {
case "t":
o(u, u, [f[1], f[2]]);
break;
case "s":
s(u, u, [f[1], f[2]]);
break;
case "r":
a(u, u, f[1]);
break;
case "m":
(n = u), (r = u), (c = f[1]), i.a.multiply(n, c, r);
}
}
return u;
}
function u(t, e) {
return t[0] * e[1] - e[0] * t[1];
}
function h(t, e, n) {
var r = i.b.angle(t, e),
o = u(t, e) >= 0;
return n ? (o ? 2 * Math.PI - r : r) : o ? r : 2 * Math.PI - r;
}
function l(t, e, n) {
return (
n
? ((t[0] = e[1]), (t[1] = -1 * e[0]))
: ((t[0] = -1 * e[1]), (t[1] = e[0])),
t
);
}
},
30: function (t, e, n) {
self,
(t.exports = (function () {
"use strict";
var t = {
d: function (e, n) {
for (var r in n)
t.o(n, r) &&
!t.o(e, r) &&
Object.defineProperty(e, r, { enumerable: !0, get: n[r] });
},
o: function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
},
r: function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, {
value: "Module",
}),
Object.defineProperty(t, "__esModule", { value: !0 });
},
},
e = {};
function n(t, e) {
return void 0 === t ? e : t;
}
t.r(e),
t.d(e, {
default: function () {
return de;
},
});
var r,
i = Math.round,
o = Math.abs,
a = Date.now,
s = "compute",
c = "auto",
u = "manipulation",
h = "none",
l = "pan-x",
f = "pan-y",
d =
((r = {}),
[
"auto",
"manipulation",
"pan-y",
"pan-x",
"pan-x pan-y",
"none",
].forEach(function (t) {
return (r[t] = !0);
}),
r),
p = "touch",
g = ["x", "y"],
v = ["clientX", "clientY"],
y = 32,
m =
"function" != typeof Object.assign
? function (t) {
if (null == t)
throw new TypeError(
"Cannot convert undefined or null to object",
);
for (var e = Object(t), n = 1; n < arguments.length; n++) {
var r = arguments[n];
if (null != r)
for (var i in r) r.hasOwnProperty(i) && (e[i] = r[i]);
}
return e;
}
: Object.assign,
b = 1;
function x(t, e, n) {
var r;
if (t)
if (t.forEach) t.forEach(e, n);
else if (void 0 !== t.length)
for (r = 0; r < t.length; ) e.call(n, t[r], r, t), r++;
else for (r in t) t.hasOwnProperty(r) && e.call(n, t[r], r, t);
}
function w(t, e, n) {
return !!Array.isArray(t) && (x(t, n[e], n), !0);
}
function S(t, e, n) {
if (t.indexOf && !n) return t.indexOf(e);
for (var r = 0; r < t.length; ) {
if ((n && t[r][n] == e) || (!n && t[r] === e)) return r;
r++;
}
return -1;
}
function O(t) {
return (O =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function M(t, e) {
return "function" === O(t) ? t.apply((e && e[0]) || void 0, e) : t;
}
function k(t, e) {
var n = e.manager;
return n ? n.get(t) : t;
}
function C(t) {
return 16 & t
? "cancel"
: 8 & t
? "end"
: 4 & t
? "move"
: 2 & t
? "start"
: "";
}
var E = (function () {
function t(e) {
!(function (t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
})(this, t),
(this.options = m({}, this.defaults, e || {})),
(this.id = b++),
(this.manager = null),
(this.options.enable = n(this.options.enable, !0)),
(this.state = 1),
(this.simultaneous = {}),
(this.requireFail = []);
}
var e, r;
return (
(e = t),
(r = [
{
key: "set",
value: function (t) {
return (
m(this.options, t),
this.manager && this.manager.touchAction.update(),
this
);
},
},
{
key: "recognizeWith",
value: function (t) {
if (w(t, "recognizeWith", this)) return this;
var e = this.simultaneous;
return (
e[(t = k(t, this)).id] ||
((e[t.id] = t), t.recognizeWith(this)),
this
);
},
},
{
key: "dropRecognizeWith",
value: function (t) {
return (
w(t, "dropRecognizeWith", this) ||
((t = k(t, this)), delete this.simultaneous[t.id]),
this
);
},
},
{
key: "requireFailure",
value: function (t) {
if (w(t, "requireFailure", this)) return this;
var e = this.requireFail;
return (
-1 === S(e, (t = k(t, this))) &&
(e.push(t), t.requireFailure(this)),
this
);
},
},
{
key: "dropRequireFailure",
value: function (t) {
if (w(t, "dropRequireFailure", this)) return this;
t = k(t, this);
var e = S(this.requireFail, t);
return e > -1 && this.requireFail.splice(e, 1), this;
},
},
{
key: "hasRequireFailures",
value: function () {
return this.requireFail.length > 0;
},
},
{
key: "canRecognizeWith",
value: function (t) {
return !!this.simultaneous[t.id];
},
},
{
key: "emit",
value: function (t) {
var e = this,
n = this.state;
function r(n) {
e.manager.emit(n, t);
}
n < 8 && r(e.options.event + C(n)),
r(e.options.event),
t.additionalEvent && r(t.additionalEvent),
n >= 8 && r(e.options.event + C(n));
},
},
{
key: "tryEmit",
value: function (t) {
if (this.canEmit()) return this.emit(t);
this.state = y;
},
},
{
key: "canEmit",
value: function () {
for (var t = 0; t < this.requireFail.length; ) {
if (!(33 & this.requireFail[t].state)) return !1;
t++;
}
return !0;
},
},
{
key: "recognize",
value: function (t) {
var e = m({}, t);
if (!M(this.options.enable, [this, e]))
return this.reset(), void (this.state = y);
56 & this.state && (this.state = 1),
(this.state = this.process(e)),
30 & this.state && this.tryEmit(e);
},
},
{ key: "process", value: function (t) {} },
{ key: "getTouchAction", value: function () {} },
{ key: "reset", value: function () {} },
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, r),
Object.defineProperty(e, "prototype", { writable: !1 }),
t
);
})();
function j(t) {
return (j =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function P(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function A(t, e) {
return (A =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function I(t, e) {
if (e && ("object" === j(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function T(t) {
return (T = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
E.prototype.defaults = {};
var N = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && A(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = T(r);
if (i) {
var n = T(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return I(this, t);
});
function a() {
return P(this, a), o.apply(this, arguments);
}
return (
(e = a),
(n = [
{
key: "attrTest",
value: function (t) {
var e = this.options.pointers;
return 0 === e || t.pointers.length === e;
},
},
{
key: "process",
value: function (t) {
var e = this.state,
n = t.eventType,
r = 6 & e,
i = this.attrTest(t);
return r && (8 & n || !i)
? 16 | e
: r || i
? 4 & n
? 8 | e
: 2 & e
? 4 | e
: 2
: y;
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(E);
function B(t) {
return (B =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function L(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function D() {
return (D =
"undefined" != typeof Reflect && Reflect.get
? Reflect.get
: function (t, e, n) {
var r = _(t, e);
if (r) {
var i = Object.getOwnPropertyDescriptor(r, e);
return i.get
? i.get.call(arguments.length < 3 ? t : n)
: i.value;
}
}).apply(this, arguments);
}
function _(t, e) {
for (
;
!Object.prototype.hasOwnProperty.call(t, e) &&
null !== (t = Y(t));
);
return t;
}
function R(t, e) {
return (R =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function F(t, e) {
if (e && ("object" === B(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Y(t) {
return (Y = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
N.prototype.defaults = { pointers: 1 };
var X = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && R(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = Y(r);
if (i) {
var n = Y(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return F(this, t);
});
function a() {
return L(this, a), o.apply(this, arguments);
}
return (
(e = a),
(n = [
{
key: "getTouchAction",
value: function () {
return [h];
},
},
{
key: "attrTest",
value: function (t) {
return (
D(Y(a.prototype), "attrTest", this).call(this, t) &&
(Math.abs(t.rotation) > this.options.threshold ||
2 & this.state)
);
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(N);
function z(t) {
return (z =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function W(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function q() {
return (q =
"undefined" != typeof Reflect && Reflect.get
? Reflect.get
: function (t, e, n) {
var r = V(t, e);
if (r) {
var i = Object.getOwnPropertyDescriptor(r, e);
return i.get
? i.get.call(arguments.length < 3 ? t : n)
: i.value;
}
}).apply(this, arguments);
}
function V(t, e) {
for (
;
!Object.prototype.hasOwnProperty.call(t, e) &&
null !== (t = U(t));
);
return t;
}
function G(t, e) {
return (G =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function H(t, e) {
if (e && ("object" === z(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function U(t) {
return (U = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
X.prototype.defaults = { event: "rotate", threshold: 0, pointers: 2 };
var Z = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && G(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = U(r);
if (i) {
var n = U(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return H(this, t);
});
function a() {
return W(this, a), o.apply(this, arguments);
}
return (
(e = a),
(n = [
{
key: "getTouchAction",
value: function () {
return [h];
},
},
{
key: "attrTest",
value: function (t) {
return (
q(U(a.prototype), "attrTest", this).call(this, t) &&
(Math.abs(t.scale - 1) > this.options.threshold ||
2 & this.state)
);
},
},
{
key: "emit",
value: function (t) {
if (1 !== t.scale) {
var e = t.scale < 1 ? "in" : "out";
t.additionalEvent = this.options.event + e;
}
q(U(a.prototype), "emit", this).call(this, t);
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(N);
function K(t) {
return 16 === t
? "down"
: 8 === t
? "up"
: 2 === t
? "left"
: 4 === t
? "right"
: "";
}
function $(t) {
return ($ =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Q(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function J() {
return (J =
"undefined" != typeof Reflect && Reflect.get
? Reflect.get
: function (t, e, n) {
var r = tt(t, e);
if (r) {
var i = Object.getOwnPropertyDescriptor(r, e);
return i.get
? i.get.call(arguments.length < 3 ? t : n)
: i.value;
}
}).apply(this, arguments);
}
function tt(t, e) {
for (
;
!Object.prototype.hasOwnProperty.call(t, e) &&
null !== (t = rt(t));
);
return t;
}
function et(t, e) {
return (et =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function nt(t, e) {
if (e && ("object" === $(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function rt(t) {
return (rt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
Z.prototype.defaults = { event: "pinch", threshold: 0, pointers: 2 };
var it = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && et(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = rt(r);
if (i) {
var n = rt(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return nt(this, t);
});
function a() {
var t;
return (
Q(this, a),
((t = o.apply(this, arguments)).pX = null),
(t.pY = null),
t
);
}
return (
(e = a),
(n = [
{
key: "getTouchAction",
value: function () {
var t = this.options.direction,
e = [];
return 6 & t && e.push(f), 24 & t && e.push(l), e;
},
},
{
key: "directionTest",
value: function (t) {
var e = this.options,
n = !0,
r = t.distance,
i = t.direction,
o = t.deltaX,
a = t.deltaY;
return (
i & e.direction ||
(6 & e.direction
? ((i = 0 === o ? 1 : o < 0 ? 2 : 4),
(n = o !== this.pX),
(r = Math.abs(t.deltaX)))
: ((i = 0 === a ? 1 : a < 0 ? 8 : 16),
(n = a !== this.pY),
(r = Math.abs(t.deltaY)))),
(t.direction = i),
n && r > e.threshold && i & e.direction
);
},
},
{
key: "attrTest",
value: function (t) {
return (
N.prototype.attrTest.call(this, t) &&
(2 & this.state ||
(!(2 & this.state) && this.directionTest(t)))
);
},
},
{
key: "emit",
value: function (t) {
(this.pX = t.deltaX), (this.pY = t.deltaY);
var e = K(t.direction);
e && (t.additionalEvent = this.options.event + e),
J(rt(a.prototype), "emit", this).call(this, t);
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(N);
function ot(t) {
return (ot =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function at(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function st() {
return (st =
"undefined" != typeof Reflect && Reflect.get
? Reflect.get
: function (t, e, n) {
var r = ct(t, e);
if (r) {
var i = Object.getOwnPropertyDescriptor(r, e);
return i.get
? i.get.call(arguments.length < 3 ? t : n)
: i.value;
}
}).apply(this, arguments);
}
function ct(t, e) {
for (
;
!Object.prototype.hasOwnProperty.call(t, e) &&
null !== (t = lt(t));
);
return t;
}
function ut(t, e) {
return (ut =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function ht(t, e) {
if (e && ("object" === ot(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function lt(t) {
return (lt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
it.prototype.defaults = {
event: "pan",
threshold: 10,
pointers: 1,
direction: 30,
};
var ft = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && ut(t, e);
})(s, t);
var e,
n,
r,
i,
a =
((r = s),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = lt(r);
if (i) {
var n = lt(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return ht(this, t);
});
function s() {
return at(this, s), a.apply(this, arguments);
}
return (
(e = s),
(n = [
{
key: "getTouchAction",
value: function () {
return it.prototype.getTouchAction.call(this);
},
},
{
key: "attrTest",
value: function (t) {
var e,
n = this.options.direction;
return (
30 & n
? (e = t.overallVelocity)
: 6 & n
? (e = t.overallVelocityX)
: 24 & n && (e = t.overallVelocityY),
st(lt(s.prototype), "attrTest", this).call(this, t) &&
n & t.offsetDirection &&
t.distance > this.options.threshold &&
t.maxPointers === this.options.pointers &&
o(e) > this.options.velocity &&
4 & t.eventType
);
},
},
{
key: "emit",
value: function (t) {
var e = K(t.offsetDirection);
e && this.manager.emit(this.options.event + e, t),
this.manager.emit(this.options.event, t);
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
s
);
})(N);
function dt(t, e) {
return function () {
return t.apply(e, arguments);
};
}
function pt(t, e, n) {
return setTimeout(dt(t, n), e);
}
function gt(t, e, n) {
n || (n = g);
var r = e[n[0]] - t[n[0]],
i = e[n[1]] - t[n[1]];
return Math.sqrt(r * r + i * i);
}
function vt(t) {
return (vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function yt(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function mt(t, e) {
return (mt =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function bt(t, e) {
if (e && ("object" === vt(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function xt(t) {
return (xt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
ft.prototype.defaults = {
event: "swipe",
threshold: 10,
velocity: 0.3,
direction: 30,
pointers: 1,
};
var wt = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && mt(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = xt(r);
if (i) {
var n = xt(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return bt(this, t);
});
function a() {
var t;
return (
yt(this, a),
((t = o.apply(this, arguments)).pTime = !1),
(t.pCenter = !1),
(t._timer = null),
(t._input = null),
(t.count = 0),
t
);
}
return (
(e = a),
(n = [
{
key: "getTouchAction",
value: function () {
return [u];
},
},
{
key: "process",
value: function (t) {
var e = this,
n = this.options,
r = t.pointers.length === n.pointers,
i = t.distance < n.threshold,
o = t.deltaTime < n.time;
if ((this.reset(), 1 & t.eventType && 0 === this.count))
return this.failTimeout();
if (i && o && r) {
if (4 !== t.eventType) return this.failTimeout();
var a =
!this.pTime || t.timeStamp - this.pTime < n.interval,
s =
!this.pCenter ||
gt(this.pCenter, t.center) < n.posThreshold;
if (
((this.pTime = t.timeStamp),
(this.pCenter = t.center),
s && a ? (this.count += 1) : (this.count = 1),
(this._input = t),
0 == this.count % n.taps)
)
return this.hasRequireFailures()
? ((this._timer = pt(
function () {
(e.state = 8), e.tryEmit();
},
n.interval,
this,
)),
2)
: 8;
}
return y;
},
},
{
key: "failTimeout",
value: function () {
var t = this;
return (
(this._timer = pt(
function () {
t.state = y;
},
this.options.interval,
this,
)),
y
);
},
},
{
key: "reset",
value: function () {
clearTimeout(this._timer), (this._timer = null);
},
},
{
key: "emit",
value: function () {
8 === this.state &&
((this._input.tapCount = this.count),
this.manager.emit(this.options.event, this._input));
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(E);
function St(t) {
return (St =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function Ot(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function Mt(t, e) {
return (Mt =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function kt(t, e) {
if (e && ("object" === St(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Ct(t) {
return (Ct = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
wt.prototype.defaults = {
event: "tap",
pointers: 1,
taps: 1,
interval: 300,
time: 250,
threshold: 9,
posThreshold: 10,
};
var Et = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && Mt(t, e);
})(s, t);
var e,
n,
r,
i,
o =
((r = s),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = Ct(r);
if (i) {
var n = Ct(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return kt(this, t);
});
function s() {
var t;
return (
Ot(this, s),
((t = o.apply(this, arguments))._timer = null),
(t._input = null),
t
);
}
return (
(e = s),
(n = [
{
key: "getTouchAction",
value: function () {
return [c];
},
},
{
key: "process",
value: function (t) {
var e = this,
n = this.options,
r = t.pointers.length === n.pointers,
i = t.distance < n.threshold,
o = t.deltaTime > n.time;
if (
((this._input = t), !i || !r || (12 & t.eventType && !o))
)
this.reset();
else if (1 & t.eventType)
this.reset(),
(this._timer = pt(
function () {
(e.state = 8), e.tryEmit();
},
n.time,
this,
));
else if (4 & t.eventType) return 8;
return y;
},
},
{
key: "reset",
value: function () {
clearTimeout(this._timer), (this._timer = null);
},
},
{
key: "emit",
value: function (t) {
8 === this.state &&
(t && 4 & t.eventType
? this.manager.emit(
"".concat(this.options.event, "up"),
t,
)
: ((this._input.timeStamp = a()),
this.manager.emit(this.options.event, this._input)));
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
s
);
})(E);
function jt(t, e) {
return t.indexOf(e) > -1;
}
Et.prototype.defaults = {
event: "press",
pointers: 1,
time: 251,
threshold: 9,
};
var Pt = (function () {
function t(e, n) {
!(function (t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
})(this, t),
(this.manager = e),
this.set(n);
}
var e, n;
return (
(e = t),
(n = [
{
key: "set",
value: function (t) {
t === s && (t = this.compute()),
(this.actions = t.toLowerCase().trim());
},
},
{
key: "update",
value: function () {
this.set(this.manager.options.touchAction);
},
},
{
key: "compute",
value: function () {
var t = [];
return (
x(this.manager.recognizers, function (e) {
M(e.options.enable, [e]) &&
(t = t.concat(e.getTouchAction()));
}),
(function (t) {
if (jt(t, h)) return h;
var e = jt(t, l),
n = jt(t, f);
return e && n
? h
: e || n
? e
? l
: f
: jt(t, u)
? u
: c;
})(t.join(" "))
);
},
},
{
key: "preventDefaults",
value: function (t) {
var e = t.srcEvent,
n = t.offsetDirection;
if (this.manager.session.prevented) e.preventDefault();
else {
var r = this.actions,
i = jt(r, h) && !d.none,
o = jt(r, f) && !d["pan-y"],
a = jt(r, l) && !d["pan-x"];
if (i) {
var s = 1 === t.pointers.length,
c = t.distance < 2,
u = t.deltaTime < 250;
if (s && c && u) return;
}
if (!a || !o)
return i || (o && 6 & n) || (a && 24 & n)
? this.preventSrc(e)
: void 0;
}
},
},
{
key: "preventSrc",
value: function (t) {
(this.manager.session.prevented = !0), t.preventDefault();
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
t
);
})();
function At(t) {
var e = t.length;
if (1 === e) return { x: i(t[0].clientX), y: i(t[0].clientY) };
for (var n = 0, r = 0, o = 0; o < e; )
(n += t[o].clientX), (r += t[o].clientY), o++;
return { x: i(n / e), y: i(r / e) };
}
function It(t) {
for (var e = [], n = 0; n < t.pointers.length; )
(e[n] = {
clientX: i(t.pointers[n].clientX),
clientY: i(t.pointers[n].clientY),
}),
n++;
return {
timeStamp: a(),
pointers: e,
center: At(e),
deltaX: t.deltaX,
deltaY: t.deltaY,
};
}
function Tt(t, e, n) {
n || (n = g);
var r = e[n[0]] - t[n[0]],
i = e[n[1]] - t[n[1]];
return (180 * Math.atan2(i, r)) / Math.PI;
}
function Nt(t, e) {
return t === e
? 1
: o(t) >= o(e)
? t < 0
? 2
: 4
: e < 0
? 8
: 16;
}
function Bt(t, e, n) {
return { x: e / t || 0, y: n / t || 0 };
}
function Lt(t, e, n) {
var r = n.pointers.length,
i = n.changedPointers.length,
s = 1 & e && r - i == 0,
c = 12 & e && r - i == 0;
(n.isFirst = !!s),
(n.isFinal = !!c),
s && (t.session = {}),
(n.eventType = e),
(function (t, e) {
var n = t.session,
r = e.pointers,
i = r.length;
n.firstInput || (n.firstInput = It(e)),
i > 1 && !n.firstMultiple
? (n.firstMultiple = It(e))
: 1 === i && (n.firstMultiple = !1);
var s = n.firstInput,
c = n.firstMultiple,
u = c ? c.center : s.center,
h = (e.center = At(r));
(e.timeStamp = a()),
(e.deltaTime = e.timeStamp - s.timeStamp),
(e.angle = Tt(u, h)),
(e.distance = gt(u, h)),
(function (t, e) {
var n = e.center,
r = t.offsetDelta || {},
i = t.prevDelta || {},
o = t.prevInput || {};
(1 !== e.eventType && 4 !== o.eventType) ||
((i = t.prevDelta =
{ x: o.deltaX || 0, y: o.deltaY || 0 }),
(r = t.offsetDelta = { x: n.x, y: n.y })),
(e.deltaX = i.x + (n.x - r.x)),
(e.deltaY = i.y + (n.y - r.y));
})(n, e),
(e.offsetDirection = Nt(e.deltaX, e.deltaY));
var l,
f,
d = Bt(e.deltaTime, e.deltaX, e.deltaY);
(e.overallVelocityX = d.x),
(e.overallVelocityY = d.y),
(e.overallVelocity = o(d.x) > o(d.y) ? d.x : d.y),
(e.scale = c
? ((l = c.pointers),
gt((f = r)[0], f[1], v) / gt(l[0], l[1], v))
: 1),
(e.rotation = c
? (function (t, e) {
return Tt(e[1], e[0], v) + Tt(t[1], t[0], v);
})(c.pointers, r)
: 0),
(e.maxPointers = n.prevInput
? e.pointers.length > n.prevInput.maxPointers
? e.pointers.length
: n.prevInput.maxPointers
: e.pointers.length),
(function (t, e) {
var n,
r,
i,
a,
s = t.lastInterval || e,
c = e.timeStamp - s.timeStamp;
if (
8 !== e.eventType &&
(c > 25 || void 0 === s.velocity)
) {
var u = e.deltaX - s.deltaX,
h = e.deltaY - s.deltaY,
l = Bt(c, u, h);
(r = l.x),
(i = l.y),
(n = o(l.x) > o(l.y) ? l.x : l.y),
(a = Nt(u, h)),
(t.lastInterval = e);
} else
(n = s.velocity),
(r = s.velocityX),
(i = s.velocityY),
(a = s.direction);
(e.velocity = n),
(e.velocityX = r),
(e.velocityY = i),
(e.direction = a);
})(n, e);
})(t, n),
t.emit("hammer.input", n),
t.recognize(n),
(t.session.prevInput = n);
}
function Dt(t) {
return t.trim().split(/\s+/g);
}
function _t(t, e, n) {
x(Dt(e), function (e) {
t.addEventListener(e, n, !1);
});
}
var Rt = (function () {
function t(e, n) {
!(function (t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
})(this, t);
var r = this;
(this.manager = e),
(this.callback = n),
(this.eventHandler = function (t) {
M(e.options.enable, [e]) && r.handler(t);
}),
this.init();
}
var e, n;
return (
(e = t),
(n = [
{ key: "handler", value: function () {} },
{
key: "init",
value: function () {
var t, e, n;
(t = this.manager),
(e = this.events || ""),
(n = this.eventHandler),
x(Dt(e), function (e) {
t.on("origin_input:".concat(e), n);
});
},
},
{
key: "destroy",
value: function () {
removeManagerListeners(
this.manager,
this.events || "",
this.eventHandler,
);
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
t
);
})();
function Ft(t) {
return Array.prototype.slice.call(t, 0);
}
function Yt(t, e, n) {
for (var r = [], i = [], o = 0; o < t.length; ) {
var a = e ? t[o][e] : t[o];
S(i, a) < 0 && r.push(t[o]), (i[o] = a), o++;
}
return (
n &&
(r = e
? r.sort(function (t, n) {
return t[e] > n[e];
})
: r.sort()),
r
);
}
function Xt(t) {
return (Xt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function zt(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function Wt(t, e) {
return (Wt =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function qt(t, e) {
if (e && ("object" === Xt(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function Vt(t) {
return (Vt = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
var Gt = { touchstart: 1, touchmove: 2, touchend: 4, touchcancel: 8 },
Ht = "touchstart touchmove touchend touchcancel",
Ut = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && Wt(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = Vt(r);
if (i) {
var n = Vt(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return qt(this, t);
});
function a() {
var t;
return (
zt(this, a),
(a.prototype.evTarget = Ht),
(a.prototype.targetIds = {}),
(a.prototype.events = Ht),
((t = o.apply(this, arguments)).evTarget = Ht),
(t.targetIds = {}),
t
);
}
return (
(e = a),
(n = [
{
key: "handler",
value: function (t) {
var e = Gt[t.type],
n = Zt.call(this, t, e);
n &&
this.callback(this.manager, e, {
pointers: n[0],
changedPointers: n[1],
pointerType: p,
srcEvent: t,
});
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(Rt);
function Zt(t, e) {
var n,
r,
i = Ft(t.touches),
o = this.targetIds;
if (3 & e && 1 === i.length)
return (o[i[0].identifier] = !0), [i, i];
var a = Ft(t.changedTouches),
s = [];
if ((this.target, (r = i), 1 === e))
for (n = 0; n < r.length; ) (o[r[n].identifier] = !0), n++;
for (n = 0; n < a.length; )
o[a[n].identifier] && s.push(a[n]),
12 & e && delete o[a[n].identifier],
n++;
return s.length ? [Yt(r.concat(s), "identifier", !0), s] : void 0;
}
var Kt = (function () {
function t(e) {
var n,
r = this;
!(function (t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
})(this, t),
(this.options = m({}, Qt.defaults, e || {})),
(this.handlers = {}),
(this.filters = []),
(this.session = {}),
(this.recognizers = []),
(this.input =
((n = Ut),
this.options.inputClass && (n = inputClass),
new n(this, Lt))),
(this.touchAction = new Pt(this, this.options.touchAction)),
x(
this.options.recognizers,
function (t) {
var e = r.add(new t[0](t[1]));
t[2] && e.recognizeWith(t[2]),
t[3] && e.requireFailure(t[3]);
},
this,
);
}
var e, n;
return (
(e = t),
(n = [
{
key: "set",
value: function (t) {
return (
m(this.options, t),
t.touchAction && this.touchAction.update(),
this
);
},
},
{
key: "stop",
value: function (t) {
this.session.stopped = t ? 2 : 1;
},
},
{
key: "addFilter",
value: function (t) {
if ("function" != typeof t)
throw new Error("filter must be a function");
this.filters.push(t);
},
},
{
key: "recognize",
value: function (t) {
var e = this.session;
if (!e.stopped) {
var n;
this.touchAction.preventDefaults(t);
var r = this.recognizers,
i = e.curRecognizer;
(!i || (i && 8 & i.state)) &&
(i = e.curRecognizer = null);
for (var o = 0; o < r.length; )
(n = r[o]),
2 === e.stopped ||
(i && n !== i && !n.canRecognizeWith(i))
? n.reset()
: n.recognize(t),
!i && 14 & n.state && (i = e.curRecognizer = n),
o++;
}
},
},
{
key: "get",
value: function (t) {
if (t instanceof E) return t;
for (var e = this.recognizers, n = 0; n < e.length; n++)
if (e[n].options.event === t) return e[n];
return null;
},
},
{
key: "add",
value: function (t) {
if (w(t, "add", this)) return this;
var e = this.get(t.options.event);
return (
e && this.remove(e),
this.recognizers.push(t),
(t.manager = this),
this.touchAction.update(),
t
);
},
},
{
key: "remove",
value: function (t) {
if (w(t, "remove", this)) return this;
if ((t = this.get(t))) {
var e = this.recognizers,
n = S(e, t);
-1 !== n && (e.splice(n, 1), this.touchAction.update());
}
return this;
},
},
{
key: "on",
value: function (t, e) {
if (void 0 !== t && void 0 !== e) {
var n = this.handlers;
return (
x(Dt(t), function (t) {
(n[t] = n[t] || []), n[t].push(e);
}),
this
);
}
},
},
{
key: "off",
value: function (t, e) {
if (void 0 !== t) {
var n = this.handlers;
return (
x(Dt(t), function (t) {
e ? n[t] && n[t].splice(S(n[t], e), 1) : delete n[t];
}),
this
);
}
},
},
{
key: "emit",
value: function (t, e) {
var n = this.handlers[t] && this.handlers[t].slice();
if ((this.filters, n && n.length)) {
t.startsWith("origin_input") ||
((e.type = t),
(e.preventDefault = function () {
e.srcEvent.preventDefault &&
e.srcEvent.preventDefault();
}));
for (var r = 0; r < n.length; ) n[r](e), r++;
}
},
},
{
key: "destroy",
value: function () {
(this.handlers = {}),
(this.filters = []),
(this.session = {}),
this.input.destroy();
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
t
);
})();
function $t(t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
}
var Qt = (function (t, e, n) {
return (
e && $t(t.prototype, e),
n && $t(t, n),
Object.defineProperty(t, "prototype", { writable: !1 }),
t
);
})(function t(e) {
return (
(function (t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
})(this, t),
((e = e || {}).recognizers = n(e.recognizers, t.defaults.preset)),
new Kt(e)
);
});
function Jt(t) {
return (Jt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function te(t, e) {
if (!(t instanceof e))
throw new TypeError("Cannot call a class as a function");
}
function ee(t, e) {
return (ee =
Object.setPrototypeOf ||
function (t, e) {
return (t.__proto__ = e), t;
})(t, e);
}
function ne(t, e) {
if (e && ("object" === Jt(e) || "function" == typeof e)) return e;
if (void 0 !== e)
throw new TypeError(
"Derived constructors may only return object or undefined",
);
return (function (t) {
if (void 0 === t)
throw new ReferenceError(
"this hasn't been initialised - super() hasn't been called",
);
return t;
})(t);
}
function re(t) {
return (re = Object.setPrototypeOf
? Object.getPrototypeOf
: function (t) {
return t.__proto__ || Object.getPrototypeOf(t);
})(t);
}
Qt.defaults = {
domEvents: !1,
touchAction: s,
enable: !0,
inputClass: null,
preset: [
[X, { enable: !1 }],
[Z, { enable: !1 }, ["rotate"]],
[ft, { direction: 6 }],
[it, { direction: 6 }, ["swipe"]],
[wt],
[wt, { event: "doubletap", taps: 2 }, ["tap"]],
[Et],
],
};
var ie = {
pointerdown: 1,
pointermove: 2,
pointerup: 4,
pointercancel: 8,
pointerout: 8,
},
oe = { 2: p, 3: "pen", 4: "mouse", 5: "kinect" },
ae = "pointerdown",
se = "pointermove pointerup pointercancel",
ce = (function (t) {
!(function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Super expression must either be null or a function",
);
(t.prototype = Object.create(e && e.prototype, {
constructor: { value: t, writable: !0, configurable: !0 },
})),
Object.defineProperty(t, "prototype", { writable: !1 }),
e && ee(t, e);
})(a, t);
var e,
n,
r,
i,
o =
((r = a),
(i = (function () {
if ("undefined" == typeof Reflect || !Reflect.construct)
return !1;
if (Reflect.construct.sham) return !1;
if ("function" == typeof Proxy) return !0;
try {
return (
Boolean.prototype.valueOf.call(
Reflect.construct(Boolean, [], function () {}),
),
!0
);
} catch (t) {
return !1;
}
})()),
function () {
var t,
e = re(r);
if (i) {
var n = re(this).constructor;
t = Reflect.construct(e, arguments, n);
} else t = e.apply(this, arguments);
return ne(this, t);
});
function a() {
var t;
return (
te(this, a),
(a.prototype.events = "".concat(ae, " ").concat(se)),
((t = o.apply(this, arguments)).evEl = ae),
(t.evWin = se),
(t.store = t.manager.session.pointerEvents = []),
t
);
}
return (
(e = a),
(n = [
{
key: "handler",
value: function (t) {
var e = this.store,
n = !1,
r = t.type.toLowerCase().replace("ms", ""),
i = ie[r],
o = oe[t.pointerType] || t.pointerType,
a = o === p,
s = S(e, t.pointerId, "pointerId");
1 & i && (0 === t.button || a)
? s < 0 && (e.push(t), (s = e.length - 1))
: 12 & i && (n = !0),
s < 0 ||
((e[s] = t),
this.callback(this.manager, i, {
pointers: e,
changedPointers: [t],
pointerType: o,
srcEvent: t,
}),
n && e.splice(s, 1));
},
},
]) &&
(function (t, e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.enumerable = r.enumerable || !1),
(r.configurable = !0),
"value" in r && (r.writable = !0),
Object.defineProperty(t, r.key, r);
}
})(e.prototype, n),
Object.defineProperty(e, "prototype", { writable: !1 }),
a
);
})(Rt);
function ue(t, e, n) {
x(Dt(e), function (e) {
t.removeEventListener(e, n, !1);
});
}
function he(t, e, n) {
var r = "DEPRECATED METHOD: ".concat(e, "\n").concat(n, " AT \n");
return function () {
var e = new Error("get-stack-trace"),
n =
e && e.stack
? e.stack
.replace(/^[^\(]+?[\n$]/gm, "")
.replace(/^\s+at\s+/gm, "")
.replace(/^Object.\s*\(/gm, "{anonymous}()@")
: "Unknown Stack Trace",
i = console.warn;
return i && i(r, n), t.apply(this, arguments);
};
}
var le = he(
function (t, e, n) {
for (var r = Object.keys(e), i = 0; i < r.length; )
(!n || (n && void 0 === t[r[i]])) && (t[r[i]] = e[r[i]]), i++;
return t;
},
"extend",
"Use `assign`.",
),
fe = he(
function (t, e) {
return le(t, e, !0);
},
"merge",
"Use `assign`.",
),
de = m(Qt, {
INPUT_START: 1,
INPUT_MOVE: 2,
INPUT_END: 4,
INPUT_CANCEL: 8,
STATE_POSSIBLE: 1,
STATE_BEGAN: 2,
STATE_CHANGED: 4,
STATE_ENDED: 8,
STATE_RECOGNIZED: 8,
STATE_CANCELLED: 16,
STATE_FAILED: y,
DIRECTION_NONE: 1,
DIRECTION_LEFT: 2,
DIRECTION_RIGHT: 4,
DIRECTION_UP: 8,
DIRECTION_DOWN: 16,
DIRECTION_HORIZONTAL: 6,
DIRECTION_VERTICAL: 24,
DIRECTION_ALL: 30,
Manager: Kt,
Input: Rt,
TouchAction: Pt,
TouchInput: Ut,
PointerEventInput: ce,
Recognizer: E,
AttrRecognizer: N,
Tap: wt,
Pan: it,
Swipe: ft,
Pinch: Z,
Rotate: X,
Press: Et,
on: _t,
off: ue,
each: x,
merge: fe,
extend: le,
assign: m,
inherit: function (t, e, n) {
var r,
i = e.prototype;
((r = t.prototype = Object.create(i)).constructor = t),
(r._super = i),
n && m(r, n);
},
bindFn: dt,
toArray: Ft,
inArray: S,
uniqueArray: Yt,
splitStr: Dt,
boolOrFn: M,
hasParent: function (t, e) {
for (; t; ) {
if (t === e) return !0;
t = t.parentNode;
}
return !1;
},
addEventListeners: _t,
removeEventListeners: ue,
});
return e;
})());
},
32: function (t, e, n) {
"use strict";
var r = {};
n.r(r),
n.d(r, "proccessToFunc", function () {
return u;
}),
n.d(r, "buildTextureData", function () {
return h;
}),
n.d(r, "buildTextureDataWithOneEdgeAttr", function () {
return l;
}),
n.d(r, "buildTextureDataWithTwoEdgeAttr", function () {
return f;
}),
n.d(r, "attributesToTextureData", function () {
return d;
}),
n.d(r, "arrayToTextureData", function () {
return p;
}),
n.d(r, "radialLayout", function () {
return g;
});
var i = n(1),
o = n(75),
a = n(2),
s = n(0),
c = a.h.traverseTree,
u = function (t, e) {
return t
? Object(s.isNumber)(t)
? function (e) {
return t;
}
: t
: function (t) {
return e || 1;
};
},
h = function (t, e) {
var n = [],
r = [],
i = {},
o = 0;
for (o = 0; o < t.length; o++) {
var a = t[o];
(i[a.id] = o),
n.push(a.x),
n.push(a.y),
n.push(0),
n.push(0),
r.push([]);
}
for (o = 0; o < e.length; o++) {
var s = e[o];
r[i[s.source]].push(i[s.target]), r[i[s.target]].push(i[s.source]);
}
var c = 0;
for (o = 0; o < t.length; o++) {
var u = n.length,
h = r[o],
l = h.length;
(n[4 * o + 2] = u),
(n[4 * o + 3] = h.length),
(c = Math.max(c, h.length));
for (var f = 0; f < l; ++f) {
var d = h[f];
n.push(+d);
}
}
for (; n.length % 4 != 0; ) n.push(0);
return { array: new Float32Array(n), maxEdgePerVetex: c };
},
l = function (t, e, n) {
var r = [],
i = [],
o = {},
a = 0;
for (a = 0; a < t.length; a++) {
var s = t[a];
(o[s.id] = a),
r.push(s.x),
r.push(s.y),
r.push(0),
r.push(0),
i.push([]);
}
for (a = 0; a < e.length; a++) {
var c = e[a];
i[o[c.source]].push(o[c.target]),
i[o[c.source]].push(n(c)),
i[o[c.target]].push(o[c.source]),
i[o[c.target]].push(n(c));
}
var u = 0;
for (a = 0; a < t.length; a++) {
var h = r.length,
l = i[a],
f = l.length;
(r[4 * a + 2] = h),
(r[4 * a + 3] = f / 2),
(u = Math.max(u, f / 2));
for (var d = 0; d < f; ++d) {
var p = l[d];
r.push(+p);
}
}
for (; r.length % 4 != 0; ) r.push(0);
return { array: new Float32Array(r), maxEdgePerVetex: u };
},
f = function (t, e, n, r) {
var i = [],
o = [],
a = {},
s = 0;
for (s = 0; s < t.length; s++) {
var c = t[s];
(a[c.id] = s),
i.push(c.x),
i.push(c.y),
i.push(0),
i.push(0),
o.push([]);
}
for (s = 0; s < e.length; s++) {
var u = e[s];
o[a[u.source]].push(a[u.target]),
o[a[u.source]].push(n(u)),
o[a[u.source]].push(r(u)),
o[a[u.source]].push(0),
o[a[u.target]].push(a[u.source]),
o[a[u.target]].push(n(u)),
o[a[u.target]].push(r(u)),
o[a[u.target]].push(0);
}
var h = 0;
for (s = 0; s < t.length; s++) {
var l = i.length,
f = o[s],
d = f.length;
(i[4 * s + 2] = l + (1048576 * d) / 4),
(i[4 * s + 3] = 0),
(h = Math.max(h, d / 4));
for (var p = 0; p < d; ++p) {
var g = f[p];
i.push(+g);
}
}
for (; i.length % 4 != 0; ) i.push(0);
return { array: new Float32Array(i), maxEdgePerVetex: h };
},
d = function (t, e) {
var n = [],
r = t.length,
i = {};
return (
e.forEach(function (e) {
t.forEach(function (t, o) {
if (
(void 0 === i[e[t]] && (i[e[t]] = Object.keys(i).length),
n.push(i[e[t]]),
o === r - 1)
)
for (; n.length % 4 != 0; ) n.push(0);
});
}),
{ array: new Float32Array(n), count: Object.keys(i).length }
);
},
p = function (t) {
for (
var e = [],
n = t.length,
r = t[0].length,
i = function (r) {
t.forEach(function (t, i) {
if ((e.push(t[r]), i === n - 1))
for (; e.length % 4 != 0; ) e.push(0);
});
},
o = 0;
o < r;
o++
)
i(o);
return new Float32Array(e);
},
g = function (t, e) {
var n = { x: 1 / 0, y: 1 / 0 },
r = { x: -1 / 0, y: -1 / 0 },
i = "x",
o = "y";
e && ["V", "TB", "BT"].indexOf(e) >= 0 && ((o = "x"), (i = "y"));
var a = 0;
c(t, function (t) {
return (
a++,
t.x > r.x && (r.x = t.x),
t.x < n.x && (n.x = t.x),
t.y > r.y && (r.y = t.y),
t.y < n.y && (n.y = t.y),
!0
);
});
var s = (2 * Math.PI) / a,
u = r[o] - n[o];
return (
0 === u ||
c(t, function (e) {
var r = ((e[o] - n[o]) / u) * (2 * Math.PI - s) + s,
a = Math.abs("x" === i ? e.x - t.x : e.y - t.y);
return (e.x = a * Math.cos(r)), (e.y = a * Math.sin(r)), !0;
}),
t
);
},
v = Object(i.a)(Object(i.a)(Object(i.a)({}, a.h), o), r);
e.a = v;
},
395: function (t, e, n) {
"use strict";
var r = function () {
return (r =
Object.assign ||
function (t) {
for (var e, n = 1, r = arguments.length; n < r; n++)
for (var i in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
return t;
}).apply(this, arguments);
};
function i(t, e) {
var n = {};
for (var r in t)
Object.prototype.hasOwnProperty.call(t, r) &&
e.indexOf(r) < 0 &&
(n[r] = t[r]);
if (null != t && "function" == typeof Object.getOwnPropertySymbols) {
var i = 0;
for (r = Object.getOwnPropertySymbols(t); i < r.length; i++)
e.indexOf(r[i]) < 0 &&
Object.prototype.propertyIsEnumerable.call(t, r[i]) &&
(n[r[i]] = t[r[i]]);
}
return n;
}
var o = n(2),
a = n(0);
Object(o.l)(
"circle",
{
options: {
size: o.e.defaultNode.size,
style: {
x: 0,
y: 0,
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "circle",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getOptions(t).icon,
i = void 0 === n ? {} : n,
o = this.getShapeStyle(t),
s = Object(a.deepMix)({}, i, t.icon),
c = e.addShape("circle", {
attrs: o,
className: "".concat(this.type, "-keyShape"),
draggable: !0,
}),
u = s.width,
h = s.height,
l = s.show,
f = s.text;
return (
l &&
(f
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
s,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})
: e.addShape("image", {
attrs: r({ x: -u / 2, y: -h / 2 }, s),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})),
this.drawLinkPoints(t, e),
c
);
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.bottom,
h = o.size,
l = o.r,
f = i(o, ["top", "left", "right", "bottom", "size", "r"]),
d = this.getSize(t)[0] / 2;
s &&
e.addShape("circle", {
attrs: r(r({}, f), { x: -d, y: 0, r: h / 2 || l || 5 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
c &&
e.addShape("circle", {
attrs: r(r({}, f), { x: d, y: 0, r: h / 2 || l || 5 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: -d, r: h / 2 || l || 5 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
u &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: d, r: h / 2 || l || 5 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.deepMix)({}, e, n),
o = this.getSize(t)[0] / 2;
return r({ x: 0, y: 0, r: o }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getSize(t),
i = { stroke: t.color, r: r[0] / 2 },
o = e.get("keyShape"),
s = Object(a.deepMix)({}, o.attr(), i, t.style);
this.updateShape(t, e, s, !0), this.updateLinkPoints(t, n);
},
},
"single-node",
),
Object(o.l)(
"rect",
{
options: {
size: [100, 30],
style: {
radius: 0,
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "rect",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t),
r = e.addShape("rect", {
attrs: n,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
});
return this.drawLinkPoints(t, e), r;
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.bottom,
h = o.size,
l = o.r,
f = i(o, ["top", "left", "right", "bottom", "size", "r"]),
d = this.getSize(t),
p = d[0],
g = d[1];
s &&
e.addShape("circle", {
attrs: r(r({}, f), { x: -p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
c &&
e.addShape("circle", {
attrs: r(r({}, f), { x: p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: -g / 2, r: h / 2 || l || 5 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
u &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: g / 2, r: h / 2 || l || 5 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getSize(t),
s = i.width || o[0],
c = i.height || o[1];
return r({ x: -s / 2, y: -c / 2, width: s, height: c }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).style,
i = this.getSize(t),
o = e.get("keyShape");
t.size ||
((i[0] = o.attr("width") || r.width),
(i[1] = o.attr("height") || r.height));
var s = {
stroke: t.color,
x: -i[0] / 2,
y: -i[1] / 2,
width: i[0],
height: i[1],
},
c = Object(a.mix)({}, r, o.attr(), s);
(c = Object(a.mix)(c, t.style)),
this.updateShape(t, e, c, !1),
this.updateLinkPoints(t, n);
},
},
"single-node",
),
Object(o.l)(
"ellipse",
{
options: {
size: [80, 40],
style: {
x: 0,
y: 0,
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "ellipse",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getOptions(t).icon,
i = void 0 === n ? {} : n,
o = this.getShapeStyle(t),
a = e.addShape("ellipse", {
attrs: o,
className: "ellipse-keyShape",
name: "ellipse-keyShape",
draggable: !0,
}),
s = i.width,
c = i.height,
u = i.show,
h = i.text;
return (
u &&
(h
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
i,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})
: e.addShape("image", {
attrs: r({ x: -s / 2, y: -c / 2 }, i),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})),
this.drawLinkPoints(t, e),
a
);
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.bottom,
h = o.size,
l = o.r,
f = i(o, ["top", "left", "right", "bottom", "size", "r"]),
d = this.getSize(t),
p = d[0] / 2,
g = d[1] / 2;
s &&
e.addShape("circle", {
attrs: r(r({}, f), { x: -p, y: 0, r: h / 2 || l || 5 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
c &&
e.addShape("circle", {
attrs: r(r({}, f), { x: p, y: 0, r: h / 2 || l || 5 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: -g, r: h / 2 || l || 5 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
u &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: g, r: h / 2 || l || 5 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getSize(t),
s = o[0] / 2,
c = o[1] / 2;
return r({ x: 0, y: 0, rx: s, ry: c }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).style,
i = this.getSize(t),
o = { stroke: t.color, rx: i[0] / 2, ry: i[1] / 2 },
s = e.get("keyShape"),
c = Object(a.mix)({}, r, s.attr(), o);
(c = Object(a.mix)(c, t.style)),
this.updateShape(t, e, c, !0),
this.updateLinkPoints(t, n);
},
},
"single-node",
),
Object(o.l)(
"diamond",
{
options: {
size: [80, 80],
style: {
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "diamond",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getOptions(t).icon,
i = void 0 === n ? {} : n,
o = this.getShapeStyle(t),
a = e.addShape("path", {
attrs: o,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
}),
s = i.width,
c = i.height,
u = i.show,
h = i.text;
return (
u &&
(h
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
i,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})
: e.addShape("image", {
attrs: r({ x: -s / 2, y: -c / 2 }, i),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})),
this.drawLinkPoints(t, e),
a
);
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.bottom,
h = o.size,
l = o.r,
f = i(o, ["top", "left", "right", "bottom", "size", "r"]),
d = this.getSize(t),
p = d[0],
g = d[1];
s &&
e.addShape("circle", {
attrs: r(r({}, f), { x: -p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
c &&
e.addShape("circle", {
attrs: r(r({}, f), { x: p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: -g / 2, r: h / 2 || l || 5 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
u &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: g / 2, r: h / 2 || l || 5 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
getPath: function (t) {
var e = this.getSize(t),
n = e[0],
r = e[1];
return [
["M", 0, -r / 2],
["L", n / 2, 0],
["L", 0, r / 2],
["L", -n / 2, 0],
["Z"],
];
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getPath(t);
return r({ path: o }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).style,
i = this.getPath(t),
o = { stroke: t.color, path: i },
s = e.get("keyShape"),
c = Object(a.mix)({}, r, s.attr(), o);
(c = Object(a.mix)(c, t.style)),
this.updateShape(t, e, c, !0),
this.updateLinkPoints(t, n);
},
},
"single-node",
),
Object(o.l)(
"triangle",
{
options: {
size: 40,
direction: "up",
style: {
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
offset: 15,
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
offset: 6,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "triangle",
labelPosition: "bottom",
drawShape: function (t, e) {
var n = this.getOptions(t),
i = n.icon,
o = void 0 === i ? {} : i,
a = n.direction,
s = this.getShapeStyle(t),
c = t.direction || a,
u = e.addShape("path", {
attrs: s,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
}),
h = o.width,
l = o.height,
f = o.show,
d = o.offset,
p = o.text;
if (f)
if (p)
e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
o,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
});
else {
var g = -h / 2,
v = -l / 2;
("up" !== c && "down" !== c) || (v += d),
("left" !== c && "right" !== c) || (g += d),
e.addShape("image", {
attrs: r({ x: g, y: v }, o),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
});
}
return this.drawLinkPoints(t, e), u;
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t),
o = n.linkPoints,
a = void 0 === o ? {} : o,
s = n.direction,
c = t.direction || s,
u = a.top,
h = a.left,
l = a.right,
f = a.bottom,
d = a.size,
p = a.r,
g = i(a, ["top", "left", "right", "bottom", "size", "r"]),
v = this.getSize(t)[0];
if (h) {
var y = null,
m = v * Math.sin((1 / 3) * Math.PI),
b = v * Math.sin((1 / 3) * Math.PI);
"up" === c
? (y = [-b, m])
: "down" === c
? (y = [-b, -m])
: "left" === c && (y = [-b, b - m]),
y &&
e.addShape("circle", {
attrs: r(r({}, g), {
x: y[0],
y: y[1],
r: d / 2 || p || 5,
}),
className: "link-point-left",
name: "link-point-left",
});
}
if (l) {
var x = null;
(m = v * Math.sin((1 / 3) * Math.PI)),
(b = v * Math.sin((1 / 3) * Math.PI));
"up" === c
? (x = [b, m])
: "down" === c
? (x = [b, -m])
: "right" === c && (x = [b, b - m]),
x &&
e.addShape("circle", {
attrs: r(r({}, g), {
x: x[0],
y: x[1],
r: d / 2 || p || 5,
}),
className: "link-point-right",
name: "link-point-right",
});
}
if (u) {
var w = null;
(m = v * Math.sin((1 / 3) * Math.PI)),
(b = v * Math.sin((1 / 3) * Math.PI));
"up" === c
? (w = [b - m, -m])
: "left" === c
? (w = [b, -m])
: "right" === c && (w = [-b, -m]),
w &&
e.addShape("circle", {
attrs: r(r({}, g), {
x: w[0],
y: w[1],
r: d / 2 || p || 5,
}),
className: "link-point-top",
name: "link-point-top",
});
}
if (f) {
var S = null;
(m = v * Math.sin((1 / 3) * Math.PI)),
(b = v * Math.sin((1 / 3) * Math.PI));
"down" === c
? (S = [-b + m, m])
: "left" === c
? (S = [b, m])
: "right" === c && (S = [-b, m]),
S &&
e.addShape("circle", {
attrs: r(r({}, g), {
x: S[0],
y: S[1],
r: d / 2 || p || 5,
}),
className: "link-point-bottom",
name: "link-point-bottom",
});
}
},
getPath: function (t) {
var e = this.getOptions(t).direction,
n = t.direction || e,
r = this.getSize(t)[0],
i = r * Math.sin((1 / 3) * Math.PI),
o = r * Math.sin((1 / 3) * Math.PI),
a = [["M", -o, i], ["L", 0, -i], ["L", o, i], ["Z"]];
return (
"down" === n
? (a = [["M", -o, -i], ["L", o, -i], ["L", 0, i], ["Z"]])
: "left" === n
? (a = [["M", -o, o - i], ["L", o, -o], ["L", o, o], ["Z"]])
: "right" === n &&
(a = [["M", o, o - i], ["L", -o, o], ["L", -o, -o], ["Z"]]),
a
);
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getPath(t);
return r({ path: o }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).style,
i = this.getPath(t),
o = { stroke: t.color, path: i },
s = e.get("keyShape"),
c = Object(a.mix)({}, r, s.attr(), o);
(c = Object(a.mix)(c, t.style)),
this.updateShape(t, e, c, !0),
this.updateLinkPoints(t, n);
},
updateLinkPoints: function (t, e) {
var n = this.getOptions({}),
i = n.linkPoints,
o = n.direction,
s = t.direction || o,
c = e.find(function (t) {
return "link-point-left" === t.get("className");
}),
u = e.find(function (t) {
return "link-point-right" === t.get("className");
}),
h = e.find(function (t) {
return "link-point-top" === t.get("className");
}),
l = e.find(function (t) {
return "link-point-bottom" === t.get("className");
}),
f = i,
d = c || u || h || l;
d && (f = d.attr());
var p = Object(a.mix)({}, f, t.linkPoints),
g = p.fill,
v = p.stroke,
y = p.lineWidth,
m = p.size / 2;
m || (m = p.r);
var b = t.linkPoints
? t.linkPoints
: {
left: void 0,
right: void 0,
top: void 0,
bottom: void 0,
},
x = b.left,
w = b.right,
S = b.top,
O = b.bottom,
M = this.getSize(t)[0],
k = { r: m, fill: g, stroke: v, lineWidth: y },
C = null,
E = M * Math.sin((1 / 3) * Math.PI),
j = M * Math.sin((1 / 3) * Math.PI);
"up" === s
? (C = [-j, E])
: "down" === s
? (C = [-j, -E])
: "left" === s && (C = [-j, j - E]),
C &&
(c
? x || void 0 === x
? c.attr(r(r({}, k), { x: C[0], y: C[1] }))
: c.remove()
: x &&
e.addShape("circle", {
attrs: r(r({}, k), { x: C[0], y: C[1] }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}));
var P = null;
"up" === s
? (P = [j, E])
: "down" === s
? (P = [j, -E])
: "right" === s && (P = [j, j - E]),
P &&
(u
? w || void 0 === w
? u.attr(r(r({}, k), { x: P[0], y: P[1] }))
: u.remove()
: w &&
e.addShape("circle", {
attrs: r(r({}, k), { x: P[0], y: P[1] }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}));
var A = null;
"up" === s
? (A = [j - E, -E])
: "left" === s
? (A = [j, -E])
: "right" === s && (A = [-j, -E]),
A &&
(h
? S || void 0 === S
? h.attr(r(r({}, k), { x: A[0], y: A[1] }))
: h.remove()
: S &&
e.addShape("circle", {
attrs: r(r({}, k), { x: A[0], y: A[1] }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}));
var I = null;
"down" === s
? (I = [-j + E, E])
: "left" === s
? (I = [j, E])
: "right" === s && (I = [-j, E]),
I &&
(l
? O || void 0 === O
? l.attr(r(r({}, k), { x: I[0], y: I[1] }))
: l.remove()
: O &&
e.addShape("circle", {
attrs: r(r({}, k), { x: I[0], y: I[1] }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
}));
},
},
"single-node",
),
Object(o.l)(
"modelRect",
{
options: {
size: [185, 70],
style: {
radius: 5,
stroke: "#69c0ff",
fill: "#ffffff",
lineWidth: o.e.defaultNode.style.lineWidth,
fillOpacity: 1,
},
labelCfg: {
style: { fill: "#595959", fontSize: 14 },
offset: 30,
},
descriptionCfg: {
style: { fontSize: 12, fill: "#bfbfbf" },
paddingTop: 0,
},
preRect: { show: !0, width: 4, fill: "#40a9ff", radius: 2 },
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: 10,
lineWidth: 1,
fill: "#72CC4A",
stroke: "#72CC4A",
},
logoIcon: {
show: !0,
x: 0,
y: 0,
img: "https://gw.alipayobjects.com/zos/basement_prod/4f81893c-1806-4de4-aff3-9a6b266bc8a2.svg",
width: 16,
height: 16,
offset: 0,
},
stateIcon: {
show: !0,
x: 0,
y: 0,
img: "https://gw.alipayobjects.com/zos/basement_prod/300a2523-67e0-4cbf-9d4a-67c077b40395.svg",
width: 16,
height: 16,
offset: -5,
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
},
shapeType: "modelRect",
drawShape: function (t, e) {
var n = this.getOptions(t).preRect,
o = void 0 === n ? {} : n,
a = this.getShapeStyle(t),
s = this.getSize(t),
c = s[0],
u = s[1],
h = e.addShape("rect", {
attrs: a,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
}),
l = o.show,
f = i(o, ["show"]);
return (
l &&
e.addShape("rect", {
attrs: r({ x: -c / 2, y: -u / 2, height: u }, f),
className: "pre-rect",
name: "pre-rect",
draggable: !0,
}),
this.drawLogoIcon(t, e),
this.drawStateIcon(t, e),
this.drawLinkPoints(t, e),
h
);
},
drawLogoIcon: function (t, e) {
var n = this.getOptions(t).logoIcon,
o = void 0 === n ? {} : n,
a = this.getSize(t)[0];
if (o.show) {
var s = o.width,
c = o.height,
u = o.x,
h = o.y,
l = o.offset,
f = o.text,
d = i(o, ["width", "height", "x", "y", "offset", "text"]);
f
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
d,
),
className: "rect-logo-icon",
name: "rect-logo-icon",
draggable: !0,
})
: e.addShape("image", {
attrs: r(r({}, d), {
x: u || -a / 2 + s + l,
y: h || -c / 2,
width: s,
height: c,
}),
className: "rect-logo-icon",
name: "rect-logo-icon",
draggable: !0,
});
}
},
drawStateIcon: function (t, e) {
var n = this.getOptions(t).stateIcon,
o = void 0 === n ? {} : n,
a = this.getSize(t)[0];
if (o.show) {
var s = o.width,
c = o.height,
u = o.x,
h = o.y,
l = o.offset,
f = o.text,
d = i(o, ["width", "height", "x", "y", "offset", "text"]);
f
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
d,
),
className: "rect-state-icon",
name: "rect-state-icon",
draggable: !0,
})
: e.addShape("image", {
attrs: r(r({}, d), {
x: u || a / 2 - s + l,
y: h || -c / 2,
width: s,
height: c,
}),
className: "rect-state-icon",
name: "rect-state-icon",
draggable: !0,
});
}
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.bottom,
h = o.size,
l = o.r,
f = i(o, ["top", "left", "right", "bottom", "size", "r"]),
d = this.getSize(t),
p = d[0],
g = d[1];
s &&
e.addShape("circle", {
attrs: r(r({}, f), { x: -p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
c &&
e.addShape("circle", {
attrs: r(r({}, f), { x: p / 2, y: 0, r: h / 2 || l || 5 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: -g / 2, r: h / 2 || l || 5 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
u &&
e.addShape("circle", {
attrs: r(r({}, f), { x: 0, y: g / 2, r: h / 2 || l || 5 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
drawLabel: function (t, e) {
var n = this.getOptions(t),
i = n.labelCfg,
o = void 0 === i ? {} : i,
s = n.logoIcon,
c = void 0 === s ? {} : s,
u = n.descriptionCfg,
h = void 0 === u ? {} : u,
l = this.getSize(t)[0],
f = null,
d = c.show,
p = c.width,
g = -l / 2 + o.offset;
d && (g = -l / 2 + p + o.offset);
var v = o.style,
y = h.style,
m = h.paddingTop;
return (
Object(a.isString)(t.description)
? ((f = e.addShape("text", {
attrs: r(r({}, v), { x: g, y: -5, text: t.label }),
className: "text-shape",
name: "text-shape",
draggable: !0,
})),
e.addShape("text", {
attrs: r(r({}, y), {
x: g,
y: 17 + (m || 0),
text: t.description,
}),
className: "rect-description",
name: "rect-description",
draggable: !0,
}))
: (f = e.addShape("text", {
attrs: r(r({}, v), { x: g, y: 7, text: t.label }),
className: "text-shape",
name: "text-shape",
draggable: !0,
})),
f
);
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getSize(t),
s = i.width || o[0],
c = i.height || o[1];
return r({ x: -s / 2, y: -c / 2, width: s, height: c }, i);
},
update: function (t, e) {
var n = this.getOptions(t),
o = n.style,
s = void 0 === o ? {} : o,
c = n.labelCfg,
u = void 0 === c ? {} : c,
h = n.descriptionCfg,
l = void 0 === h ? {} : h,
f = this.getSize(t),
d = f[0],
p = f[1];
e.get("keyShape").attr(
r(r({}, s), { x: -d / 2, y: -p / 2, width: d, height: p }),
);
var g = e.getContainer(),
v = g.find(function (t) {
return "rect-logo-icon" === t.get("className");
}),
y = v ? v.attr() : {},
m = Object(a.mix)({}, y, t.logoIcon),
b = m.width;
void 0 === b && (b = this.options.logoIcon.width);
var x = t.logoIcon ? t.logoIcon.show : void 0,
w = u.offset,
S = -d / 2 + b + w;
x || void 0 === x || (S = -d / 2 + w);
var O = g.find(function (t) {
return "node-label" === t.get("className");
}),
M = g.find(function (t) {
return "rect-description" === t.get("className");
});
if (t.label)
if (O) {
var k = t.labelCfg ? t.labelCfg.style : {},
C = Object(a.mix)({}, O.attr(), k);
t.label && (C.text = t.label),
(C.x = S),
Object(a.isString)(t.description) && (C.y = -5),
M && (M.resetMatrix(), M.attr({ x: S })),
O.resetMatrix(),
O.attr(C);
} else
g.addShape("text", {
attrs: r(r({}, u.style), {
x: S,
y: t.description ? -5 : 7,
text: t.label,
}),
className: "node-label",
name: "node-label",
draggable: !0,
});
if (Object(a.isString)(t.description)) {
var E = l.paddingTop;
if (M) {
k = t.descriptionCfg ? t.descriptionCfg.style : {};
var j = Object(a.mix)({}, M.attr(), k);
Object(a.isString)(t.description) && (j.text = t.description),
(j.x = S),
M.resetMatrix(),
M.attr(r(r({}, j), { y: 17 + (E || 0) }));
} else
g.addShape("text", {
attrs: r(r({}, l.style), {
x: S,
y: 17 + (E || 0),
text: t.description,
}),
className: "rect-description",
name: "rect-description",
draggable: !0,
});
}
var P = g.find(function (t) {
return "pre-rect" === t.get("className");
});
if (P) {
var A = Object(a.mix)({}, P.attr(), t.preRect);
P.attr(r(r({}, A), { x: -d / 2, y: -p / 2, height: p }));
}
if (v)
if (x || void 0 === x) {
var I = m.width,
T = m.height,
N = m.x,
B = m.y,
L = m.offset,
D = i(m, ["width", "height", "x", "y", "offset"]);
v.attr(
r(r({}, D), {
x: N || -d / 2 + I + L,
y: B || -T / 2,
width: I,
height: T,
}),
);
} else v.remove();
else x && this.drawLogoIcon(t, g);
var _ = g.find(function (t) {
return "rect-state-icon" === t.get("className");
}),
R = _ ? _.attr() : {},
F = Object(a.mix)({}, R, t.stateIcon);
if (_) {
F.show || void 0 === F.show || _.remove();
var Y = F.width,
X = ((T = F.height), (N = F.x), (B = F.y), F.offset),
z = i(F, ["width", "height", "x", "y", "offset"]);
_.attr(
r(r({}, z), {
x: N || d / 2 - Y + X,
y: B || -T / 2,
width: Y,
height: T,
}),
);
} else F.show && this.drawStateIcon(t, g);
this.updateLinkPoints(t, g);
},
},
"single-node",
),
Object(o.l)(
"star",
{
options: {
size: 60,
style: {
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "star",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getOptions(t).icon,
i = void 0 === n ? {} : n,
o = this.getShapeStyle(t),
a = e.addShape("path", {
attrs: o,
className: "".concat(this.type, "-keyShape"),
name: "".concat(this.type, "-keyShape"),
draggable: !0,
}),
s = i.width,
c = i.height,
u = i.show,
h = i.text;
return (
u &&
(h
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
i,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})
: e.addShape("image", {
attrs: r({ x: -s / 2, y: -c / 2 }, i),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})),
this.drawLinkPoints(t, e),
a
);
},
drawLinkPoints: function (t, e) {
var n = this.getOptions(t).linkPoints,
o = void 0 === n ? {} : n,
a = o.top,
s = o.left,
c = o.right,
u = o.leftBottom,
h = o.rightBottom,
l = o.size,
f = o.r,
d = i(o, [
"top",
"left",
"right",
"leftBottom",
"rightBottom",
"size",
"r",
]),
p = this.getSize(t)[0];
if (c) {
var g = Math.cos(0.1 * Math.PI) * p,
v = Math.sin(0.1 * Math.PI) * p;
e.addShape("circle", {
attrs: r(r({}, d), { x: g, y: -v, r: l / 2 || f || 5 }),
className: "link-point-right",
name: "link-point-right",
});
}
if (a) {
(g = Math.cos(0.5 * Math.PI) * p),
(v = Math.sin(0.5 * Math.PI) * p);
e.addShape("circle", {
attrs: r(r({}, d), { x: g, y: -v, r: l / 2 || f || 5 }),
className: "link-point-top",
name: "link-point-top",
});
}
if (s) {
(g = Math.cos(0.9 * Math.PI) * p),
(v = Math.sin(0.9 * Math.PI) * p);
e.addShape("circle", {
attrs: r(r({}, d), { x: g, y: -v, r: l / 2 || f || 5 }),
className: "link-point-left",
name: "link-point-left",
});
}
if (u) {
(g = Math.cos(1.3 * Math.PI) * p),
(v = Math.sin(1.3 * Math.PI) * p);
e.addShape("circle", {
attrs: r(r({}, d), { x: g, y: -v, r: l / 2 || f || 5 }),
className: "link-point-left-bottom",
name: "link-point-left-bottom",
});
}
if (h) {
(g = Math.cos(1.7 * Math.PI) * p),
(v = Math.sin(1.7 * Math.PI) * p);
e.addShape("circle", {
attrs: r(r({}, d), { x: g, y: -v, r: l / 2 || f || 5 }),
className: "link-point-right-bottom",
name: "link-point-right-bottom",
});
}
},
getPath: function (t) {
for (
var e = this.getSize(t)[0],
n = (3 * e) / 8,
r = t.innerR || n,
i = [],
o = 0;
o < 5;
o++
) {
var a = Math.cos(((18 + 72 * o) / 180) * Math.PI) * e,
s = Math.sin(((18 + 72 * o) / 180) * Math.PI) * e,
c = Math.cos(((54 + 72 * o) / 180) * Math.PI) * r,
u = Math.sin(((54 + 72 * o) / 180) * Math.PI) * r;
0 === o ? i.push(["M", a, -s]) : i.push(["L", a, -s]),
i.push(["L", c, -u]);
}
return i.push(["Z"]), i;
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
i = Object(a.mix)({}, e, n),
o = this.getPath(t);
return r({ path: o }, i);
},
update: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).style,
i = this.getPath(t),
o = { stroke: t.color, path: i },
s = e.get("keyShape"),
c = Object(a.mix)({}, r, s.attr(), o);
(c = Object(a.mix)(c, t.style)),
this.updateShape(t, e, c, !0),
this.updateLinkPoints(t, n);
},
updateLinkPoints: function (t, e) {
var n = this.getOptions({}).linkPoints,
i = e.find(function (t) {
return "link-point-left" === t.get("className");
}),
o = e.find(function (t) {
return "link-point-right" === t.get("className");
}),
s = e.find(function (t) {
return "link-point-top" === t.get("className");
}),
c = e.find(function (t) {
return "link-point-left-bottom" === t.get("className");
}),
u = e.find(function (t) {
return "link-point-right-bottom" === t.get("className");
}),
h = n,
l = i || o || s || c || u;
l && (h = l.attr());
var f = Object(a.mix)({}, h, t.linkPoints),
d = f.fill,
p = f.stroke,
g = f.lineWidth,
v = f.size / 2;
v || (v = f.r);
var y = t.linkPoints
? t.linkPoints
: {
left: void 0,
right: void 0,
top: void 0,
leftBottom: void 0,
rightBottom: void 0,
},
m = y.left,
b = y.right,
x = y.top,
w = y.leftBottom,
S = y.rightBottom,
O = this.getSize(t)[0],
M = { r: v, fill: d, stroke: p, lineWidth: g },
k = Math.cos(0.1 * Math.PI) * O,
C = Math.sin(0.1 * Math.PI) * O;
o
? b || void 0 === b
? o.attr(r(r({}, M), { x: k, y: -C }))
: o.remove()
: b &&
e.addShape("circle", {
attrs: r(r({}, M), { x: k, y: -C }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
(k = Math.cos(0.5 * Math.PI) * O),
(C = Math.sin(0.5 * Math.PI) * O),
s
? x || void 0 === x
? s.attr(r(r({}, M), { x: k, y: -C }))
: s.remove()
: x &&
e.addShape("circle", {
attrs: r(r({}, M), { x: k, y: -C }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
(k = Math.cos(0.9 * Math.PI) * O),
(C = Math.sin(0.9 * Math.PI) * O),
i
? m || void 0 === m
? i.attr(r(r({}, M), { x: k, y: -C }))
: i.remove()
: m &&
e.addShape("circle", {
attrs: r(r({}, M), { x: k, y: -C }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
(k = Math.cos(1.3 * Math.PI) * O),
(C = Math.sin(1.3 * Math.PI) * O),
c
? w || void 0 === w
? c.attr(r(r({}, M), { x: k, y: -C }))
: c.remove()
: w &&
e.addShape("circle", {
attrs: r(r({}, M), { x: k, y: -C }),
className: "link-point-left-bottom",
name: "link-point-left-bottom",
isAnchorPoint: !0,
}),
(k = Math.cos(1.7 * Math.PI) * O),
(C = Math.sin(1.7 * Math.PI) * O),
u
? S || void 0 === S
? u.attr(r(r({}, M), { x: k, y: -C }))
: c.remove()
: S &&
e.addShape("circle", {
attrs: r(r({}, M), { x: k, y: -C }),
className: "link-point-right-bottom",
name: "link-point-right-bottom",
isAnchorPoint: !0,
});
},
},
"single-node",
);
var s = o.h.defaultSubjectColors;
Object(o.l)(
"donut",
{
options: {
size: o.e.defaultNode.size,
style: {
x: 0,
y: 0,
stroke: o.e.defaultNode.style.stroke,
fill: o.e.defaultNode.style.fill,
lineWidth: o.e.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: o.e.nodeLabel.style.fill,
fontSize: o.e.nodeLabel.style.fontSize,
},
},
linkPoints: {
top: !1,
right: !1,
bottom: !1,
left: !1,
size: o.e.defaultNode.linkPoints.size,
lineWidth: o.e.defaultNode.linkPoints.lineWidth,
fill: o.e.defaultNode.linkPoints.fill,
stroke: o.e.defaultNode.linkPoints.stroke,
},
icon: {
show: !1,
img: "https://gw.alipayobjects.com/zos/bmw-prod/5d015065-8505-4e7a-baec-976f81e3c41d.svg",
width: 20,
height: 20,
},
stateStyles: r({}, o.e.nodeStateStyles),
},
shapeType: "circle",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getOptions(t).icon,
i = void 0 === n ? {} : n,
o = this.getShapeStyle(t),
c = Object(a.deepMix)({}, i, t.icon),
u = e.addShape("circle", {
attrs: o,
className: "".concat(this.type, "-keyShape"),
draggable: !0,
name: "".concat(this.type, "-keyShape"),
}),
h = c.width,
l = c.height,
f = c.show,
d = c.text;
f &&
(d
? e.addShape("text", {
attrs: r(
{
x: 0,
y: 0,
fontSize: 12,
fill: "#000",
stroke: "#000",
textBaseline: "middle",
textAlign: "center",
},
c,
),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
})
: e.addShape("image", {
attrs: r({ x: -h / 2, y: -l / 2 }, c),
className: "".concat(this.type, "-icon"),
name: "".concat(this.type, "-icon"),
draggable: !0,
}));
var p = u.attr("r"),
g = 0.6 * p,
v = (p + g) / 2,
y = t,
m = y.donutAttrs,
b = void 0 === m ? {} : m,
x = y.donutColorMap,
w = void 0 === x ? {} : x,
S = Object.keys(b).length;
if (b && S > 1) {
var O = [],
M = 0;
if (
(Object.keys(b).forEach(function (t) {
var e = b[t] || 0;
Object(a.isNumber)(e) &&
(O.push({ key: t, value: e, color: w[t] }), (M += e));
}),
M)
) {
var k = p - g;
if (1 === S)
return void e.addShape("circle", {
attrs: {
r: v,
x: 0,
y: 0,
stroke: O[0].color || s[0],
lineWidth: k,
},
name: "fan-shape-0",
});
var C = [v, 0],
E = 0;
O.forEach(function (t, n) {
var r = t.value / M;
if (!(r < 0.001))
if ((r > 0.999 && (r = 1), 1 !== r)) {
(t.percent = r),
(t.angle = r * Math.PI * 2),
(t.beginAgnle = E),
(E += t.angle),
(t.endAngle = E),
(t.arcBegin = C),
(t.arcEnd = [
v * Math.cos(t.endAngle),
-v * Math.sin(t.endAngle),
]);
var i = t.angle > Math.PI ? 1 : 0,
o = [
["M", t.arcBegin[0], t.arcBegin[1]],
["A", v, v, 0, i, 0, t.arcEnd[0], t.arcEnd[1]],
["L", t.arcEnd[0], t.arcEnd[1]],
];
e.addShape("path", {
attrs: {
path: o,
lineWidth: k,
stroke: t.color || s[n % s.length],
},
name: "fan-shape-".concat(n),
}),
(C = t.arcEnd);
} else
e.addShape("circle", {
attrs: {
r: v,
x: 0,
y: 0,
stroke: t.color || s[n % s.length],
lineWidth: k,
},
name: "fan-shape-".concat(n),
});
});
}
}
return this.drawLinkPoints(t, e), u;
},
update: void 0,
},
"circle",
);
var c = function (t) {
var e = t.x,
n = t.y;
return {
x: e,
y: n,
centerX: e,
centerY: n,
minX: e,
minY: n,
maxX: e,
maxY: n,
height: 0,
width: 0,
};
},
u = function (t) {
for (var e = [], n = {}, r = t.length - 1; r >= 0; r--) {
var i = t[r];
(i.id = "".concat(i.x, "|||").concat(i.y)),
(n[i.id] = i),
e.push(i);
}
return e;
},
h = function (t) {
return u(t);
},
l = function (t, e) {
return t.width || t.height
? {
centerX: t.centerX,
centerY: t.centerY,
minX: t.minX - e,
minY: t.minY - e,
maxX: t.maxX + e,
maxY: t.maxY + e,
height: t.height + 2 * e,
width: t.width + 2 * e,
}
: t;
},
f = function (t, e, n) {
var r = (function (t, e) {
var n = Math.abs(t.x - e.centerX),
r = Math.abs(t.y - e.centerY);
return 0 === n && 0 === r ? 0 : n / e.width > r / e.height;
})(e, t);
if (0 === r) {
var i = t.centerX,
o = t.centerY;
return (
n.y < e.y
? (o = t.minY)
: n.x > e.x
? (i = t.maxX)
: n.x < e.x
? (i = t.minX)
: n.x === e.x && (o = t.maxY),
{ x: i, y: o }
);
}
return r
? { x: e.x > t.centerX ? t.maxX : t.minX, y: e.y }
: { x: e.x, y: e.y > t.centerY ? t.maxY : t.minY };
},
d = function (t, e) {
var n = Math.min(t.minX, e.minX),
r = Math.min(t.minY, e.minY),
i = Math.max(t.maxX, e.maxX),
o = Math.max(t.maxY, e.maxY);
return {
centerX: (n + i) / 2,
centerY: (r + o) / 2,
minX: n,
minY: r,
maxX: i,
maxY: o,
height: o - r,
width: i - n,
};
},
p = function (t) {
return [
{ x: t.minX, y: t.minY },
{ x: t.maxX, y: t.minY },
{ x: t.maxX, y: t.maxY },
{ x: t.minX, y: t.maxY },
];
},
g = function (t, e) {
var n = t.x,
r = t.y;
return n < e.minX || n > e.maxX || r < e.minY || r > e.maxY;
},
v = function (t, e) {
return Math.abs(t.x - e.x) + Math.abs(t.y - e.y);
},
y = function (t, e, n, r, i) {
return (
v(t, e) +
v(t, n) +
(function (t, e) {
var n = 0;
return (
e.forEach(function (e) {
e && (t.x === e.x && (n += -2), t.y === e.y && (n += -2));
}),
n
);
})(t, [e, n, r, i])
);
},
m = function t(e, n, r, i, o) {
void 0 === o && (o = 0),
e.unshift(n[i]),
r[i] && r[i] !== i && o <= 100 && t(e, n, r, r[i], o + 1);
},
b = function (t, e, n, r) {
var i = n.x - t.x,
o = n.y - t.y,
a = r.x - t.x,
s = r.y - t.y,
c = n.x - e.x,
u = n.y - e.y,
h = r.x - e.x,
l = r.y - e.y;
return (
(i * s - o * a) * (c * l - u * h) <= 0 &&
(i * u - o * c) * (a * l - s * h) <= 0
);
},
x = function (t, e, n) {
if (n.width || n.height) {
var r = p(n),
i = r[0],
o = r[1],
a = r[2],
s = r[3];
return (
b(t, e, i, o) || b(t, e, i, s) || b(t, e, o, a) || b(t, e, a, s)
);
}
return !1;
},
w = function (t, e, n, r) {
var i = [];
return (
t.forEach(function (t) {
if (t !== e && (t.x === e.x || t.y === e.y)) {
if (x(t, e, n) || x(t, e, r)) return;
i.push(t);
}
}),
u(i)
);
},
S = function (t, e) {
var n = [],
r = t[0];
return (
n.push("M".concat(r.x, " ").concat(r.y)),
t.forEach(function (r, i) {
var o = t[i + 1],
a = t[i + 2];
if (o && a)
if (
(function (t, e, n) {
return !(
(t.x === e.x && e.x === n.x) ||
(t.y === e.y && e.y === n.y)
);
})(r, o, a)
) {
var s = (function (t, e, n, r) {
var i = v(t, e),
o = v(n, e);
return (
i < r && (r = i),
o < r && (r = o),
[
{
x: e.x - (r / i) * (e.x - t.x),
y: e.y - (r / i) * (e.y - t.y),
},
{
x: e.x - (r / o) * (e.x - n.x),
y: e.y - (r / o) * (e.y - n.y),
},
]
);
})(r, o, a, e),
c = s[0],
u = s[1];
n.push("L".concat(c.x, " ").concat(c.y)),
n.push(
"Q"
.concat(o.x, " ")
.concat(o.y, " ")
.concat(u.x, " ")
.concat(u.y),
),
n.push("L".concat(u.x, " ").concat(u.y));
} else n.push("L".concat(o.x, " ").concat(o.y));
else o && n.push("L".concat(o.x, " ").concat(o.y));
}),
n.join("")
);
},
O = function (t, e, n, r, i) {
var o, a;
if (n && n.getType())
if ("combo" === n.getType()) {
((o = n.getKeyShape().getCanvasBBox() || c(t)).centerX =
(o.minX + o.maxX) / 2),
(o.centerY = (o.minY + o.maxY) / 2);
} else o = n.getBBox();
else o = c(t);
if (r && r.getType())
if ("combo" === r.getType()) {
var s = r.getKeyShape().getBBox();
if (s) {
var b = r.getModel(),
x = b.x,
S = b.y;
((a = {
x: x,
y: S,
width: s.width,
height: s.height,
minX: s.minX + x,
maxX: s.maxX + x,
minY: s.minY + S,
maxY: s.maxY + S,
}).centerX = (a.minX + a.maxX) / 2),
(a.centerY = (a.minY + a.maxY) / 2);
} else a = c(e);
} else a = r && r.getBBox();
else a = c(e);
var O = l(o, i),
M = l(a, i),
k = f(O, t, e),
C = f(M, e, t),
E = (function (t) {
void 0 === t && (t = []);
var e = [],
n = [];
t.forEach(function (t) {
e.push(t.x), n.push(t.y);
});
var r = Math.min.apply(Math, e),
i = Math.max.apply(Math, e),
o = Math.min.apply(Math, n),
a = Math.max.apply(Math, n);
return {
centerX: (r + i) / 2,
centerY: (o + a) / 2,
maxX: i,
maxY: a,
minX: r,
minY: o,
height: a - o,
width: i - r,
};
})([k, C]),
j = d(O, E),
P = d(M, E),
A = [];
A = A.concat(p(j)).concat(p(P));
var I = { x: (t.x + e.x) / 2, y: (t.y + e.y) / 2 };
[E, j, P].forEach(function (t) {
A = A.concat(
(function (t, e) {
return (function (t, e) {
return e < t.minX || e > t.maxX
? []
: [
{ x: e, y: t.minY },
{ x: e, y: t.maxY },
];
})(t, e.x).concat(
(function (t, e) {
return e < t.minY || e > t.maxY
? []
: [
{ x: t.minX, y: e },
{ x: t.maxX, y: e },
];
})(t, e.y),
);
})(t, I).filter(function (t) {
return g(t, O) && g(t, M);
}),
);
}),
[
{ x: k.x, y: C.y },
{ x: C.x, y: k.y },
].forEach(function (t) {
g(t, O) && g(t, M) && A.push(t);
}),
A.unshift(k),
A.push(C);
var T = (function (t, e, n, r, i, o, a) {
var s = [],
c = [e],
u = {},
h = {},
l = {};
(h[e.id] = 0), (l[e.id] = y(e, n, e));
var f,
d,
p,
g,
b,
x = {};
for (
t.forEach(function (t) {
x[t.id] = t;
});
c.length;
) {
if (
((f = void 0),
(d = 1 / 0),
c.forEach(function (t) {
l[t.id] <= d && ((d = l[t.id]), (f = t));
}),
f === n)
) {
var S = [];
return m(S, x, u, n.id), S;
}
(g = f),
(b = void 0),
(b = (p = c).indexOf(g)) > -1 && p.splice(b, 1),
s.push(f),
w(t, f, r, i).forEach(function (t) {
if (-1 === s.indexOf(t)) {
-1 === c.indexOf(t) && c.push(t);
var r = l[f.id] + v(f, t);
(h[t.id] && r >= h[t.id]) ||
((u[t.id] = f.id),
(h[t.id] = r),
(l[t.id] = h[t.id] + y(t, n, e, o, a)));
}
});
}
return [e, n];
})((A = u(A)), k, C, o, a, t, e);
return T.unshift(t), T.push(e), h(T);
},
M = {
offset: 20,
maxAllowedDirectionChange: Math.PI / 2,
maximumLoops: 2e3,
gridSize: 10,
directions: [
{ stepX: 1, stepY: 0 },
{ stepX: -1, stepY: 0 },
{ stepX: 0, stepY: 1 },
{ stepX: 0, stepY: -1 },
],
get penalties() {
return { 0: 0, 45: this.gridSize / 2, 90: this.gridSize / 2 };
},
distFunc: function (t, e) {
return Math.abs(t.x - e.x) + Math.abs(t.y - e.y);
},
fallbackRoute: function (t, e, n, r, i) {
return h(O(t, e, n, r, i.offset));
},
},
k =
(Math.PI,
function (t, e) {
var n = Math.round(Math.abs(t / e));
return n < 0 ? 0 : (t < 0 ? -1 : 1) * n;
}),
C = function (t, e) {
var n = e.x - t.x,
r = e.y - t.y;
return n || r ? Math.atan2(r, n) : 0;
},
E = function (t, e) {
var n = Math.abs(t - e);
return n > Math.PI ? 2 * Math.PI - n : n;
},
j = function (t, e, n) {
for (var r = 1 / 0, i = 0, o = e.length; i < o; i++) {
var a = n(t, e[i]);
a < r && (r = a);
}
return r;
},
P = function (t, e, n, r, i) {
var a = [];
if (!n) return [t];
var s = i.directions,
c = i.offset,
u = n.getBBox(),
h = e.x > u.minX && e.x < u.maxX && e.y > u.minY && e.y < u.maxY,
d = l(u, c);
for (var p in d) d[p] = k(d[p], i.gridSize);
if (h) {
for (var g = 0, v = s; g < v.length; g++) {
var y = v[g],
m = [
[
{ x: d.minX, y: d.minY },
{ x: d.maxX, y: d.minY },
],
[
{ x: d.minX, y: d.minY },
{ x: d.minX, y: d.maxY },
],
[
{ x: d.maxX, y: d.minY },
{ x: d.maxX, y: d.maxY },
],
[
{ x: d.minX, y: d.maxY },
{ x: d.maxX, y: d.maxY },
],
];
for (p = 0; p < 4; p++) {
var b = m[p],
w = o.h.getLineIntersect(
t,
{ x: t.x + y.stepX * d.width, y: t.y + y.stepY * d.height },
b[0],
b[1],
);
w &&
!x(t, w, u) &&
((w.id = "".concat(w.x, "|||").concat(w.y)), a.push(w));
}
}
return a;
}
var S = f(d, t, r);
return (S.id = "".concat(S.x, "|||").concat(S.y)), [S];
},
A = function (t, e, n, r) {
var i = C(t, e);
if (!n[t.id]) {
var o = C(r, t);
return E(o, i);
}
var a = C({ x: n[t.id].x, y: n[t.id].y }, t);
return E(a, i);
},
I = function (t, e, n, r, i, o, a) {
var s = [r],
c = t.id,
u = t.x,
h = t.y,
l = { x: u, y: h, id: c };
for (
A(l, o, e, n) &&
s.unshift({
x: o.x === r.x ? r.x : l.x * a,
y: o.y === r.y ? r.y : l.y * a,
});
e[c] && e[c].id !== c;
) {
var f = { x: u, y: h, id: c },
d = e[c].id,
p = e[c].x,
g = e[c].y,
v = { x: p, y: g, id: d };
A(v, f, e, n) &&
s.unshift({
x: v.x === f.x ? s[0].x : v.x * a,
y: v.y === f.y ? s[0].y : v.y * a,
}),
(c = d),
(u = p),
(h = g);
}
var y = u,
m = h;
return (
(s[0].x = y === n.x ? i.x : s[0].x),
(s[0].y = m === n.y ? i.y : s[0].y),
s.unshift(i),
s
);
},
T = function (t, e, n, r, i) {
if (isNaN(t.x) || isNaN(e.x)) return [];
var o = Object(a.deepMix)(M, i);
o.obstacles = o.obstacles || [];
var s = o.gridSize,
c = (function (t, e, n) {
var r = {};
return (
t.forEach(function (t) {
if (t)
for (
var i = l(t.getBBox(), n), o = k(i.minX, e);
o <= k(i.maxX, e);
o += 1
)
for (var a = k(i.minY, e); a <= k(i.maxY, e); a += 1)
r["".concat(o, "|||").concat(a)] = !0;
}),
r
);
})(o.obstacles.concat([n, r]), s, o.offset),
u = { x: k(t.x, s), y: k(t.y, s) },
h = { x: k(e.x, s), y: k(e.y, s) };
(t.id = "".concat(u.x, "|||").concat(u.y)),
(e.id = "".concat(h.x, "|||").concat(h.y));
var f = P(u, t, n, h, o),
d = P(h, e, r, u, o);
f.forEach(function (t) {
delete c[t.id];
}),
d.forEach(function (t) {
delete c[t.id];
});
for (
var p = {}, g = {}, v = {}, y = {}, m = {}, b = 0;
b < f.length;
b++
) {
var x = f[b];
(p[x.id] = x), (y[x.id] = 0), (m[x.id] = j(x, d, o.distFunc));
}
for (
var w, S, O, C, E, T, N, B = o.maximumLoops, L = o.penalties;
Object.keys(p).length > 0 &&
B > 0 &&
((w = void 0),
(S = 1 / 0),
Object.keys(p).forEach(function (t) {
var e = p[t].id;
m[e] <= S && ((S = m[e]), (w = p[e]));
}),
w);
) {
if (
d.findIndex(function (t) {
return t.x === w.x && t.y === w.y;
}) > -1
)
return I(w, v, u, e, t, h, s);
delete p[w.id], (g[w.id] = !0);
for (b = 0; b < o.directions.length; b++)
(O = o.directions[b]),
g[
(C = {
x: w.x + O.stepX,
y: w.y + O.stepY,
id: ""
.concat(Math.round(w.x) + O.stepX, "|||")
.concat(Math.round(w.y) + O.stepY),
}).id
] ||
(N = A(w, C, v, u)) > o.maxAllowedDirectionChange ||
c[C.id] ||
(p[C.id] || (p[C.id] = C),
(E = o.distFunc(w, C) + (isNaN(L[N]) ? s : L[N])),
(T = y[w.id] + E),
(y[C.id] && T >= y[C.id]) ||
((v[C.id] = w),
(y[C.id] = T),
(m[C.id] = T + j(C, d, o.distFunc))));
B -= 1;
}
return o.fallbackRoute(t, e, n, r, o);
};
Object(o.k)(
"polyline",
{
options: {
color: o.e.defaultEdge.color,
size: o.e.defaultEdge.size,
style: {
radius: 0,
offset: 15,
x: 0,
y: 0,
stroke: o.e.defaultEdge.style.stroke,
lineAppendWidth: o.e.defaultEdge.style.lineAppendWidth,
},
labelCfg: {
style: {
fill: o.e.edgeLabel.style.fill,
fontSize: o.e.edgeLabel.style.fontSize,
},
},
routeCfg: {
obstacles: [],
maxAllowedDirectionChange: Math.PI,
maximumLoops: 500,
gridSize: 10,
},
stateStyles: r({}, o.e.edgeStateStyles),
},
shapeType: "polyline",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return (
0 === n.radius && delete n.radius,
e.addShape("path", {
className: "edge-shape",
name: "edge-shape",
attrs: n,
})
);
},
getShapeStyle: function (t) {
var e = this.options.style,
n = { stroke: t.color },
r = Object(a.mix)({}, e, n, t.style);
(t = this.getPathPoints(t)),
(this.radius = r.radius),
(this.offset = r.offset);
var i = t.startPoint,
s = t.endPoint,
c = this.getControlPoints(t),
u = [i];
c && (u = u.concat(c)), u.push(s);
var h = t.sourceNode,
l = t.targetNode,
f = r.radius,
d = this.options.routeCfg,
p = Object(a.mix)({}, d, t.routeCfg);
p.offset = r.offset;
var g = this.getPath(u, h, l, f, p);
return (
((Object(a.isArray)(g) && g.length <= 1) ||
(Object(a.isString)(g) && -1 === g.indexOf("L"))) &&
(g = "M0 0, L0 0"),
(isNaN(i.x) || isNaN(i.y) || isNaN(s.x) || isNaN(s.y)) &&
(g = "M0 0, L0 0"),
Object(a.mix)({}, o.e.defaultEdge.style, r, {
lineWidth: t.size,
path: g,
})
);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer();
if (e.isVisible()) {
var r = { stroke: t.color },
i =
n.find(function (t) {
return "edge-shape" === t.get("className");
}) || e.getKeyShape(),
o = t.size,
s = (t = this.getPathPoints(t)).startPoint,
c = t.endPoint,
u = this.getControlPoints(t),
h = [s];
u && (h = h.concat(u)), h.push(c);
var l = i.attr(),
f = Object(a.mix)({}, r, l, t.style),
d = t.sourceNode,
p = t.targetNode,
g = f.radius,
v = this.options.routeCfg,
y = Object(a.mix)({}, v, t.routeCfg);
y.offset = f.offset;
var m = this.getPath(h, d, p, g, y);
((Object(a.isArray)(m) && m.length <= 1) ||
(Object(a.isString)(m) && -1 === m.indexOf("L"))) &&
(m = "M0 0, L0 0"),
(isNaN(s.x) || isNaN(s.y) || isNaN(c.x) || isNaN(c.y)) &&
(m = "M0 0, L0 0"),
l.endArrow &&
!1 === f.endArrow &&
(t.style.endArrow = { path: "" }),
l.startArrow &&
!1 === f.startArrow &&
(t.style.startArrow = { path: "" });
var b = Object(a.mix)(
r,
i.attr(),
{ lineWidth: o, path: m },
t.style,
);
i && i.attr(b);
}
},
getPath: function (t, e, n, r, i) {
var s = i.offset,
c = i.simple;
if (!s || t.length > 2) {
if (r) return S(t, r);
var u = [];
return (
Object(a.each)(t, function (t, e) {
0 === e ? u.push(["M", t.x, t.y]) : u.push(["L", t.x, t.y]);
}),
u
);
}
var h = c
? O(t[t.length - 1], t[0], n, e, s)
: T(t[0], t[t.length - 1], e, n, i);
return h && h.length
? r
? S(h, r)
: o.h.pointsToPolygon(h)
: "M0 0, L0 0";
},
},
"single-edge",
);
},
396: function (t, e, n) {
"use strict";
var r = n(1),
i = n(0),
o = n(2),
a = n(32),
s = a.a.cloneEvent,
c = a.a.isNaN,
u = Math.abs,
h = {
getDefaultCfg: function () {
return {
direction: "both",
enableOptimize: !1,
scalableRange: 0,
allowDragOnItem: !1,
};
},
getEvents: function () {
return {
dragstart: "onDragStart",
drag: "onDragMove",
dragend: "onDragEnd",
};
},
updateViewport: function (t) {
var e = this.origin,
n = +t.clientX,
r = +t.clientY;
if (!c(n) && !c(r)) {
var i = n - e.x,
o = r - e.y;
"x" === this.get("direction")
? (o = 0)
: "y" === this.get("direction") && (i = 0),
(this.origin = { x: n, y: r });
var a = this.graph.get("width"),
s = this.graph.get("height"),
u = this.graph.get("canvas").getCanvasBBox();
((u.minX <= a + this.scalableRange &&
u.minX + i > a + this.scalableRange) ||
(u.maxX + this.scalableRange >= 0 &&
u.maxX + this.scalableRange + i < 0)) &&
(i = 0),
((u.minY <= s + this.scalableRange &&
u.minY + o > s + this.scalableRange) ||
(u.maxY + this.scalableRange >= 0 &&
u.maxY + this.scalableRange + o < 0)) &&
(o = 0),
this.graph.translate(i, o);
}
},
onDragStart: function (t) {
t.originalEvent;
if (this.shouldBegin.call(this, t)) {
var e = t.target,
n = e && e.isCanvas && e.isCanvas();
if (
(this.allowDragOnItem || n) &&
((this.origin = { x: t.clientX, y: t.clientY }),
(this.dragging = !1),
this.enableOptimize)
) {
for (
var r = this.graph, i = r.getEdges(), o = 0, a = i.length;
o < a;
o++
) {
var s = i[o].get("group").get("children");
s &&
s.forEach(function (t) {
t.set(
"ori-visibility",
t.get("ori-visibility") || t.get("visible"),
),
t.hide();
});
}
for (var c = r.getNodes(), u = 0, h = c.length; u < h; u++)
for (
var l = 0, f = c[u].getContainer().get("children");
l < f.length;
l++
) {
var d = f[l];
d.get("isKeyShape") ||
(d.set(
"ori-visibility",
d.get("ori-visibility") || d.get("visible"),
),
d.hide());
}
}
}
},
onDragMove: function (t) {
this.graph;
var e = t.target,
n = e && e.isCanvas && e.isCanvas();
if ((this.allowDragOnItem || n) && ((t = s(t)), this.origin)) {
if (!this.dragging) {
if (
u(this.origin.x - t.clientX) + u(this.origin.y - t.clientY) <
10
)
return;
this.shouldBegin.call(this, t) &&
((t.type = "dragstart"), (this.dragging = !0));
}
this.shouldUpdate.call(this, t) && this.updateViewport(t);
}
},
onDragEnd: function (t) {
var e = this.graph;
if (this.enableOptimize) {
for (var n = e.getEdges(), r = 0, i = n.length; r < i; r++) {
var o = n[r].get("group").get("children");
o &&
o.forEach(function (t) {
t.get("ori-visibility") && t.show();
});
}
for (var a = e.getNodes(), c = 0, u = a.length; c < u; c++)
for (
var h = 0, l = a[c].getContainer().get("children");
h < l.length;
h++
) {
var f = l[h];
if (!f.get("isKeyShape")) f.get("ori-visibility") && f.show();
}
}
this.dragging
? ((t = s(t)),
this.shouldEnd.call(this, t) && this.updateViewport(t),
(t.type = "dragend"),
this.endDrag())
: (this.origin = null);
},
endDrag: function () {
(this.origin = null), (this.dragging = !1), (this.dragbegin = !1);
},
},
l = n(18),
f = {
getDefaultCfg: function () {
return {
updateEdge: !0,
delegateStyle: {},
enableDelegate: !1,
onlyChangeComboSize: !1,
comboActiveState: "",
selectedState: "selected",
};
},
getEvents: function () {
return {
"node:dragstart": "onDragStart",
"node:drag": "onDrag",
"node:dragend": "onDragEnd",
"combo:dragenter": "onDragEnter",
"combo:dragleave": "onDragLeave",
"combo:drop": "onDropCombo",
"node:drop": "onDropNode",
"canvas:drop": "onDropCanvas",
};
},
validationCombo: function (t) {
return (
!(!this.origin || !t || t.destroyed) && "combo" === t.getType()
);
},
onDragStart: function (t) {
var e = this;
if (this.shouldBegin.call(this, t)) {
var n = t.item;
if (n && !n.destroyed && !n.hasLocked()) {
var r = t.target;
if (r) if (r.get("isAnchorPoint")) return;
var o = this.graph;
(this.targets = []), (this.targetCombo = null);
var a = o.findAllByState("node", this.selectedState),
s = n.get("id");
0 ===
a.filter(function (t) {
var e = t.get("id");
return s === e;
}).length
? this.targets.push(n)
: a.length > 1
? a.forEach(function (t) {
t.hasLocked() || e.targets.push(t);
})
: this.targets.push(n);
var c = [];
this.targets.forEach(function (t) {
c.push(Object(i.clone)(t.getModel()));
}),
this.set("beforeDragNodes", c),
(this.origin = { x: t.x, y: t.y }),
(this.point = {}),
(this.originPoint = {});
}
}
},
onDrag: function (t) {
var e = this;
this.origin &&
this.shouldUpdate(this, t) &&
(this.get("enableDelegate")
? this.updateDelegate(t)
: this.targets.map(function (n) {
e.update(n, t);
}));
},
onDragEnd: function (t) {
if (this.origin && this.shouldEnd.call(this, t)) {
var e = t.item;
if (e) e.getContainer().set("capture", !0);
this.delegateRect &&
(this.delegateRect.remove(), (this.delegateRect = null)),
this.updatePositions(t);
var n = this.graph;
if (n.get("enabledStack")) {
var r = {
before: {
nodes: this.get("beforeDragNodes"),
edges: [],
combos: [],
},
after: { nodes: [], edges: [], combos: [] },
};
this.targets.forEach(function (t) {
r.after.nodes.push(t.getModel());
}),
n.pushStack("update", Object(i.clone)(r));
}
n.emit("dragnodeend", { items: this.targets, targetItem: null }),
(this.point = {}),
(this.origin = null),
(this.originPoint = {}),
(this.targets.length = 0),
(this.targetCombo = null);
}
},
onDropCombo: function (t) {
var e = t.item;
if (this.validationCombo(e)) {
this.updatePositions(t);
var n = this.graph;
if (
(this.comboActiveState &&
n.setItemState(e, this.comboActiveState, !1),
(this.targetCombo = e),
this.onlyChangeComboSize)
)
n.updateCombos();
else {
var r = e.getModel();
this.targets.map(function (t) {
t.getModel().comboId !== r.id && n.updateComboTree(t, r.id);
}),
n.updateCombo(e);
}
n.emit("dragnodeend", {
items: this.targets,
targetItem: this.targetCombo,
});
}
},
onDropCanvas: function (t) {
var e = this.graph;
this.targets &&
0 !== this.targets.length &&
(this.updatePositions(t),
this.onlyChangeComboSize
? e.updateCombos()
: this.targets.map(function (t) {
t.getModel().comboId && e.updateComboTree(t);
}));
},
onDropNode: function (t) {
if (this.targets && 0 !== this.targets.length) {
var e = t.item;
this.updatePositions(t);
var n = this.graph,
r = e.getModel().comboId;
if (r) {
var i = n.findById(r);
this.comboActiveState &&
n.setItemState(i, this.comboActiveState, !1),
this.targets.map(function (t) {
var e = t.getModel();
r !== e.comboId && n.updateComboTree(t, r);
}),
n.updateCombo(i);
} else
this.targets.map(function (t) {
t.getModel().comboId && n.updateComboTree(t);
});
n.emit("dragnodeend", { items: this.targets, targetItem: e });
}
},
onDragEnter: function (t) {
var e = t.item;
if (this.validationCombo(e)) {
var n = this.graph;
this.comboActiveState &&
n.setItemState(e, this.comboActiveState, !0);
}
},
onDragLeave: function (t) {
var e = t.item;
if (this.validationCombo(e)) {
var n = this.graph;
this.comboActiveState &&
n.setItemState(e, this.comboActiveState, !1);
}
},
updatePositions: function (t) {
var e = this;
this.targets &&
0 !== this.targets.length &&
this.get("enableDelegate") &&
this.targets.map(function (n) {
return e.update(n, t);
});
},
update: function (t, e) {
var n = this.origin,
r = t.get("model"),
i = t.get("id");
this.point[i] || (this.point[i] = { x: r.x || 0, y: r.y || 0 });
var o = {
x: e.x - n.x + this.point[i].x,
y: e.y - n.y + this.point[i].y,
};
this.get("updateEdge")
? this.graph.updateItem(t, o, !1)
: t.updatePosition(o);
},
updateDelegate: function (t) {
this.graph;
if (this.delegateRect) {
var e = t.x - this.origin.x + this.originPoint.minX,
n = t.y - this.origin.y + this.originPoint.minY;
this.delegateRect.attr({ x: e, y: n });
} else {
var o = this.graph.get("group"),
a = Object(i.deepMix)(
{},
l.a.delegateStyle,
this.delegateStyle,
),
s = this.calculationGroupPosition(t),
c = s.x,
u = s.y,
h = s.width,
f = s.height,
d = s.minX,
p = s.minY;
(this.originPoint = {
x: c,
y: u,
width: h,
height: f,
minX: d,
minY: p,
}),
(this.delegateRect = o.addShape("rect", {
attrs: Object(r.a)({ width: h, height: f, x: c, y: u }, a),
name: "rect-delegate-shape",
}));
}
},
calculationGroupPosition: function (t) {
var e = this.graph.findAllByState("node", this.selectedState);
0 === e.length && e.push(t.item);
for (
var n = 1 / 0, r = -1 / 0, i = 1 / 0, o = -1 / 0, a = 0;
a < e.length;
a++
) {
var s = e[a].getBBox(),
c = s.minX,
u = s.minY,
h = s.maxX,
l = s.maxY;
c < n && (n = c),
u < i && (i = u),
h > r && (r = h),
l > o && (o = l);
}
return {
x: Math.floor(n),
y: Math.floor(i),
width: Math.ceil(r) - Math.floor(n),
height: Math.ceil(o) - Math.floor(i),
minX: n,
minY: i,
};
},
},
d = {
getDefaultCfg: function () {
return { multiple: !0, selectedState: "selected" };
},
getEvents: function () {
return {
"node:tap": "onClick",
"combo:tap": "onClick",
"canvas:tap": "onCanvasClick",
};
},
onClick: function (t) {
var e = this,
n = t.item;
if (n && !n.destroyed) {
var r = n.getType(),
o = e.graph,
a = e.multiple,
s = e.shouldUpdate;
if (e.shouldBegin.call(e, t)) {
if (!a) {
var c = o.findAllByState(r, e.selectedState);
Object(i.each)(c, function (t) {
t !== n && o.setItemState(t, e.selectedState, !1);
});
}
if (n.hasState(e.selectedState)) {
s.call(e, t) && o.setItemState(n, e.selectedState, !1);
var u = o.findAllByState("node", e.selectedState),
h = o.findAllByState("combo", e.selectedState);
o.emit("nodeselectchange", {
target: n,
selectedItems: { nodes: u, combos: h },
select: !1,
});
} else {
s.call(e, t) && o.setItemState(n, e.selectedState, !0);
(u = o.findAllByState("node", e.selectedState)),
(h = o.findAllByState("combo", e.selectedState));
o.emit("nodeselectchange", {
target: n,
selectedItems: { nodes: u, combos: h },
select: !0,
});
}
}
}
},
onCanvasClick: function () {
var t = this,
e = this.graph,
n = e.findAllByState("node", this.selectedState);
Object(i.each)(n, function (n) {
e.setItemState(n, t.selectedState, !1);
});
var r = e.findAllByState("combo", this.selectedState);
Object(i.each)(r, function (n) {
e.setItemState(n, t.selectedState, !1);
}),
e.emit("nodeselectchange", {
selectedItems: { nodes: [], edges: [], combos: [] },
select: !1,
});
},
},
p = {
firstScale: null,
getDefaultCfg: function () {
return {
originScale: 1,
sensitivity: 2,
minZoom: void 0,
maxZoom: void 0,
enableOptimize: !1,
optimizeZoom: 0.1,
fixSelectedItems: {
fixAll: !1,
fixLineWidth: !1,
fixLabel: !1,
fixState: "selected",
},
};
},
getEvents: function () {
var t = this.fixSelectedItems;
return (
t.fixState || (t.fixState = "selected"),
t.fixAll && ((t.fixLineWidth = !0), (t.fixLabel = !0)),
{ pinchstart: "onPinch", pinchmove: "onPinch" }
);
},
onPinch: function (t) {
t.preventDefault && t.preventDefault(),
t.originalEvent.preventDefault &&
t.originalEvent.preventDefault();
var e = t.originalEvent.pointers;
if (!(e.length < 2)) {
"pinchstart" === t.type &&
(this.firstScale = this.graph.getZoom());
var n =
t.originalEvent.scale || t.originalEvent.srcEvent.extra.scale,
r = this.firstScale * n;
this.currentScale = r;
var i = this.get("minZoom") || this.graph.get("minZoom");
if (
!(
r > (this.get("maxZoom") || this.graph.get("maxZoom")) ||
r < i
)
) {
var o = this.graph.get("canvas"),
a = e[0].clientX,
s = e[0].clientY,
c = e[1].clientX,
u = e[1].clientY,
h = o.getPointByClient((a + c) / 2, (s + u) / 2);
this.graph.zoomTo(r, { x: h.x, y: h.y });
}
}
},
},
g = ["tap", "dbltap"],
v = {
getDefaultCfg: function () {
return { trigger: "tap", onChange: function () {} };
},
getEvents: function () {
var t, e;
return (
g.includes(this.trigger)
? (e = this.trigger)
: ((e = "tap"),
console.warn(
"Behavior collapse-expand 的 trigger 参数不合法，请输入 'click' 或 'dblclick'",
)),
((t = {})["node:" + e] = "onNodeTap"),
(t.touchstart = "onNodeTap"),
t
);
},
onNodeTap: function (t) {
var e = t.item,
n = this.graph.findDataById(e.get("id"));
if (n) {
var r = n.children;
if (r && 0 !== r.length) {
var i = !n.collapsed;
if (
this.shouldBegin(t, i) &&
((n.collapsed = i),
(e.getModel().collapsed = i),
this.graph.emit("itemcollapsed", {
item: t.item,
collapsed: i,
}),
this.shouldUpdate(t, i))
) {
try {
this.onChange(e, i);
} catch (t) {
console.warn(t);
}
this.graph.layout();
}
}
}
},
},
y = a.a.calculationItemsBBox,
m = function (t, e) {
if (!1 !== e(t) && t) {
var n = t.get("combos");
if (0 === n.length) return !1;
Object(i.each)(n, function (t) {
m(t, e);
});
}
},
b = ["click", "dblclick"],
x = ["tap", "drag"],
w = ["shift", "ctrl", "control", "alt", "meta", void 0],
S = {
bind: function (t) {
"drag-canvas" === this.type && t.get("canvas").set("draggable", !0);
var e = this.events;
(this.graph = t),
Object(i.each)(e, function (e, n) {
t.on(n, e);
});
},
unbind: function (t) {
var e = this.events;
"drag-canvas" === this.type && t.get("canvas").set("draggable", !1),
(this.graph = null),
Object(i.each)(e, function (e, n) {
t.off(n, e);
});
},
},
O = {
"drag-canvas": h,
"zoom-canvas": p,
"drag-node": f,
"activate-relations": {
getDefaultCfg: function () {
return {
activeState: "active",
inactiveState: "inactive",
resetSelected: !1,
shouldUpdate: function () {
return !0;
},
};
},
getEvents: function () {
return {
"node:tap": "setAllItemStates",
"canvas:tap": "clearAllItemStates",
};
},
setAllItemStates: function (t) {
var e = t.item,
n = this.graph;
if (
((this.item = e),
this.shouldUpdate(t.item, { event: t, action: "activate" }))
) {
for (
var r = this.activeState,
i = this.inactiveState,
o = n.getNodes(),
a = n.getEdges(),
s = o.length,
c = a.length,
u = 0;
u < s;
u++
) {
var h = o[u],
l = h.hasState("selected");
this.resetSelected && l && n.setItemState(h, "selected", !1),
n.setItemState(h, r, !1),
i && n.setItemState(h, i, !0);
}
for (u = 0; u < c; u++) {
var f = a[u];
n.setItemState(f, r, !1), i && n.setItemState(f, i, !0);
}
i && n.setItemState(e, i, !1), n.setItemState(e, r, !0);
var d = e.getEdges(),
p = d.length;
for (u = 0; u < p; u++) {
var g = void 0;
(g =
(f = d[u]).getSource() === e
? f.getTarget()
: f.getSource()),
i && n.setItemState(g, i, !1),
n.setItemState(g, r, !0),
n.setItemState(f, i, !1),
n.setItemState(f, r, !0),
f.toFront();
}
n.emit("afteractivaterelations", {
item: t.item,
action: "activate",
});
}
},
clearActiveState: function (t) {
var e = this.get("graph");
if (
this.shouldUpdate(t.item, { event: t, action: "deactivate" })
) {
var n = this.activeState,
r = this.inactiveState,
i = e.get("autoPaint");
e.setAutoPaint(!1);
for (
var o = e.getNodes(),
a = e.getEdges(),
s = o.length,
c = a.length,
u = 0;
u < s;
u++
) {
var h = o[u];
e.clearItemStates(h, [n, r]);
}
for (u = 0; u < c; u++) {
var l = a[u];
e.clearItemStates(l, [n, r, "deactivate"]);
}
e.paint(),
e.setAutoPaint(i),
e.emit("afteractivaterelations", {
item: t.item || this.get("item"),
action: "deactivate",
});
}
},
clearAllItemStates: function (t) {
var e = this.graph;
if (
this.shouldUpdate(t.item, { event: t, action: "deactivate" })
) {
for (
var n = this.activeState,
r = this.inactiveState,
i = e.getNodes(),
o = e.getEdges(),
a = i.length,
s = o.length,
c = 0;
c < a;
c++
) {
var u = i[c];
e.clearItemStates(u, [n, r]);
}
for (c = 0; c < s; c++) {
var h = o[c];
e.clearItemStates(h, [n, r, "deactivate"]);
}
e.emit("afteractivaterelations", {
item: t.item || this.get("item"),
action: "deactivate",
});
}
},
},
"click-select": d,
"collapse-expand": v,
"drag-combo": {
getDefaultCfg: function () {
return {
enableDelegate: !1,
delegateStyle: {},
onlyChangeComboSize: !1,
activeState: "",
selectedState: "selected",
};
},
getEvents: function () {
return {
"combo:dragstart": "onDragStart",
"combo:drag": "onDrag",
"combo:dragend": "onDragEnd",
"combo:drop": "onDrop",
"node:drop": "onNodeDrop",
"combo:dragenter": "onDragEnter",
"combo:dragleave": "onDragLeave",
};
},
validationCombo: function (t) {
var e = t.item;
return (
!(!e || e.destroyed) &&
!!this.shouldUpdate(this, t) &&
"combo" === e.getType()
);
},
onDragStart: function (t) {
var e = this,
n = this.graph,
r = t.item;
if (this.validationCombo(t)) {
this.targets = [];
var i = n.findAllByState("combo", this.selectedState),
o = r.get("id");
0 ===
i.filter(function (t) {
var e = t.get("id");
return o === e;
}).length
? this.targets.push(r)
: (this.targets = i),
this.activeState &&
this.targets.map(function (t) {
var r = t.getModel();
if (r.parentId) {
var i = n.findById(r.parentId);
i && n.setItemState(i, e.activeState, !0);
}
}),
(this.point = {}),
(this.originPoint = {}),
(this.origin = { x: t.x, y: t.y }),
(this.currentItemChildCombos = []),
m(r, function (t) {
if (t.destroyed) return !1;
var n = t.getModel();
return e.currentItemChildCombos.push(n.id), !0;
});
}
},
onDrag: function (t) {
var e = this;
if (this.origin && this.validationCombo(t))
if (this.enableDelegate) this.updateDelegate(t);
else {
if (this.activeState) {
var n = this.graph,
r = t.item,
o = r.getModel(),
a = n.getCombos(),
s = r.getBBox(),
c = s.centerX,
u = s.centerY,
h = s.width;
a.filter(function (t) {
var n = t.getModel();
return (
o.parentId,
n.id !== o.id &&
!e.currentItemChildCombos.includes(n.id)
);
}).map(function (t) {
var r = t.getBBox(),
i = r.centerX,
o = r.centerY,
a = r.width,
s = c - i,
l = u - o,
f = 2 * Math.sqrt(s * s + l * l);
h + a - f > 0.8 * h
? n.setItemState(t, e.activeState, !0)
: n.setItemState(t, e.activeState, !1);
});
}
Object(i.each)(this.targets, function (n) {
e.updateCombo(n, t);
});
}
},
updatePositions: function (t) {
var e = this;
this.enableDelegate &&
Object(i.each)(this.targets, function (n) {
e.updateCombo(n, t);
});
},
onDrop: function (t) {
var e = this,
n = t.item;
if (n && this.targets && !n.destroyed) {
this.updatePositions(t);
var r = this.graph,
i = n.getModel();
this.targets.map(function (t) {
t.getModel().parentId !== i.id
? (e.activeState && r.setItemState(n, e.activeState, !1),
e.onlyChangeComboSize
? r.updateCombo(t)
: r.updateComboTree(t, i.id))
: r.updateCombo(n);
}),
this.end(n, t),
(this.endComparison = !0);
}
},
onNodeDrop: function (t) {
var e = this;
if (this.targets && 0 !== this.targets.length) {
this.updatePositions(t);
var n,
r = this.graph,
i = t.item.getModel().comboId;
if (i) {
if (this.activeState) {
var o = r.findById(i);
r.setItemState(o, this.activeState, !1);
}
this.targets.map(function (t) {
e.onlyChangeComboSize
? r.updateCombo(t)
: i !== t.getID() &&
((n = r.findById(i)),
i !== t.getModel().parentId && r.updateComboTree(t, i));
});
} else
this.targets.map(function (t) {
e.onlyChangeComboSize
? r.updateCombo(t)
: t.getModel().comboId && r.updateComboTree(t);
});
(this.endComparison = !0), this.end(n, t);
}
},
onDragEnter: function (t) {
if (this.origin && this.validationCombo(t)) {
var e = t.item,
n = this.graph;
this.activeState && n.setItemState(e, this.activeState, !0);
}
},
onDragLeave: function (t) {
if (this.origin && this.validationCombo(t)) {
var e = t.item,
n = this.graph;
this.activeState && n.setItemState(e, this.activeState, !1);
}
},
onDragEnd: function (t) {
if (this.targets && 0 !== this.targets.length) {
var e = t.item;
this.updatePositions(t);
var n = this.getParentCombo(e.getModel().parentId),
r = this.graph;
n &&
this.activeState &&
r.setItemState(n, this.activeState, !1),
this.end(void 0, t);
}
},
end: function (t, e) {
var n = this;
if (this.origin) {
var r = this.graph;
if (this.delegateShape)
r.get("delegateGroup").clear(), (this.delegateShape = null);
t &&
this.activeState &&
r.setItemState(t, this.activeState, !1),
t ||
this.targets.map(function (t) {
n.onlyChangeComboSize
? r.updateCombo(t)
: r.updateComboTree(t);
}),
(this.point = []),
(this.origin = null),
(this.originPoint = null),
(this.targets.length = 0);
}
},
traverse: function (t, e) {
var n = this;
if (!1 !== e(t) && t) {
var r = t.get("combos");
Object(i.each)(r, function (t) {
n.traverse(t, e);
});
var o = t.get("nodes");
Object(i.each)(o, function (t) {
n.traverse(t, e);
});
}
},
updateCombo: function (t, e) {
var n = this;
this.traverse(t, function (t) {
return !t.destroyed && (n.updateSignleItem(t, e), !0);
});
},
updateSignleItem: function (t, e) {
var n = this.origin,
r = this.graph,
i = t.getModel(),
o = t.get("id");
this.point[o] || (this.point[o] = { x: i.x, y: i.y });
var a = e.x - n.x + this.point[o].x,
s = e.y - n.y + this.point[o].y;
r.updateItem(t, { x: a, y: s });
},
getParentCombo: function (t) {
var e = this.graph;
if (t) {
var n = e.findById(t);
if (n) return n;
}
},
updateDelegate: function (t) {
var e = this.graph;
if (this.delegateShape) {
var n = t.x - this.origin.x + this.originPoint.minX,
i = t.y - this.origin.y + this.originPoint.minY;
this.delegateShape.attr({ x: n, y: i });
} else {
var o = e.get("delegateGroup"),
a = null,
s = (a =
this.targets.length > 1
? y(this.targets)
: this.targets[0].getBBox()).x,
c = a.y,
u = a.width,
h = a.height,
f = a.minX,
d = a.minY;
this.originPoint = {
x: s,
y: c,
width: u,
height: h,
minX: f,
minY: d,
};
var p = Object(r.a)(
Object(r.a)({}, l.a.delegateStyle),
this.delegateStyle,
);
this.delegateShape = o.addShape("rect", {
attrs: Object(r.a)(
{ width: a.width, height: a.height, x: a.x, y: a.y },
p,
),
name: "combo-delegate-shape",
});
}
},
},
"collapse-expand-combo": {
getDefaultCfg: function () {
return { trigger: "dblclick", relayout: !0 };
},
getEvents: function () {
var t, e;
return (
b.includes(this.trigger)
? (e = this.trigger)
: ((e = "dblclick"),
console.warn(
"Behavior collapse-expand-group 的 trigger 参数不合法，请输入 'click' 或 'dblclick'",
)),
((t = {})["combo:" + e] = "onComboClick"),
t
);
},
onComboClick: function (t) {
var e = t.item,
n = this.graph,
r = this.relayout;
if (e && !e.destroyed && "combo" === e.getType()) {
var i = e.getModel().id;
i &&
(n.collapseExpandCombo(i),
r && n.get("layout") ? n.layout() : n.refreshPositions());
}
},
},
"create-edge": {
getDefaultCfg: function () {
return { trigger: "tap", key: void 0, edgeConfig: {} };
},
getEvents: function () {
var t;
return (
x.indexOf(this.trigger.toLowerCase()) > -1 ||
((this.trigger = "tap"),
console.warn(
"Behavior create-edge 的 trigger 参数不合法，请输入 'click'，'drag'",
)),
this.key &&
-1 === w.indexOf(this.key.toLowerCase()) &&
((this.trigger = void 0),
console.warn(
"Behavior create-edge 的 key 参数不合法，请输入 'shift'，'ctrl'，'alt'，'control'，或 undefined",
)),
"drag" === this.trigger
? (t = {
"node:dragstart": "onClick",
"combo:dragstart": "onClick",
drag: "updateEndPoint",
"node:drop": "onClick",
"combo:drop": "onClick",
dragend: "onDragEnd",
})
: "click" === this.trigger &&
(t = {
"node:tap": "onClick",
mousemove: "updateEndPoint",
"edge:tap": "cancelCreating",
"canvas:tap": "cancelCreating",
"combo:tap": "onClick",
}),
this.key && ((t.keydown = "onKeyDown"), (t.keyup = "onKeyUp")),
t
);
},
onDragEnd: function (t) {
if (!this.key || this.keydown) {
var e = t.item;
(e && e.getID() !== this.source && "node" === e.getType()) ||
this.cancelCreating({ item: this.edge, x: t.x, y: t.y });
}
},
onClick: function (t) {
if (!this.key || this.keydown) {
var e = t.item,
n = this.graph,
i = e.getModel();
if (this.addingEdge && this.edge) {
if (!this.shouldEnd.call(this, t)) return;
var o = { target: i.id };
this.source === i.id && (o.type = "loop"),
n.emit("beforecreateedge", {}),
n.updateItem(this.edge, o),
n.emit("aftercreateedge", { edge: this.edge }),
this.edge.getKeyShape().set("capture", !0),
(this.edge = null),
(this.addingEdge = !1);
} else {
if (!this.shouldBegin.call(this, t)) return;
(this.edge = n.addItem(
"edge",
Object(r.a)(
{ source: i.id, target: i.id },
this.edgeConfig,
),
!1,
)),
(this.source = i.id),
(this.addingEdge = !0),
this.edge.getKeyShape().set("capture", !1);
}
}
},
updateEndPoint: function (t) {
if (!this.key || this.keydown) {
var e = { x: t.x, y: t.y };
this.graph.findById(this.source)
? this.addingEdge &&
this.edge &&
this.graph.updateItem(this.edge, { target: e }, !1)
: (this.addingEdge = !1);
}
},
cancelCreating: function (t) {
if (!this.key || this.keydown) {
var e = this.graph,
n = t.item;
if (
this.addingEdge &&
t.target &&
t.target.isCanvas &&
t.target.isCanvas()
)
return (
e.removeItem(this.edge, !1),
(this.edge = null),
void (this.addingEdge = !1)
);
if (this.addingEdge && this.edge === n) {
var r = !0;
if (!e.get("groupByTypes"))
for (
var i = t.x,
o = t.y,
a = e.getNodes(),
s = a.length,
c = 0;
c < s;
c++
) {
var u = a[c],
h = u.getModel(),
l = u.getBBox();
if (
i <= l.maxX &&
i >= l.minX &&
o <= l.maxY &&
o >= l.minY
) {
if (
!this.shouldEnd.call(this, {
x: t.x,
y: t.y,
canvasX: t.canvasX,
canvasY: t.canvasY,
clientX: t.clientX,
clientY: t.clientY,
item: u,
})
)
return;
e.emit("beforecreateedge", {}),
e.updateItem(this.edge, { target: h.id }),
e.emit("aftercreateedge", { edge: this.edge }),
(r = !1);
break;
}
}
r && e.removeItem(this.edge, !1),
(this.edge = null),
(this.addingEdge = !1);
}
}
},
onKeyDown: function (t) {
var e = t.key;
e &&
(e.toLowerCase() === this.key.toLowerCase()
? (this.keydown = !0)
: (this.keydown = !1));
},
onKeyUp: function () {
this.addingEdge &&
this.edge &&
(this.graph.removeItem(this.edge, !1),
(this.addingEdge = !1),
(this.edge = null)),
(this.keydown = !1);
},
},
};
Object(i.each)(O, function (t, e) {
Object(o.i)(e, Object(r.a)(Object(r.a)({}, t), S));
});
},
4: function (t, e, n) {
"use strict";
n.d(e, "a", function () {
return r;
}),
n.d(e, "b", function () {
return _;
}),
n.d(e, "c", function () {
return R;
});
var r = {};
n.r(r),
n.d(r, "create", function () {
return o;
}),
n.d(r, "fromMat4", function () {
return a;
}),
n.d(r, "clone", function () {
return s;
}),
n.d(r, "copy", function () {
return c;
}),
n.d(r, "fromValues", function () {
return u;
}),
n.d(r, "set", function () {
return h;
}),
n.d(r, "identity", function () {
return l;
}),
n.d(r, "transpose", function () {
return f;
}),
n.d(r, "invert", function () {
return d;
}),
n.d(r, "adjoint", function () {
return p;
}),
n.d(r, "determinant", function () {
return g;
}),
n.d(r, "multiply", function () {
return v;
}),
n.d(r, "translate", function () {
return y;
}),
n.d(r, "rotate", function () {
return m;
}),
n.d(r, "scale", function () {
return b;
}),
n.d(r, "fromTranslation", function () {
return x;
}),
n.d(r, "fromRotation", function () {
return w;
}),
n.d(r, "fromScaling", function () {
return S;
}),
n.d(r, "fromMat2d", function () {
return O;
}),
n.d(r, "fromQuat", function () {
return M;
}),
n.d(r, "normalFromMat4", function () {
return k;
}),
n.d(r, "projection", function () {
return C;
}),
n.d(r, "str", function () {
return E;
}),
n.d(r, "frob", function () {
return j;
}),
n.d(r, "add", function () {
return P;
}),
n.d(r, "subtract", function () {
return A;
}),
n.d(r, "multiplyScalar", function () {
return I;
}),
n.d(r, "multiplyScalarAndAdd", function () {
return T;
}),
n.d(r, "exactEquals", function () {
return N;
}),
n.d(r, "equals", function () {
return B;
}),
n.d(r, "mul", function () {
return L;
}),
n.d(r, "sub", function () {
return D;
});
var i = n(5);
function o() {
var t = new i.a(9);
return (
i.a != Float32Array &&
((t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0)),
(t[0] = 1),
(t[4] = 1),
(t[8] = 1),
t
);
}
function a(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = e[2]),
(t[3] = e[4]),
(t[4] = e[5]),
(t[5] = e[6]),
(t[6] = e[8]),
(t[7] = e[9]),
(t[8] = e[10]),
t
);
}
function s(t) {
var e = new i.a(9);
return (
(e[0] = t[0]),
(e[1] = t[1]),
(e[2] = t[2]),
(e[3] = t[3]),
(e[4] = t[4]),
(e[5] = t[5]),
(e[6] = t[6]),
(e[7] = t[7]),
(e[8] = t[8]),
e
);
}
function c(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = e[2]),
(t[3] = e[3]),
(t[4] = e[4]),
(t[5] = e[5]),
(t[6] = e[6]),
(t[7] = e[7]),
(t[8] = e[8]),
t
);
}
function u(t, e, n, r, o, a, s, c, u) {
var h = new i.a(9);
return (
(h[0] = t),
(h[1] = e),
(h[2] = n),
(h[3] = r),
(h[4] = o),
(h[5] = a),
(h[6] = s),
(h[7] = c),
(h[8] = u),
h
);
}
function h(t, e, n, r, i, o, a, s, c, u) {
return (
(t[0] = e),
(t[1] = n),
(t[2] = r),
(t[3] = i),
(t[4] = o),
(t[5] = a),
(t[6] = s),
(t[7] = c),
(t[8] = u),
t
);
}
function l(t) {
return (
(t[0] = 1),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = 1),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function f(t, e) {
if (t === e) {
var n = e[1],
r = e[2],
i = e[5];
(t[1] = e[3]),
(t[2] = e[6]),
(t[3] = n),
(t[5] = e[7]),
(t[6] = r),
(t[7] = i);
} else
(t[0] = e[0]),
(t[1] = e[3]),
(t[2] = e[6]),
(t[3] = e[1]),
(t[4] = e[4]),
(t[5] = e[7]),
(t[6] = e[2]),
(t[7] = e[5]),
(t[8] = e[8]);
return t;
}
function d(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
c = e[6],
u = e[7],
h = e[8],
l = h * a - s * u,
f = -h * o + s * c,
d = u * o - a * c,
p = n * l + r * f + i * d;
return p
? ((p = 1 / p),
(t[0] = l * p),
(t[1] = (-h * r + i * u) * p),
(t[2] = (s * r - i * a) * p),
(t[3] = f * p),
(t[4] = (h * n - i * c) * p),
(t[5] = (-s * n + i * o) * p),
(t[6] = d * p),
(t[7] = (-u * n + r * c) * p),
(t[8] = (a * n - r * o) * p),
t)
: null;
}
function p(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
c = e[6],
u = e[7],
h = e[8];
return (
(t[0] = a * h - s * u),
(t[1] = i * u - r * h),
(t[2] = r * s - i * a),
(t[3] = s * c - o * h),
(t[4] = n * h - i * c),
(t[5] = i * o - n * s),
(t[6] = o * u - a * c),
(t[7] = r * c - n * u),
(t[8] = n * a - r * o),
t
);
}
function g(t) {
var e = t[0],
n = t[1],
r = t[2],
i = t[3],
o = t[4],
a = t[5],
s = t[6],
c = t[7],
u = t[8];
return e * (u * o - a * c) + n * (-u * i + a * s) + r * (c * i - o * s);
}
function v(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
c = e[5],
u = e[6],
h = e[7],
l = e[8],
f = n[0],
d = n[1],
p = n[2],
g = n[3],
v = n[4],
y = n[5],
m = n[6],
b = n[7],
x = n[8];
return (
(t[0] = f * r + d * a + p * u),
(t[1] = f * i + d * s + p * h),
(t[2] = f * o + d * c + p * l),
(t[3] = g * r + v * a + y * u),
(t[4] = g * i + v * s + y * h),
(t[5] = g * o + v * c + y * l),
(t[6] = m * r + b * a + x * u),
(t[7] = m * i + b * s + x * h),
(t[8] = m * o + b * c + x * l),
t
);
}
function y(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
c = e[5],
u = e[6],
h = e[7],
l = e[8],
f = n[0],
d = n[1];
return (
(t[0] = r),
(t[1] = i),
(t[2] = o),
(t[3] = a),
(t[4] = s),
(t[5] = c),
(t[6] = f * r + d * a + u),
(t[7] = f * i + d * s + h),
(t[8] = f * o + d * c + l),
t
);
}
function m(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
c = e[5],
u = e[6],
h = e[7],
l = e[8],
f = Math.sin(n),
d = Math.cos(n);
return (
(t[0] = d * r + f * a),
(t[1] = d * i + f * s),
(t[2] = d * o + f * c),
(t[3] = d * a - f * r),
(t[4] = d * s - f * i),
(t[5] = d * c - f * o),
(t[6] = u),
(t[7] = h),
(t[8] = l),
t
);
}
function b(t, e, n) {
var r = n[0],
i = n[1];
return (
(t[0] = r * e[0]),
(t[1] = r * e[1]),
(t[2] = r * e[2]),
(t[3] = i * e[3]),
(t[4] = i * e[4]),
(t[5] = i * e[5]),
(t[6] = e[6]),
(t[7] = e[7]),
(t[8] = e[8]),
t
);
}
function x(t, e) {
return (
(t[0] = 1),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = 1),
(t[5] = 0),
(t[6] = e[0]),
(t[7] = e[1]),
(t[8] = 1),
t
);
}
function w(t, e) {
var n = Math.sin(e),
r = Math.cos(e);
return (
(t[0] = r),
(t[1] = n),
(t[2] = 0),
(t[3] = -n),
(t[4] = r),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function S(t, e) {
return (
(t[0] = e[0]),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = e[1]),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function O(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = 0),
(t[3] = e[2]),
(t[4] = e[3]),
(t[5] = 0),
(t[6] = e[4]),
(t[7] = e[5]),
(t[8] = 1),
t
);
}
function M(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = n + n,
s = r + r,
c = i + i,
u = n * a,
h = r * a,
l = r * s,
f = i * a,
d = i * s,
p = i * c,
g = o * a,
v = o * s,
y = o * c;
return (
(t[0] = 1 - l - p),
(t[3] = h - y),
(t[6] = f + v),
(t[1] = h + y),
(t[4] = 1 - u - p),
(t[7] = d - g),
(t[2] = f - v),
(t[5] = d + g),
(t[8] = 1 - u - l),
t
);
}
function k(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
c = e[6],
u = e[7],
h = e[8],
l = e[9],
f = e[10],
d = e[11],
p = e[12],
g = e[13],
v = e[14],
y = e[15],
m = n * s - r * a,
b = n * c - i * a,
x = n * u - o * a,
w = r * c - i * s,
S = r * u - o * s,
O = i * u - o * c,
M = h * g - l * p,
k = h * v - f * p,
C = h * y - d * p,
E = l * v - f * g,
j = l * y - d * g,
P = f * y - d * v,
A = m * P - b * j + x * E + w * C - S * k + O * M;
return A
? ((A = 1 / A),
(t[0] = (s * P - c * j + u * E) * A),
(t[1] = (c * C - a * P - u * k) * A),
(t[2] = (a * j - s * C + u * M) * A),
(t[3] = (i * j - r * P - o * E) * A),
(t[4] = (n * P - i * C + o * k) * A),
(t[5] = (r * C - n * j - o * M) * A),
(t[6] = (g * O - v * S + y * w) * A),
(t[7] = (v * x - p * O - y * b) * A),
(t[8] = (p * S - g * x + y * m) * A),
t)
: null;
}
function C(t, e, n) {
return (
(t[0] = 2 / e),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = -2 / n),
(t[5] = 0),
(t[6] = -1),
(t[7] = 1),
(t[8] = 1),
t
);
}
function E(t) {
return (
"mat3(" +
t[0] +
", " +
t[1] +
", " +
t[2] +
", " +
t[3] +
", " +
t[4] +
", " +
t[5] +
", " +
t[6] +
", " +
t[7] +
", " +
t[8] +
")"
);
}
function j(t) {
return Math.hypot(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8]);
}
function P(t, e, n) {
return (
(t[0] = e[0] + n[0]),
(t[1] = e[1] + n[1]),
(t[2] = e[2] + n[2]),
(t[3] = e[3] + n[3]),
(t[4] = e[4] + n[4]),
(t[5] = e[5] + n[5]),
(t[6] = e[6] + n[6]),
(t[7] = e[7] + n[7]),
(t[8] = e[8] + n[8]),
t
);
}
function A(t, e, n) {
return (
(t[0] = e[0] - n[0]),
(t[1] = e[1] - n[1]),
(t[2] = e[2] - n[2]),
(t[3] = e[3] - n[3]),
(t[4] = e[4] - n[4]),
(t[5] = e[5] - n[5]),
(t[6] = e[6] - n[6]),
(t[7] = e[7] - n[7]),
(t[8] = e[8] - n[8]),
t
);
}
function I(t, e, n) {
return (
(t[0] = e[0] * n),
(t[1] = e[1] * n),
(t[2] = e[2] * n),
(t[3] = e[3] * n),
(t[4] = e[4] * n),
(t[5] = e[5] * n),
(t[6] = e[6] * n),
(t[7] = e[7] * n),
(t[8] = e[8] * n),
t
);
}
function T(t, e, n, r) {
return (
(t[0] = e[0] + n[0] * r),
(t[1] = e[1] + n[1] * r),
(t[2] = e[2] + n[2] * r),
(t[3] = e[3] + n[3] * r),
(t[4] = e[4] + n[4] * r),
(t[5] = e[5] + n[5] * r),
(t[6] = e[6] + n[6] * r),
(t[7] = e[7] + n[7] * r),
(t[8] = e[8] + n[8] * r),
t
);
}
function N(t, e) {
return (
t[0] === e[0] &&
t[1] === e[1] &&
t[2] === e[2] &&
t[3] === e[3] &&
t[4] === e[4] &&
t[5] === e[5] &&
t[6] === e[6] &&
t[7] === e[7] &&
t[8] === e[8]
);
}
function B(t, e) {
var n = t[0],
r = t[1],
o = t[2],
a = t[3],
s = t[4],
c = t[5],
u = t[6],
h = t[7],
l = t[8],
f = e[0],
d = e[1],
p = e[2],
g = e[3],
v = e[4],
y = e[5],
m = e[6],
b = e[7],
x = e[8];
return (
Math.abs(n - f) <= i.b * Math.max(1, Math.abs(n), Math.abs(f)) &&
Math.abs(r - d) <= i.b * Math.max(1, Math.abs(r), Math.abs(d)) &&
Math.abs(o - p) <= i.b * Math.max(1, Math.abs(o), Math.abs(p)) &&
Math.abs(a - g) <= i.b * Math.max(1, Math.abs(a), Math.abs(g)) &&
Math.abs(s - v) <= i.b * Math.max(1, Math.abs(s), Math.abs(v)) &&
Math.abs(c - y) <= i.b * Math.max(1, Math.abs(c), Math.abs(y)) &&
Math.abs(u - m) <= i.b * Math.max(1, Math.abs(u), Math.abs(m)) &&
Math.abs(h - b) <= i.b * Math.max(1, Math.abs(h), Math.abs(b)) &&
Math.abs(l - x) <= i.b * Math.max(1, Math.abs(l), Math.abs(x))
);
}
var L = v,
D = A,
_ = n(42),
R = n(72);
},
42: function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "create", function () {
return i;
}),
n.d(e, "clone", function () {
return o;
}),
n.d(e, "fromValues", function () {
return a;
}),
n.d(e, "copy", function () {
return s;
}),
n.d(e, "set", function () {
return c;
}),
n.d(e, "add", function () {
return u;
}),
n.d(e, "subtract", function () {
return h;
}),
n.d(e, "multiply", function () {
return l;
}),
n.d(e, "divide", function () {
return f;
}),
n.d(e, "ceil", function () {
return d;
}),
n.d(e, "floor", function () {
return p;
}),
n.d(e, "min", function () {
return g;
}),
n.d(e, "max", function () {
return v;
}),
n.d(e, "round", function () {
return y;
}),
n.d(e, "scale", function () {
return m;
}),
n.d(e, "scaleAndAdd", function () {
return b;
}),
n.d(e, "distance", function () {
return x;
}),
n.d(e, "squaredDistance", function () {
return w;
}),
n.d(e, "length", function () {
return S;
}),
n.d(e, "squaredLength", function () {
return O;
}),
n.d(e, "negate", function () {
return M;
}),
n.d(e, "inverse", function () {
return k;
}),
n.d(e, "normalize", function () {
return C;
}),
n.d(e, "dot", function () {
return E;
}),
n.d(e, "cross", function () {
return j;
}),
n.d(e, "lerp", function () {
return P;
}),
n.d(e, "random", function () {
return A;
}),
n.d(e, "transformMat2", function () {
return I;
}),
n.d(e, "transformMat2d", function () {
return T;
}),
n.d(e, "transformMat3", function () {
return N;
}),
n.d(e, "transformMat4", function () {
return B;
}),
n.d(e, "rotate", function () {
return L;
}),
n.d(e, "angle", function () {
return D;
}),
n.d(e, "zero", function () {
return _;
}),
n.d(e, "str", function () {
return R;
}),
n.d(e, "exactEquals", function () {
return F;
}),
n.d(e, "equals", function () {
return Y;
}),
n.d(e, "len", function () {
return z;
}),
n.d(e, "sub", function () {
return W;
}),
n.d(e, "mul", function () {
return q;
}),
n.d(e, "div", function () {
return V;
}),
n.d(e, "dist", function () {
return G;
}),
n.d(e, "sqrDist", function () {
return H;
}),
n.d(e, "sqrLen", function () {
return U;
}),
n.d(e, "forEach", function () {
return Z;
});
var r = n(5);
function i() {
var t = new r.a(2);
return r.a != Float32Array && ((t[0] = 0), (t[1] = 0)), t;
}
function o(t) {
var e = new r.a(2);
return (e[0] = t[0]), (e[1] = t[1]), e;
}
function a(t, e) {
var n = new r.a(2);
return (n[0] = t), (n[1] = e), n;
}
function s(t, e) {
return (t[0] = e[0]), (t[1] = e[1]), t;
}
function c(t, e, n) {
return (t[0] = e), (t[1] = n), t;
}
function u(t, e, n) {
return (t[0] = e[0] + n[0]), (t[1] = e[1] + n[1]), t;
}
function h(t, e, n) {
return (t[0] = e[0] - n[0]), (t[1] = e[1] - n[1]), t;
}
function l(t, e, n) {
return (t[0] = e[0] * n[0]), (t[1] = e[1] * n[1]), t;
}
function f(t, e, n) {
return (t[0] = e[0] / n[0]), (t[1] = e[1] / n[1]), t;
}
function d(t, e) {
return (t[0] = Math.ceil(e[0])), (t[1] = Math.ceil(e[1])), t;
}
function p(t, e) {
return (t[0] = Math.floor(e[0])), (t[1] = Math.floor(e[1])), t;
}
function g(t, e, n) {
return (t[0] = Math.min(e[0], n[0])), (t[1] = Math.min(e[1], n[1])), t;
}
function v(t, e, n) {
return (t[0] = Math.max(e[0], n[0])), (t[1] = Math.max(e[1], n[1])), t;
}
function y(t, e) {
return (t[0] = Math.round(e[0])), (t[1] = Math.round(e[1])), t;
}
function m(t, e, n) {
return (t[0] = e[0] * n), (t[1] = e[1] * n), t;
}
function b(t, e, n, r) {
return (t[0] = e[0] + n[0] * r), (t[1] = e[1] + n[1] * r), t;
}
function x(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1];
return Math.hypot(n, r);
}
function w(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1];
return n * n + r * r;
}
function S(t) {
var e = t[0],
n = t[1];
return Math.hypot(e, n);
}
function O(t) {
var e = t[0],
n = t[1];
return e * e + n * n;
}
function M(t, e) {
return (t[0] = -e[0]), (t[1] = -e[1]), t;
}
function k(t, e) {
return (t[0] = 1 / e[0]), (t[1] = 1 / e[1]), t;
}
function C(t, e) {
var n = e[0],
r = e[1],
i = n * n + r * r;
return (
i > 0 && (i = 1 / Math.sqrt(i)),
(t[0] = e[0] * i),
(t[1] = e[1] * i),
t
);
}
function E(t, e) {
return t[0] * e[0] + t[1] * e[1];
}
function j(t, e, n) {
var r = e[0] * n[1] - e[1] * n[0];
return (t[0] = t[1] = 0), (t[2] = r), t;
}
function P(t, e, n, r) {
var i = e[0],
o = e[1];
return (t[0] = i + r * (n[0] - i)), (t[1] = o + r * (n[1] - o)), t;
}
function A(t, e) {
e = e || 1;
var n = 2 * r.c() * Math.PI;
return (t[0] = Math.cos(n) * e), (t[1] = Math.sin(n) * e), t;
}
function I(t, e, n) {
var r = e[0],
i = e[1];
return (t[0] = n[0] * r + n[2] * i), (t[1] = n[1] * r + n[3] * i), t;
}
function T(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[2] * i + n[4]),
(t[1] = n[1] * r + n[3] * i + n[5]),
t
);
}
function N(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[3] * i + n[6]),
(t[1] = n[1] * r + n[4] * i + n[7]),
t
);
}
function B(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[4] * i + n[12]),
(t[1] = n[1] * r + n[5] * i + n[13]),
t
);
}
function L(t, e, n, r) {
var i = e[0] - n[0],
o = e[1] - n[1],
a = Math.sin(r),
s = Math.cos(r);
return (t[0] = i * s - o * a + n[0]), (t[1] = i * a + o * s + n[1]), t;
}
function D(t, e) {
var n = t[0],
r = t[1],
i = e[0],
o = e[1],
a = Math.sqrt(n * n + r * r) * Math.sqrt(i * i + o * o),
s = a && (n * i + r * o) / a;
return Math.acos(Math.min(Math.max(s, -1), 1));
}
function _(t) {
return (t[0] = 0), (t[1] = 0), t;
}
function R(t) {
return "vec2(" + t[0] + ", " + t[1] + ")";
}
function F(t, e) {
return t[0] === e[0] && t[1] === e[1];
}
function Y(t, e) {
var n = t[0],
i = t[1],
o = e[0],
a = e[1];
return (
Math.abs(n - o) <= r.b * Math.max(1, Math.abs(n), Math.abs(o)) &&
Math.abs(i - a) <= r.b * Math.max(1, Math.abs(i), Math.abs(a))
);
}
var X,
z = S,
W = h,
q = l,
V = f,
G = x,
H = w,
U = O,
Z =
((X = i()),
function (t, e, n, r, i, o) {
var a, s;
for (
e || (e = 2),
n || (n = 0),
s = r ? Math.min(r * e + n, t.length) : t.length,
a = n;
a < s;
a += e
)
(X[0] = t[a]),
(X[1] = t[a + 1]),
i(X, X, o),
(t[a] = X[0]),
(t[a + 1] = X[1]);
return t;
});
},
43: function (t, e, n) {
"use strict";
var r, i, o, a;
function s(t) {
r ||
((r = document.createElement("table")),
(i = document.createElement("tr")),
(o = /^\s*<(\w+|!)[^>]*>/),
(a = {
tr: document.createElement("tbody"),
tbody: r,
thead: r,
tfoot: r,
td: i,
th: i,
"*": document.createElement("div"),
}));
var e = o.test(t) && RegExp.$1;
(e && e in a) || (e = "*");
var n = a[e];
(t = "string" == typeof t ? t.replace(/(^\s*)|(\s*$)/g, "") : t),
(n.innerHTML = "" + t);
var s = n.childNodes[0];
return s && n.contains(s) && n.removeChild(s), s;
}
function c(t, e) {
if (t) for (var n in e) e.hasOwnProperty(n) && (t.style[n] = e[n]);
return t;
}
n.d(e, "a", function () {
return s;
}),
n.d(e, "b", function () {
return c;
});
},
44: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function i(t) {
return (i =
"function" == typeof Symbol && "symbol" == r(Symbol.iterator)
? function (t) {
return r(t);
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: r(t);
})(t);
}
var o = n(181),
a = n(185),
s = [].slice,
c = ["keyword", "gray", "hex"],
u = {};
Object.keys(a).forEach(function (t) {
u[s.call(a[t].labels).sort().join("")] = t;
});
var h = {};
function l(t, e) {
if (!(this instanceof l)) return new l(t, e);
if ((e && e in c && (e = null), e && !(e in a)))
throw new Error("Unknown model: " + e);
var n, r, i, f, d, p, g, y, m;
if (null == t)
(this.model = "rgb"), (this.color = [0, 0, 0]), (this.valpha = 1);
else if (t instanceof l)
(this.model = t.model),
(this.color = t.color.slice()),
(this.valpha = t.valpha);
else if ("string" == typeof t) {
if (null === (r = o.get(t)))
throw new Error("Unable to parse color from string: " + t);
(this.model = r.model),
(m = a[this.model].channels),
(this.color = r.value.slice(0, m)),
(this.valpha = "number" == typeof r.value[m] ? r.value[m] : 1);
} else if (t.length)
(this.model = e || "rgb"),
(m = a[this.model].channels),
(i = s.call(t, 0, m)),
(this.color = v(i, m)),
(this.valpha = "number" == typeof t[m] ? t[m] : 1);
else if ("number" == typeof t)
(t &= 16777215),
(this.model = "rgb"),
(this.color = [(t >> 16) & 255, (t >> 8) & 255, 255 & t]),
(this.valpha = 1);
else {
if (
((this.valpha = 1),
(f = Object.keys(t)),
"alpha" in t &&
(f.splice(f.indexOf("alpha"), 1),
(this.valpha = "number" == typeof t.alpha ? t.alpha : 0)),
!((d = f.sort().join("")) in u))
)
throw new Error(
"Unable to parse color from object: " + JSON.stringify(t),
);
for (
this.model = u[d], p = a[this.model].labels, g = [], n = 0;
n < p.length;
n++
)
g.push(t[p[n]]);
this.color = v(g);
}
if (h[this.model])
for (m = a[this.model].channels, n = 0; n < m; n++)
(y = h[this.model][n]) && (this.color[n] = y(this.color[n]));
(this.valpha = Math.max(0, Math.min(1, this.valpha))),
Object.freeze && Object.freeze(this);
}
function f(t) {
return function (e) {
return (function (t, e) {
return Number(t.toFixed(e));
})(e, t);
};
}
function d(t, e, n) {
return (
(t = Array.isArray(t) ? t : [t]).forEach(function (t) {
(h[t] || (h[t] = []))[e] = n;
}),
(t = t[0]),
function (r) {
var i;
return arguments.length
? (n && (r = n(r)), ((i = this[t]()).color[e] = r), i)
: ((i = this[t]().color[e]), n && (i = n(i)), i);
}
);
}
function p(t) {
return function (e) {
return Math.max(0, Math.min(t, e));
};
}
function g(t) {
return Array.isArray(t) ? t : [t];
}
function v(t, e) {
var n;
for (n = 0; n < e; n++) "number" != typeof t[n] && (t[n] = 0);
return t;
}
(l.prototype = {
toString: function () {
return this.string();
},
toJSON: function () {
return this[this.model]();
},
string: function (t) {
var e = this.model in o.to ? this : this.rgb(),
n =
1 === (e = e.round("number" == typeof t ? t : 1)).valpha
? e.color
: e.color.concat(this.valpha);
return o.to[e.model](n);
},
percentString: function (t) {
var e = this.rgb().round("number" == typeof t ? t : 1),
n = 1 === e.valpha ? e.color : e.color.concat(this.valpha);
return o.to.rgb.percent(n);
},
array: function () {
return 1 === this.valpha
? this.color.slice()
: this.color.concat(this.valpha);
},
object: function () {
var t,
e = {},
n = a[this.model].channels,
r = a[this.model].labels;
for (t = 0; t < n; t++) e[r[t]] = this.color[t];
return 1 !== this.valpha && (e.alpha = this.valpha), e;
},
unitArray: function () {
var t = this.rgb().color;
return (
(t[0] /= 255),
(t[1] /= 255),
(t[2] /= 255),
1 !== this.valpha && t.push(this.valpha),
t
);
},
unitObject: function () {
var t = this.rgb().object();
return (
(t.r /= 255),
(t.g /= 255),
(t.b /= 255),
1 !== this.valpha && (t.alpha = this.valpha),
t
);
},
round: function (t) {
return (
(t = Math.max(t || 0, 0)),
new l(this.color.map(f(t)).concat(this.valpha), this.model)
);
},
alpha: function (t) {
return arguments.length
? new l(this.color.concat(Math.max(0, Math.min(1, t))), this.model)
: this.valpha;
},
red: d("rgb", 0, p(255)),
green: d("rgb", 1, p(255)),
blue: d("rgb", 2, p(255)),
hue: d(["hsl", "hsv", "hsl", "hwb", "hcg"], 0, function (t) {
return ((t % 360) + 360) % 360;
}),
saturationl: d("hsl", 1, p(100)),
lightness: d("hsl", 2, p(100)),
saturationv: d("hsv", 1, p(100)),
value: d("hsv", 2, p(100)),
chroma: d("hcg", 1, p(100)),
gray: d("hcg", 2, p(100)),
white: d("hwb", 1, p(100)),
wblack: d("hwb", 2, p(100)),
cyan: d("cmyk", 0, p(100)),
magenta: d("cmyk", 1, p(100)),
yellow: d("cmyk", 2, p(100)),
black: d("cmyk", 3, p(100)),
x: d("xyz", 0, p(100)),
y: d("xyz", 1, p(100)),
z: d("xyz", 2, p(100)),
l: d("lab", 0, p(100)),
a: d("lab", 1),
b: d("lab", 2),
keyword: function (t) {
return arguments.length
? new l(t)
: a[this.model].keyword(this.color);
},
hex: function (t) {
return arguments.length
? new l(t)
: o.to.hex(this.rgb().round().color);
},
rgbNumber: function () {
var t = this.rgb().color;
return ((255 & t[0]) << 16) | ((255 & t[1]) << 8) | (255 & t[2]);
},
luminosity: function () {
var t,
e,
n = this.rgb().color,
r = [];
for (t = 0; t < n.length; t++)
(e = n[t] / 255),
(r[t] =
e <= 0.03928 ? e / 12.92 : Math.pow((e + 0.055) / 1.055, 2.4));
return 0.2126 * r[0] + 0.7152 * r[1] + 0.0722 * r[2];
},
contrast: function (t) {
var e = this.luminosity(),
n = t.luminosity();
return e > n ? (e + 0.05) / (n + 0.05) : (n + 0.05) / (e + 0.05);
},
level: function (t) {
var e = this.contrast(t);
return e >= 7.1 ? "AAA" : e >= 4.5 ? "AA" : "";
},
isDark: function () {
var t = this.rgb().color;
return (299 * t[0] + 587 * t[1] + 114 * t[2]) / 1e3 < 128;
},
isLight: function () {
return !this.isDark();
},
negate: function () {
var t,
e = this.rgb();
for (t = 0; t < 3; t++) e.color[t] = 255 - e.color[t];
return e;
},
lighten: function (t) {
var e = this.hsl();
return (e.color[2] += e.color[2] * t), e;
},
darken: function (t) {
var e = this.hsl();
return (e.color[2] -= e.color[2] * t), e;
},
saturate: function (t) {
var e = this.hsl();
return (e.color[1] += e.color[1] * t), e;
},
desaturate: function (t) {
var e = this.hsl();
return (e.color[1] -= e.color[1] * t), e;
},
whiten: function (t) {
var e = this.hwb();
return (e.color[1] += e.color[1] * t), e;
},
blacken: function (t) {
var e = this.hwb();
return (e.color[2] += e.color[2] * t), e;
},
grayscale: function () {
var t = this.rgb().color,
e = 0.3 * t[0] + 0.59 * t[1] + 0.11 * t[2];
return l.rgb(e, e, e);
},
fade: function (t) {
return this.alpha(this.valpha - this.valpha * t);
},
opaquer: function (t) {
return this.alpha(this.valpha + this.valpha * t);
},
rotate: function (t) {
var e = this.hsl(),
n = e.color[0];
return (
(n = (n = (n + t) % 360) < 0 ? 360 + n : n), (e.color[0] = n), e
);
},
mix: function (t, e) {
if (!t || !t.rgb)
throw new Error(
'Argument to "mix" was not a Color instance, but rather an instance of ' +
i(t),
);
var n = t.rgb(),
r = this.rgb(),
o = void 0 === e ? 0.5 : e,
a = 2 * o - 1,
s = n.alpha() - r.alpha(),
c = ((a * s == -1 ? a : (a + s) / (1 + a * s)) + 1) / 2,
u = 1 - c;
return l.rgb(
c * n.red() + u * r.red(),
c * n.green() + u * r.green(),
c * n.blue() + u * r.blue(),
n.alpha() * o + r.alpha() * (1 - o),
);
},
}),
Object.keys(a).forEach(function (t) {
if (-1 === c.indexOf(t)) {
var e = a[t].channels;
(l.prototype[t] = function () {
if (this.model === t) return new l(this);
if (arguments.length) return new l(arguments, t);
var n = "number" == typeof arguments[e] ? e : this.valpha;
return new l(g(a[this.model][t].raw(this.color)).concat(n), t);
}),
(l[t] = function (n) {
return (
"number" == typeof n && (n = v(s.call(arguments), e)),
new l(n, t)
);
});
}
}),
(t.exports = l);
},
5: function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return r;
}),
n.d(e, "a", function () {
return i;
}),
n.d(e, "c", function () {
return o;
});
var r = 1e-6,
i = "undefined" != typeof Float32Array ? Float32Array : Array,
o = Math.random;
Math.PI;
Math.hypot ||
(Math.hypot = function () {
for (var t = 0, e = arguments.length; e--; )
t += arguments[e] * arguments[e];
return Math.sqrt(t);
});
},
51: function (t, e, n) {
"use strict";
var r,
i =
((r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.getLayoutByName = e.unRegisterLayout = e.registerLayout = void 0);
var o = n(53),
a = n(188),
s = new Map();
e.registerLayout = function (t, e) {
var n;
s.get(t) &&
console.warn(
"The layout with the name " +
t +
" exists already, it will be overridden",
),
a.isObject(e)
? ((n = (function (t) {
function n(n) {
var r = t.call(this) || this,
i = r,
o = {},
a = i.getDefaultCfg();
return (
Object.assign(o, a, e, n),
Object.keys(o).forEach(function (t) {
var e = o[t];
i[t] = e;
}),
r
);
}
return i(n, t), n;
})(o.Base)),
s.set(t, n))
: s.set(t, e);
};
e.unRegisterLayout = function (t) {
s.has(t) && s.delete(t);
};
e.getLayoutByName = function (t) {
return s.has(t) ? s.get(t) : null;
};
},
52: function (t, e, n) {
"use strict";
var r,
i =
((r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
}),
function (t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
});
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.RandomLayout = void 0);
var o = (function (t) {
function e(e) {
var n = t.call(this) || this;
return (
(n.center = [0, 0]),
(n.width = 300),
(n.height = 300),
(n.nodes = []),
(n.edges = []),
(n.onLayoutEnd = function () {}),
n.updateCfg(e),
n
);
}
return (
i(e, t),
(e.prototype.getDefaultCfg = function () {
return { center: [0, 0], width: 300, height: 300 };
}),
(e.prototype.execute = function () {
var t = this,
e = t.nodes,
n = t.center;
return (
t.width ||
"undefined" == typeof window ||
(t.width = window.innerWidth),
t.height ||
"undefined" == typeof window ||
(t.height = window.innerHeight),
e &&
e.forEach(function (e) {
(e.x = 0.9 * (Math.random() - 0.5) * t.width + n[0]),
(e.y = 0.9 * (Math.random() - 0.5) * t.height + n[1]);
}),
t.onLayoutEnd && t.onLayoutEnd(),
{ nodes: e, edges: this.edges }
);
}),
(e.prototype.getType = function () {
return "random";
}),
e
);
})(n(53).Base);
e.RandomLayout = o;
},
53: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }), (e.Base = void 0);
var r = (function () {
function t() {
(this.nodes = []),
(this.edges = []),
(this.combos = []),
(this.positions = []),
(this.destroyed = !1),
(this.onLayoutEnd = function () {});
}
return (
(t.prototype.layout = function (t) {
return this.init(t), this.execute(!0);
}),
(t.prototype.init = function (t) {
(this.nodes = t.nodes || []),
(this.edges = t.edges || []),
(this.combos = t.combos || []);
}),
(t.prototype.execute = function () {}),
(t.prototype.executeWithWorker = function () {}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.updateCfg = function (t) {
t && Object.assign(this, t);
}),
(t.prototype.getType = function () {
return "base";
}),
(t.prototype.destroy = function () {
(this.nodes = null),
(this.edges = null),
(this.combos = null),
(this.positions = null),
(this.destroyed = !0);
}),
t
);
})();
e.Base = r;
},
6: function (t, e, n) {
"use strict";
n.d(e, "d", function () {
return F;
}),
n.d(e, "a", function () {
return cn;
}),
n.d(e, "b", function () {
return un;
}),
n.d(e, "c", function () {
return hn;
}),
n.d(e, "e", function () {
return r;
}),
n.d(e, "g", function () {
return dn;
}),
n.d(e, "l", function () {
return fn;
}),
n.d(e, "h", function () {
return xn;
}),
n.d(e, "f", function () {
return Sn;
}),
n.d(e, "j", function () {
return V;
}),
n.d(e, "k", function () {
return Z;
}),
n.d(e, "i", function () {
return K;
});
var r = {};
n.r(r),
n.d(r, "catmullRomToBezier", function () {
return h;
}),
n.d(r, "fillPath", function () {
return T;
}),
n.d(r, "fillPathByDiff", function () {
return L;
}),
n.d(r, "formatPath", function () {
return R;
}),
n.d(r, "intersection", function () {
return P;
}),
n.d(r, "parsePathArray", function () {
return m;
}),
n.d(r, "parsePathString", function () {
return u;
}),
n.d(r, "pathToAbsolute", function () {
return f;
}),
n.d(r, "pathToCurve", function () {
return v;
}),
n.d(r, "rectPath", function () {
return M;
});
var i = {};
n.r(i),
n.d(i, "easeLinear", function () {
return me;
}),
n.d(i, "easeQuad", function () {
return we;
}),
n.d(i, "easeQuadIn", function () {
return be;
}),
n.d(i, "easeQuadOut", function () {
return xe;
}),
n.d(i, "easeQuadInOut", function () {
return we;
}),
n.d(i, "easeCubic", function () {
return Me;
}),
n.d(i, "easeCubicIn", function () {
return Se;
}),
n.d(i, "easeCubicOut", function () {
return Oe;
}),
n.d(i, "easeCubicInOut", function () {
return Me;
}),
n.d(i, "easePoly", function () {
return Ee;
}),
n.d(i, "easePolyIn", function () {
return ke;
}),
n.d(i, "easePolyOut", function () {
return Ce;
}),
n.d(i, "easePolyInOut", function () {
return Ee;
}),
n.d(i, "easeSin", function () {
return Te;
}),
n.d(i, "easeSinIn", function () {
return Ae;
}),
n.d(i, "easeSinOut", function () {
return Ie;
}),
n.d(i, "easeSinInOut", function () {
return Te;
}),
n.d(i, "easeExp", function () {
return De;
}),
n.d(i, "easeExpIn", function () {
return Be;
}),
n.d(i, "easeExpOut", function () {
return Le;
}),
n.d(i, "easeExpInOut", function () {
return De;
}),
n.d(i, "easeCircle", function () {
return Fe;
}),
n.d(i, "easeCircleIn", function () {
return _e;
}),
n.d(i, "easeCircleOut", function () {
return Re;
}),
n.d(i, "easeCircleInOut", function () {
return Fe;
}),
n.d(i, "easeBounce", function () {
return ze;
}),
n.d(i, "easeBounceIn", function () {
return Xe;
}),
n.d(i, "easeBounceOut", function () {
return ze;
}),
n.d(i, "easeBounceInOut", function () {
return We;
}),
n.d(i, "easeBack", function () {
return Ge;
}),
n.d(i, "easeBackIn", function () {
return qe;
}),
n.d(i, "easeBackOut", function () {
return Ve;
}),
n.d(i, "easeBackInOut", function () {
return Ge;
}),
n.d(i, "easeElastic", function () {
return Ze;
}),
n.d(i, "easeElasticIn", function () {
return Ue;
}),
n.d(i, "easeElasticOut", function () {
return Ze;
}),
n.d(i, "easeElasticInOut", function () {
return Ke;
});
var o = n(0),
a = "\t\n\v\f\r \u2028\u2029",
s = new RegExp(
"([a-z])[" +
a +
",]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[" +
a +
"]*,?[" +
a +
"]*)+)",
"ig",
),
c = new RegExp(
"(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[" + a + "]*,?[" + a + "]*",
"ig",
),
u = function (t) {
if (!t) return null;
if (Object(o.isArray)(t)) return t;
var e = {
a: 7,
c: 6,
o: 2,
h: 1,
l: 2,
m: 2,
r: 4,
q: 4,
s: 4,
t: 2,
v: 1,
u: 3,
z: 0,
},
n = [];
return (
String(t).replace(s, function (r, i, o) {
var a = [],
s = i.toLowerCase();
if (
(o.replace(c, function (t, e) {
e && a.push(+e);
}),
"m" === s &&
a.length > 2 &&
(n.push([i].concat(a.splice(0, 2))),
(s = "l"),
(i = "m" === i ? "l" : "L")),
"o" === s && 1 === a.length && n.push([i, a[0]]),
"r" === s)
)
n.push([i].concat(a));
else
for (
;
a.length >= e[s] &&
(n.push([i].concat(a.splice(0, e[s]))), e[s]);
);
return t;
}),
n
);
},
h = function (t, e) {
for (var n = [], r = 0, i = t.length; i - 2 * !e > r; r += 2) {
var o = [
{ x: +t[r - 2], y: +t[r - 1] },
{ x: +t[r], y: +t[r + 1] },
{ x: +t[r + 2], y: +t[r + 3] },
{ x: +t[r + 4], y: +t[r + 5] },
];
e
? r
? i - 4 === r
? (o[3] = { x: +t[0], y: +t[1] })
: i - 2 === r &&
((o[2] = { x: +t[0], y: +t[1] }),
(o[3] = { x: +t[2], y: +t[3] }))
: (o[0] = { x: +t[i - 2], y: +t[i - 1] })
: i - 4 === r
? (o[3] = o[2])
: r || (o[0] = { x: +t[r], y: +t[r + 1] }),
n.push([
"C",
(-o[0].x + 6 * o[1].x + o[2].x) / 6,
(-o[0].y + 6 * o[1].y + o[2].y) / 6,
(o[1].x + 6 * o[2].x - o[3].x) / 6,
(o[1].y + 6 * o[2].y - o[3].y) / 6,
o[2].x,
o[2].y,
]);
}
return n;
},
l = function (t, e, n, r, i) {
var o = [];
if (
(null === i && null === r && (r = n),
(t = +t),
(e = +e),
(n = +n),
(r = +r),
null !== i)
) {
var a = Math.PI / 180,
s = t + n * Math.cos(-r * a),
c = t + n * Math.cos(-i * a);
o = [
["M", s, e + n * Math.sin(-r * a)],
["A", n, n, 0, +(i - r > 180), 0, c, e + n * Math.sin(-i * a)],
];
} else
o = [
["M", t, e],
["m", 0, -r],
["a", n, r, 0, 1, 1, 0, 2 * r],
["a", n, r, 0, 1, 1, 0, -2 * r],
["z"],
];
return o;
},
f = function (t) {
if (!(t = u(t)) || !t.length) return [["M", 0, 0]];
var e,
n,
r = [],
i = 0,
o = 0,
a = 0,
s = 0,
c = 0;
"M" === t[0][0] &&
((a = i = +t[0][1]), (s = o = +t[0][2]), c++, (r[0] = ["M", i, o]));
for (
var f =
3 === t.length &&
"M" === t[0][0] &&
"R" === t[1][0].toUpperCase() &&
"Z" === t[2][0].toUpperCase(),
d = void 0,
p = void 0,
g = c,
v = t.length;
g < v;
g++
) {
if ((r.push((d = [])), (e = (p = t[g])[0]) !== e.toUpperCase()))
switch (((d[0] = e.toUpperCase()), d[0])) {
case "A":
(d[1] = p[1]),
(d[2] = p[2]),
(d[3] = p[3]),
(d[4] = p[4]),
(d[5] = p[5]),
(d[6] = +p[6] + i),
(d[7] = +p[7] + o);
break;
case "V":
d[1] = +p[1] + o;
break;
case "H":
d[1] = +p[1] + i;
break;
case "R":
for (
var y = 2, m = (n = [i, o].concat(p.slice(1))).length;
y < m;
y++
)
(n[y] = +n[y] + i), (n[++y] = +n[y] + o);
r.pop(), (r = r.concat(h(n, f)));
break;
case "O":
r.pop(),
(n = l(i, o, p[1], p[2])).push(n[0]),
(r = r.concat(n));
break;
case "U":
r.pop(),
(r = r.concat(l(i, o, p[1], p[2], p[3]))),
(d = ["U"].concat(r[r.length - 1].slice(-2)));
break;
case "M":
(a = +p[1] + i), (s = +p[2] + o);
break;
default:
for (y = 1, m = p.length; y < m; y++)
d[y] = +p[y] + (y % 2 ? i : o);
}
else if ("R" === e)
(n = [i, o].concat(p.slice(1))),
r.pop(),
(r = r.concat(h(n, f))),
(d = ["R"].concat(p.slice(-2)));
else if ("O" === e)
r.pop(), (n = l(i, o, p[1], p[2])).push(n[0]), (r = r.concat(n));
else if ("U" === e)
r.pop(),
(r = r.concat(l(i, o, p[1], p[2], p[3]))),
(d = ["U"].concat(r[r.length - 1].slice(-2)));
else for (var b = 0, x = p.length; b < x; b++) d[b] = p[b];
if ("O" !== (e = e.toUpperCase()))
switch (d[0]) {
case "Z":
(i = +a), (o = +s);
break;
case "H":
i = d[1];
break;
case "V":
o = d[1];
break;
case "M":
(a = d[d.length - 2]), (s = d[d.length - 1]);
break;
default:
(i = d[d.length - 2]), (o = d[d.length - 1]);
}
}
return r;
},
d = function (t, e, n, r) {
return [t, e, n, r, n, r];
},
p = function (t, e, n, r, i, o) {
return [
(1 / 3) * t + (2 / 3) * n,
(1 / 3) * e + (2 / 3) * r,
(1 / 3) * i + (2 / 3) * n,
(1 / 3) * o + (2 / 3) * r,
i,
o,
];
},
g = function t(e, n, r, i, o, a, s, c, u, h) {
r === i && (r += 1);
var l,
f,
d,
p,
g,
v = (120 * Math.PI) / 180,
y = (Math.PI / 180) * (+o || 0),
m = [],
b = function (t, e, n) {
return {
x: t * Math.cos(n) - e * Math.sin(n),
y: t * Math.sin(n) + e * Math.cos(n),
};
};
if (h) (f = h[0]), (d = h[1]), (p = h[2]), (g = h[3]);
else {
(e = (l = b(e, n, -y)).x),
(n = l.y),
(c = (l = b(c, u, -y)).x),
(u = l.y),
e === c && n === u && ((c += 1), (u += 1));
var x = (e - c) / 2,
w = (n - u) / 2,
S = (x * x) / (r * r) + (w * w) / (i * i);
S > 1 && ((r *= S = Math.sqrt(S)), (i *= S));
var O = r * r,
M = i * i,
k =
(a === s ? -1 : 1) *
Math.sqrt(
Math.abs(
(O * M - O * w * w - M * x * x) / (O * w * w + M * x * x),
),
);
(p = (k * r * w) / i + (e + c) / 2),
(g = (k * -i * x) / r + (n + u) / 2),
(f = Math.asin(((n - g) / i).toFixed(9))),
(d = Math.asin(((u - g) / i).toFixed(9))),
(f = e < p ? Math.PI - f : f),
(d = c < p ? Math.PI - d : d),
f < 0 && (f = 2 * Math.PI + f),
d < 0 && (d = 2 * Math.PI + d),
s && f > d && (f -= 2 * Math.PI),
!s && d > f && (d -= 2 * Math.PI);
}
var C = d - f;
if (Math.abs(C) > v) {
var E = d,
j = c,
P = u;
(d = f + v * (s && d > f ? 1 : -1)),
(m = t(
(c = p + r * Math.cos(d)),
(u = g + i * Math.sin(d)),
r,
i,
o,
0,
s,
j,
P,
[d, E, p, g],
));
}
C = d - f;
var A = Math.cos(f),
I = Math.sin(f),
T = Math.cos(d),
N = Math.sin(d),
B = Math.tan(C / 4),
L = (4 / 3) * r * B,
D = (4 / 3) * i * B,
_ = [e, n],
R = [e + L * I, n - D * A],
F = [c + L * N, u - D * T],
Y = [c, u];
if (((R[0] = 2 * _[0] - R[0]), (R[1] = 2 * _[1] - R[1]), h))
return [R, F, Y].concat(m);
for (
var X = [],
z = 0,
W = (m = [R, F, Y].concat(m).join().split(",")).length;
z < W;
z++
)
X[z] = z % 2 ? b(m[z - 1], m[z], y).y : b(m[z], m[z + 1], y).x;
return X;
},
v = function (t, e) {
var n,
r = f(t),
i = e && f(e),
o = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
a = { x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null },
s = [],
c = [],
u = "",
h = "",
l = function (t, e, n) {
var r, i;
if (!t) return ["C", e.x, e.y, e.x, e.y, e.x, e.y];
switch (
(!(t[0] in { T: 1, Q: 1 }) && (e.qx = e.qy = null), t[0])
) {
case "M":
(e.X = t[1]), (e.Y = t[2]);
break;
case "A":
t = ["C"].concat(g.apply(0, [e.x, e.y].concat(t.slice(1))));
break;
case "S":
"C" === n || "S" === n
? ((r = 2 * e.x - e.bx), (i = 2 * e.y - e.by))
: ((r = e.x), (i = e.y)),
(t = ["C", r, i].concat(t.slice(1)));
break;
case "T":
"Q" === n || "T" === n
? ((e.qx = 2 * e.x - e.qx), (e.qy = 2 * e.y - e.qy))
: ((e.qx = e.x), (e.qy = e.y)),
(t = ["C"].concat(p(e.x, e.y, e.qx, e.qy, t[1], t[2])));
break;
case "Q":
(e.qx = t[1]),
(e.qy = t[2]),
(t = ["C"].concat(p(e.x, e.y, t[1], t[2], t[3], t[4])));
break;
case "L":
t = ["C"].concat(d(e.x, e.y, t[1], t[2]));
break;
case "H":
t = ["C"].concat(d(e.x, e.y, t[1], e.y));
break;
case "V":
t = ["C"].concat(d(e.x, e.y, e.x, t[1]));
break;
case "Z":
t = ["C"].concat(d(e.x, e.y, e.X, e.Y));
}
return t;
},
v = function (t, e) {
if (t[e].length > 7) {
t[e].shift();
for (var o = t[e]; o.length; )
(s[e] = "A"),
i && (c[e] = "A"),
t.splice(e++, 0, ["C"].concat(o.splice(0, 6)));
t.splice(e, 1), (n = Math.max(r.length, (i && i.length) || 0));
}
},
y = function (t, e, o, a, s) {
t &&
e &&
"M" === t[s][0] &&
"M" !== e[s][0] &&
(e.splice(s, 0, ["M", a.x, a.y]),
(o.bx = 0),
(o.by = 0),
(o.x = t[s][1]),
(o.y = t[s][2]),
(n = Math.max(r.length, (i && i.length) || 0)));
};
n = Math.max(r.length, (i && i.length) || 0);
for (var m = 0; m < n; m++) {
r[m] && (u = r[m][0]),
"C" !== u && ((s[m] = u), m && (h = s[m - 1])),
(r[m] = l(r[m], o, h)),
"A" !== s[m] && "C" === u && (s[m] = "C"),
v(r, m),
i &&
(i[m] && (u = i[m][0]),
"C" !== u && ((c[m] = u), m && (h = c[m - 1])),
(i[m] = l(i[m], a, h)),
"A" !== c[m] && "C" === u && (c[m] = "C"),
v(i, m)),
y(r, i, o, a, m),
y(i, r, a, o, m);
var b = r[m],
x = i && i[m],
w = b.length,
S = i && x.length;
(o.x = b[w - 2]),
(o.y = b[w - 1]),
(o.bx = parseFloat(b[w - 4]) || o.x),
(o.by = parseFloat(b[w - 3]) || o.y),
(a.bx = i && (parseFloat(x[S - 4]) || a.x)),
(a.by = i && (parseFloat(x[S - 3]) || a.y)),
(a.x = i && x[S - 2]),
(a.y = i && x[S - 1]);
}
return i ? [r, i] : r;
},
y = /,?([a-z]),?/gi,
m = function (t) {
return t.join(",").replace(y, "$1");
},
b = function (t, e, n, r, i) {
return (
t *
(t * (-3 * e + 9 * n - 9 * r + 3 * i) + 6 * e - 12 * n + 6 * r) -
3 * e +
3 * n
);
},
x = function (t, e, n, r, i, o, a, s, c) {
null === c && (c = 1);
for (
var u = (c = c > 1 ? 1 : c < 0 ? 0 : c) / 2,
h = [
-0.1252, 0.1252, -0.3678, 0.3678, -0.5873, 0.5873, -0.7699,
0.7699, -0.9041, 0.9041, -0.9816, 0.9816,
],
l = [
0.2491, 0.2491, 0.2335, 0.2335, 0.2032, 0.2032, 0.1601, 0.1601,
0.1069, 0.1069, 0.0472, 0.0472,
],
f = 0,
d = 0;
d < 12;
d++
) {
var p = u * h[d] + u,
g = b(p, t, n, i, a),
v = b(p, e, r, o, s),
y = g * g + v * v;
f += l[d] * Math.sqrt(y);
}
return u * f;
},
w = function (t, e, n, r, i, o, a, s) {
for (var c, u, h, l, f = [], d = [[], []], p = 0; p < 2; ++p)
if (
(0 === p
? ((u = 6 * t - 12 * n + 6 * i),
(c = -3 * t + 9 * n - 9 * i + 3 * a),
(h = 3 * n - 3 * t))
: ((u = 6 * e - 12 * r + 6 * o),
(c = -3 * e + 9 * r - 9 * o + 3 * s),
(h = 3 * r - 3 * e)),
Math.abs(c) < 1e-12)
) {
if (Math.abs(u) < 1e-12) continue;
(l = -h / u) > 0 && l < 1 && f.push(l);
} else {
var g = u * u - 4 * h * c,
v = Math.sqrt(g);
if (!(g < 0)) {
var y = (-u + v) / (2 * c);
y > 0 && y < 1 && f.push(y);
var m = (-u - v) / (2 * c);
m > 0 && m < 1 && f.push(m);
}
}
for (var b, x = f.length, w = x; x--; )
(b = 1 - (l = f[x])),
(d[0][x] =
b * b * b * t +
3 * b * b * l * n +
3 * b * l * l * i +
l * l * l * a),
(d[1][x] =
b * b * b * e +
3 * b * b * l * r +
3 * b * l * l * o +
l * l * l * s);
return (
(d[0][w] = t),
(d[1][w] = e),
(d[0][w + 1] = a),
(d[1][w + 1] = s),
(d[0].length = d[1].length = w + 2),
{
min: { x: Math.min.apply(0, d[0]), y: Math.min.apply(0, d[1]) },
max: { x: Math.max.apply(0, d[0]), y: Math.max.apply(0, d[1]) },
}
);
},
S = function (t, e, n, r, i, o, a, s) {
if (
!(
Math.max(t, n) < Math.min(i, a) ||
Math.min(t, n) > Math.max(i, a) ||
Math.max(e, r) < Math.min(o, s) ||
Math.min(e, r) > Math.max(o, s)
)
) {
var c = (t - n) * (o - s) - (e - r) * (i - a);
if (c) {
var u =
((t * r - e * n) * (i - a) - (t - n) * (i * s - o * a)) / c,
h = ((t * r - e * n) * (o - s) - (e - r) * (i * s - o * a)) / c,
l = +u.toFixed(2),
f = +h.toFixed(2);
if (
!(
l < +Math.min(t, n).toFixed(2) ||
l > +Math.max(t, n).toFixed(2) ||
l < +Math.min(i, a).toFixed(2) ||
l > +Math.max(i, a).toFixed(2) ||
f < +Math.min(e, r).toFixed(2) ||
f > +Math.max(e, r).toFixed(2) ||
f < +Math.min(o, s).toFixed(2) ||
f > +Math.max(o, s).toFixed(2)
)
)
return { x: u, y: h };
}
}
},
O = function (t, e, n) {
return (
e >= t.x && e <= t.x + t.width && n >= t.y && n <= t.y + t.height
);
},
M = function (t, e, n, r, i) {
if (i)
return [
["M", +t + +i, e],
["l", n - 2 * i, 0],
["a", i, i, 0, 0, 1, i, i],
["l", 0, r - 2 * i],
["a", i, i, 0, 0, 1, -i, i],
["l", 2 * i - n, 0],
["a", i, i, 0, 0, 1, -i, -i],
["l", 0, 2 * i - r],
["a", i, i, 0, 0, 1, i, -i],
["z"],
];
var o = [["M", t, e], ["l", n, 0], ["l", 0, r], ["l", -n, 0], ["z"]];
return (o.parsePathArray = m), o;
},
k = function (t, e, n, r) {
return (
null === t && (t = e = n = r = 0),
null === e && ((e = t.y), (n = t.width), (r = t.height), (t = t.x)),
{
x: t,
y: e,
width: n,
w: n,
height: r,
h: r,
x2: t + n,
y2: e + r,
cx: t + n / 2,
cy: e + r / 2,
r1: Math.min(n, r) / 2,
r2: Math.max(n, r) / 2,
r0: Math.sqrt(n * n + r * r) / 2,
path: M(t, e, n, r),
vb: [t, e, n, r].join(" "),
}
);
},
C = function (t, e, n, r, i, a, s, c) {
Object(o.isArray)(t) || (t = [t, e, n, r, i, a, s, c]);
var u = w.apply(null, t);
return k(u.min.x, u.min.y, u.max.x - u.min.x, u.max.y - u.min.y);
},
E = function (t, e, n, r, i, o, a, s, c) {
var u = 1 - c,
h = Math.pow(u, 3),
l = Math.pow(u, 2),
f = c * c,
d = f * c,
p = t + 2 * c * (n - t) + f * (i - 2 * n + t),
g = e + 2 * c * (r - e) + f * (o - 2 * r + e),
v = n + 2 * c * (i - n) + f * (a - 2 * i + n),
y = r + 2 * c * (o - r) + f * (s - 2 * o + r);
return {
x: h * t + 3 * l * c * n + 3 * u * c * c * i + d * a,
y: h * e + 3 * l * c * r + 3 * u * c * c * o + d * s,
m: { x: p, y: g },
n: { x: v, y: y },
start: { x: u * t + c * n, y: u * e + c * r },
end: { x: u * i + c * a, y: u * o + c * s },
alpha: 90 - (180 * Math.atan2(p - v, g - y)) / Math.PI,
};
},
j = function (t, e, n) {
if (
!(function (t, e) {
return (
(t = k(t)),
(e = k(e)),
O(e, t.x, t.y) ||
O(e, t.x2, t.y) ||
O(e, t.x, t.y2) ||
O(e, t.x2, t.y2) ||
O(t, e.x, e.y) ||
O(t, e.x2, e.y) ||
O(t, e.x, e.y2) ||
O(t, e.x2, e.y2) ||
(((t.x < e.x2 && t.x > e.x) || (e.x < t.x2 && e.x > t.x)) &&
((t.y < e.y2 && t.y > e.y) || (e.y < t.y2 && e.y > t.y)))
);
})(C(t), C(e))
)
return n ? 0 : [];
for (
var r = ~~(x.apply(0, t) / 8),
i = ~~(x.apply(0, e) / 8),
o = [],
a = [],
s = {},
c = n ? 0 : [],
u = 0;
u < r + 1;
u++
) {
var h = E.apply(0, t.concat(u / r));
o.push({ x: h.x, y: h.y, t: u / r });
}
for (u = 0; u < i + 1; u++) {
h = E.apply(0, e.concat(u / i));
a.push({ x: h.x, y: h.y, t: u / i });
}
for (u = 0; u < r; u++)
for (var l = 0; l < i; l++) {
var f = o[u],
d = o[u + 1],
p = a[l],
g = a[l + 1],
v = Math.abs(d.x - f.x) < 0.001 ? "y" : "x",
y = Math.abs(g.x - p.x) < 0.001 ? "y" : "x",
m = S(f.x, f.y, d.x, d.y, p.x, p.y, g.x, g.y);
if (m) {
if (s[m.x.toFixed(4)] === m.y.toFixed(4)) continue;
s[m.x.toFixed(4)] = m.y.toFixed(4);
var b =
f.t + Math.abs((m[v] - f[v]) / (d[v] - f[v])) * (d.t - f.t),
w =
p.t + Math.abs((m[y] - p[y]) / (g[y] - p[y])) * (g.t - p.t);
b >= 0 &&
b <= 1 &&
w >= 0 &&
w <= 1 &&
(n ? (c += 1) : c.push({ x: m.x, y: m.y, t1: b, t2: w }));
}
}
return c;
},
P = function (t, e) {
return (function (t, e, n) {
var r, i, o, a, s, c, u, h, l, f;
(t = v(t)), (e = v(e));
for (var d = n ? 0 : [], p = 0, g = t.length; p < g; p++) {
var y = t[p];
if ("M" === y[0]) (r = s = y[1]), (i = c = y[2]);
else {
"C" === y[0]
? ((l = [r, i].concat(y.slice(1))), (r = l[6]), (i = l[7]))
: ((l = [r, i, r, i, s, c, s, c]), (r = s), (i = c));
for (var m = 0, b = e.length; m < b; m++) {
var x = e[m];
if ("M" === x[0]) (o = u = x[1]), (a = h = x[2]);
else {
"C" === x[0]
? ((f = [o, a].concat(x.slice(1))),
(o = f[6]),
(a = f[7]))
: ((f = [o, a, o, a, u, h, u, h]), (o = u), (a = h));
var w = j(l, f, n);
if (n) d += w;
else {
for (var S = 0, O = w.length; S < O; S++)
(w[S].segment1 = p),
(w[S].segment2 = m),
(w[S].bez1 = l),
(w[S].bez2 = f);
d = d.concat(w);
}
}
}
}
}
return d;
})(t, e);
};
function A(t, e) {
var n = [],
r = [];
return (
t.length &&
(function t(e, i) {
if (1 === e.length) n.push(e[0]), r.push(e[0]);
else {
for (var o = [], a = 0; a < e.length - 1; a++)
0 === a && n.push(e[0]),
a === e.length - 2 && r.push(e[a + 1]),
(o[a] = [
(1 - i) * e[a][0] + i * e[a + 1][0],
(1 - i) * e[a][1] + i * e[a + 1][1],
]);
t(o, i);
}
})(t, e),
{ left: n, right: r.reverse() }
);
}
var I = function (t, e, n) {
if (1 === n) return [[].concat(t)];
var r = [];
if ("L" === e[0] || "C" === e[0] || "Q" === e[0])
r = r.concat(
(function (t, e, n) {
var r = [[t[1], t[2]]];
n = n || 2;
var i = [];
"A" === e[0]
? (r.push(e[6]), r.push(e[7]))
: "C" === e[0]
? (r.push([e[1], e[2]]),
r.push([e[3], e[4]]),
r.push([e[5], e[6]]))
: "S" === e[0] || "Q" === e[0]
? (r.push([e[1], e[2]]), r.push([e[3], e[4]]))
: r.push([e[1], e[2]]);
for (var o = r, a = 1 / n, s = 0; s < n - 1; s++) {
var c = A(o, a / (1 - a * s));
i.push(c.left), (o = c.right);
}
return (
i.push(o),
i.map(function (t) {
var e = [];
return (
4 === t.length && (e.push("C"), (e = e.concat(t[2]))),
t.length >= 3 &&
(3 === t.length && e.push("Q"), (e = e.concat(t[1]))),
2 === t.length && e.push("L"),
(e = e.concat(t[t.length - 1]))
);
})
);
})(t, e, n),
);
else {
var i = [].concat(t);
"M" === i[0] && (i[0] = "L");
for (var o = 0; o <= n - 1; o++) r.push(i);
}
return r;
},
T = function (t, e) {
if (1 === t.length) return t;
var n = t.length - 1,
r = e.length - 1,
i = n / r,
o = [];
if (1 === t.length && "M" === t[0][0]) {
for (var a = 0; a < r - n; a++) t.push(t[0]);
return t;
}
for (a = 0; a < r; a++) {
var s = Math.floor(i * a);
o[s] = (o[s] || 0) + 1;
}
var c = o.reduce(function (e, r, i) {
return i === n ? e.concat(t[n]) : e.concat(I(t[i], t[i + 1], r));
}, []);
return (
c.unshift(t[0]), ("Z" !== e[r] && "z" !== e[r]) || c.push("Z"), c
);
},
N = function (t, e) {
if (t.length !== e.length) return !1;
var n = !0;
return (
Object(o.each)(t, function (t, r) {
if (t !== e[r]) return (n = !1), !1;
}),
n
);
};
function B(t, e, n) {
var r = null,
i = n;
return (
e < i && ((i = e), (r = "add")),
t < i && ((i = t), (r = "del")),
{ type: r, min: i }
);
}
var L = function (t, e) {
var n = (function (t, e) {
var n,
r,
i = t.length,
o = e.length,
a = 0;
if (0 === i || 0 === o) return null;
for (var s = [], c = 0; c <= i; c++)
(s[c] = []), (s[c][0] = { min: c });
for (var u = 0; u <= o; u++) s[0][u] = { min: u };
for (c = 1; c <= i; c++) {
n = t[c - 1];
for (u = 1; u <= o; u++) {
(r = e[u - 1]), (a = N(n, r) ? 0 : 1);
var h = s[c - 1][u].min + 1,
l = s[c][u - 1].min + 1,
f = s[c - 1][u - 1].min + a;
s[c][u] = B(h, l, f);
}
}
return s;
})(t, e),
r = t.length,
i = e.length,
o = [],
a = 1,
s = 1;
if (n[r][i].min !== r) {
for (var c = 1; c <= r; c++) {
var u = n[c][c].min;
s = c;
for (var h = a; h <= i; h++)
n[c][h].min < u && ((u = n[c][h].min), (s = h));
(a = s),
n[c][a].type && o.push({ index: c - 1, type: n[c][a].type });
}
for (c = o.length - 1; c >= 0; c--)
(a = o[c].index),
"add" === o[c].type
? t.splice(a, 0, [].concat(t[a]))
: t.splice(a, 1);
}
var l = i - (r = t.length);
if (r < i)
for (c = 0; c < l; c++)
"z" === t[r - 1][0] || "Z" === t[r - 1][0]
? t.splice(r - 2, 0, t[r - 2])
: t.push(t[r - 1]),
(r += 1);
return t;
};
function D(t, e, n) {
for (
var r, i = [].concat(t), o = 1 / (n + 1), a = _(e)[0], s = 1;
s <= n;
s++
)
(o *= s),
0 === (r = Math.floor(t.length * o))
? i.unshift([
a[0] * o + t[r][0] * (1 - o),
a[1] * o + t[r][1] * (1 - o),
])
: i.splice(r, 0, [
a[0] * o + t[r][0] * (1 - o),
a[1] * o + t[r][1] * (1 - o),
]);
return i;
}
function _(t) {
var e = [];
switch (t[0]) {
case "M":
case "L":
e.push([t[1], t[2]]);
break;
case "A":
e.push([t[6], t[7]]);
break;
case "Q":
e.push([t[3], t[4]]), e.push([t[1], t[2]]);
break;
case "T":
e.push([t[1], t[2]]);
break;
case "C":
e.push([t[5], t[6]]), e.push([t[1], t[2]]), e.push([t[3], t[4]]);
break;
case "S":
e.push([t[3], t[4]]), e.push([t[1], t[2]]);
break;
case "H":
case "V":
e.push([t[1], t[1]]);
}
return e;
}
var R = function (t, e) {
if (t.length <= 1) return t;
for (var n, r = 0; r < e.length; r++)
if (t[r][0] !== e[r][0])
switch (((n = _(t[r])), e[r][0])) {
case "M":
t[r] = ["M"].concat(n[0]);
break;
case "L":
t[r] = ["L"].concat(n[0]);
break;
case "A":
(t[r] = [].concat(e[r])),
(t[r][6] = n[0][0]),
(t[r][7] = n[0][1]);
break;
case "Q":
if (n.length < 2) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = D(n, t[r - 1], 1);
}
t[r] = ["Q"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
case "T":
t[r] = ["T"].concat(n[0]);
break;
case "C":
if (n.length < 3) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = D(n, t[r - 1], 2);
}
t[r] = ["C"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
case "S":
if (n.length < 2) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = D(n, t[r - 1], 1);
}
t[r] = ["S"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
default:
t[r] = e[r];
}
return t;
},
F = (function () {
function t(t, e) {
(this.bubbles = !0),
(this.target = null),
(this.currentTarget = null),
(this.delegateTarget = null),
(this.delegateObject = null),
(this.defaultPrevented = !1),
(this.propagationStopped = !1),
(this.shape = null),
(this.fromShape = null),
(this.toShape = null),
(this.propagationPath = []),
(this.type = t),
(this.name = t),
(this.originalEvent = e),
(this.timeStamp = e.timeStamp);
}
return (
(t.prototype.preventDefault = function () {
(this.defaultPrevented = !0),
this.originalEvent.preventDefault &&
this.originalEvent.preventDefault();
}),
(t.prototype.stopPropagation = function () {
this.propagationStopped = !0;
}),
(t.prototype.toString = function () {
return "[Event (type=" + this.type + ")]";
}),
(t.prototype.save = function () {}),
(t.prototype.restore = function () {}),
t
);
})(),
Y = n(1),
X = n(73);
function z(t, e) {
var n = t.indexOf(e);
-1 !== n && t.splice(n, 1);
}
var W = "undefined" != typeof window && void 0 !== window.document;
function q(t, e) {
if (t.isCanvas()) return !0;
for (var n = e.getParent(), r = !1; n; ) {
if (n === t) {
r = !0;
break;
}
n = n.getParent();
}
return r;
}
function V(t) {
return t.cfg.visible && t.cfg.capture;
}
var G = (function (t) {
function e(e) {
var n = t.call(this) || this;
n.destroyed = !1;
var r = n.getDefaultCfg();
return (n.cfg = Object(o.mix)(r, e)), n;
}
return (
Object(Y.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.get = function (t) {
return this.cfg[t];
}),
(e.prototype.set = function (t, e) {
this.cfg[t] = e;
}),
(e.prototype.destroy = function () {
(this.cfg = { destroyed: !0 }), this.off(), (this.destroyed = !0);
}),
e
);
})(X.a),
H = n(157);
function U(t, e) {
var n = [],
r = t[0],
i = t[1],
o = t[2],
a = t[3],
s = t[4],
c = t[5],
u = t[6],
h = t[7],
l = t[8],
f = e[0],
d = e[1],
p = e[2],
g = e[3],
v = e[4],
y = e[5],
m = e[6],
b = e[7],
x = e[8];
return (
(n[0] = f * r + d * a + p * u),
(n[1] = f * i + d * s + p * h),
(n[2] = f * o + d * c + p * l),
(n[3] = g * r + v * a + y * u),
(n[4] = g * i + v * s + y * h),
(n[5] = g * o + v * c + y * l),
(n[6] = m * r + b * a + x * u),
(n[7] = m * i + b * s + x * h),
(n[8] = m * o + b * c + x * l),
n
);
}
function Z(t, e) {
var n = [],
r = e[0],
i = e[1];
return (
(n[0] = t[0] * r + t[3] * i + t[6]),
(n[1] = t[1] * r + t[4] * i + t[7]),
n
);
}
function K(t) {
var e = [],
n = t[0],
r = t[1],
i = t[2],
o = t[3],
a = t[4],
s = t[5],
c = t[6],
u = t[7],
h = t[8],
l = h * a - s * u,
f = -h * o + s * c,
d = u * o - a * c,
p = n * l + r * f + i * d;
return p
? ((p = 1 / p),
(e[0] = l * p),
(e[1] = (-h * r + i * u) * p),
(e[2] = (s * r - i * a) * p),
(e[3] = f * p),
(e[4] = (h * n - i * c) * p),
(e[5] = (-s * n + i * o) * p),
(e[6] = d * p),
(e[7] = (-u * n + r * c) * p),
(e[8] = (a * n - r * o) * p),
e)
: null;
}
var $ = n(3).a.transform,
Q = ["zIndex", "capture", "visible", "type"],
J = ["repeat"];
function tt(t, e) {
var n = {},
r = e.attrs;
for (var i in t) n[i] = r[i];
return n;
}
function et(t, e) {
var n = {},
r = e.attr();
return (
Object(o.each)(t, function (t, e) {
-1 !== J.indexOf(e) || Object(o.isEqual)(r[e], t) || (n[e] = t);
}),
n
);
}
function nt(t, e) {
if (e.onFrame) return t;
var n = e.startTime,
r = e.delay,
i = e.duration,
a = Object.prototype.hasOwnProperty;
return (
Object(o.each)(t, function (t) {
n + r < t.startTime + t.delay + t.duration &&
i > t.delay &&
Object(o.each)(e.toAttrs, function (e, n) {
a.call(t.toAttrs, n) &&
(delete t.toAttrs[n], delete t.fromAttrs[n]);
});
}),
t
);
}
var rt = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
n.attrs = {};
var r = n.getDefaultAttrs();
return (
Object(o.mix)(r, e.attrs),
(n.attrs = r),
n.initAttrs(r),
n.initAnimate(),
n
);
}
return (
Object(Y.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return { visible: !0, capture: !0, zIndex: 0 };
}),
(e.prototype.getDefaultAttrs = function () {
return { matrix: this.getDefaultMatrix(), opacity: 1 };
}),
(e.prototype.onCanvasChange = function (t) {}),
(e.prototype.initAttrs = function (t) {}),
(e.prototype.initAnimate = function () {
this.set("animable", !0), this.set("animating", !1);
}),
(e.prototype.isGroup = function () {
return !1;
}),
(e.prototype.getParent = function () {
return this.get("parent");
}),
(e.prototype.getCanvas = function () {
return this.get("canvas");
}),
(e.prototype.attr = function () {
for (var t, e = [], n = 0; n < arguments.length; n++)
e[n] = arguments[n];
var r = e[0],
i = e[1];
if (!r) return this.attrs;
if (Object(o.isObject)(r)) {
for (var a in r) this.setAttr(a, r[a]);
return this.afterAttrsChange(r), this;
}
return 2 === e.length
? (this.setAttr(r, i),
this.afterAttrsChange((((t = {})[r] = i), t)),
this)
: this.attrs[r];
}),
(e.prototype.isClipped = function (t, e) {
var n = this.getClip();
return n && !n.isHit(t, e);
}),
(e.prototype.setAttr = function (t, e) {
var n = this.attrs[t];
n !== e && ((this.attrs[t] = e), this.onAttrChange(t, e, n));
}),
(e.prototype.onAttrChange = function (t, e, n) {
"matrix" === t && this.set("totalMatrix", null);
}),
(e.prototype.afterAttrsChange = function (t) {
if (this.cfg.isClipShape) {
var e = this.cfg.applyTo;
e && e.onCanvasChange("clip");
} else this.onCanvasChange("attr");
}),
(e.prototype.show = function () {
return this.set("visible", !0), this.onCanvasChange("show"), this;
}),
(e.prototype.hide = function () {
return this.set("visible", !1), this.onCanvasChange("hide"), this;
}),
(e.prototype.setZIndex = function (t) {
this.set("zIndex", t);
var e = this.getParent();
return e && e.sort(), this;
}),
(e.prototype.toFront = function () {
var t = this.getParent();
if (t) {
var e = t.getChildren(),
n = (this.get("el"), e.indexOf(this));
e.splice(n, 1), e.push(this), this.onCanvasChange("zIndex");
}
}),
(e.prototype.toBack = function () {
var t = this.getParent();
if (t) {
var e = t.getChildren(),
n = (this.get("el"), e.indexOf(this));
e.splice(n, 1), e.unshift(this), this.onCanvasChange("zIndex");
}
}),
(e.prototype.remove = function (t) {
void 0 === t && (t = !0);
var e = this.getParent();
e
? (z(e.getChildren(), this),
e.get("clearing") || this.onCanvasChange("remove"))
: this.onCanvasChange("remove"),
t && this.destroy();
}),
(e.prototype.resetMatrix = function () {
this.attr("matrix", this.getDefaultMatrix()),
this.onCanvasChange("matrix");
}),
(e.prototype.getMatrix = function () {
return this.attr("matrix");
}),
(e.prototype.setMatrix = function (t) {
this.attr("matrix", t), this.onCanvasChange("matrix");
}),
(e.prototype.getTotalMatrix = function () {
var t = this.cfg.totalMatrix;
if (!t) {
var e = this.attr("matrix"),
n = this.cfg.parentMatrix;
(t = n && e ? U(n, e) : e || n), this.set("totalMatrix", t);
}
return t;
}),
(e.prototype.applyMatrix = function (t) {
var e = this.attr("matrix"),
n = null;
(n = t && e ? U(t, e) : e || t),
this.set("totalMatrix", n),
this.set("parentMatrix", t);
}),
(e.prototype.getDefaultMatrix = function () {
return null;
}),
(e.prototype.applyToMatrix = function (t) {
var e = this.attr("matrix");
return e ? Z(e, t) : t;
}),
(e.prototype.invertFromMatrix = function (t) {
var e = this.attr("matrix");
if (e) {
var n = K(e);
if (n) return Z(n, t);
}
return t;
}),
(e.prototype.setClip = function (t) {
var e = this.getCanvas(),
n = null;
if (t) {
var r = this.getShapeBase()[Object(o.upperFirst)(t.type)];
r &&
(n = new r({
type: t.type,
isClipShape: !0,
applyTo: this,
attrs: t.attrs,
canvas: e,
}));
}
return this.set("clipShape", n), this.onCanvasChange("clip"), n;
}),
(e.prototype.getClip = function () {
var t = this.cfg.clipShape;
return t || null;
}),
(e.prototype.clone = function () {
var t = this,
e = this.attrs,
n = {};
Object(o.each)(e, function (t, r) {
Object(o.isArray)(e[r])
? (n[r] = (function (t) {
for (var e = [], n = 0; n < t.length; n++)
Object(o.isArray)(t[n])
? e.push([].concat(t[n]))
: e.push(t[n]);
return e;
})(e[r]))
: (n[r] = e[r]);
});
var r = new (0, this.constructor)({ attrs: n });
return (
Object(o.each)(Q, function (e) {
r.set(e, t.get(e));
}),
r
);
}),
(e.prototype.destroy = function () {
this.destroyed ||
((this.attrs = {}), t.prototype.destroy.call(this));
}),
(e.prototype.isAnimatePaused = function () {
return this.get("_pause").isPaused;
}),
(e.prototype.animate = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
if (this.get("timeline") || this.get("canvas")) {
this.set("animating", !0);
var n = this.get("timeline");
n ||
((n = this.get("canvas").get("timeline")),
this.set("timeline", n));
var r = this.get("animations") || [];
n.timer || n.initTimer();
var i,
a,
s,
c,
u,
h = t[0],
l = t[1],
f = t[2],
d = void 0 === f ? "easeLinear" : f,
p = t[3],
g = void 0 === p ? o.noop : p,
v = t[4],
y = void 0 === v ? 0 : v;
Object(o.isFunction)(h)
? ((i = h), (h = {}))
: Object(o.isObject)(h) &&
h.onFrame &&
((i = h.onFrame), (a = h.repeat)),
Object(o.isObject)(l)
? ((l = (u = l).duration),
(d = u.easing || "easeLinear"),
(y = u.delay || 0),
(a = u.repeat || a || !1),
(g = u.callback || o.noop),
(s = u.pauseCallback || o.noop),
(c = u.resumeCallback || o.noop))
: (Object(o.isNumber)(g) && ((y = g), (g = null)),
Object(o.isFunction)(d)
? ((g = d), (d = "easeLinear"))
: (d = d || "easeLinear"));
var m = et(h, this),
b = {
fromAttrs: tt(m, this),
toAttrs: m,
duration: l,
easing: d,
repeat: a,
callback: g,
pauseCallback: s,
resumeCallback: c,
delay: y,
startTime: n.getTime(),
id: Object(o.uniqueId)(),
onFrame: i,
pathFormatted: !1,
};
r.length > 0 ? (r = nt(r, b)) : n.addAnimator(this),
r.push(b),
this.set("animations", r),
this.set("_pause", { isPaused: !1 });
}
}),
(e.prototype.stopAnimate = function (t) {
var e = this;
void 0 === t && (t = !0);
var n = this.get("animations");
Object(o.each)(n, function (n) {
t && (n.onFrame ? e.attr(n.onFrame(1)) : e.attr(n.toAttrs)),
n.callback && n.callback();
}),
this.set("animating", !1),
this.set("animations", []);
}),
(e.prototype.pauseAnimate = function () {
var t = this.get("timeline"),
e = this.get("animations"),
n = t.getTime();
return (
Object(o.each)(e, function (t) {
(t._paused = !0),
(t._pauseTime = n),
t.pauseCallback && t.pauseCallback();
}),
this.set("_pause", { isPaused: !0, pauseTime: n }),
this
);
}),
(e.prototype.resumeAnimate = function () {
var t = this.get("timeline").getTime(),
e = this.get("animations"),
n = this.get("_pause").pauseTime;
return (
Object(o.each)(e, function (e) {
(e.startTime = e.startTime + (t - n)),
(e._paused = !1),
(e._pauseTime = null),
e.resumeCallback && e.resumeCallback();
}),
this.set("_pause", { isPaused: !1 }),
this.set("animations", e),
this
);
}),
(e.prototype.emitDelegation = function (t, e) {
var n,
r = this,
i = e.propagationPath;
this.getEvents();
"mouseenter" === t
? (n = e.fromShape)
: "mouseleave" === t && (n = e.toShape);
for (
var a = function (t) {
var a = i[t],
c = a.get("name");
if (c) {
if (
(a.isGroup() || (a.isCanvas && a.isCanvas())) &&
n &&
q(a, n)
)
return "break";
Object(o.isArray)(c)
? Object(o.each)(c, function (t) {
r.emitDelegateEvent(a, t, e);
})
: s.emitDelegateEvent(a, c, e);
}
},
s = this,
c = 0;
c < i.length;
c++
) {
if ("break" === a(c)) break;
}
}),
(e.prototype.emitDelegateEvent = function (t, e, n) {
var r = this.getEvents(),
i = e + ":" + n.type;
(r[i] || r["*"]) &&
((n.name = i),
(n.currentTarget = t),
(n.delegateTarget = this),
(n.delegateObject = t.get("delegateObject")),
this.emit(i, n));
}),
(e.prototype.translate = function (t, e) {
void 0 === t && (t = 0), void 0 === e && (e = 0);
var n = this.getMatrix(),
r = $(n, [["t", t, e]]);
return this.setMatrix(r), this;
}),
(e.prototype.move = function (t, e) {
var n = this.attr("x") || 0,
r = this.attr("y") || 0;
return this.translate(t - n, e - r), this;
}),
(e.prototype.moveTo = function (t, e) {
return this.move(t, e);
}),
(e.prototype.scale = function (t, e) {
var n = this.getMatrix(),
r = $(n, [["s", t, e || t]]);
return this.setMatrix(r), this;
}),
(e.prototype.rotate = function (t) {
var e = this.getMatrix(),
n = $(e, [["r", t]]);
return this.setMatrix(n), this;
}),
(e.prototype.rotateAtStart = function (t) {
var e = this.attr(),
n = e.x,
r = e.y,
i = this.getMatrix(),
o = $(i, [
["t", -n, -r],
["r", t],
["t", n, r],
]);
return this.setMatrix(o), this;
}),
(e.prototype.rotateAtPoint = function (t, e, n) {
var r = this.getMatrix(),
i = $(r, [
["t", -t, -e],
["r", n],
["t", t, e],
]);
return this.setMatrix(i), this;
}),
e
);
})(G),
it = {};
var ot = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(Y.c)(e, t),
(e.prototype.isCanvas = function () {
return !1;
}),
(e.prototype.getBBox = function () {
var t = 1 / 0,
e = -1 / 0,
n = 1 / 0,
r = -1 / 0,
i = [],
a = [],
s = this.getChildren().filter(function (t) {
return (
t.get("visible") &&
(!t.isGroup() || (t.isGroup() && t.getChildren().length > 0))
);
});
return (
s.length > 0
? (Object(o.each)(s, function (t) {
var e = t.getBBox();
i.push(e.minX, e.maxX), a.push(e.minY, e.maxY);
}),
(t = Object(o.min)(i)),
(e = Object(o.max)(i)),
(n = Object(o.min)(a)),
(r = Object(o.max)(a)))
: ((t = 0), (e = 0), (n = 0), (r = 0)),
{
x: t,
y: n,
minX: t,
minY: n,
maxX: e,
maxY: r,
width: e - t,
height: r - n,
}
);
}),
(e.prototype.getCanvasBBox = function () {
var t = 1 / 0,
e = -1 / 0,
n = 1 / 0,
r = -1 / 0,
i = [],
a = [],
s = this.getChildren().filter(function (t) {
return (
t.get("visible") &&
(!t.isGroup() || (t.isGroup() && t.getChildren().length > 0))
);
});
return (
s.length > 0
? (Object(o.each)(s, function (t) {
var e = t.getCanvasBBox();
i.push(e.minX, e.maxX), a.push(e.minY, e.maxY);
}),
(t = Object(o.min)(i)),
(e = Object(o.max)(i)),
(n = Object(o.min)(a)),
(r = Object(o.max)(a)))
: ((t = 0), (e = 0), (n = 0), (r = 0)),
{
x: t,
y: n,
minX: t,
minY: n,
maxX: e,
maxY: r,
width: e - t,
height: r - n,
}
);
}),
(e.prototype.getDefaultCfg = function () {
var e = t.prototype.getDefaultCfg.call(this);
return (e.children = []), e;
}),
(e.prototype.onAttrChange = function (e, n, r) {
if (
(t.prototype.onAttrChange.call(this, e, n, r), "matrix" === e)
) {
var i = this.getTotalMatrix();
this._applyChildrenMarix(i);
}
}),
(e.prototype.applyMatrix = function (e) {
var n = this.getTotalMatrix();
t.prototype.applyMatrix.call(this, e);
var r = this.getTotalMatrix();
r !== n && this._applyChildrenMarix(r);
}),
(e.prototype._applyChildrenMarix = function (t) {
var e = this.getChildren();
Object(o.each)(e, function (e) {
e.applyMatrix(t);
});
}),
(e.prototype.addShape = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
var n = t[0],
r = t[1];
Object(o.isObject)(n) ? (r = n) : (r.type = n);
var i = it[r.type];
i || ((i = Object(o.upperFirst)(r.type)), (it[r.type] = i));
var a = this.getShapeBase(),
s = new a[i](r);
return this.add(s), s;
}),
(e.prototype.addGroup = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
var n,
r = t[0],
i = t[1];
if (Object(o.isFunction)(r)) n = new r(i || { parent: this });
else {
var a = r || {},
s = this.getGroupBase();
n = new s(a);
}
return this.add(n), n;
}),
(e.prototype.getCanvas = function () {
return this.isCanvas() ? this : this.get("canvas");
}),
(e.prototype.getShape = function (t, e, n) {
if (!V(this)) return null;
var r,
i = this.getChildren();
if (this.isCanvas()) r = this._findShape(i, t, e, n);
else {
var o = [t, e, 1];
(o = this.invertFromMatrix(o)),
this.isClipped(o[0], o[1]) ||
(r = this._findShape(i, o[0], o[1], n));
}
return r;
}),
(e.prototype._findShape = function (t, e, n, r) {
for (var i = null, o = t.length - 1; o >= 0; o--) {
var a = t[o];
if (
(V(a) &&
(a.isGroup()
? (i = a.getShape(e, n, r))
: a.isHit(e, n) && (i = a)),
i)
)
break;
}
return i;
}),
(e.prototype.add = function (t) {
var e = this.getCanvas(),
n = this.getChildren(),
r = this.get("timeline"),
i = t.getParent();
i &&
(function (t, e, n) {
void 0 === n && (n = !0),
n
? e.destroy()
: (e.set("parent", null), e.set("canvas", null)),
z(t.getChildren(), e);
})(i, t, !1),
t.set("parent", this),
e &&
(function t(e, n) {
if ((e.set("canvas", n), e.isGroup())) {
var r = e.get("children");
r.length &&
r.forEach(function (e) {
t(e, n);
});
}
})(t, e),
r &&
(function t(e, n) {
if ((e.set("timeline", n), e.isGroup())) {
var r = e.get("children");
r.length &&
r.forEach(function (e) {
t(e, n);
});
}
})(t, r),
n.push(t),
t.onCanvasChange("add"),
this._applyElementMatrix(t);
}),
(e.prototype._applyElementMatrix = function (t) {
var e = this.getTotalMatrix();
e && t.applyMatrix(e);
}),
(e.prototype.getChildren = function () {
return this.get("children");
}),
(e.prototype.sort = function () {
var t,
e = this.getChildren();
Object(o.each)(e, function (t, e) {
return (t._INDEX = e), t;
}),
e.sort(
((t = function (t, e) {
return t.get("zIndex") - e.get("zIndex");
}),
function (e, n) {
var r = t(e, n);
return 0 === r ? e._INDEX - n._INDEX : r;
}),
),
this.onCanvasChange("sort");
}),
(e.prototype.clear = function () {
if ((this.set("clearing", !0), !this.destroyed)) {
for (var t = this.getChildren(), e = t.length - 1; e >= 0; e--)
t[e].destroy();
this.set("children", []),
this.onCanvasChange("clear"),
this.set("clearing", !1);
}
}),
(e.prototype.destroy = function () {
this.get("destroyed") ||
(this.clear(), t.prototype.destroy.call(this));
}),
(e.prototype.getFirst = function () {
return this.getChildByIndex(0);
}),
(e.prototype.getLast = function () {
var t = this.getChildren();
return this.getChildByIndex(t.length - 1);
}),
(e.prototype.getChildByIndex = function (t) {
return this.getChildren()[t];
}),
(e.prototype.getCount = function () {
return this.getChildren().length;
}),
(e.prototype.contain = function (t) {
return this.getChildren().indexOf(t) > -1;
}),
(e.prototype.removeChild = function (t, e) {
void 0 === e && (e = !0), this.contain(t) && t.remove(e);
}),
(e.prototype.findAll = function (t) {
var e = [],
n = this.getChildren();
return (
Object(o.each)(n, function (n) {
t(n) && e.push(n), n.isGroup() && (e = e.concat(n.findAll(t)));
}),
e
);
}),
(e.prototype.find = function (t) {
var e = null,
n = this.getChildren();
return (
Object(o.each)(n, function (n) {
if ((t(n) ? (e = n) : n.isGroup() && (e = n.find(t)), e))
return !1;
}),
e
);
}),
(e.prototype.findById = function (t) {
return this.find(function (e) {
return e.get("id") === t;
});
}),
(e.prototype.findByClassName = function (t) {
return this.find(function (e) {
return e.get("className") === t;
});
}),
(e.prototype.findAllByName = function (t) {
return this.findAll(function (e) {
return e.get("name") === t;
});
}),
e
);
})(rt);
function at(t) {
return (at =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var st,
ct,
ut = 0,
ht = 0,
lt = 0,
ft = 0,
dt = 0,
pt = 0,
gt =
"object" ===
("undefined" == typeof performance
? "undefined"
: at(performance)) && performance.now
? performance
: Date,
vt =
"object" ===
("undefined" == typeof window ? "undefined" : at(window)) &&
window.requestAnimationFrame
? window.requestAnimationFrame.bind(window)
: function (t) {
setTimeout(t, 17);
};
function yt() {
return dt || (vt(mt), (dt = gt.now() + pt));
}
function mt() {
dt = 0;
}
function bt() {
this._call = this._time = this._next = null;
}
function xt(t, e, n) {
var r = new bt();
return r.restart(t, e, n), r;
}
function wt() {
(dt = (ft = gt.now()) + pt), (ut = ht = 0);
try {
!(function () {
yt(), ++ut;
for (var t, e = st; e; )
(t = dt - e._time) >= 0 && e._call.call(null, t), (e = e._next);
--ut;
})();
} finally {
(ut = 0),
(function () {
var t,
e,
n = st,
r = 1 / 0;
for (; n; )
n._call
? (r > n._time && (r = n._time), (t = n), (n = n._next))
: ((e = n._next),
(n._next = null),
(n = t ? (t._next = e) : (st = e)));
(ct = t), Ot(r);
})(),
(dt = 0);
}
}
function St() {
var t = gt.now(),
e = t - ft;
e > 1e3 && ((pt -= e), (ft = t));
}
function Ot(t) {
ut ||
(ht && (ht = clearTimeout(ht)),
t - dt > 24
? (t < 1 / 0 && (ht = setTimeout(wt, t - gt.now() - pt)),
lt && (lt = clearInterval(lt)))
: (lt || ((ft = gt.now()), (lt = setInterval(St, 1e3))),
(ut = 1),
vt(wt)));
}
bt.prototype = xt.prototype = {
constructor: bt,
restart: function (t, e, n) {
if ("function" != typeof t)
throw new TypeError("callback is not a function");
(n = (null == n ? yt() : +n) + (null == e ? 0 : +e)),
this._next ||
ct === this ||
(ct ? (ct._next = this) : (st = this), (ct = this)),
(this._call = t),
(this._time = n),
Ot();
},
stop: function () {
this._call && ((this._call = null), (this._time = 1 / 0), Ot());
},
};
var Mt = function (t, e, n) {
(t.prototype = e.prototype = n), (n.constructor = t);
};
function kt(t, e) {
var n = Object.create(t.prototype);
for (var r in e) n[r] = e[r];
return n;
}
function Ct() {}
var Et = "\\s*([+-]?\\d+)\\s*",
jt = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
Pt = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
At = /^#([0-9a-f]{3,8})$/,
It = new RegExp("^rgb\\(" + [Et, Et, Et] + "\\)$"),
Tt = new RegExp("^rgb\\(" + [Pt, Pt, Pt] + "\\)$"),
Nt = new RegExp("^rgba\\(" + [Et, Et, Et, jt] + "\\)$"),
Bt = new RegExp("^rgba\\(" + [Pt, Pt, Pt, jt] + "\\)$"),
Lt = new RegExp("^hsl\\(" + [jt, Pt, Pt] + "\\)$"),
Dt = new RegExp("^hsla\\(" + [jt, Pt, Pt, jt] + "\\)$"),
_t = {
aliceblue: 15792383,
antiquewhite: 16444375,
aqua: 65535,
aquamarine: 8388564,
azure: 15794175,
beige: 16119260,
bisque: 16770244,
black: 0,
blanchedalmond: 16772045,
blue: 255,
blueviolet: 9055202,
brown: 10824234,
burlywood: 14596231,
cadetblue: 6266528,
chartreuse: 8388352,
chocolate: 13789470,
coral: 16744272,
cornflowerblue: 6591981,
cornsilk: 16775388,
crimson: 14423100,
cyan: 65535,
darkblue: 139,
darkcyan: 35723,
darkgoldenrod: 12092939,
darkgray: 11119017,
darkgreen: 25600,
darkgrey: 11119017,
darkkhaki: 12433259,
darkmagenta: 9109643,
darkolivegreen: 5597999,
darkorange: 16747520,
darkorchid: 10040012,
darkred: 9109504,
darksalmon: 15308410,
darkseagreen: 9419919,
darkslateblue: 4734347,
darkslategray: 3100495,
darkslategrey: 3100495,
darkturquoise: 52945,
darkviolet: 9699539,
deeppink: 16716947,
deepskyblue: 49151,
dimgray: 6908265,
dimgrey: 6908265,
dodgerblue: 2003199,
firebrick: 11674146,
floralwhite: 16775920,
forestgreen: 2263842,
fuchsia: 16711935,
gainsboro: 14474460,
ghostwhite: 16316671,
gold: 16766720,
goldenrod: 14329120,
gray: 8421504,
green: 32768,
greenyellow: 11403055,
grey: 8421504,
honeydew: 15794160,
hotpink: 16738740,
indianred: 13458524,
indigo: 4915330,
ivory: 16777200,
khaki: 15787660,
lavender: 15132410,
lavenderblush: 16773365,
lawngreen: 8190976,
lemonchiffon: 16775885,
lightblue: 11393254,
lightcoral: 15761536,
lightcyan: 14745599,
lightgoldenrodyellow: 16448210,
lightgray: 13882323,
lightgreen: 9498256,
lightgrey: 13882323,
lightpink: 16758465,
lightsalmon: 16752762,
lightseagreen: 2142890,
lightskyblue: 8900346,
lightslategray: 7833753,
lightslategrey: 7833753,
lightsteelblue: 11584734,
lightyellow: 16777184,
lime: 65280,
limegreen: 3329330,
linen: 16445670,
magenta: 16711935,
maroon: 8388608,
mediumaquamarine: 6737322,
mediumblue: 205,
mediumorchid: 12211667,
mediumpurple: 9662683,
mediumseagreen: 3978097,
mediumslateblue: 8087790,
mediumspringgreen: 64154,
mediumturquoise: 4772300,
mediumvioletred: 13047173,
midnightblue: 1644912,
mintcream: 16121850,
mistyrose: 16770273,
moccasin: 16770229,
navajowhite: 16768685,
navy: 128,
oldlace: 16643558,
olive: 8421376,
olivedrab: 7048739,
orange: 16753920,
orangered: 16729344,
orchid: 14315734,
palegoldenrod: 15657130,
palegreen: 10025880,
paleturquoise: 11529966,
palevioletred: 14381203,
papayawhip: 16773077,
peachpuff: 16767673,
peru: 13468991,
pink: 16761035,
plum: 14524637,
powderblue: 11591910,
purple: 8388736,
rebeccapurple: 6697881,
red: 16711680,
rosybrown: 12357519,
royalblue: 4286945,
saddlebrown: 9127187,
salmon: 16416882,
sandybrown: 16032864,
seagreen: 3050327,
seashell: 16774638,
sienna: 10506797,
silver: 12632256,
skyblue: 8900331,
slateblue: 6970061,
slategray: 7372944,
slategrey: 7372944,
snow: 16775930,
springgreen: 65407,
steelblue: 4620980,
tan: 13808780,
teal: 32896,
thistle: 14204888,
tomato: 16737095,
turquoise: 4251856,
violet: 15631086,
wheat: 16113331,
white: 16777215,
whitesmoke: 16119285,
yellow: 16776960,
yellowgreen: 10145074,
};
function Rt() {
return this.rgb().formatHex();
}
function Ft() {
return this.rgb().formatRgb();
}
function Yt(t) {
var e, n;
return (
(t = (t + "").trim().toLowerCase()),
(e = At.exec(t))
? ((n = e[1].length),
(e = parseInt(e[1], 16)),
6 === n
? Xt(e)
: 3 === n
? new Vt(
((e >> 8) & 15) | ((e >> 4) & 240),
((e >> 4) & 15) | (240 & e),
((15 & e) << 4) | (15 & e),
1,
)
: 8 === n
? zt(
(e >> 24) & 255,
(e >> 16) & 255,
(e >> 8) & 255,
(255 & e) / 255,
)
: 4 === n
? zt(
((e >> 12) & 15) | ((e >> 8) & 240),
((e >> 8) & 15) | ((e >> 4) & 240),
((e >> 4) & 15) | (240 & e),
(((15 & e) << 4) | (15 & e)) / 255,
)
: null)
: (e = It.exec(t))
? new Vt(e[1], e[2], e[3], 1)
: (e = Tt.exec(t))
? new Vt(
(255 * e[1]) / 100,
(255 * e[2]) / 100,
(255 * e[3]) / 100,
1,
)
: (e = Nt.exec(t))
? zt(e[1], e[2], e[3], e[4])
: (e = Bt.exec(t))
? zt(
(255 * e[1]) / 100,
(255 * e[2]) / 100,
(255 * e[3]) / 100,
e[4],
)
: (e = Lt.exec(t))
? Zt(e[1], e[2] / 100, e[3] / 100, 1)
: (e = Dt.exec(t))
? Zt(e[1], e[2] / 100, e[3] / 100, e[4])
: _t.hasOwnProperty(t)
? Xt(_t[t])
: "transparent" === t
? new Vt(NaN, NaN, NaN, 0)
: null
);
}
function Xt(t) {
return new Vt((t >> 16) & 255, (t >> 8) & 255, 255 & t, 1);
}
function zt(t, e, n, r) {
return r <= 0 && (t = e = n = NaN), new Vt(t, e, n, r);
}
function Wt(t) {
return (
t instanceof Ct || (t = Yt(t)),
t ? new Vt((t = t.rgb()).r, t.g, t.b, t.opacity) : new Vt()
);
}
function qt(t, e, n, r) {
return 1 === arguments.length
? Wt(t)
: new Vt(t, e, n, null == r ? 1 : r);
}
function Vt(t, e, n, r) {
(this.r = +t), (this.g = +e), (this.b = +n), (this.opacity = +r);
}
function Gt() {
return "#" + Ut(this.r) + Ut(this.g) + Ut(this.b);
}
function Ht() {
var t = this.opacity;
return (
(1 === (t = isNaN(t) ? 1 : Math.max(0, Math.min(1, t)))
? "rgb("
: "rgba(") +
Math.max(0, Math.min(255, Math.round(this.r) || 0)) +
", " +
Math.max(0, Math.min(255, Math.round(this.g) || 0)) +
", " +
Math.max(0, Math.min(255, Math.round(this.b) || 0)) +
(1 === t ? ")" : ", " + t + ")")
);
}
function Ut(t) {
return (
((t = Math.max(0, Math.min(255, Math.round(t) || 0))) < 16
? "0"
: "") + t.toString(16)
);
}
function Zt(t, e, n, r) {
return (
r <= 0
? (t = e = n = NaN)
: n <= 0 || n >= 1
? (t = e = NaN)
: e <= 0 && (t = NaN),
new $t(t, e, n, r)
);
}
function Kt(t) {
if (t instanceof $t) return new $t(t.h, t.s, t.l, t.opacity);
if ((t instanceof Ct || (t = Yt(t)), !t)) return new $t();
if (t instanceof $t) return t;
var e = (t = t.rgb()).r / 255,
n = t.g / 255,
r = t.b / 255,
i = Math.min(e, n, r),
o = Math.max(e, n, r),
a = NaN,
s = o - i,
c = (o + i) / 2;
return (
s
? ((a =
e === o
? (n - r) / s + 6 * (n < r)
: n === o
? (r - e) / s + 2
: (e - n) / s + 4),
(s /= c < 0.5 ? o + i : 2 - o - i),
(a *= 60))
: (s = c > 0 && c < 1 ? 0 : a),
new $t(a, s, c, t.opacity)
);
}
function $t(t, e, n, r) {
(this.h = +t), (this.s = +e), (this.l = +n), (this.opacity = +r);
}
function Qt(t, e, n) {
return (
255 *
(t < 60
? e + ((n - e) * t) / 60
: t < 180
? n
: t < 240
? e + ((n - e) * (240 - t)) / 60
: e)
);
}
function Jt(t, e, n, r, i) {
var o = t * t,
a = o * t;
return (
((1 - 3 * t + 3 * o - a) * e +
(4 - 6 * o + 3 * a) * n +
(1 + 3 * t + 3 * o - 3 * a) * r +
a * i) /
6
);
}
Mt(Ct, Yt, {
copy: function (t) {
return Object.assign(new this.constructor(), this, t);
},
displayable: function () {
return this.rgb().displayable();
},
hex: Rt,
formatHex: Rt,
formatHsl: function () {
return Kt(this).formatHsl();
},
formatRgb: Ft,
toString: Ft,
}),
Mt(
Vt,
qt,
kt(Ct, {
brighter: function (t) {
return (
(t = null == t ? 1 / 0.7 : Math.pow(1 / 0.7, t)),
new Vt(this.r * t, this.g * t, this.b * t, this.opacity)
);
},
darker: function (t) {
return (
(t = null == t ? 0.7 : Math.pow(0.7, t)),
new Vt(this.r * t, this.g * t, this.b * t, this.opacity)
);
},
rgb: function () {
return this;
},
displayable: function () {
return (
-0.5 <= this.r &&
this.r < 255.5 &&
-0.5 <= this.g &&
this.g < 255.5 &&
-0.5 <= this.b &&
this.b < 255.5 &&
0 <= this.opacity &&
this.opacity <= 1
);
},
hex: Gt,
formatHex: Gt,
formatRgb: Ht,
toString: Ht,
}),
),
Mt(
$t,
function (t, e, n, r) {
return 1 === arguments.length
? Kt(t)
: new $t(t, e, n, null == r ? 1 : r);
},
kt(Ct, {
brighter: function (t) {
return (
(t = null == t ? 1 / 0.7 : Math.pow(1 / 0.7, t)),
new $t(this.h, this.s, this.l * t, this.opacity)
);
},
darker: function (t) {
return (
(t = null == t ? 0.7 : Math.pow(0.7, t)),
new $t(this.h, this.s, this.l * t, this.opacity)
);
},
rgb: function () {
var t = (this.h % 360) + 360 * (this.h < 0),
e = isNaN(t) || isNaN(this.s) ? 0 : this.s,
n = this.l,
r = n + (n < 0.5 ? n : 1 - n) * e,
i = 2 * n - r;
return new Vt(
Qt(t >= 240 ? t - 240 : t + 120, i, r),
Qt(t, i, r),
Qt(t < 120 ? t + 240 : t - 120, i, r),
this.opacity,
);
},
displayable: function () {
return (
((0 <= this.s && this.s <= 1) || isNaN(this.s)) &&
0 <= this.l &&
this.l <= 1 &&
0 <= this.opacity &&
this.opacity <= 1
);
},
formatHsl: function () {
var t = this.opacity;
return (
(1 === (t = isNaN(t) ? 1 : Math.max(0, Math.min(1, t)))
? "hsl("
: "hsla(") +
(this.h || 0) +
", " +
100 * (this.s || 0) +
"%, " +
100 * (this.l || 0) +
"%" +
(1 === t ? ")" : ", " + t + ")")
);
},
}),
);
var te = function (t) {
return function () {
return t;
};
};
function ee(t, e) {
return function (n) {
return t + n * e;
};
}
function ne(t) {
return 1 == (t = +t)
? re
: function (e, n) {
return n - e
? (function (t, e, n) {
return (
(t = Math.pow(t, n)),
(e = Math.pow(e, n) - t),
(n = 1 / n),
function (r) {
return Math.pow(t + r * e, n);
}
);
})(e, n, t)
: te(isNaN(e) ? n : e);
};
}
function re(t, e) {
var n = e - t;
return n ? ee(t, n) : te(isNaN(t) ? e : t);
}
var ie = (function t(e) {
var n = ne(e);
function r(t, e) {
var r = n((t = qt(t)).r, (e = qt(e)).r),
i = n(t.g, e.g),
o = n(t.b, e.b),
a = re(t.opacity, e.opacity);
return function (e) {
return (
(t.r = r(e)),
(t.g = i(e)),
(t.b = o(e)),
(t.opacity = a(e)),
t + ""
);
};
}
return (r.gamma = t), r;
})(1);
function oe(t) {
return function (e) {
var n,
r,
i = e.length,
o = new Array(i),
a = new Array(i),
s = new Array(i);
for (n = 0; n < i; ++n)
(r = qt(e[n])),
(o[n] = r.r || 0),
(a[n] = r.g || 0),
(s[n] = r.b || 0);
return (
(o = t(o)),
(a = t(a)),
(s = t(s)),
(r.opacity = 1),
function (t) {
return (r.r = o(t)), (r.g = a(t)), (r.b = s(t)), r + "";
}
);
};
}
oe(function (t) {
var e = t.length - 1;
return function (n) {
var r =
n <= 0 ? (n = 0) : n >= 1 ? ((n = 1), e - 1) : Math.floor(n * e),
i = t[r],
o = t[r + 1],
a = r > 0 ? t[r - 1] : 2 * i - o,
s = r < e - 1 ? t[r + 2] : 2 * o - i;
return Jt((n - r / e) * e, a, i, o, s);
};
}),
oe(function (t) {
var e = t.length;
return function (n) {
var r = Math.floor(((n %= 1) < 0 ? ++n : n) * e),
i = t[(r + e - 1) % e],
o = t[r % e],
a = t[(r + 1) % e],
s = t[(r + 2) % e];
return Jt((n - r / e) * e, i, o, a, s);
};
});
var ae = function (t, e) {
e || (e = []);
var n,
r = t ? Math.min(e.length, t.length) : 0,
i = e.slice();
return function (o) {
for (n = 0; n < r; ++n) i[n] = t[n] * (1 - o) + e[n] * o;
return i;
};
};
function se(t) {
return ArrayBuffer.isView(t) && !(t instanceof DataView);
}
function ce(t, e) {
var n,
r = e ? e.length : 0,
i = t ? Math.min(r, t.length) : 0,
o = new Array(i),
a = new Array(r);
for (n = 0; n < i; ++n) o[n] = ye(t[n], e[n]);
for (; n < r; ++n) a[n] = e[n];
return function (t) {
for (n = 0; n < i; ++n) a[n] = o[n](t);
return a;
};
}
var ue = function (t, e) {
var n = new Date();
return (
(t = +t),
(e = +e),
function (r) {
return n.setTime(t * (1 - r) + e * r), n;
}
);
},
he = function (t, e) {
return (
(t = +t),
(e = +e),
function (n) {
return t * (1 - n) + e * n;
}
);
};
function le(t) {
return (le =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var fe = function (t, e) {
var n,
r = {},
i = {};
for (n in ((null !== t && "object" === le(t)) || (t = {}),
(null !== e && "object" === le(e)) || (e = {}),
e))
n in t ? (r[n] = ye(t[n], e[n])) : (i[n] = e[n]);
return function (t) {
for (n in r) i[n] = r[n](t);
return i;
};
},
de = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
pe = new RegExp(de.source, "g");
var ge = function (t, e) {
var n,
r,
i,
o = (de.lastIndex = pe.lastIndex = 0),
a = -1,
s = [],
c = [];
for (t += "", e += ""; (n = de.exec(t)) && (r = pe.exec(e)); )
(i = r.index) > o &&
((i = e.slice(o, i)), s[a] ? (s[a] += i) : (s[++a] = i)),
(n = n[0]) === (r = r[0])
? s[a]
? (s[a] += r)
: (s[++a] = r)
: ((s[++a] = null), c.push({ i: a, x: he(n, r) })),
(o = pe.lastIndex);
return (
o < e.length && ((i = e.slice(o)), s[a] ? (s[a] += i) : (s[++a] = i)),
s.length < 2
? c[0]
? (function (t) {
return function (e) {
return t(e) + "";
};
})(c[0].x)
: (function (t) {
return function () {
return t;
};
})(e)
: ((e = c.length),
function (t) {
for (var n, r = 0; r < e; ++r) s[(n = c[r]).i] = n.x(t);
return s.join("");
})
);
};
function ve(t) {
return (ve =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var ye = function (t, e) {
var n,
r = ve(e);
return null == e || "boolean" === r
? te(e)
: ("number" === r
? he
: "string" === r
? (n = Yt(e))
? ((e = n), ie)
: ge
: e instanceof Yt
? ie
: e instanceof Date
? ue
: se(e)
? ae
: Array.isArray(e)
? ce
: ("function" != typeof e.valueOf &&
"function" != typeof e.toString) ||
isNaN(e)
? fe
: he)(t, e);
};
function me(t) {
return +t;
}
function be(t) {
return t * t;
}
function xe(t) {
return t * (2 - t);
}
function we(t) {
return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;
}
function Se(t) {
return t * t * t;
}
function Oe(t) {
return --t * t * t + 1;
}
function Me(t) {
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
}
var ke = (function t(e) {
function n(t) {
return Math.pow(t, e);
}
return (e = +e), (n.exponent = t), n;
})(3),
Ce = (function t(e) {
function n(t) {
return 1 - Math.pow(1 - t, e);
}
return (e = +e), (n.exponent = t), n;
})(3),
Ee = (function t(e) {
function n(t) {
return (
((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2
);
}
return (e = +e), (n.exponent = t), n;
})(3),
je = Math.PI,
Pe = je / 2;
function Ae(t) {
return 1 == +t ? 1 : 1 - Math.cos(t * Pe);
}
function Ie(t) {
return Math.sin(t * Pe);
}
function Te(t) {
return (1 - Math.cos(je * t)) / 2;
}
function Ne(t) {
return 1.0009775171065494 * (Math.pow(2, -10 * t) - 0.0009765625);
}
function Be(t) {
return Ne(1 - +t);
}
function Le(t) {
return 1 - Ne(t);
}
function De(t) {
return ((t *= 2) <= 1 ? Ne(1 - t) : 2 - Ne(t - 1)) / 2;
}
function _e(t) {
return 1 - Math.sqrt(1 - t * t);
}
function Re(t) {
return Math.sqrt(1 - --t * t);
}
function Fe(t) {
return (
((t *= 2) <= 1
? 1 - Math.sqrt(1 - t * t)
: Math.sqrt(1 - (t -= 2) * t) + 1) / 2
);
}
var Ye = 7.5625;
function Xe(t) {
return 1 - ze(1 - t);
}
function ze(t) {
return (t = +t) < 4 / 11
? Ye * t * t
: t < 8 / 11
? Ye * (t -= 6 / 11) * t + 3 / 4
: t < 10 / 11
? Ye * (t -= 9 / 11) * t + 15 / 16
: Ye * (t -= 21 / 22) * t + 63 / 64;
}
function We(t) {
return ((t *= 2) <= 1 ? 1 - ze(1 - t) : ze(t - 1) + 1) / 2;
}
var qe = (function t(e) {
function n(t) {
return (t = +t) * t * (e * (t - 1) + t);
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
Ve = (function t(e) {
function n(t) {
return --t * t * ((t + 1) * e + t) + 1;
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
Ge = (function t(e) {
function n(t) {
return (
((t *= 2) < 1
? t * t * ((e + 1) * t - e)
: (t -= 2) * t * ((e + 1) * t + e) + 2) / 2
);
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
He = 2 * Math.PI,
Ue = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= He);
function i(t) {
return e * Ne(-(--t)) * Math.sin((r - t) / n);
}
return (
(i.amplitude = function (e) {
return t(e, n * He);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
Ze = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= He);
function i(t) {
return 1 - e * Ne((t = +t)) * Math.sin((t + r) / n);
}
return (
(i.amplitude = function (e) {
return t(e, n * He);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
Ke = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= He);
function i(t) {
return (
((t = 2 * t - 1) < 0
? e * Ne(-t) * Math.sin((r - t) / n)
: 2 - e * Ne(t) * Math.sin((r + t) / n)) / 2
);
}
return (
(i.amplitude = function (e) {
return t(e, n * He);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
$e = {};
var Qe = [1, 0, 0, 0, 1, 0, 0, 0, 1];
function Je(t, e, n) {
var r,
a = e.startTime;
if (n < a + e.delay || e._paused) return !1;
var s,
c = e.duration,
h = e.easing,
l = $e[(s = h).toLowerCase()] || i[s];
if (((n = n - a - e.delay), e.repeat)) r = l((r = (n % c) / c));
else {
if (!((r = n / c) < 1))
return e.onFrame ? t.attr(e.onFrame(1)) : t.attr(e.toAttrs), !0;
r = l(r);
}
if (e.onFrame) {
var f = e.onFrame(r);
t.attr(f);
} else
!(function (t, e, n) {
var r = {},
i = e.fromAttrs,
a = e.toAttrs;
if (!t.destroyed) {
var s, c, h, l;
for (var f in a)
if (!Object(o.isEqual)(i[f], a[f]))
if ("path" === f) {
var d = a[f],
p = i[f];
d.length > p.length
? ((d = u(a[f])),
(p = u(i[f])),
(p = L(p, d)),
(p = R(p, d)),
(e.fromAttrs.path = p),
(e.toAttrs.path = d))
: e.pathFormatted ||
((d = u(a[f])),
(p = u(i[f])),
(p = R(p, d)),
(e.fromAttrs.path = p),
(e.toAttrs.path = d),
(e.pathFormatted = !0)),
(r[f] = []);
for (var g = 0; g < d.length; g++) {
for (
var v = d[g], y = p[g], m = [], b = 0;
b < v.length;
b++
)
Object(o.isNumber)(v[b]) &&
y &&
Object(o.isNumber)(y[b])
? ((s = ye(y[b], v[b])), m.push(s(n)))
: m.push(v[b]);
r[f].push(m);
}
} else if ("matrix" === f) {
var x = ((h = i[f] || Qe),
(se((l = a[f] || Qe)) ? ae : ce)(h, l))(n);
r[f] = x;
} else
["fill", "stroke", "fillStyle", "strokeStyle"].includes(
f,
) && ((c = a[f]), /^[r,R,L,l]{1}[\s]*\(/.test(c))
? (r[f] = a[f])
: Object(o.isFunction)(a[f]) ||
((s = ye(i[f], a[f])), (r[f] = s(n)));
t.attr(r);
}
})(t, e, r);
return !1;
}
var tn = (function () {
function t(t) {
(this.animators = []),
(this.current = 0),
(this.timer = null),
(this.canvas = t);
}
return (
(t.prototype.initTimer = function () {
var t,
e,
n,
r = this;
this.timer = xt(function (i) {
if (((r.current = i), r.animators.length > 0)) {
for (var o = r.animators.length - 1; o >= 0; o--)
if ((t = r.animators[o]).destroyed) r.removeAnimator(o);
else {
if (!t.isAnimatePaused())
for (
var a = (e = t.get("animations")).length - 1;
a >= 0;
a--
)
(n = e[a]),
Je(t, n, i) &&
(e.splice(a, 1), !1, n.callback && n.callback());
0 === e.length && r.removeAnimator(o);
}
r.canvas.get("autoDraw") || r.canvas.draw();
}
});
}),
(t.prototype.addAnimator = function (t) {
this.animators.push(t);
}),
(t.prototype.removeAnimator = function (t) {
this.animators.splice(t, 1);
}),
(t.prototype.isAnimating = function () {
return !!this.animators.length;
}),
(t.prototype.stop = function () {
this.timer && this.timer.stop();
}),
(t.prototype.stopAllAnimations = function (t) {
void 0 === t && (t = !0),
this.animators.forEach(function (e) {
e.stopAnimate(t);
}),
(this.animators = []),
this.canvas.draw();
}),
(t.prototype.getTime = function () {
return this.current;
}),
t
);
})(),
en = [
"mousedown",
"mouseup",
"dblclick",
"mouseout",
"mouseover",
"mousemove",
"mouseleave",
"mouseenter",
"touchstart",
"touchmove",
"touchend",
"dragenter",
"dragover",
"dragleave",
"drop",
"contextmenu",
"mousewheel",
];
function nn(t, e, n) {
(n.name = e),
(n.target = t),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
function rn(t, e, n) {
if (n.bubbles) {
var r = void 0,
i = !1;
if (
("mouseenter" === e
? ((r = n.fromShape), (i = !0))
: "mouseleave" === e && ((i = !0), (r = n.toShape)),
t.isCanvas() && i)
)
return;
if (r && q(t, r)) return void (n.bubbles = !1);
(n.name = e),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
}
var on = (function () {
function t(t) {
var e = this;
(this.draggingShape = null),
(this.dragging = !1),
(this.currentShape = null),
(this.mousedownShape = null),
(this.mousedownPoint = null),
(this._eventCallback = function (t) {
var n = t.type;
e._triggerEvent(n, t);
}),
(this._onDocumentMove = function (t) {
if (
e.canvas.get("el") !== t.target &&
(e.dragging || e.currentShape)
) {
var n = e._getPointInfo(t);
e.dragging && e._emitEvent("drag", t, n, e.draggingShape);
}
}),
(this._onDocumentMouseUp = function (t) {
if (e.canvas.get("el") !== t.target && e.dragging) {
var n = e._getPointInfo(t);
e.draggingShape && e._emitEvent("drop", t, n, null),
e._emitEvent("dragend", t, n, e.draggingShape),
e._afterDrag(e.draggingShape, n, t);
}
}),
(this.canvas = t.canvas);
}
return (
(t.prototype.init = function () {
this._bindEvents();
}),
(t.prototype._bindEvents = function () {
var t = this,
e = this.canvas.get("el");
Object(o.each)(en, function (n) {
e.addEventListener(n, t._eventCallback);
}),
document &&
(document.addEventListener("mousemove", this._onDocumentMove),
document.addEventListener(
"mouseup",
this._onDocumentMouseUp,
));
}),
(t.prototype._clearEvents = function () {
var t = this,
e = this.canvas.get("el");
Object(o.each)(en, function (n) {
e.removeEventListener(n, t._eventCallback);
}),
document &&
(document.removeEventListener(
"mousemove",
this._onDocumentMove,
),
document.removeEventListener(
"mouseup",
this._onDocumentMouseUp,
));
}),
(t.prototype._getEventObj = function (t, e, n, r, i, o) {
var a = new F(t, e);
return (
(a.fromShape = i),
(a.toShape = o),
(a.x = n.x),
(a.y = n.y),
(a.clientX = n.clientX),
(a.clientY = n.clientY),
a.propagationPath.push(r),
a
);
}),
(t.prototype._getShape = function (t, e) {
return this.canvas.getShape(t.x, t.y, e);
}),
(t.prototype._getPointInfo = function (t) {
var e = this.canvas,
n = e.getClientByEvent(t),
r = e.getPointByEvent(t);
return { x: r.x, y: r.y, clientX: n.x, clientY: n.y };
}),
(t.prototype._triggerEvent = function (t, e) {
var n = this._getPointInfo(e),
r = this._getShape(n, e),
i = this["_on" + t],
o = !1;
if (i) i.call(this, n, r, e);
else {
var a = this.currentShape;
"mouseenter" === t || "dragenter" === t || "mouseover" === t
? (this._emitEvent(t, e, n, null, null, r),
r && this._emitEvent(t, e, n, r, null, r),
"mouseenter" === t &&
this.draggingShape &&
this._emitEvent("dragenter", e, n, null))
: "mouseleave" === t || "dragleave" === t || "mouseout" === t
? ((o = !0),
a && this._emitEvent(t, e, n, a, a, null),
this._emitEvent(t, e, n, null, a, null),
"mouseleave" === t &&
this.draggingShape &&
this._emitEvent("dragleave", e, n, null))
: this._emitEvent(t, e, n, r, null, null);
}
if ((o || (this.currentShape = r), r && !r.get("destroyed"))) {
var s = this.canvas;
s.get("el").style.cursor = r.attr("cursor") || s.get("cursor");
}
}),
(t.prototype._onmousedown = function (t, e, n) {
0 === n.button &&
((this.mousedownShape = e),
(this.mousedownPoint = t),
(this.mousedownTimeStamp = n.timeStamp)),
this._emitEvent("mousedown", n, t, e, null, null);
}),
(t.prototype._emitMouseoverEvents = function (t, e, n, r) {
var i = this.canvas.get("el");
n !== r &&
(n &&
(this._emitEvent("mouseout", t, e, n, n, r),
this._emitEvent("mouseleave", t, e, n, n, r),
(r && !r.get("destroyed")) ||
(i.style.cursor = this.canvas.get("cursor"))),
r &&
(this._emitEvent("mouseover", t, e, r, n, r),
this._emitEvent("mouseenter", t, e, r, n, r)));
}),
(t.prototype._emitDragoverEvents = function (t, e, n, r, i) {
r
? (r !== n &&
(n && this._emitEvent("dragleave", t, e, n, n, r),
this._emitEvent("dragenter", t, e, r, n, r)),
i || this._emitEvent("dragover", t, e, r))
: n && this._emitEvent("dragleave", t, e, n, n, r),
i && this._emitEvent("dragover", t, e, r);
}),
(t.prototype._afterDrag = function (t, e, n) {
t && (t.set("capture", !0), (this.draggingShape = null)),
(this.dragging = !1);
var r = this._getShape(e, n);
r !== t && this._emitMouseoverEvents(n, e, t, r),
(this.currentShape = r);
}),
(t.prototype._onmouseup = function (t, e, n) {
if (0 === n.button) {
var r = this.draggingShape;
this.dragging
? (r && this._emitEvent("drop", n, t, e),
this._emitEvent("dragend", n, t, r),
this._afterDrag(r, t, n))
: (this._emitEvent("mouseup", n, t, e),
e === this.mousedownShape &&
this._emitEvent("click", n, t, e),
(this.mousedownShape = null),
(this.mousedownPoint = null));
}
}),
(t.prototype._ondragover = function (t, e, n) {
n.preventDefault();
var r = this.currentShape;
this._emitDragoverEvents(n, t, r, e, !0);
}),
(t.prototype._onmousemove = function (t, e, n) {
var r = this.canvas,
i = this.currentShape,
o = this.draggingShape;
if (this.dragging)
o && this._emitDragoverEvents(n, t, i, e, !1),
this._emitEvent("drag", n, t, o);
else {
var a = this.mousedownPoint;
if (a) {
var s = this.mousedownShape,
c = n.timeStamp - this.mousedownTimeStamp,
u = a.clientX - t.clientX,
h = a.clientY - t.clientY;
c > 120 || u * u + h * h > 40
? s && s.get("draggable")
? ((o = this.mousedownShape).set("capture", !1),
(this.draggingShape = o),
(this.dragging = !0),
this._emitEvent("dragstart", n, t, o),
(this.mousedownShape = null),
(this.mousedownPoint = null))
: !s && r.get("draggable")
? ((this.dragging = !0),
this._emitEvent("dragstart", n, t, null),
(this.mousedownShape = null),
(this.mousedownPoint = null))
: (this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e))
: (this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e));
} else
this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e);
}
}),
(t.prototype._emitEvent = function (t, e, n, r, i, o) {
var a = this._getEventObj(t, e, n, r, i, o);
if (r) {
(a.shape = r), nn(r, t, a);
for (var s = r.getParent(); s; )
s.emitDelegation(t, a),
a.propagationStopped || rn(s, t, a),
a.propagationPath.push(s),
(s = s.getParent());
} else {
nn(this.canvas, t, a);
}
}),
(t.prototype.destroy = function () {
this._clearEvents(),
(this.canvas = null),
(this.currentShape = null),
(this.draggingShape = null),
(this.mousedownPoint = null),
(this.mousedownShape = null),
(this.mousedownTimeStamp = null);
}),
t
);
})(),
an = Object(H.a)(),
sn = an && "firefox" === an.name,
cn = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
return (
n.initContainer(),
n.initDom(),
n.initEvents(),
n.initTimeline(),
n
);
}
return (
Object(Y.c)(e, t),
(e.prototype.getDefaultCfg = function () {
var e = t.prototype.getDefaultCfg.call(this);
return (e.cursor = "default"), (e.supportCSSTransform = !1), e;
}),
(e.prototype.initContainer = function () {
var t = this.get("container");
Object(o.isString)(t) &&
((t = document.getElementById(t)), this.set("container", t));
}),
(e.prototype.initDom = function () {
var t = this.createDom();
this.set("el", t),
this.get("container").appendChild(t),
this.setDOMSize(this.get("width"), this.get("height"));
}),
(e.prototype.initEvents = function () {
var t = new on({ canvas: this });
t.init(), this.set("eventController", t);
}),
(e.prototype.initTimeline = function () {
var t = new tn(this);
this.set("timeline", t);
}),
(e.prototype.setDOMSize = function (t, e) {
var n = this.get("el");
W && ((n.style.width = t + "px"), (n.style.height = e + "px"));
}),
(e.prototype.changeSize = function (t, e) {
this.setDOMSize(t, e),
this.set("width", t),
this.set("height", e),
this.onCanvasChange("changeSize");
}),
(e.prototype.getRenderer = function () {
return this.get("renderer");
}),
(e.prototype.getCursor = function () {
return this.get("cursor");
}),
(e.prototype.setCursor = function (t) {
this.set("cursor", t);
var e = this.get("el");
W && e && (e.style.cursor = t);
}),
(e.prototype.getPointByEvent = function (t) {
if (this.get("supportCSSTransform")) {
if (sn && !Object(o.isNil)(t.layerX) && t.layerX !== t.offsetX)
return { x: t.layerX, y: t.layerY };
if (!Object(o.isNil)(t.offsetX))
return { x: t.offsetX, y: t.offsetY };
}
var e = this.getClientByEvent(t),
n = e.x,
r = e.y;
return this.getPointByClient(n, r);
}),
(e.prototype.getClientByEvent = function (t) {
var e = t;
return (
t.touches &&
(e =
"touchend" === t.type ? t.changedTouches[0] : t.touches[0]),
{ x: e.clientX, y: e.clientY }
);
}),
(e.prototype.getPointByClient = function (t, e) {
var n = this.get("el").getBoundingClientRect();
return { x: t - n.left, y: e - n.top };
}),
(e.prototype.getClientByPoint = function (t, e) {
var n = this.get("el").getBoundingClientRect();
return { x: t + n.left, y: e + n.top };
}),
(e.prototype.draw = function () {}),
(e.prototype.removeDom = function () {
var t = this.get("el");
t.parentNode.removeChild(t);
}),
(e.prototype.clearEvents = function () {
this.get("eventController").destroy();
}),
(e.prototype.isCanvas = function () {
return !0;
}),
(e.prototype.getParent = function () {
return null;
}),
(e.prototype.destroy = function () {
var e = this.get("timeline");
this.get("destroyed") ||
(this.clear(),
e && e.stop(),
this.clearEvents(),
this.removeDom(),
t.prototype.destroy.call(this));
}),
e
);
})(ot),
un = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(Y.c)(e, t),
(e.prototype.isGroup = function () {
return !0;
}),
(e.prototype.isEntityGroup = function () {
return !1;
}),
(e.prototype.clone = function () {
for (
var e = t.prototype.clone.call(this),
n = this.getChildren(),
r = 0;
r < n.length;
r++
) {
var i = n[r];
e.add(i.clone());
}
return e;
}),
e
);
})(ot),
hn = (function (t) {
function e(e) {
return t.call(this, e) || this;
}
return (
Object(Y.c)(e, t),
(e.prototype._isInBBox = function (t, e) {
var n = this.getBBox();
return n.minX <= t && n.maxX >= t && n.minY <= e && n.maxY >= e;
}),
(e.prototype.afterAttrsChange = function (e) {
t.prototype.afterAttrsChange.call(this, e), this.clearCacheBBox();
}),
(e.prototype.getBBox = function () {
var t = this.cfg.bbox;
return t || ((t = this.calculateBBox()), this.set("bbox", t)), t;
}),
(e.prototype.getCanvasBBox = function () {
var t = this.cfg.canvasBBox;
return (
t ||
((t = this.calculateCanvasBBox()), this.set("canvasBBox", t)),
t
);
}),
(e.prototype.applyMatrix = function (e) {
t.prototype.applyMatrix.call(this, e),
this.set("canvasBBox", null);
}),
(e.prototype.calculateCanvasBBox = function () {
var t = this.getBBox(),
e = this.getTotalMatrix(),
n = t.minX,
r = t.minY,
i = t.maxX,
o = t.maxY;
if (e) {
var a = Z(e, [t.minX, t.minY]),
s = Z(e, [t.maxX, t.minY]),
c = Z(e, [t.minX, t.maxY]),
u = Z(e, [t.maxX, t.maxY]);
(n = Math.min(a[0], s[0], c[0], u[0])),
(i = Math.max(a[0], s[0], c[0], u[0])),
(r = Math.min(a[1], s[1], c[1], u[1])),
(o = Math.max(a[1], s[1], c[1], u[1]));
}
var h = this.attrs;
if (h.shadowColor) {
var l = h.shadowBlur,
f = void 0 === l ? 0 : l,
d = h.shadowOffsetX,
p = void 0 === d ? 0 : d,
g = h.shadowOffsetY,
v = void 0 === g ? 0 : g,
y = n - f + p,
m = i + f + p,
b = r - f + v,
x = o + f + v;
(n = Math.min(n, y)),
(i = Math.max(i, m)),
(r = Math.min(r, b)),
(o = Math.max(o, x));
}
return {
x: n,
y: r,
minX: n,
minY: r,
maxX: i,
maxY: o,
width: i - n,
height: o - r,
};
}),
(e.prototype.clearCacheBBox = function () {
this.set("bbox", null), this.set("canvasBBox", null);
}),
(e.prototype.isClipShape = function () {
return this.get("isClipShape");
}),
(e.prototype.isInShape = function (t, e) {
return !1;
}),
(e.prototype.isOnlyHitBox = function () {
return !1;
}),
(e.prototype.isHit = function (t, e) {
var n = this.get("startArrowShape"),
r = this.get("endArrowShape"),
i = [t, e, 1],
o = (i = this.invertFromMatrix(i))[0],
a = i[1],
s = this._isInBBox(o, a);
if (this.isOnlyHitBox()) return s;
if (s && !this.isClipped(o, a)) {
if (this.isInShape(o, a)) return !0;
if (n && n.isHit(o, a)) return !0;
if (r && r.isHit(o, a)) return !0;
}
return !1;
}),
e
);
})(rt),
ln = new Map();
function fn(t, e) {
ln.set(t, e);
}
function dn(t) {
return ln.get(t);
}
var pn = function (t) {
var e = t.attr();
return { x: e.x, y: e.y, width: e.width, height: e.height };
},
gn = function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.r;
return { x: n - i, y: r - i, width: 2 * i, height: 2 * i };
},
vn = n(7);
function yn(t, e) {
return t && e
? {
minX: Math.min(t.minX, e.minX),
minY: Math.min(t.minY, e.minY),
maxX: Math.max(t.maxX, e.maxX),
maxY: Math.max(t.maxY, e.maxY),
}
: t || e;
}
function mn(t, e) {
var n = t.get("startArrowShape"),
r = t.get("endArrowShape");
return (
n && (e = yn(e, n.getCanvasBBox())),
r && (e = yn(e, r.getCanvasBBox())),
e
);
}
var bn = null;
function xn(t, e, n) {
var r = 1;
return (
Object(o.isString)(t) && (r = t.split("\n").length),
r > 1
? e * r +
(function (t, e) {
return e ? e - t : 0.14 * t;
})(e, n) *
(r - 1)
: e
);
}
function wn(t, e) {
var n = (function () {
if (!bn) {
var t = document.createElement("canvas");
(t.width = 1), (t.height = 1), (bn = t.getContext("2d"));
}
return bn;
})(),
r = 0;
if (Object(o.isNil)(t) || "" === t) return r;
if (
(n.save(), (n.font = e), Object(o.isString)(t) && t.includes("\n"))
) {
var i = t.split("\n");
Object(o.each)(i, function (t) {
var e = n.measureText(t).width;
r < e && (r = e);
});
} else r = n.measureText(t).width;
return n.restore(), r;
}
function Sn(t) {
var e = t.fontSize,
n = t.fontFamily,
r = t.fontWeight;
return [t.fontStyle, t.fontVariant, r, e + "px", n].join(" ").trim();
}
var On = n(22);
function Mn(t, e) {
var n = t.prePoint,
r = t.currentPoint,
i = t.nextPoint,
a = Math.pow(r[0] - n[0], 2) + Math.pow(r[1] - n[1], 2),
s = Math.pow(r[0] - i[0], 2) + Math.pow(r[1] - i[1], 2),
c = Math.pow(n[0] - i[0], 2) + Math.pow(n[1] - i[1], 2),
u = Math.acos((a + s - c) / (2 * Math.sqrt(a) * Math.sqrt(s)));
if (!u || 0 === Math.sin(u) || Object(o.isNumberEqual)(u, 0))
return { xExtra: 0, yExtra: 0 };
var h = Math.abs(Math.atan2(i[1] - r[1], i[0] - r[0])),
l = Math.abs(Math.atan2(i[0] - r[0], i[1] - r[1]));
return (
(h = h > Math.PI / 2 ? Math.PI - h : h),
(l = l > Math.PI / 2 ? Math.PI - l : l),
{
xExtra:
Math.cos(u / 2 - h) * ((e / 2) * (1 / Math.sin(u / 2))) - e / 2 ||
0,
yExtra:
Math.cos(l - u / 2) * ((e / 2) * (1 / Math.sin(u / 2))) - e / 2 ||
0,
}
);
}
fn("rect", pn),
fn("image", pn),
fn("circle", gn),
fn("marker", gn),
fn("polyline", function (t) {
for (
var e = t.attr().points, n = [], r = [], i = 0;
i < e.length;
i++
) {
var o = e[i];
n.push(o[0]), r.push(o[1]);
}
var a = vn.f.getBBoxByArray(n, r),
s = a.x,
c = a.y,
u = { minX: s, minY: c, maxX: s + a.width, maxY: c + a.height };
return {
x: (u = mn(t, u)).minX,
y: u.minY,
width: u.maxX - u.minX,
height: u.maxY - u.minY,
};
}),
fn("polygon", function (t) {
for (
var e = t.attr().points, n = [], r = [], i = 0;
i < e.length;
i++
) {
var o = e[i];
n.push(o[0]), r.push(o[1]);
}
return vn.f.getBBoxByArray(n, r);
}),
fn("text", function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.text,
o = e.fontSize,
a = e.lineHeight,
s = e.font;
s || (s = Sn(e));
var c,
u = wn(i, s);
if (u) {
var h = e.textAlign,
l = e.textBaseline,
f = xn(i, o, a),
d = { x: n, y: r - f };
h &&
("end" === h || "right" === h
? (d.x -= u)
: "center" === h && (d.x -= u / 2)),
l &&
("top" === l ? (d.y += f) : "middle" === l && (d.y += f / 2)),
(c = { x: d.x, y: d.y, width: u, height: f });
} else c = { x: n, y: r, width: 0, height: 0 };
return c;
}),
fn("path", function (t) {
var e = t.attr(),
n = e.path,
r = e.stroke ? e.lineWidth : 0,
i = (function (t, e) {
for (var n = [], r = [], i = [], a = 0; a < t.length; a++) {
var s = (v = t[a]).currentPoint,
c = v.params,
u = v.prePoint,
h = void 0;
switch (v.command) {
case "Q":
h = vn.e.box(u[0], u[1], c[1], c[2], c[3], c[4]);
break;
case "C":
h = vn.b.box(
u[0],
u[1],
c[1],
c[2],
c[3],
c[4],
c[5],
c[6],
);
break;
case "A":
var l = v.arcParams;
h = vn.a.box(
l.cx,
l.cy,
l.rx,
l.ry,
l.xRotation,
l.startAngle,
l.endAngle,
);
break;
default:
n.push(s[0]), r.push(s[1]);
}
h &&
((v.box = h),
n.push(h.x, h.x + h.width),
r.push(h.y, h.y + h.height)),
e &&
("L" === v.command || "M" === v.command) &&
v.prePoint &&
v.nextPoint &&
i.push(v);
}
(n = n.filter(function (t) {
return !Number.isNaN(t) && t !== 1 / 0 && t !== -1 / 0;
})),
(r = r.filter(function (t) {
return !Number.isNaN(t) && t !== 1 / 0 && t !== -1 / 0;
}));
var f = Object(o.min)(n),
d = Object(o.min)(r),
p = Object(o.max)(n),
g = Object(o.max)(r);
if (0 === i.length)
return { x: f, y: d, width: p - f, height: g - d };
for (a = 0; a < i.length; a++) {
var v;
(s = (v = i[a]).currentPoint)[0] === f
? (f -= Mn(v, e).xExtra)
: s[0] === p && (p += Mn(v, e).xExtra),
s[1] === d
? (d -= Mn(v, e).yExtra)
: s[1] === g && (g += Mn(v, e).yExtra);
}
return { x: f, y: d, width: p - f, height: g - d };
})(t.get("segments") || Object(On.d)(n), r),
a = i.x,
s = i.y,
c = { minX: a, minY: s, maxX: a + i.width, maxY: s + i.height };
return {
x: (c = mn(t, c)).minX,
y: c.minY,
width: c.maxX - c.minX,
height: c.maxY - c.minY,
};
}),
fn("line", function (t) {
var e = t.attr(),
n = e.x1,
r = e.y1,
i = e.x2,
o = e.y2,
a = {
minX: Math.min(n, i),
maxX: Math.max(n, i),
minY: Math.min(r, o),
maxY: Math.max(r, o),
};
return {
x: (a = mn(t, a)).minX,
y: a.minY,
width: a.maxX - a.minX,
height: a.maxY - a.minY,
};
}),
fn("ellipse", function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.rx,
o = e.ry;
return { x: n - i, y: r - o, width: 2 * i, height: 2 * o };
});
},
7: function (t, e, n) {
"use strict";
n.d(e, "e", function () {
return m;
}),
n.d(e, "b", function () {
return M;
}),
n.d(e, "a", function () {
return I;
}),
n.d(e, "c", function () {
return f;
}),
n.d(e, "d", function () {
return _;
}),
n.d(e, "f", function () {
return r;
});
var r = {};
function i(t) {
return Math.min.apply(null, t);
}
function o(t) {
return Math.max.apply(null, t);
}
function a(t, e, n, r) {
var i = t - n,
o = e - r;
return Math.sqrt(i * i + o * o);
}
function s(t, e) {
return Math.abs(t - e) < 0.001;
}
function c(t, e) {
var n = i(t),
r = i(e);
return { x: n, y: r, width: o(t) - n, height: o(e) - r };
}
function u(t, e, n, r) {
return {
minX: i([t, n]),
maxX: o([t, n]),
minY: i([e, r]),
maxY: o([e, r]),
};
}
function h(t) {
return (t + 2 * Math.PI) % (2 * Math.PI);
}
n.r(r),
n.d(r, "distance", function () {
return a;
}),
n.d(r, "isNumberEqual", function () {
return s;
}),
n.d(r, "getBBoxByArray", function () {
return c;
}),
n.d(r, "getBBoxRange", function () {
return u;
}),
n.d(r, "piMod", function () {
return h;
});
var l = n(42),
f = {
box: function (t, e, n, r) {
return c([t, n], [e, r]);
},
length: function (t, e, n, r) {
return a(t, e, n, r);
},
pointAt: function (t, e, n, r, i) {
return { x: (1 - i) * t + i * n, y: (1 - i) * e + i * r };
},
pointDistance: function (t, e, n, r, i, o) {
var s = (n - t) * (i - t) + (r - e) * (o - e);
return s < 0
? a(t, e, i, o)
: s > (n - t) * (n - t) + (r - e) * (r - e)
? a(n, r, i, o)
: this.pointToLine(t, e, n, r, i, o);
},
pointToLine: function (t, e, n, r, i, o) {
var a = [n - t, r - e];
if (l.exactEquals(a, [0, 0]))
return Math.sqrt((i - t) * (i - t) + (o - e) * (o - e));
var s = [-a[1], a[0]];
l.normalize(s, s);
var c = [i - t, o - e];
return Math.abs(l.dot(c, s));
},
tangentAngle: function (t, e, n, r) {
return Math.atan2(r - e, n - t);
},
};
function d(t, e, n, r, i, o) {
var s,
c = 1 / 0,
u = [n, r],
h = 20;
o && o > 200 && (h = o / 10);
for (var l = 1 / h, f = l / 10, d = 0; d <= h; d++) {
var p = d * l,
g = [i.apply(null, t.concat([p])), i.apply(null, e.concat([p]))];
(b = a(u[0], u[1], g[0], g[1])) < c && ((s = p), (c = b));
}
if (0 === s) return { x: t[0], y: e[0] };
if (1 === s) {
var v = t.length;
return { x: t[v - 1], y: e[v - 1] };
}
c = 1 / 0;
for (d = 0; d < 32 && !(f < 1e-4); d++) {
var y = s - f,
m = s + f,
b =
((g = [
i.apply(null, t.concat([y])),
i.apply(null, e.concat([y])),
]),
a(u[0], u[1], g[0], g[1]));
if (y >= 0 && b < c) (s = y), (c = b);
else {
var x = [
i.apply(null, t.concat([m])),
i.apply(null, e.concat([m])),
],
w = a(u[0], u[1], x[0], x[1]);
m <= 1 && w < c ? ((s = m), (c = w)) : (f *= 0.5);
}
}
return {
x: i.apply(null, t.concat([s])),
y: i.apply(null, e.concat([s])),
};
}
function p(t, e, n, r) {
var i = 1 - r;
return i * i * t + 2 * r * i * e + r * r * n;
}
function g(t, e, n) {
var r = t + n - 2 * e;
if (s(r, 0)) return [0.5];
var i = (t - e) / r;
return i <= 1 && i >= 0 ? [i] : [];
}
function v(t, e, n, r) {
return 2 * (1 - r) * (e - t) + 2 * r * (n - e);
}
function y(t, e, n, r, i, o, a) {
var s = p(t, n, i, a),
c = p(e, r, o, a),
u = f.pointAt(t, e, n, r, a),
h = f.pointAt(n, r, i, o, a);
return [
[t, e, u.x, u.y, s, c],
[s, c, h.x, h.y, i, o],
];
}
var m = {
box: function (t, e, n, r, i, o) {
var a = g(t, n, i)[0],
s = g(e, r, o)[0],
u = [t, i],
h = [e, o];
return (
void 0 !== a && u.push(p(t, n, i, a)),
void 0 !== s && h.push(p(e, r, o, s)),
c(u, h)
);
},
length: function (t, e, n, r, i, o) {
return (function t(e, n, r, i, o, s, c) {
if (0 === c)
return (a(e, n, r, i) + a(r, i, o, s) + a(e, n, o, s)) / 2;
var u = y(e, n, r, i, o, s, 0.5),
h = u[0],
l = u[1];
return (
h.push(c - 1), l.push(c - 1), t.apply(null, h) + t.apply(null, l)
);
})(t, e, n, r, i, o, 3);
},
nearestPoint: function (t, e, n, r, i, o, a, s) {
return d([t, n, i], [e, r, o], a, s, p);
},
pointDistance: function (t, e, n, r, i, o, s, c) {
var u = this.nearestPoint(t, e, n, r, i, o, s, c);
return a(u.x, u.y, s, c);
},
interpolationAt: p,
pointAt: function (t, e, n, r, i, o, a) {
return { x: p(t, n, i, a), y: p(e, r, o, a) };
},
divide: function (t, e, n, r, i, o, a) {
return y(t, e, n, r, i, o, a);
},
tangentAngle: function (t, e, n, r, i, o, a) {
var s = v(t, n, i, a),
c = v(e, r, o, a);
return h(Math.atan2(c, s));
},
};
function b(t, e, n, r, i) {
var o = 1 - i;
return (
o * o * o * t + 3 * e * i * o * o + 3 * n * i * i * o + r * i * i * i
);
}
function x(t, e, n, r, i) {
var o = 1 - i;
return 3 * (o * o * (e - t) + 2 * o * i * (n - e) + i * i * (r - n));
}
function w(t, e, n, r) {
var i,
o,
a,
c = -3 * t + 9 * e - 9 * n + 3 * r,
u = 6 * t - 12 * e + 6 * n,
h = 3 * e - 3 * t,
l = [];
if (s(c, 0)) s(u, 0) || ((i = -h / u) >= 0 && i <= 1 && l.push(i));
else {
var f = u * u - 4 * c * h;
s(f, 0)
? l.push(-u / (2 * c))
: f > 0 &&
((o = (-u - (a = Math.sqrt(f))) / (2 * c)),
(i = (-u + a) / (2 * c)) >= 0 && i <= 1 && l.push(i),
o >= 0 && o <= 1 && l.push(o));
}
return l;
}
function S(t, e, n, r, i, o, a, s, c) {
var u = b(t, n, i, a, c),
h = b(e, r, o, s, c),
l = f.pointAt(t, e, n, r, c),
d = f.pointAt(n, r, i, o, c),
p = f.pointAt(i, o, a, s, c),
g = f.pointAt(l.x, l.y, d.x, d.y, c),
v = f.pointAt(d.x, d.y, p.x, p.y, c);
return [
[t, e, l.x, l.y, g.x, g.y, u, h],
[u, h, v.x, v.y, p.x, p.y, a, s],
];
}
function O(t, e, n, r, i, o, s, c, u) {
if (0 === u)
return (function (t, e) {
for (var n = 0, r = t.length, i = 0; i < r; i++) {
n += a(t[i], e[i], t[(i + 1) % r], e[(i + 1) % r]);
}
return n / 2;
})([t, n, i, s], [e, r, o, c]);
var h = S(t, e, n, r, i, o, s, c, 0.5),
l = h[0],
f = h[1];
return (
l.push(u - 1), f.push(u - 1), O.apply(null, l) + O.apply(null, f)
);
}
var M = {
extrema: w,
box: function (t, e, n, r, i, o, a, s) {
for (
var u = [t, a],
h = [e, s],
l = w(t, n, i, a),
f = w(e, r, o, s),
d = 0;
d < l.length;
d++
)
u.push(b(t, n, i, a, l[d]));
for (d = 0; d < f.length; d++) h.push(b(e, r, o, s, f[d]));
return c(u, h);
},
length: function (t, e, n, r, i, o, a, s) {
return O(t, e, n, r, i, o, a, s, 3);
},
nearestPoint: function (t, e, n, r, i, o, a, s, c, u, h) {
return d([t, n, i, a], [e, r, o, s], c, u, b, h);
},
pointDistance: function (t, e, n, r, i, o, s, c, u, h, l) {
var f = this.nearestPoint(t, e, n, r, i, o, s, c, u, h, l);
return a(f.x, f.y, u, h);
},
interpolationAt: b,
pointAt: function (t, e, n, r, i, o, a, s, c) {
return { x: b(t, n, i, a, c), y: b(e, r, o, s, c) };
},
divide: function (t, e, n, r, i, o, a, s, c) {
return S(t, e, n, r, i, o, a, s, c);
},
tangentAngle: function (t, e, n, r, i, o, a, s, c) {
var u = x(t, n, i, a, c),
l = x(e, r, o, s, c);
return h(Math.atan2(l, u));
},
};
function k(t, e) {
var n = Math.abs(t);
return e > 0 ? n : -1 * n;
}
var C = function (t, e, n, r, i, o) {
var a = n,
s = r;
if (0 === a || 0 === s) return { x: t, y: e };
for (
var c,
u,
h = i - t,
l = o - e,
f = Math.abs(h),
d = Math.abs(l),
p = a * a,
g = s * s,
v = Math.PI / 4,
y = 0;
y < 4;
y++
) {
(c = a * Math.cos(v)), (u = s * Math.sin(v));
var m = ((p - g) * Math.pow(Math.cos(v), 3)) / a,
b = ((g - p) * Math.pow(Math.sin(v), 3)) / s,
x = c - m,
w = u - b,
S = f - m,
O = d - b,
M = Math.hypot(w, x),
C = Math.hypot(O, S);
(v +=
(M * Math.asin((x * O - w * S) / (M * C))) /
Math.sqrt(p + g - c * c - u * u)),
(v = Math.min(Math.PI / 2, Math.max(0, v)));
}
return { x: t + k(c, h), y: e + k(u, l) };
};
function E(t, e, n, r, i, o) {
return (
n * Math.cos(i) * Math.cos(o) - r * Math.sin(i) * Math.sin(o) + t
);
}
function j(t, e, n, r, i, o) {
return (
n * Math.sin(i) * Math.cos(o) + r * Math.cos(i) * Math.sin(o) + e
);
}
function P(t, e, n) {
return { x: t * Math.cos(n), y: e * Math.sin(n) };
}
function A(t, e, n) {
var r = Math.cos(n),
i = Math.sin(n);
return [t * r - e * i, t * i + e * r];
}
var I = {
box: function (t, e, n, r, i, o, a) {
for (
var s = (function (t, e, n) {
return Math.atan((-e / t) * Math.tan(n));
})(n, r, i),
c = 1 / 0,
u = -1 / 0,
h = [o, a],
l = 2 * -Math.PI;
l <= 2 * Math.PI;
l += Math.PI
) {
var f = s + l;
o < a ? o < f && f < a && h.push(f) : a < f && f < o && h.push(f);
}
for (l = 0; l < h.length; l++) {
var d = E(t, 0, n, r, i, h[l]);
d < c && (c = d), d > u && (u = d);
}
var p = (function (t, e, n) {
return Math.atan(e / (t * Math.tan(n)));
})(n, r, i),
g = 1 / 0,
v = -1 / 0,
y = [o, a];
for (l = 2 * -Math.PI; l <= 2 * Math.PI; l += Math.PI) {
var m = p + l;
o < a ? o < m && m < a && y.push(m) : a < m && m < o && y.push(m);
}
for (l = 0; l < y.length; l++) {
var b = j(0, e, n, r, i, y[l]);
b < g && (g = b), b > v && (v = b);
}
return { x: c, y: g, width: u - c, height: v - g };
},
length: function (t, e, n, r, i, o, a) {},
nearestPoint: function (t, e, n, r, i, o, a, s, c) {
var u = A(s - t, c - e, -i),
h = u[0],
l = u[1],
f = C(0, 0, n, r, h, l),
d = (function (t, e, n, r) {
return (Math.atan2(r * t, n * e) + 2 * Math.PI) % (2 * Math.PI);
})(n, r, f.x, f.y);
d < o ? (f = P(n, r, o)) : d > a && (f = P(n, r, a));
var p = A(f.x, f.y, i);
return { x: p[0] + t, y: p[1] + e };
},
pointDistance: function (t, e, n, r, i, o, s, c, u) {
var h = this.nearestPoint(t, e, n, r, c, u);
return a(h.x, h.y, c, u);
},
pointAt: function (t, e, n, r, i, o, a, s) {
var c = (a - o) * s + o;
return { x: E(t, 0, n, r, i, c), y: j(0, e, n, r, i, c) };
},
tangentAngle: function (t, e, n, r, i, o, a, s) {
var c = (a - o) * s + o,
u = (function (t, e, n, r, i, o, a, s) {
return (
-1 * n * Math.cos(i) * Math.sin(s) -
r * Math.sin(i) * Math.cos(s)
);
})(0, 0, n, r, i, 0, 0, c),
l = (function (t, e, n, r, i, o, a, s) {
return (
-1 * n * Math.sin(i) * Math.sin(s) +
r * Math.cos(i) * Math.cos(s)
);
})(0, 0, n, r, i, 0, 0, c);
return h(Math.atan2(l, u));
},
};
function T(t) {
for (var e = 0, n = [], r = 0; r < t.length - 1; r++) {
var i = t[r],
o = t[r + 1],
s = a(i[0], i[1], o[0], o[1]),
c = { from: i, to: o, length: s };
n.push(c), (e += s);
}
return { segments: n, totalLength: e };
}
function N(t) {
if (t.length < 2) return 0;
for (var e = 0, n = 0; n < t.length - 1; n++) {
var r = t[n],
i = t[n + 1];
e += a(r[0], r[1], i[0], i[1]);
}
return e;
}
function B(t, e) {
if (e > 1 || e < 0 || t.length < 2) return null;
var n = T(t),
r = n.segments,
i = n.totalLength;
if (0 === i) return { x: t[0][0], y: t[0][1] };
for (var o = 0, a = null, s = 0; s < r.length; s++) {
var c = r[s],
u = c.from,
h = c.to,
l = c.length / i;
if (e >= o && e <= o + l) {
var d = (e - o) / l;
a = f.pointAt(u[0], u[1], h[0], h[1], d);
break;
}
o += l;
}
return a;
}
function L(t, e) {
if (e > 1 || e < 0 || t.length < 2) return 0;
for (
var n = T(t), r = n.segments, i = n.totalLength, o = 0, a = 0, s = 0;
s < r.length;
s++
) {
var c = r[s],
u = c.from,
h = c.to,
l = c.length / i;
if (e >= o && e <= o + l) {
a = Math.atan2(h[1] - u[1], h[0] - u[0]);
break;
}
o += l;
}
return a;
}
function D(t, e, n) {
for (var r = 1 / 0, i = 0; i < t.length - 1; i++) {
var o = t[i],
a = t[i + 1],
s = f.pointDistance(o[0], o[1], a[0], a[1], e, n);
s < r && (r = s);
}
return r;
}
var _ = {
box: function (t) {
for (var e = [], n = [], r = 0; r < t.length; r++) {
var i = t[r];
e.push(i[0]), n.push(i[1]);
}
return c(e, n);
},
length: function (t) {
return N(t);
},
pointAt: function (t, e) {
return B(t, e);
},
pointDistance: function (t, e, n) {
return D(t, e, n);
},
tangentAngle: function (t, e) {
return L(t, e);
},
};
},
72: function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "create", function () {
return i;
}),
n.d(e, "clone", function () {
return o;
}),
n.d(e, "length", function () {
return a;
}),
n.d(e, "fromValues", function () {
return s;
}),
n.d(e, "copy", function () {
return c;
}),
n.d(e, "set", function () {
return u;
}),
n.d(e, "add", function () {
return h;
}),
n.d(e, "subtract", function () {
return l;
}),
n.d(e, "multiply", function () {
return f;
}),
n.d(e, "divide", function () {
return d;
}),
n.d(e, "ceil", function () {
return p;
}),
n.d(e, "floor", function () {
return g;
}),
n.d(e, "min", function () {
return v;
}),
n.d(e, "max", function () {
return y;
}),
n.d(e, "round", function () {
return m;
}),
n.d(e, "scale", function () {
return b;
}),
n.d(e, "scaleAndAdd", function () {
return x;
}),
n.d(e, "distance", function () {
return w;
}),
n.d(e, "squaredDistance", function () {
return S;
}),
n.d(e, "squaredLength", function () {
return O;
}),
n.d(e, "negate", function () {
return M;
}),
n.d(e, "inverse", function () {
return k;
}),
n.d(e, "normalize", function () {
return C;
}),
n.d(e, "dot", function () {
return E;
}),
n.d(e, "cross", function () {
return j;
}),
n.d(e, "lerp", function () {
return P;
}),
n.d(e, "hermite", function () {
return A;
}),
n.d(e, "bezier", function () {
return I;
}),
n.d(e, "random", function () {
return T;
}),
n.d(e, "transformMat4", function () {
return N;
}),
n.d(e, "transformMat3", function () {
return B;
}),
n.d(e, "transformQuat", function () {
return L;
}),
n.d(e, "rotateX", function () {
return D;
}),
n.d(e, "rotateY", function () {
return _;
}),
n.d(e, "rotateZ", function () {
return R;
}),
n.d(e, "angle", function () {
return F;
}),
n.d(e, "zero", function () {
return Y;
}),
n.d(e, "str", function () {
return X;
}),
n.d(e, "exactEquals", function () {
return z;
}),
n.d(e, "equals", function () {
return W;
}),
n.d(e, "sub", function () {
return V;
}),
n.d(e, "mul", function () {
return G;
}),
n.d(e, "div", function () {
return H;
}),
n.d(e, "dist", function () {
return U;
}),
n.d(e, "sqrDist", function () {
return Z;
}),
n.d(e, "len", function () {
return K;
}),
n.d(e, "sqrLen", function () {
return $;
}),
n.d(e, "forEach", function () {
return Q;
});
var r = n(5);
function i() {
var t = new r.a(3);
return r.a != Float32Array && ((t[0] = 0), (t[1] = 0), (t[2] = 0)), t;
}
function o(t) {
var e = new r.a(3);
return (e[0] = t[0]), (e[1] = t[1]), (e[2] = t[2]), e;
}
function a(t) {
var e = t[0],
n = t[1],
r = t[2];
return Math.hypot(e, n, r);
}
function s(t, e, n) {
var i = new r.a(3);
return (i[0] = t), (i[1] = e), (i[2] = n), i;
}
function c(t, e) {
return (t[0] = e[0]), (t[1] = e[1]), (t[2] = e[2]), t;
}
function u(t, e, n, r) {
return (t[0] = e), (t[1] = n), (t[2] = r), t;
}
function h(t, e, n) {
return (
(t[0] = e[0] + n[0]), (t[1] = e[1] + n[1]), (t[2] = e[2] + n[2]), t
);
}
function l(t, e, n) {
return (
(t[0] = e[0] - n[0]), (t[1] = e[1] - n[1]), (t[2] = e[2] - n[2]), t
);
}
function f(t, e, n) {
return (
(t[0] = e[0] * n[0]), (t[1] = e[1] * n[1]), (t[2] = e[2] * n[2]), t
);
}
function d(t, e, n) {
return (
(t[0] = e[0] / n[0]), (t[1] = e[1] / n[1]), (t[2] = e[2] / n[2]), t
);
}
function p(t, e) {
return (
(t[0] = Math.ceil(e[0])),
(t[1] = Math.ceil(e[1])),
(t[2] = Math.ceil(e[2])),
t
);
}
function g(t, e) {
return (
(t[0] = Math.floor(e[0])),
(t[1] = Math.floor(e[1])),
(t[2] = Math.floor(e[2])),
t
);
}
function v(t, e, n) {
return (
(t[0] = Math.min(e[0], n[0])),
(t[1] = Math.min(e[1], n[1])),
(t[2] = Math.min(e[2], n[2])),
t
);
}
function y(t, e, n) {
return (
(t[0] = Math.max(e[0], n[0])),
(t[1] = Math.max(e[1], n[1])),
(t[2] = Math.max(e[2], n[2])),
t
);
}
function m(t, e) {
return (
(t[0] = Math.round(e[0])),
(t[1] = Math.round(e[1])),
(t[2] = Math.round(e[2])),
t
);
}
function b(t, e, n) {
return (t[0] = e[0] * n), (t[1] = e[1] * n), (t[2] = e[2] * n), t;
}
function x(t, e, n, r) {
return (
(t[0] = e[0] + n[0] * r),
(t[1] = e[1] + n[1] * r),
(t[2] = e[2] + n[2] * r),
t
);
}
function w(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1],
i = e[2] - t[2];
return Math.hypot(n, r, i);
}
function S(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1],
i = e[2] - t[2];
return n * n + r * r + i * i;
}
function O(t) {
var e = t[0],
n = t[1],
r = t[2];
return e * e + n * n + r * r;
}
function M(t, e) {
return (t[0] = -e[0]), (t[1] = -e[1]), (t[2] = -e[2]), t;
}
function k(t, e) {
return (t[0] = 1 / e[0]), (t[1] = 1 / e[1]), (t[2] = 1 / e[2]), t;
}
function C(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = n * n + r * r + i * i;
return (
o > 0 && (o = 1 / Math.sqrt(o)),
(t[0] = e[0] * o),
(t[1] = e[1] * o),
(t[2] = e[2] * o),
t
);
}
function E(t, e) {
return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
}
function j(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = n[0],
s = n[1],
c = n[2];
return (
(t[0] = i * c - o * s),
(t[1] = o * a - r * c),
(t[2] = r * s - i * a),
t
);
}
function P(t, e, n, r) {
var i = e[0],
o = e[1],
a = e[2];
return (
(t[0] = i + r * (n[0] - i)),
(t[1] = o + r * (n[1] - o)),
(t[2] = a + r * (n[2] - a)),
t
);
}
function A(t, e, n, r, i, o) {
var a = o * o,
s = a * (2 * o - 3) + 1,
c = a * (o - 2) + o,
u = a * (o - 1),
h = a * (3 - 2 * o);
return (
(t[0] = e[0] * s + n[0] * c + r[0] * u + i[0] * h),
(t[1] = e[1] * s + n[1] * c + r[1] * u + i[1] * h),
(t[2] = e[2] * s + n[2] * c + r[2] * u + i[2] * h),
t
);
}
function I(t, e, n, r, i, o) {
var a = 1 - o,
s = a * a,
c = o * o,
u = s * a,
h = 3 * o * s,
l = 3 * c * a,
f = c * o;
return (
(t[0] = e[0] * u + n[0] * h + r[0] * l + i[0] * f),
(t[1] = e[1] * u + n[1] * h + r[1] * l + i[1] * f),
(t[2] = e[2] * u + n[2] * h + r[2] * l + i[2] * f),
t
);
}
function T(t, e) {
e = e || 1;
var n = 2 * r.c() * Math.PI,
i = 2 * r.c() - 1,
o = Math.sqrt(1 - i * i) * e;
return (
(t[0] = Math.cos(n) * o), (t[1] = Math.sin(n) * o), (t[2] = i * e), t
);
}
function N(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = n[3] * r + n[7] * i + n[11] * o + n[15];
return (
(a = a || 1),
(t[0] = (n[0] * r + n[4] * i + n[8] * o + n[12]) / a),
(t[1] = (n[1] * r + n[5] * i + n[9] * o + n[13]) / a),
(t[2] = (n[2] * r + n[6] * i + n[10] * o + n[14]) / a),
t
);
}
function B(t, e, n) {
var r = e[0],
i = e[1],
o = e[2];
return (
(t[0] = r * n[0] + i * n[3] + o * n[6]),
(t[1] = r * n[1] + i * n[4] + o * n[7]),
(t[2] = r * n[2] + i * n[5] + o * n[8]),
t
);
}
function L(t, e, n) {
var r = n[0],
i = n[1],
o = n[2],
a = n[3],
s = e[0],
c = e[1],
u = e[2],
h = i * u - o * c,
l = o * s - r * u,
f = r * c - i * s,
d = i * f - o * l,
p = o * h - r * f,
g = r * l - i * h,
v = 2 * a;
return (
(h *= v),
(l *= v),
(f *= v),
(d *= 2),
(p *= 2),
(g *= 2),
(t[0] = s + h + d),
(t[1] = c + l + p),
(t[2] = u + f + g),
t
);
}
function D(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[0]),
(o[1] = i[1] * Math.cos(r) - i[2] * Math.sin(r)),
(o[2] = i[1] * Math.sin(r) + i[2] * Math.cos(r)),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function _(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[2] * Math.sin(r) + i[0] * Math.cos(r)),
(o[1] = i[1]),
(o[2] = i[2] * Math.cos(r) - i[0] * Math.sin(r)),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function R(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[0] * Math.cos(r) - i[1] * Math.sin(r)),
(o[1] = i[0] * Math.sin(r) + i[1] * Math.cos(r)),
(o[2] = i[2]),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function F(t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = e[0],
a = e[1],
s = e[2],
c =
Math.sqrt(n * n + r * r + i * i) * Math.sqrt(o * o + a * a + s * s),
u = c && E(t, e) / c;
return Math.acos(Math.min(Math.max(u, -1), 1));
}
function Y(t) {
return (t[0] = 0), (t[1] = 0), (t[2] = 0), t;
}
function X(t) {
return "vec3(" + t[0] + ", " + t[1] + ", " + t[2] + ")";
}
function z(t, e) {
return t[0] === e[0] && t[1] === e[1] && t[2] === e[2];
}
function W(t, e) {
var n = t[0],
i = t[1],
o = t[2],
a = e[0],
s = e[1],
c = e[2];
return (
Math.abs(n - a) <= r.b * Math.max(1, Math.abs(n), Math.abs(a)) &&
Math.abs(i - s) <= r.b * Math.max(1, Math.abs(i), Math.abs(s)) &&
Math.abs(o - c) <= r.b * Math.max(1, Math.abs(o), Math.abs(c))
);
}
var q,
V = l,
G = f,
H = d,
U = w,
Z = S,
K = a,
$ = O,
Q =
((q = i()),
function (t, e, n, r, i, o) {
var a, s;
for (
e || (e = 3),
n || (n = 0),
s = r ? Math.min(r * e + n, t.length) : t.length,
a = n;
a < s;
a += e
)
(q[0] = t[a]),
(q[1] = t[a + 1]),
(q[2] = t[a + 2]),
i(q, q, o),
(t[a] = q[0]),
(t[a + 1] = q[1]),
(t[a + 2] = q[2]);
return t;
});
},
73: function (t, e, n) {
"use strict";
var r = (function () {
function t() {
this._events = {};
}
return (
(t.prototype.on = function (t, e, n) {
return (
this._events[t] || (this._events[t] = []),
this._events[t].push({ callback: e, once: !!n }),
this
);
}),
(t.prototype.once = function (t, e) {
return this.on(t, e, !0);
}),
(t.prototype.emit = function (t) {
for (var e = this, n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
var i = this._events[t] || [],
o = this._events["*"] || [],
a = function (r) {
for (var i = r.length, o = 0; o < i; o++)
if (r[o]) {
var a = r[o],
s = a.callback;
a.once &&
(r.splice(o, 1),
0 === r.length && delete e._events[t],
i--,
o--),
s.apply(e, n);
}
};
a(i), a(o);
}),
(t.prototype.off = function (t, e) {
if (t)
if (e) {
for (
var n = this._events[t] || [], r = n.length, i = 0;
i < r;
i++
)
n[i].callback === e && (n.splice(i, 1), r--, i--);
0 === n.length && delete this._events[t];
} else delete this._events[t];
else this._events = {};
return this;
}),
(t.prototype.getEvents = function () {
return this._events;
}),
t
);
})();
e.a = r;
},
74: function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return Wt;
});
var r = {};
n.r(r),
n.d(r, "Base", function () {
return V;
}),
n.d(r, "Circle", function () {
return G;
}),
n.d(r, "Ellipse", function () {
return U;
}),
n.d(r, "Image", function () {
return $;
}),
n.d(r, "Line", function () {
return tt;
}),
n.d(r, "Marker", function () {
return rt;
}),
n.d(r, "Path", function () {
return dt;
}),
n.d(r, "Polygon", function () {
return gt;
}),
n.d(r, "Polyline", function () {
return vt;
}),
n.d(r, "Rect", function () {
return yt;
}),
n.d(r, "Text", function () {
return mt;
});
var i = n(1),
o = n(6),
a = n(0);
function s(t) {
return (s =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var c = {};
function u(t) {
return (null == c ? void 0 : c.clearAnimationFrame)
? c.clearAnimationFrame(t)
: ("object" ===
("undefined" == typeof window ? "undefined" : s(window)) &&
window.cancelAnimationFrame
? window.cancelAnimationFrame
: clearTimeout)(t);
}
function h(t) {
return (h =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function l(t, e, n, r) {
var i = t - n,
o = e - r;
return Math.sqrt(i * i + o * o);
}
function f(t, e, n, r, i, o) {
return i >= t && i <= t + n && o >= e && o <= e + r;
}
function d(t, e) {
return !(
e.minX > t.maxX ||
e.maxX < t.minX ||
e.minY > t.maxY ||
e.maxY < t.minY
);
}
function p(t, e) {
return t[0] === e[0] && t[1] === e[1];
}
var g = /^l\s*\(\s*([\d.]+)\s*\)\s*(.*)/i,
v = /^r\s*\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*\)\s*(.*)/i,
y = /^p\s*\(\s*([axyn])\s*\)\s*(.*)/i,
m = /[\d.]+:(#[^\s]+|[^\)]+\))/gi;
function b(t, e) {
var n = t.match(m);
Object(a.each)(n, function (t) {
var n = t.split(":");
e.addColorStop(n[0], n[1]);
});
}
function x(t, e, n) {
if (Object(a.isString)(n)) {
if ("(" === n[1] || "(" === n[2]) {
if ("l" === n[0])
return (function (t, e, n) {
var r,
i,
o = g.exec(n),
a = (parseFloat(o[1]) % 360) * (Math.PI / 180),
s = o[2],
c = e.getBBox();
a >= 0 && a < 0.5 * Math.PI
? ((r = { x: c.minX, y: c.minY }),
(i = { x: c.maxX, y: c.maxY }))
: 0.5 * Math.PI <= a && a < Math.PI
? ((r = { x: c.maxX, y: c.minY }),
(i = { x: c.minX, y: c.maxY }))
: Math.PI <= a && a < 1.5 * Math.PI
? ((r = { x: c.maxX, y: c.maxY }),
(i = { x: c.minX, y: c.minY }))
: ((r = { x: c.minX, y: c.maxY }),
(i = { x: c.maxX, y: c.minY }));
var u = Math.tan(a),
h = u * u,
l = (i.x - r.x + u * (i.y - r.y)) / (h + 1) + r.x,
f = (u * (i.x - r.x + u * (i.y - r.y))) / (h + 1) + r.y,
d = t.createLinearGradient(r.x, r.y, l, f);
return b(s, d), d;
})(t, e, n);
if ("r" === n[0])
return (function (t, e, n) {
var r = v.exec(n),
i = parseFloat(r[1]),
o = parseFloat(r[2]),
a = parseFloat(r[3]),
s = r[4];
if (0 === a) {
var c = s.match(m);
return c[c.length - 1].split(":")[1];
}
var u = e.getBBox(),
h = u.maxX - u.minX,
l = u.maxY - u.minY,
f = Math.sqrt(h * h + l * l) / 2,
d = t.createRadialGradient(
u.minX + h * i,
u.minY + l * o,
0,
u.minX + h / 2,
u.minY + l / 2,
a * f,
);
return b(s, d), d;
})(t, e, n);
if ("p" === n[0])
return (function (t, e, n) {
if (e.get("patternSource") && e.get("patternSource") === n)
return e.get("pattern");
var r,
i,
o = y.exec(n),
a = o[1],
s = o[2];
function c() {
(r = t.createPattern(i, a)),
e.set("pattern", r),
e.set("patternSource", n);
}
switch (a) {
case "a":
a = "repeat";
break;
case "x":
a = "repeat-x";
break;
case "y":
a = "repeat-y";
break;
case "n":
a = "no-repeat";
break;
default:
a = "no-repeat";
}
return (
(i = new Image()),
s.match(/^data:/i) || (i.crossOrigin = "Anonymous"),
(i.src = s),
i.complete ? c() : ((i.onload = c), (i.src = i.src)),
r
);
})(t, e, n);
}
return n;
}
}
function w(t) {
return Math.sqrt(t[0] * t[0] + t[1] * t[1]);
}
function S(t, e) {
return w(t) * w(e) ? (t[0] * e[0] + t[1] * e[1]) / (w(t) * w(e)) : 1;
}
function O(t, e) {
return (t[0] * e[1] < t[1] * e[0] ? -1 : 1) * Math.acos(S(t, e));
}
function M(t, e) {
var n = e[1],
r = e[2],
i = Object(a.mod)(Object(a.toRadian)(e[3]), 2 * Math.PI),
o = e[4],
s = e[5],
c = t[0],
u = t[1],
h = e[6],
l = e[7],
f = (Math.cos(i) * (c - h)) / 2 + (Math.sin(i) * (u - l)) / 2,
d = (-1 * Math.sin(i) * (c - h)) / 2 + (Math.cos(i) * (u - l)) / 2,
g = (f * f) / (n * n) + (d * d) / (r * r);
g > 1 && ((n *= Math.sqrt(g)), (r *= Math.sqrt(g)));
var v = n * n * (d * d) + r * r * (f * f),
y = v ? Math.sqrt((n * n * (r * r) - v) / v) : 1;
o === s && (y *= -1), isNaN(y) && (y = 0);
var m = r ? (y * n * d) / r : 0,
b = n ? (y * -r * f) / n : 0,
x = (c + h) / 2 + Math.cos(i) * m - Math.sin(i) * b,
w = (u + l) / 2 + Math.sin(i) * m + Math.cos(i) * b,
M = [(f - m) / n, (d - b) / r],
k = [(-1 * f - m) / n, (-1 * d - b) / r],
C = O([1, 0], M),
E = O(M, k);
return (
S(M, k) <= -1 && (E = Math.PI),
S(M, k) >= 1 && (E = 0),
0 === s && E > 0 && (E -= 2 * Math.PI),
1 === s && E < 0 && (E += 2 * Math.PI),
{
cx: x,
cy: w,
rx: p(t, [h, l]) ? 0 : n,
ry: p(t, [h, l]) ? 0 : r,
startAngle: C,
endAngle: C + E,
xRotation: i,
arcFlag: o,
sweepFlag: s,
}
);
}
function k(t) {
return (k =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var C = Math.sin,
E = Math.cos,
j = Math.atan2,
P = Math.PI;
function A(t, e, n, r, i, o, a) {
var s = e.stroke,
c = e.lineWidth,
u = j(r - o, n - i),
h = new dt({
type: "path",
canvas: t.get("canvas"),
isArrowShape: !0,
attrs: {
path:
"M" +
10 * E(P / 6) +
"," +
10 * C(P / 6) +
" L0,0 L" +
10 * E(P / 6) +
",-" +
10 * C(P / 6),
stroke: s,
lineWidth: c,
},
});
h.translate(i, o),
h.rotateAtPoint(i, o, u),
t.set(a ? "startArrowShape" : "endArrowShape", h);
}
function I(t, e, n, r, o, a, s) {
var c = e.startArrow,
u = e.endArrow,
h = e.stroke,
l = e.lineWidth,
f = s ? c : u,
d = f.d,
p = f.fill,
g = f.stroke,
v = f.lineWidth,
y = Object(i.e)(f, ["d", "fill", "stroke", "lineWidth"]),
m = j(r - a, n - o);
d && ((o -= E(m) * d), (a -= C(m) * d));
var b = new dt({
type: "path",
canvas: t.get("canvas"),
isArrowShape: !0,
attrs: Object(i.a)(Object(i.a)({}, y), {
stroke: g || h,
lineWidth: v || l,
fill: p,
}),
});
b.translate(o, a),
b.rotateAtPoint(o, a, m),
t.set(s ? "startArrowShape" : "endArrowShape", b);
}
function T(t, e, n, r, i) {
var o = j(r - e, n - t);
return { dx: E(o) * i, dy: C(o) * i };
}
function N(t, e, n, r, i, o) {
"object" === k(e.startArrow)
? I(t, e, n, r, i, o, !0)
: e.startArrow
? A(t, e, n, r, i, o, !0)
: t.set("startArrowShape", null);
}
function B(t, e, n, r, i, o) {
"object" === k(e.endArrow)
? I(t, e, n, r, i, o, !1)
: e.endArrow
? A(t, e, n, r, i, o, !1)
: t.set("startArrowShape", null);
}
var L = {
fill: "fillStyle",
stroke: "strokeStyle",
opacity: "globalAlpha",
};
function D(t, e) {
var n = e.attr();
for (var r in n) {
var i = n[r],
o = L[r] ? L[r] : r;
"matrix" === o && i
? t.transform(i[0], i[1], i[3], i[4], i[6], i[7])
: "lineDash" === o && t.setLineDash
? Object(a.isArray)(i) && t.setLineDash(i)
: ("strokeStyle" === o || "fillStyle" === o
? (i = x(t, e, i))
: "globalAlpha" === o && (i *= t.globalAlpha),
(t[o] = i));
}
}
function _(t, e, n) {
for (var r = 0; r < e.length; r++) {
var i = e[r];
i.cfg.visible ? i.draw(t, n) : i.skipDraw();
}
}
function R(t, e, n) {
var r = t.get("refreshElements");
Object(a.each)(r, function (e) {
if (e !== t)
for (var n = e.cfg.parent; n && n !== t && !n.cfg.refresh; )
(n.cfg.refresh = !0), (n = n.cfg.parent);
}),
r[0] === t
? F(e, n)
: (function t(e, n) {
for (var r = 0; r < e.length; r++) {
var i = e[r];
if (i.cfg.visible)
if (i.cfg.hasChanged)
(i.cfg.refresh = !0), i.isGroup() && F(i.cfg.children, n);
else if (i.cfg.refresh) i.isGroup() && t(i.cfg.children, n);
else {
var o = Y(i, n);
(i.cfg.refresh = o),
o && i.isGroup() && t(i.cfg.children, n);
}
}
})(e, n);
}
function F(t, e) {
for (var n = 0; n < t.length; n++) {
var r = t[n];
(r.cfg.refresh = !0), r.isGroup() && F(r.get("children"), e);
}
}
function Y(t, e) {
var n = t.cfg.cacheCanvasBBox;
return t.cfg.isInView && n && d(n, e);
}
function X(t, e, n, r) {
var i = n.path,
o = n.startArrow,
a = n.endArrow;
if (i) {
var s = [0, 0],
c = [0, 0],
u = { dx: 0, dy: 0 };
e.beginPath();
for (var h = 0; h < i.length; h++) {
var l = i[h],
f = l[0];
if (0 === h && o && o.d)
u = T(
(d = t.getStartTangent())[0][0],
d[0][1],
d[1][0],
d[1][1],
o.d,
);
else if (h === i.length - 2 && "Z" === i[h + 1][0] && a && a.d) {
if ("Z" === i[h + 1][0])
u = T(
(d = t.getEndTangent())[0][0],
d[0][1],
d[1][0],
d[1][1],
a.d,
);
} else if (h === i.length - 1 && a && a.d) {
var d;
if ("Z" !== i[0])
u = T(
(d = t.getEndTangent())[0][0],
d[0][1],
d[1][0],
d[1][1],
a.d,
);
}
var p = u.dx,
g = u.dy;
switch (f) {
case "M":
e.moveTo(l[1] - p, l[2] - g), (c = [l[1], l[2]]);
break;
case "L":
e.lineTo(l[1] - p, l[2] - g);
break;
case "Q":
e.quadraticCurveTo(l[1], l[2], l[3] - p, l[4] - g);
break;
case "C":
e.bezierCurveTo(l[1], l[2], l[3], l[4], l[5] - p, l[6] - g);
break;
case "A":
var v = void 0;
r ? (v = r[h]) || ((v = M(s, l)), (r[h] = v)) : (v = M(s, l));
var y = v.cx,
m = v.cy,
b = v.rx,
x = v.ry,
w = v.startAngle,
S = v.endAngle,
O = v.xRotation,
k = v.sweepFlag;
if (e.ellipse) e.ellipse(y, m, b, x, O, w, S, 1 - k);
else {
var C = b > x ? b : x,
E = b > x ? 1 : b / x,
j = b > x ? x / b : 1;
e.translate(y, m),
e.rotate(O),
e.scale(E, j),
e.arc(0, 0, C, w, S, 1 - k),
e.scale(1 / E, 1 / j),
e.rotate(-O),
e.translate(-y, -m);
}
break;
case "Z":
e.closePath();
}
if ("Z" === f) s = c;
else {
var P = l.length;
s = [l[P - 2], l[P - 1]];
}
}
}
}
function z(t, e) {
var n = t.get("canvas");
n &&
("remove" === e && (t._cacheCanvasBBox = t.get("cacheCanvasBBox")),
t.get("hasChanged") ||
(t.set("hasChanged", !0),
(t.cfg.parent && t.cfg.parent.get("hasChanged")) ||
(n.refreshElement(t, e, n), n.get("autoDraw") && n.draw())));
}
function W(t) {
var e, n, r;
if (t.destroyed) e = t._cacheCanvasBBox;
else {
var i = t.get("cacheCanvasBBox"),
o = i && !(!i.width || !i.height),
a = t.getCanvasBBox(),
s = a && !(!a.width || !a.height);
o && s
? ((r = a),
(e =
(n = i) && r
? {
minX: Math.min(n.minX, r.minX),
minY: Math.min(n.minY, r.minY),
maxX: Math.max(n.maxX, r.maxX),
maxY: Math.max(n.maxY, r.maxY),
}
: n || r))
: o
? (e = i)
: s && (e = a);
}
return e;
}
var q = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.onCanvasChange = function (t) {
z(this, t);
}),
(e.prototype.getShapeBase = function () {
return r;
}),
(e.prototype.getGroupBase = function () {
return e;
}),
(e.prototype._applyClip = function (t, e) {
e &&
(t.save(),
D(t, e),
e.createPath(t),
t.restore(),
t.clip(),
e._afterDraw());
}),
(e.prototype.cacheCanvasBBox = function () {
var t = this.cfg.children,
e = [],
n = [];
Object(a.each)(t, function (t) {
var r = t.cfg.cacheCanvasBBox;
r &&
t.cfg.isInView &&
(e.push(r.minX, r.maxX), n.push(r.minY, r.maxY));
});
var r = null;
if (e.length) {
var i = Math.min.apply(null, e),
o = Math.max.apply(null, e),
s = Math.min.apply(null, n),
c = Math.max.apply(null, n);
r = {
minX: i,
minY: s,
x: i,
y: s,
maxX: o,
maxY: c,
width: o - i,
height: c - s,
};
var u = this.cfg.canvas;
if (u) {
var h = u.getViewRange();
this.set("isInView", d(r, h));
}
} else this.set("isInView", !1);
this.set("cacheCanvasBBox", r);
}),
(e.prototype.draw = function (t, e) {
var n = this.cfg.children,
r = !e || this.cfg.refresh;
n.length &&
r &&
(t.save(),
D(t, this),
this._applyClip(t, this.getClip()),
_(t, n, e),
t.restore(),
this.cacheCanvasBBox()),
(this.cfg.refresh = null),
this.set("hasChanged", !1);
}),
(e.prototype.skipDraw = function () {
this.set("cacheCanvasBBox", null), this.set("hasChanged", !1);
}),
e
);
})(o.b),
V = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
lineWidth: 1,
lineAppendWidth: 0,
strokeOpacity: 1,
fillOpacity: 1,
});
}),
(e.prototype.getShapeBase = function () {
return r;
}),
(e.prototype.getGroupBase = function () {
return q;
}),
(e.prototype.onCanvasChange = function (t) {
z(this, t);
}),
(e.prototype.calculateBBox = function () {
var t = this.get("type"),
e = this.getHitLineWidth(),
n = Object(o.g)(t)(this),
r = e / 2,
i = n.x - r,
a = n.y - r,
s = n.x + n.width + r,
c = n.y + n.height + r;
return {
x: i,
minX: i,
y: a,
minY: a,
width: n.width + e,
height: n.height + e,
maxX: s,
maxY: c,
};
}),
(e.prototype.isFill = function () {
return !!this.attrs.fill || this.isClipShape();
}),
(e.prototype.isStroke = function () {
return !!this.attrs.stroke;
}),
(e.prototype._applyClip = function (t, e) {
e &&
(t.save(),
D(t, e),
e.createPath(t),
t.restore(),
t.clip(),
e._afterDraw());
}),
(e.prototype.draw = function (t, e) {
var n = this.cfg.clipShape;
if (e) {
if (!1 === this.cfg.refresh)
return void this.set("hasChanged", !1);
if (!d(e, this.getCanvasBBox()))
return (
this.set("hasChanged", !1),
void (this.cfg.isInView && this._afterDraw())
);
}
t.save(),
D(t, this),
this._applyClip(t, n),
this.drawPath(t),
t.restore(),
this._afterDraw();
}),
(e.prototype.getCanvasViewBox = function () {
var t = this.cfg.canvas;
return t ? t.getViewRange() : null;
}),
(e.prototype.cacheCanvasBBox = function () {
var t = this.getCanvasViewBox();
if (t) {
var e = this.getCanvasBBox(),
n = d(e, t);
this.set("isInView", n),
n
? this.set("cacheCanvasBBox", e)
: this.set("cacheCanvasBBox", null);
}
}),
(e.prototype._afterDraw = function () {
this.cacheCanvasBBox(),
this.set("hasChanged", !1),
this.set("refresh", null);
}),
(e.prototype.skipDraw = function () {
this.set("cacheCanvasBBox", null),
this.set("isInView", null),
this.set("hasChanged", !1);
}),
(e.prototype.drawPath = function (t) {
this.createPath(t), this.strokeAndFill(t), this.afterDrawPath(t);
}),
(e.prototype.fill = function (t) {
t.fill();
}),
(e.prototype.stroke = function (t) {
t.stroke();
}),
(e.prototype.strokeAndFill = function (t) {
var e = this.attrs,
n = e.lineWidth,
r = e.opacity,
i = e.strokeOpacity,
o = e.fillOpacity;
this.isFill() &&
(Object(a.isNil)(o) || 1 === o
? this.fill(t)
: ((t.globalAlpha = o), this.fill(t), (t.globalAlpha = r))),
this.isStroke() &&
n > 0 &&
(Object(a.isNil)(i) || 1 === i || (t.globalAlpha = i),
this.stroke(t)),
this.afterDrawPath(t);
}),
(e.prototype.createPath = function (t) {}),
(e.prototype.afterDrawPath = function (t) {}),
(e.prototype.isInShape = function (t, e) {
var n = this.isStroke(),
r = this.isFill(),
i = this.getHitLineWidth();
return this.isInStrokeOrPath(t, e, n, r, i);
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
return !1;
}),
(e.prototype.getHitLineWidth = function () {
if (!this.isStroke()) return 0;
var t = this.attrs;
return t.lineWidth + t.lineAppendWidth;
}),
e
);
})(o.c),
G = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), { x: 0, y: 0, r: 0 });
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
var o = this.attr(),
a = o.x,
s = o.y,
c = o.r,
u = i / 2,
h = l(a, s, t, e);
return r && n
? h <= c + u
: r
? h <= c
: !!n && h >= c - u && h <= c + u;
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.x,
r = e.y,
i = e.r;
t.beginPath(), t.arc(n, r, i, 0, 2 * Math.PI, !1), t.closePath();
}),
e
);
})(V);
function H(t, e, n, r) {
return t / (n * n) + e / (r * r);
}
var U = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
x: 0,
y: 0,
rx: 0,
ry: 0,
});
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
var o = this.attr(),
a = i / 2,
s = o.x,
c = o.y,
u = o.rx,
h = o.ry,
l = (t - s) * (t - s),
f = (e - c) * (e - c);
return r && n
? H(l, f, u + a, h + a) <= 1
: r
? H(l, f, u, h) <= 1
: !!n && H(l, f, u - a, h - a) >= 1 && H(l, f, u + a, h + a) <= 1;
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.x,
r = e.y,
i = e.rx,
o = e.ry;
if ((t.beginPath(), t.ellipse))
t.ellipse(n, r, i, o, 0, 0, 2 * Math.PI, !1);
else {
var a = i > o ? i : o,
s = i > o ? 1 : i / o,
c = i > o ? o / i : 1;
t.save(),
t.translate(n, r),
t.scale(s, c),
t.arc(0, 0, a, 0, 2 * Math.PI),
t.restore(),
t.closePath();
}
}),
e
);
})(V);
function Z(t) {
return (
t instanceof HTMLElement &&
Object(a.isString)(t.nodeName) &&
"CANVAS" === t.nodeName.toUpperCase()
);
}
var K = null;
var $ = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
x: 0,
y: 0,
width: 0,
height: 0,
});
}),
(e.prototype.initAttrs = function (t) {
this._setImage(t.img);
}),
(e.prototype.isStroke = function () {
return !1;
}),
(e.prototype.isOnlyHitBox = function () {
return !0;
}),
(e.prototype._afterLoading = function () {
if (!0 === this.get("toDraw")) {
var t = this.get("canvas");
t ? t.draw() : this.createPath(this.get("context"));
}
}),
(e.prototype._setImage = function (t) {
var e = this,
n = this.attrs;
if (
!(null == K ? void 0 : K.isMini()) ||
(null == K ? void 0 : K.isMiniNative())
)
if (Object(a.isString)(t)) {
var r = null;
((r = (null == K ? void 0 : K.isMiniNative())
? null == K
? void 0
: K.get("container").createImage()
: new Image()).onload = function () {
if (e.destroyed) return !1;
e.attr("img", r), e.set("loading", !1), e._afterLoading();
var t = e.get("callback");
t && t.call(e);
}),
(r.crossOrigin = "Anonymous"),
(r.src = t),
this.set("loading", !0);
} else
(null == K ? void 0 : K.isMiniNative()) || t instanceof Image
? (n.width || (n.width = t.width),
n.height || (n.height = t.height))
: Z(t) &&
(n.width || (n.width = Number(t.getAttribute("width"))),
n.height || (n.height, Number(t.getAttribute("height"))));
else this.attr("img", t);
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r),
"img" === e && this._setImage(n);
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.img,
r = e.x,
i = e.y,
o = e.width,
s = e.height,
c = e.sx,
u = e.sy,
h = e.swidth,
l = e.sheight;
if (this.get("loading"))
return this.set("toDraw", !0), void this.set("context", t);
(null == K ? void 0 : K.isMini())
? t.drawImage(n, r, i, o, s)
: (n instanceof Image || Z(n)) &&
(Object(a.isNil)(c) ||
Object(a.isNil)(u) ||
Object(a.isNil)(h) ||
Object(a.isNil)(l)
? t.drawImage(n, r, i, o, s)
: t.drawImage(n, c, u, h, l, r, i, o, s));
}),
e
);
})(V),
Q = n(7);
function J(t, e, n, r, i, o, a) {
var s = Math.min(t, n),
c = Math.max(t, n),
u = Math.min(e, r),
h = Math.max(e, r),
l = i / 2;
return (
o >= s - l &&
o <= c + l &&
a >= u - l &&
a <= h + l &&
Q.c.pointToLine(t, e, n, r, o, a) <= i / 2
);
}
var tt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
x1: 0,
y1: 0,
x2: 0,
y2: 0,
startArrow: !1,
endArrow: !1,
});
}),
(e.prototype.initAttrs = function (t) {
this.setArrow();
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r), this.setArrow();
}),
(e.prototype.setArrow = function () {
var t = this.attr(),
e = t.x1,
n = t.y1,
r = t.x2,
i = t.y2,
o = t.startArrow,
a = t.endArrow;
o && N(this, t, r, i, e, n), a && B(this, t, e, n, r, i);
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
if (!n || !i) return !1;
var o = this.attr();
return J(o.x1, o.y1, o.x2, o.y2, i, t, e);
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.x1,
r = e.y1,
i = e.x2,
o = e.y2,
a = e.startArrow,
s = e.endArrow,
c = { dx: 0, dy: 0 },
u = { dx: 0, dy: 0 };
a && a.d && (c = T(n, r, i, o, e.startArrow.d)),
s && s.d && (u = T(n, r, i, o, e.endArrow.d)),
t.beginPath(),
t.moveTo(n + c.dx, r + c.dy),
t.lineTo(i - u.dx, o - u.dy);
}),
(e.prototype.afterDrawPath = function (t) {
var e = this.get("startArrowShape"),
n = this.get("endArrowShape");
e && e.draw(t), n && n.draw(t);
}),
(e.prototype.getTotalLength = function () {
var t = this.attr(),
e = t.x1,
n = t.y1,
r = t.x2,
i = t.y2;
return Q.c.length(e, n, r, i);
}),
(e.prototype.getPoint = function (t) {
var e = this.attr(),
n = e.x1,
r = e.y1,
i = e.x2,
o = e.y2;
return Q.c.pointAt(n, r, i, o, t);
}),
e
);
})(V),
et = n(22),
nt = {
circle: function (t, e, n) {
return [
["M", t - n, e],
["A", n, n, 0, 1, 0, t + n, e],
["A", n, n, 0, 1, 0, t - n, e],
];
},
square: function (t, e, n) {
return [
["M", t - n, e - n],
["L", t + n, e - n],
["L", t + n, e + n],
["L", t - n, e + n],
["Z"],
];
},
diamond: function (t, e, n) {
return [
["M", t - n, e],
["L", t, e - n],
["L", t + n, e],
["L", t, e + n],
["Z"],
];
},
triangle: function (t, e, n) {
var r = n * Math.sin((1 / 3) * Math.PI);
return [
["M", t - n, e + r],
["L", t, e - r],
["L", t + n, e + r],
["Z"],
];
},
"triangle-down": function (t, e, n) {
var r = n * Math.sin((1 / 3) * Math.PI);
return [
["M", t - n, e - r],
["L", t + n, e - r],
["L", t, e + r],
["Z"],
];
},
},
rt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.initAttrs = function (t) {
this._resetParamsCache();
}),
(e.prototype._resetParamsCache = function () {
this.set("paramsCache", {});
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r),
-1 !== ["symbol", "x", "y", "r", "radius"].indexOf(e) &&
this._resetParamsCache();
}),
(e.prototype.isOnlyHitBox = function () {
return !0;
}),
(e.prototype._getR = function (t) {
return Object(a.isNil)(t.r) ? t.radius : t.r;
}),
(e.prototype._getPath = function () {
var t,
n,
r = this.attr(),
i = r.x,
o = r.y,
s = r.symbol || "circle",
c = this._getR(r);
if (Object(a.isFunction)(s))
(n = (t = s)(i, o, c)), (n = Object(et.c)(n));
else {
if (!(t = e.Symbols[s]))
return console.warn(s + " marker is not supported."), null;
n = t(i, o, c);
}
return n;
}),
(e.prototype.createPath = function (t) {
X(this, t, { path: this._getPath() }, this.get("paramsCache"));
}),
(e.Symbols = nt),
e
);
})(V);
function it(t) {
return Math.abs(t) < 1e-6 ? 0 : t < 0 ? -1 : 1;
}
function ot(t, e, n) {
return (
(n[0] - t[0]) * (e[1] - t[1]) == (e[0] - t[0]) * (n[1] - t[1]) &&
Math.min(t[0], e[0]) <= n[0] &&
n[0] <= Math.max(t[0], e[0]) &&
Math.min(t[1], e[1]) <= n[1] &&
n[1] <= Math.max(t[1], e[1])
);
}
function at(t, e, n) {
var r = !1,
i = t.length;
if (i <= 2) return !1;
for (var o = 0; o < i; o++) {
var a = t[o],
s = t[(o + 1) % i];
if (ot(a, s, [e, n])) return !0;
it(a[1] - n) > 0 != it(s[1] - n) > 0 &&
it(e - ((n - a[1]) * (a[0] - s[0])) / (a[1] - s[1]) - a[0]) < 0 &&
(r = !r);
}
return r;
}
var st = n(3),
ct = n(72);
function ut(t, e, n, r, i, o, a, s) {
var c = (Math.atan2(s - e, a - t) + 2 * Math.PI) % (2 * Math.PI);
if (c < r || c > i) return !1;
var u = { x: t + n * Math.cos(c), y: e + n * Math.sin(c) };
return l(u.x, u.y, a, s) <= o / 2;
}
var ht = st.a.transform;
var lt = Object(i.a)(
{
hasArc: function (t) {
for (var e = !1, n = t.length, r = 0; r < n; r++) {
var i = t[r][0];
if ("C" === i || "A" === i || "Q" === i) {
e = !0;
break;
}
}
return e;
},
extractPolygons: function (t) {
for (var e = t.length, n = [], r = [], i = [], o = 0; o < e; o++) {
var a = t[o],
s = a[0];
"M" === s
? (i.length && (r.push(i), (i = [])), i.push([a[1], a[2]]))
: "Z" === s
? i.length && (n.push(i), (i = []))
: i.push([a[1], a[2]]);
}
return i.length > 0 && r.push(i), { polygons: n, polylines: r };
},
isPointInStroke: function (t, e, n, r, i) {
for (var o = !1, a = e / 2, s = 0; s < t.length; s++) {
var c = t[s],
u = c.currentPoint,
h = c.params,
l = c.prePoint,
d = c.box;
if (!d || f(d.x - a, d.y - a, d.width + e, d.height + e, n, r)) {
switch (c.command) {
case "L":
case "Z":
o = J(l[0], l[1], u[0], u[1], e, n, r);
break;
case "Q":
o =
Q.e.pointDistance(
l[0],
l[1],
h[1],
h[2],
h[3],
h[4],
n,
r,
) <=
e / 2;
break;
case "C":
o =
Q.b.pointDistance(
l[0],
l[1],
h[1],
h[2],
h[3],
h[4],
h[5],
h[6],
n,
r,
i,
) <=
e / 2;
break;
case "A":
var p = c.arcParams,
g = p.cx,
v = p.cy,
y = p.rx,
m = p.ry,
b = p.startAngle,
x = p.endAngle,
w = p.xRotation,
S = [n, r, 1],
O = y > m ? y : m,
M = ht(null, [
["t", -g, -v],
["r", -w],
["s", 1 / (y > m ? 1 : y / m), 1 / (y > m ? m / y : 1)],
]);
ct.transformMat3(S, S, M),
(o = ut(0, 0, O, b, x, e, S[0], S[1]));
}
if (o) break;
}
}
return o;
},
},
o.e,
);
function ft(t, e, n) {
for (var r = !1, i = 0; i < t.length; i++) {
if ((r = at(t[i], e, n))) break;
}
return r;
}
var dt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
startArrow: !1,
endArrow: !1,
});
}),
(e.prototype.initAttrs = function (t) {
this._setPathArr(t.path), this.setArrow();
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r),
"path" === e && this._setPathArr(n),
this.setArrow();
}),
(e.prototype._setPathArr = function (t) {
this.attrs.path = Object(et.c)(t);
var e = lt.hasArc(t);
this.set("hasArc", e),
this.set("paramsCache", {}),
this.set("segments", null),
this.set("curve", null),
this.set("tCache", null),
this.set("totalLength", null);
}),
(e.prototype.getSegments = function () {
var t = this.get("segements");
return (
t ||
((t = Object(et.d)(this.attr("path"))),
this.set("segments", t)),
t
);
}),
(e.prototype.setArrow = function () {
var t,
e = this.attr(),
n = e.startArrow,
r = e.endArrow;
n &&
N(
this,
e,
(t = this.getStartTangent())[0][0],
t[0][1],
t[1][0],
t[1][1],
);
r &&
B(
this,
e,
(t = this.getEndTangent())[0][0],
t[0][1],
t[1][0],
t[1][1],
);
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
var o = this.getSegments(),
a = (this.get("hasArc"), !1);
if (n) {
var s = this.getTotalLength();
a = lt.isPointInStroke(o, i, t, e, s);
}
if (!a && r) {
var c = this.attr("path"),
u = lt.extractPolygons(c);
a = ft(u.polygons, t, e) || ft(u.polylines, t, e);
}
return a;
}),
(e.prototype.createPath = function (t) {
X(this, t, this.attr(), this.get("paramsCache"));
}),
(e.prototype.afterDrawPath = function (t) {
var e = this.get("startArrowShape"),
n = this.get("endArrowShape");
e && e.draw(t), n && n.draw(t);
}),
(e.prototype.getTotalLength = function () {
var t = this.get("totalLength");
return Object(a.isNil)(t)
? (this._calculateCurve(),
this._setTcache(),
this.get("totalLength"))
: t;
}),
(e.prototype.getPoint = function (t) {
var e,
n,
r = this.get("tCache");
r ||
(this._calculateCurve(),
this._setTcache(),
(r = this.get("tCache")));
var i = this.get("curve");
if (!r || 0 === r.length)
return i ? { x: i[0][1], y: i[0][2] } : null;
Object(a.each)(r, function (r, i) {
t >= r[0] &&
t <= r[1] &&
((e = (t - r[0]) / (r[1] - r[0])), (n = i));
});
var o = i[n];
if (Object(a.isNil)(o) || Object(a.isNil)(n)) return null;
var s = o.length,
c = i[n + 1];
return Q.b.pointAt(
o[s - 2],
o[s - 1],
c[1],
c[2],
c[3],
c[4],
c[5],
c[6],
e,
);
}),
(e.prototype._calculateCurve = function () {
var t = this.attr().path;
this.set("curve", lt.pathToCurve(t));
}),
(e.prototype._setTcache = function () {
var t,
e,
n,
r,
i = 0,
o = 0,
s = [],
c = this.get("curve");
c &&
(Object(a.each)(c, function (t, e) {
(n = c[e + 1]),
(r = t.length),
n &&
(i +=
Q.b.length(
t[r - 2],
t[r - 1],
n[1],
n[2],
n[3],
n[4],
n[5],
n[6],
) || 0);
}),
this.set("totalLength", i),
0 !== i
? (Object(a.each)(c, function (a, u) {
(n = c[u + 1]),
(r = a.length),
n &&
(((t = [])[0] = o / i),
(e = Q.b.length(
a[r - 2],
a[r - 1],
n[1],
n[2],
n[3],
n[4],
n[5],
n[6],
)),
(o += e || 0),
(t[1] = o / i),
s.push(t));
}),
this.set("tCache", s))
: this.set("tCache", []));
}),
(e.prototype.getStartTangent = function () {
var t,
e = this.getSegments();
if (e.length > 1) {
var n = e[0].currentPoint,
r = e[1].currentPoint,
i = e[1].startTangent;
(t = []),
i
? (t.push([n[0] - i[0], n[1] - i[1]]), t.push([n[0], n[1]]))
: (t.push([r[0], r[1]]), t.push([n[0], n[1]]));
}
return t;
}),
(e.prototype.getEndTangent = function () {
var t,
e = this.getSegments(),
n = e.length;
if (n > 1) {
var r = e[n - 2].currentPoint,
i = e[n - 1].currentPoint,
o = e[n - 1].endTangent;
(t = []),
o
? (t.push([i[0] - o[0], i[1] - o[1]]), t.push([i[0], i[1]]))
: (t.push([r[0], r[1]]), t.push([i[0], i[1]]));
}
return t;
}),
e
);
})(V);
function pt(t, e, n, r, i) {
var o = t.length;
if (o < 2) return !1;
for (var a = 0; a < o - 1; a++) {
if (J(t[a][0], t[a][1], t[a + 1][0], t[a + 1][1], e, n, r)) return !0;
}
if (i) {
var s = t[0],
c = t[o - 1];
if (J(s[0], s[1], c[0], c[1], e, n, r)) return !0;
}
return !1;
}
var gt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
var o = this.attr().points,
a = !1;
return (
n && (a = pt(o, i, t, e, !0)), !a && r && (a = at(o, t, e)), a
);
}),
(e.prototype.createPath = function (t) {
var e = this.attr().points;
if (!(e.length < 2)) {
t.beginPath();
for (var n = 0; n < e.length; n++) {
var r = e[n];
0 === n ? t.moveTo(r[0], r[1]) : t.lineTo(r[0], r[1]);
}
t.closePath();
}
}),
e
);
})(V),
vt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
startArrow: !1,
endArrow: !1,
});
}),
(e.prototype.initAttrs = function (t) {
this.setArrow();
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r),
this.setArrow(),
-1 !== ["points"].indexOf(e) && this._resetCache();
}),
(e.prototype._resetCache = function () {
this.set("totalLength", null), this.set("tCache", null);
}),
(e.prototype.setArrow = function () {
var t = this.attr(),
e = this.attrs,
n = e.points,
r = e.startArrow,
i = e.endArrow,
o = n.length,
a = n[0][0],
s = n[0][1],
c = n[o - 1][0],
u = n[o - 1][1];
r && N(this, t, n[1][0], n[1][1], a, s),
i && B(this, t, n[o - 2][0], n[o - 2][1], c, u);
}),
(e.prototype.isFill = function () {
return !1;
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
return !(!n || !i) && pt(this.attr().points, i, t, e, !1);
}),
(e.prototype.isStroke = function () {
return !0;
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.points,
r = e.startArrow,
i = e.endArrow,
o = n.length;
if (!(n.length < 2)) {
var a,
s = n[0][0],
c = n[0][1],
u = n[o - 1][0],
h = n[o - 1][1];
if (r && r.d)
(s += (a = T(s, c, n[1][0], n[1][1], r.d)).dx), (c += a.dy);
if (i && i.d)
(u -= (a = T(n[o - 2][0], n[o - 2][1], u, h, i.d)).dx),
(h -= a.dy);
t.beginPath(), t.moveTo(s, c);
for (var l = 0; l < o - 1; l++) {
var f = n[l];
t.lineTo(f[0], f[1]);
}
t.lineTo(u, h);
}
}),
(e.prototype.afterDrawPath = function (t) {
var e = this.get("startArrowShape"),
n = this.get("endArrowShape");
e && e.draw(t), n && n.draw(t);
}),
(e.prototype.getTotalLength = function () {
var t = this.attr().points,
e = this.get("totalLength");
return Object(a.isNil)(e)
? (this.set("totalLength", Q.d.length(t)),
this.get("totalLength"))
: e;
}),
(e.prototype.getPoint = function (t) {
var e,
n,
r = this.attr().points,
i = this.get("tCache");
return (
i || (this._setTcache(), (i = this.get("tCache"))),
Object(a.each)(i, function (r, i) {
t >= r[0] &&
t <= r[1] &&
((e = (t - r[0]) / (r[1] - r[0])), (n = i));
}),
Q.c.pointAt(r[n][0], r[n][1], r[n + 1][0], r[n + 1][1], e)
);
}),
(e.prototype._setTcache = function () {
var t = this.attr().points;
if (t && 0 !== t.length) {
var e = this.getTotalLength();
if (!(e <= 0)) {
var n,
r,
i = 0,
o = [];
Object(a.each)(t, function (a, s) {
t[s + 1] &&
(((n = [])[0] = i / e),
(r = Q.c.length(a[0], a[1], t[s + 1][0], t[s + 1][1])),
(i += r),
(n[1] = i / e),
o.push(n));
}),
this.set("tCache", o);
}
}
}),
(e.prototype.getStartTangent = function () {
var t = this.attr().points,
e = [];
return e.push([t[1][0], t[1][1]]), e.push([t[0][0], t[0][1]]), e;
}),
(e.prototype.getEndTangent = function () {
var t = this.attr().points,
e = t.length - 1,
n = [];
return (
n.push([t[e - 1][0], t[e - 1][1]]),
n.push([t[e][0], t[e][1]]),
n
);
}),
e
);
})(V);
var yt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
x: 0,
y: 0,
width: 0,
height: 0,
radius: 0,
});
}),
(e.prototype.isInStrokeOrPath = function (t, e, n, r, i) {
var o = this.attr(),
a = o.x,
s = o.y,
c = o.width,
u = o.height,
h = o.radius;
if (h) {
var l = !1;
return (
n &&
(l = (function (t, e, n, r, i, o, a, s) {
return (
J(t + i, e, t + n - i, e, o, a, s) ||
J(t + n, e + i, t + n, e + r - i, o, a, s) ||
J(t + n - i, e + r, t + i, e + r, o, a, s) ||
J(t, e + r - i, t, e + i, o, a, s) ||
ut(
t + n - i,
e + i,
i,
1.5 * Math.PI,
2 * Math.PI,
o,
a,
s,
) ||
ut(
t + n - i,
e + r - i,
i,
0,
0.5 * Math.PI,
o,
a,
s,
) ||
ut(
t + i,
e + r - i,
i,
0.5 * Math.PI,
Math.PI,
o,
a,
s,
) ||
ut(t + i, e + i, i, Math.PI, 1.5 * Math.PI, o, a, s)
);
})(a, s, c, u, h, i, t, e)),
!l && r && (l = f(a, s, c, u, t, e)),
l
);
}
var d = i / 2;
return r && n
? f(a - d, s - d, c + d, u + d, t, e)
: r
? f(a, s, c, u, t, e)
: n
? (function (t, e, n, r, i, o, a) {
var s = i / 2;
return (
f(t - s, e - s, n, i, o, a) ||
f(t + n - s, e - s, i, r, o, a) ||
f(t + s, e + r - s, n, i, o, a) ||
f(t - s, e + s, i, r, o, a)
);
})(a, s, c, u, i, t, e)
: void 0;
}),
(e.prototype.createPath = function (t) {
var e = this.attr(),
n = e.x,
r = e.y,
i = e.width,
o = e.height,
s = e.radius;
if ((t.beginPath(), 0 === s)) t.rect(n, r, i, o);
else {
var c = (function (t) {
var e = 0,
n = 0,
r = 0,
i = 0;
return (
Object(a.isArray)(t)
? 1 === t.length
? (e = n = r = i = t[0])
: 2 === t.length
? ((e = r = t[0]), (n = i = t[1]))
: 3 === t.length
? ((e = t[0]), (n = i = t[1]), (r = t[2]))
: ((e = t[0]), (n = t[1]), (r = t[2]), (i = t[3]))
: (e = n = r = i = t),
[e, n, r, i]
);
})(s),
u = c[0],
h = c[1],
l = c[2],
f = c[3];
t.moveTo(n + u, r),
t.lineTo(n + i - h, r),
0 !== h && t.arc(n + i - h, r + h, h, -Math.PI / 2, 0),
t.lineTo(n + i, r + o - l),
0 !== l && t.arc(n + i - l, r + o - l, l, 0, Math.PI / 2),
t.lineTo(n + f, r + o),
0 !== f && t.arc(n + f, r + o - f, f, Math.PI / 2, Math.PI),
t.lineTo(n, r + u),
0 !== u && t.arc(n + u, r + u, u, Math.PI, 1.5 * Math.PI),
t.closePath();
}
}),
e
);
})(V),
mt = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(i.c)(e, t),
(e.prototype.getDefaultAttrs = function () {
var e = t.prototype.getDefaultAttrs.call(this);
return Object(i.a)(Object(i.a)({}, e), {
x: 0,
y: 0,
text: null,
fontSize: 12,
fontFamily: "sans-serif",
fontStyle: "normal",
fontWeight: "normal",
fontVariant: "normal",
textAlign: "start",
textBaseline: "bottom",
});
}),
(e.prototype.isOnlyHitBox = function () {
return !0;
}),
(e.prototype.initAttrs = function (t) {
this._assembleFont(), t.text && this._setText(t.text);
}),
(e.prototype._assembleFont = function () {
var t = this.attrs;
t.font = Object(o.f)(t);
}),
(e.prototype._setText = function (t) {
var e = null;
Object(a.isString)(t) &&
-1 !== t.indexOf("\n") &&
(e = t.split("\n")),
this.set("textArr", e);
}),
(e.prototype.onAttrChange = function (e, n, r) {
t.prototype.onAttrChange.call(this, e, n, r),
e.startsWith("font") && this._assembleFont(),
"text" === e && this._setText(n);
}),
(e.prototype._getSpaceingY = function () {
var t = this.attrs,
e = t.lineHeight,
n = 1 * t.fontSize;
return e ? e - n : 0.14 * n;
}),
(e.prototype._drawTextArr = function (t, e, n) {
var r,
i = this.attrs,
s = i.textBaseline,
c = i.x,
u = i.y,
h = 1 * i.fontSize,
l = this._getSpaceingY(),
f = Object(o.h)(i.text, i.fontSize, i.lineHeight);
Object(a.each)(e, function (e, i) {
(r = u + i * (l + h) - f + h),
"middle" === s && (r += f - h - (f - h) / 2),
"top" === s && (r += f - h),
n ? t.fillText(e, c, r) : t.strokeText(e, c, r);
});
}),
(e.prototype._drawText = function (t, e) {
var n = this.attr(),
r = n.x,
i = n.y,
o = this.get("textArr");
if (o) this._drawTextArr(t, o, e);
else {
var a = n.text;
e ? t.fillText(a, r, i) : t.strokeText(a, r, i);
}
}),
(e.prototype.strokeAndFill = function (t) {
var e = this.attrs,
n = e.lineWidth,
r = e.opacity,
i = e.strokeOpacity,
o = e.fillOpacity;
this.isStroke() &&
n > 0 &&
(Object(a.isNil)(i) || 1 === i || (t.globalAlpha = r),
this.stroke(t)),
this.isFill() &&
(Object(a.isNil)(o) || 1 === o
? this.fill(t)
: ((t.globalAlpha = o), this.fill(t), (t.globalAlpha = r))),
this.afterDrawPath(t);
}),
(e.prototype.fill = function (t) {
this._drawText(t, !0);
}),
(e.prototype.stroke = function (t) {
this._drawText(t, !1);
}),
e
);
})(V);
function bt(t, e, n) {
var r = t.getTotalMatrix();
if (r) {
var i = (function (t, e) {
if (e) {
var n = Object(o.i)(e);
return Object(o.k)(n, t);
}
return t;
})([e, n, 1], r);
return [i[0], i[1]];
}
return [e, n];
}
function xt(t, e, n) {
if (t.isCanvas && t.isCanvas()) return !0;
if (!Object(o.j)(t) || !1 === t.cfg.isInView) return !1;
if (t.cfg.clipShape) {
var r = bt(t, e, n),
i = r[0],
a = r[1];
if (t.isClipped(i, a)) return !1;
}
var s = t.cfg.cacheCanvasBBox || t.getCanvasBBox();
return e >= s.minX && e <= s.maxX && n >= s.minY && n <= s.maxY;
}
var wt = n(30),
St = n.n(wt);
function Ot(t, e, n) {
(n.name = e),
(n.target = t),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
function Mt(t, e, n) {
if (n.bubbles) {
t.isCanvas(),
0,
(n.name = e),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
}
var kt = (function () {
function t(t) {
var e = this;
(this.draggingShape = null),
(this.dragging = !1),
(this.currentShape = null),
(this.panstartShape = null),
(this.panstartPoint = null),
(this.handleEvent = function (t) {
e.hammerRuntime.emit("origin_input:" + t.type, t);
}),
(this.canvas = t.canvas),
this._initEvent();
}
return (
(t.prototype._initEvent = function () {
var t = this;
(this.hammerRuntime = new St.a(
{},
{ inputClass: wt.TouchInput },
)),
this.hammerRuntime.add(
new St.a.Pan({ threshold: 0, pointers: 1 }),
),
this.hammerRuntime
.add(new St.a.Swipe())
.recognizeWith(this.hammerRuntime.get("pan")),
this.hammerRuntime.add(
new St.a.Pinch({ threshold: 0, pointers: 2 }),
),
this.hammerRuntime.add(
new St.a.Tap({ event: "dbltap", taps: 2 }),
),
this.hammerRuntime.add(new St.a.Tap()),
this.hammerRuntime.add(new St.a.Press({ time: 500 })),
this.hammerRuntime.on(
"panstart panmove panend pancancel",
function (e) {
e.srcEvent.extra = e;
var n = t._getPointInfo(e),
r = t._getShape(n, e);
("panend" !== e.type && "pancancel" !== e.type) ||
t._onpanend(n, r, e),
"panstart" === e.type &&
(t.dragging &&
((t.draggingShape = null),
(t.dragging = !1),
(t.panstartShape = null),
(t.panstartPoint = null)),
t._onpanstart(n, r, e)),
"panmove" === e.type && t._onpanmove(n, r, e),
(t.currentShape = r);
},
),
this.hammerRuntime.on(
"tap dbltap press swipe rotatestart rotatemove",
function (e) {
t._emitMobileEvent(e.type, e);
},
),
this.hammerRuntime.on(
"pinchstart pinchmove pinchend pinchcancel",
function (e) {
"pinchend" !== e.type && "pinchcancel" !== e.type
? ((e.srcEvent.extra = { scale: e.scale }),
t._emitMobileEvent(e.type, e))
: t._emitMobileEvent(e.type, e);
},
);
}),
(t.prototype._emitMobileEvent = function (t, e) {
var n = this._getPointInfo(e),
r = this._getShape(n, e);
this._emitEvent(t, e, n, r);
}),
(t.prototype._getEventObj = function (t, e, n, r, i, a) {
var s = new o.d(t, e);
return (
(s.fromShape = i),
(s.toShape = a),
(s.x = n.x),
(s.y = n.y),
(s.clientX = n.clientX),
(s.clientY = n.clientY),
s.propagationPath.push(r),
s
);
}),
(t.prototype._getShape = function (t, e) {
var n = e.srcEvent;
return this.canvas.getShape(t.x, t.y, n);
}),
(t.prototype._getPointInfo = function (t) {
var e = this.canvas,
n = e.getClientByEvent(t),
r = e.getPointByEvent(t);
return { x: r.x, y: r.y, clientX: n.x, clientY: n.y };
}),
(t.prototype._triggerEvent = function (t, e) {
var n = this._getPointInfo(e),
r = this._getShape(n, e),
i = this["_on" + t];
if (i) i.call(this, n, r, e);
else {
var o = this.currentShape;
"panstart" === t || "dragenter" === t
? (this._emitEvent(t, e, n, null, null, r),
r && this._emitEvent(t, e, n, r, null, r),
"panstart" === t &&
this.draggingShape &&
this._emitEvent("dragenter", e, n, null))
: "panend" === t || "dragleave" === t
? (o && this._emitEvent(t, e, n, o, o, null),
this._emitEvent(t, e, n, null, o, null),
"panend" === t &&
this.draggingShape &&
this._emitEvent("dragleave", e, n, null))
: this._emitEvent(t, e, n, r, null, null);
}
}),
(t.prototype._onpanstart = function (t, e, n) {
(this.panstartShape = e),
(this.panstartPoint = t),
(this.panstartTimeStamp = n.timeStamp),
this._emitEvent("panstart", n, t, e, null, null);
}),
(t.prototype._emitDragoverEvents = function (t, e, n, r, i) {
r
? (r !== n &&
(n && this._emitEvent("dragleave", t, e, n, n, r),
this._emitEvent("dragenter", t, e, r, n, r)),
i || this._emitEvent("dragover", t, e, r))
: n && this._emitEvent("dragleave", t, e, n, n, r),
i && this._emitEvent("dragover", t, e, r);
}),
(t.prototype._afterDrag = function (t, e, n) {
t && (t.set("capture", !0), (this.draggingShape = null)),
(this.dragging = !1);
var r = this._getShape(e, n);
this.currentShape = r;
}),
(t.prototype._onpanend = function (t, e, n) {
var r = this.draggingShape;
this.dragging &&
(r && this._emitEvent("drop", n, t, e),
this._emitEvent("dragend", n, t, r),
this._afterDrag(r, t, n)),
this._emitEvent("panend", n, t, e),
(this.panstartShape = null),
(this.panstartPoint = null);
}),
(t.prototype._onpanmove = function (t, e, n) {
var r = this.canvas,
i = this.currentShape,
o = this.draggingShape;
if (this.dragging)
o && this._emitDragoverEvents(n, t, i, e, !1),
this._emitEvent("drag", n, t, o);
else {
var a = this.panstartPoint;
if (a) {
var s = this.panstartShape,
c = n.timeStamp - this.panstartTimeStamp,
u = a.clientX - t.clientX,
h = a.clientY - t.clientY;
(c > 120 || u * u + h * h > 40) &&
(s && s.get("draggable")
? ((o = this.panstartShape).set("capture", !1),
(this.draggingShape = o),
(this.dragging = !0),
this._emitEvent("dragstart", n, t, o),
(this.panstartShape = null),
(this.panstartPoint = null))
: !s && r.get("draggable")
? ((this.dragging = !0),
this._emitEvent("dragstart", n, t, null),
(this.panstartShape = null),
(this.panstartPoint = null))
: this._emitEvent("panmove", n, t, e));
}
}
this._emitEvent("panmove", n, t, e);
}),
(t.prototype._emitEvent = function (t, e, n, r, i, o) {
var a = this._getEventObj(t, e, n, r, i, o);
if (r) {
(a.shape = r), Ot(r, t, a);
for (var s = r.getParent(); s; )
s.emitDelegation(t, a),
a.propagationStopped || Mt(s, t, a),
a.propagationPath.push(s),
(s = s.getParent());
} else {
Ot(this.canvas, t, a);
}
}),
(t.prototype.destroy = function () {
(this.canvas = null),
(this.currentShape = null),
(this.draggingShape = null),
(this.panstartPoint = null),
(this.panstartShape = null),
(this.panstartTimeStamp = null);
}),
t
);
})(),
Ct = (function () {
function t() {}
return (
(t.prototype.set = function (t, e, n) {
switch (e) {
case "strokeStyle":
t.setStrokeStyle(n);
break;
case "fillStyle":
t.setFillStyle(n);
break;
case "lineWidth":
t.setLineWidth(n);
break;
case "lineDash":
t.setLineDash(n);
break;
case "globalAlpha":
(n || 0 === n) && ((t.globalAlpha = n), t.setGlobalAlpha(n));
break;
case "fontSize":
t.setFontSize(n);
break;
case "textAlign":
t.setTextAlign(n);
break;
case "fontStyle":
case "font":
t.setFont(n);
break;
case "textBaseline":
t.setTextBaseline(n);
break;
default:
t[e] = n;
}
return !0;
}),
(t.prototype.get = function (t, e) {
return "globalAlpha" === e && void 0 === t[e]
? 1
: "function" == typeof t[e]
? t[e].bind(t)
: t[e];
}),
t
);
})(),
Et = n(98),
jt = null;
var Pt = function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.text,
o = e.fontSize,
s = e.lineHeight,
c = e.font;
c || (c = Object(Et.assembleFont)(e));
var u,
h = (function (t, e) {
var n = 0;
if (Object(a.isNil)(t) || "" === t) return n;
if (
(jt.save(),
(jt.font = e),
Object(a.isString)(t) && t.includes("\n"))
) {
var r = t.split("\n");
Object(a.each)(r, function (t) {
var e = jt.measureText(t).width;
n < e && (n = e);
});
} else n = jt.measureText(t).width;
return jt.restore(), n;
})(i, c);
if (h) {
var l = e.textAlign,
f = e.textBaseline,
d = Object(Et.getTextHeight)(i, o, s),
p = { x: n, y: r - d };
l &&
("end" === l || "right" === l
? (p.x -= h)
: "center" === l && (p.x -= h / 2)),
f &&
("top" === f ? (p.y += d) : "middle" === f && (p.y += d / 2)),
(u = { x: p.x, y: p.y, width: h, height: d });
} else u = { x: n, y: r, width: 0, height: 0 };
return u;
},
At = function (t) {
(jt = t), Object(o.l)("text", Pt);
},
It = function (t, e) {
!(function (t) {
K = t;
})(e),
At(t);
},
Tt = (function (t) {
function e(e) {
var n,
r = t.call(this, e) || this,
i = r.get("context");
return (
r.isMini() &&
(r.isMiniNative()
? (void 0 === (n = r.get("container")) && (n = {}), (n = n))
: r.set("context", new Proxy(i, new Ct())),
It(i, r)),
r
);
}
return (
Object(i.c)(e, t),
(e.prototype.isMiniNative = function () {
return "mini-native" === this.get("renderer");
}),
(e.prototype.isMini = function () {
return this.get("renderer").startsWith("mini");
}),
(e.prototype.getDefaultCfg = function () {
var e = t.prototype.getDefaultCfg.call(this);
return (
(e.renderer = "canvas"),
(e.autoDraw = !0),
(e.localRefresh = !0),
(e.refreshElements = []),
(e.clipView = !0),
(e.quickHit = !1),
(e.boundingClientRect = {
width: 0,
height: 0,
left: 0,
top: 0,
bottom: 0,
right: 0,
}),
e
);
}),
(e.prototype.initEvents = function () {
var t = new kt({ canvas: this });
this.set("eventController", t);
}),
(e.prototype.registerEventCallback = function (t) {
this.get("eventController").handleEvent(t);
}),
(e.prototype.clearEvents = function () {
this.get("eventController").destroy();
}),
(e.prototype.onCanvasChange = function (t) {
("attr" !== t && "sort" !== t && "changeSize" !== t) ||
(this.set("refreshElements", [this]), this.draw());
}),
(e.prototype.getShapeBase = function () {
return r;
}),
(e.prototype.getGroupBase = function () {
return q;
}),
(e.prototype.getPixelRatio = function () {
var t =
this.get("pixelRatio") ||
("object" ===
("undefined" == typeof window ? "undefined" : h(window)) &&
window.devicePixelRatio
? window.devicePixelRatio
: 1);
return t >= 1 ? Math.ceil(t) : 1;
}),
(e.prototype.getViewRange = function () {
return {
minX: 0,
minY: 0,
maxX: this.cfg.width,
maxY: this.cfg.height,
};
}),
(e.prototype.initDom = function () {
if (this.isMini()) {
var e = this.get("context"),
n = this.getPixelRatio();
n > 1 && e.scale(n, n);
} else t.prototype.initDom.call(this);
}),
(e.prototype.createDom = function () {
var t = document.createElement("canvas"),
e = t.getContext("2d");
return this.set("context", e), t;
}),
(e.prototype.setDOMSize = function (e, n) {
t.prototype.setDOMSize.call(this, e, n);
var r = this.get("context"),
i = this.get("el"),
o = this.getPixelRatio();
(i.width = o * e), (i.height = o * n), o > 1 && r.scale(o, o);
}),
(e.prototype.clear = function () {
t.prototype.clear.call(this),
this._clearFrame(),
this.get("context").clearRect(
0,
0,
this.get("width"),
this.get("height"),
);
}),
(e.prototype.getShape = function (e, n) {
return this.get("quickHit")
? (function t(e, n, r) {
if (!xt(e, n, r)) return null;
for (
var i = null, o = e.getChildren(), a = o.length - 1;
a >= 0;
a--
) {
var s = o[a];
if (s.isGroup()) i = t(s, n, r);
else if (xt(s, n, r)) {
var c = s,
u = bt(s, n, r),
h = u[0],
l = u[1];
c.isInShape(h, l) && (i = s);
}
if (i) break;
}
return i;
})(this, e, n)
: t.prototype.getShape.call(this, e, n, null);
}),
(e.prototype._getRefreshRegion = function () {
var t,
e = this.get("refreshElements"),
n = this.getViewRange();
e.length && e[0] === this
? (t = n)
: (t = (function (t) {
if (!t.length) return null;
var e = [],
n = [],
r = [],
i = [];
return (
Object(a.each)(t, function (t) {
var o = W(t);
o &&
(e.push(o.minX),
n.push(o.minY),
r.push(o.maxX),
i.push(o.maxY));
}),
{
minX: Math.min.apply(null, e),
minY: Math.min.apply(null, n),
maxX: Math.max.apply(null, r),
maxY: Math.max.apply(null, i),
}
);
})(e)) &&
((t.minX = Math.floor(t.minX)),
(t.minY = Math.floor(t.minY)),
(t.maxX = Math.ceil(t.maxX)),
(t.maxY = Math.ceil(t.maxY)),
(t.maxY += 1),
this.get("clipView") &&
(t = (function (t, e) {
return t && e && d(t, e)
? {
minX: Math.max(t.minX, e.minX),
minY: Math.max(t.minY, e.minY),
maxX: Math.min(t.maxX, e.maxX),
maxY: Math.min(t.maxY, e.maxY),
}
: null;
})(t, n)));
return t;
}),
(e.prototype._clearFrame = function () {
var t = this.get("drawFrame");
t &&
(u(t),
this.set("drawFrame", null),
this.set("refreshElements", []));
}),
(e.prototype.draw = function () {
var t = this.get("drawFrame");
(this.get("autoDraw") && t) || this._startDraw();
}),
(e.prototype._startDraw = function () {
var t,
e = this,
n = this.get("drawFrame");
n ||
((t = function () {
e.get("localRefresh") ? e._drawRegion() : e._drawAll(),
u(n),
e.set("drawFrame", null);
}),
(n = (null == c ? void 0 : c.requestAnimationFrame)
? c.requestAnimationFrame(t)
: ("object" ===
("undefined" == typeof window
? "undefined"
: s(window)) && window.requestAnimationFrame
? window.requestAnimationFrame
: function (t) {
return setTimeout(t, 16);
})(t)),
this.set("drawFrame", n));
}),
(e.prototype._drawRegion = function () {
var t = this.get("context"),
e = this.get("refreshElements"),
n = this.getChildren(),
r = this._getRefreshRegion();
r
? (t.clearRect(
r.minX,
r.minY,
r.maxX - r.minX,
r.maxY - r.minY,
),
t.save(),
t.beginPath(),
t.rect(r.minX, r.minY, r.maxX - r.minX, r.maxY - r.minY),
t.clip(),
D(t, this),
R(this, n, r),
_(t, n, r),
t.restore())
: e.length &&
(function t(e) {
for (var n = 0; n < e.length; n++) {
var r = e[n];
(r.cfg.hasChanged = !1),
r.isGroup() && !r.destroyed && t(r.cfg.children);
}
})(e),
Object(a.each)(e, function (t) {
t.get("hasChanged") && t.set("hasChanged", !1);
}),
this.isMini() && !this.isMiniNative() && t.draw(!0),
this.set("refreshElements", []);
}),
(e.prototype._drawAll = function () {
var t = this.get("context"),
e = this.getChildren();
t.clearRect(0, 0, this.get("width"), this.get("height")),
D(t, this),
_(t, e),
this.isMini() && !this.isMiniNative() && t.draw(!0),
this.set("refreshElements", []);
}),
(e.prototype.skipDraw = function () {}),
(e.prototype.refreshElement = function (t) {
this.get("refreshElements").push(t);
}),
(e.prototype.getPointByEvent = function (e) {
if (this.isMini()) {
var n = this.getClientByEvent(e),
r = n.x,
i = n.y;
return this.getPointByClient(r, i);
}
return t.prototype.getPointByEvent.call(this, e);
}),
(e.prototype.getClientByEvent = function (t) {
var e = t.srcEvent,
n = null;
return (
e.touches &&
(n =
"touchend" === e.type ? e.changedTouches[0] : e.touches[0]),
n ? { x: n.clientX, y: n.clientY } : {}
);
}),
(e.prototype.getPointByClient = function (t, e) {
if (this.isMini()) {
var n = this.get("boundingClientRect");
return { x: t + n.left, y: e + n.top };
}
var r = this.get("el").getBoundingClientRect();
return { x: t - r.left, y: e - r.top };
}),
(e.prototype.removeDom = function () {
this.isMini() || t.prototype.removeDom.call(this);
}),
(e.prototype.getClientByPoint = function (t, e) {
if (this.isMini()) {
var n = this.get("boundingClientRect");
return { x: t + n.left, y: e + n.top };
}
var r = this.get("el").getBoundingClientRect();
return { x: t + r.left, y: e + r.top };
}),
e
);
})(o.a),
Nt = n(4);
var Bt = n(2),
Lt = n(18),
Dt = Bt.h.cloneEvent,
_t = Bt.h.isViewportChanged,
Rt = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
return (
(n.extendEvents = []),
(n.dragging = !1),
(n.preItem = null),
(n.graph = e),
(n.destroyed = !1),
n
);
}
return (
Object(i.c)(e, t),
(e.prototype.initEvents = function () {
var t = this.graph,
e = (this.extendEvents, t.get("canvas"));
(this.canvasHandler = Object(a.wrapBehavior)(
this,
"onCanvasEvents",
)),
e.off("*").on("*", this.canvasHandler);
}),
(e.getItemRoot = function (t) {
for (; t && !t.get("item"); ) t = t.get("parent");
return t;
}),
(e.prototype.onCanvasEvents = function (t) {
var n = this.graph,
r = n.get("canvas"),
i = t.target,
o = t.type;
(t.canvasX = t.x), (t.canvasY = t.y);
var a = { x: t.canvasX, y: t.canvasY },
s = n.get("group").getMatrix();
if (
(s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
_t(s) && (a = n.getPointByClient(t.clientX, t.clientY)),
(t.x = a.x),
(t.y = a.y),
(t.currentTarget = n),
i === r)
)
return (
"panmove" === o && this.handleTouchMove(t, "canvas"),
(t.target = r),
(t.item = null),
n.emit(o, t),
void n.emit("canvas:" + o, t)
);
var c = e.getItemRoot(i);
if (c) {
var u = c.get("item");
if (!u.destroyed) {
var h = u.getType();
if (
((t.target = i),
(t.item = u),
t.canvasX === t.x && t.canvasY === t.y)
) {
var l = n.getCanvasByPoint(t.x, t.y);
(t.canvasX = l.x), (t.canvasY = l.y);
}
n.emit(o, t),
t.name && !t.name.includes(":")
? n.emit(h + ":" + o, t)
: n.emit(t.name, t),
"dragstart" === o && (this.dragging = !0),
"dragend" === o && (this.dragging = !1),
"panmove" === o && this.handleTouchMove(t, h);
}
} else n.emit(o, t);
}),
(e.prototype.onExtendEvents = function (t) {
this.graph.emit(t.type, t);
}),
(e.prototype.emitCustomEvent = function (t, e, n) {
(n.type = e), this.graph.emit(t + ":" + e, n);
}),
(e.prototype.destroy = function () {
var t = this.graph,
e = this.canvasHandler,
n = this.extendEvents;
t.get("canvas").off("*", e),
Object(a.each)(n, function (t) {
t.remove();
}),
(this.dragging = !1),
(this.preItem = null),
(this.extendEvents.length = 0),
(this.canvasHandler = null),
(this.destroyed = !0);
}),
(e.prototype.handleTouchMove = function (t, e) {
var n = this.graph,
r = this.preItem,
i = n.get("canvas"),
o = t.target === i ? null : t.item;
(t = Dt(t)),
r &&
r !== o &&
!r.destroyed &&
((t.item = r),
this.emitCustomEvent(r.getType(), "touchleave", t),
this.dragging &&
this.emitCustomEvent(r.getType(), "dragleave", t)),
o &&
r !== o &&
((t.item = o),
this.emitCustomEvent(e, "touchenter", t),
this.dragging && this.emitCustomEvent(e, "dragenter", t)),
(this.preItem = o);
}),
e
);
})(Bt.a),
Ft = n(26),
Yt = ["force", "grid", "circular"],
Xt = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
return (
(n.graph = e),
(n.layoutCfg = e.get("layout") || {}),
(n.layoutType = n.getLayoutType()),
n
);
}
return (
Object(i.c)(e, t),
(e.prototype.updateLayoutCfg = function (t) {
var e = this,
n = this.graph,
r = this.layoutMethods,
i = Object(a.mix)({}, this.layoutCfg, t);
if (((this.layoutCfg = i), null == r ? void 0 : r.length)) {
(this.data = this.setDataFromGraph()), n.emit("beforelayout");
var o = Promise.resolve();
1 === r.length
? (o = o.then(function () {
return e.updateLayoutMethod(r[0], i);
}))
: null == r ||
r.forEach(function (t, n) {
var r = i.pipes[n];
o = o.then(function () {
return e.updateLayoutMethod(t, r);
});
}),
(this.data = this.setDataFromGraph()),
o
.then(function () {
i.onAllLayoutEnd && i.onAllLayoutEnd();
})
.catch(function (t) {
console.warn("layout failed", t);
});
} else this.layout();
}),
(e.prototype.layout = function (t) {
var e = this,
n = this.graph;
this.data = this.setDataFromGraph();
var r = this.data,
o = r.nodes,
a = r.hiddenNodes;
if (!o) return !1;
var s = n.get("width"),
c = n.get("height"),
u = {};
Object.assign(
u,
{ width: s, height: c, center: [s / 2, c / 2] },
this.layoutCfg,
),
(this.layoutCfg = u),
this.destoryLayoutMethods(),
n.emit("beforelayout"),
this.initPositions(u.center, o),
this.initPositions(u.center, a);
var h = u.onLayoutEnd,
l = u.layoutEndFormatted,
f = u.adjust;
l ||
((u.layoutEndFormatted = !0),
(u.onAllLayoutEnd = function () {
return Object(i.b)(e, void 0, void 0, function () {
return Object(i.d)(this, function (t) {
switch (t.label) {
case 0:
return (
h && h(),
this.refreshLayout(),
f && u.pipes
? [4, this.adjustPipesBox(this.data, f)]
: [3, 2]
);
case 1:
t.sent(), this.refreshLayout(), (t.label = 2);
case 2:
return n.emit("afterlayout"), [2];
}
});
});
}));
var d = Promise.resolve();
return (
u.type
? (d = d.then(function () {
return e.execLayoutMethod(u, 0);
}))
: u.pipes &&
u.pipes.forEach(function (t, n) {
d = d.then(function () {
return e.execLayoutMethod(t, n);
});
}),
d
.then(function () {
u.onAllLayoutEnd && u.onAllLayoutEnd(), t && t();
})
.catch(function (t) {
console.warn("graph layout failed,", t);
}),
!1
);
}),
(e.prototype.execLayoutMethod = function (t, e) {
var n = this;
return new Promise(function (r, i) {
var o = n.graph,
a = t.type;
if (
((t.onLayoutEnd = function () {
o.emit("aftersublayout", { type: a }), r();
}),
"force" === a || "g6force" === a || "gForce" === a)
) {
var s = t.onTick,
c = function () {
s && s(), o.refreshPositions();
};
t.tick = c;
} else
"comboForce" === t.type &&
(t.comboTrees = o.get("comboTrees"));
var u;
try {
u = new Ft.a(t);
} catch (t) {
console.warn(
"The layout method: '" +
a +
"' does not exist! Please specify it first.",
),
i();
}
if (u.enableTick) {
var h = t.onTick;
c = function () {
h && h(), o.refreshPositions();
};
u.tick = c;
}
var l = n.filterLayoutData(n.data, t);
!(function (t, e) {
var n;
if (
!(null === (n = null == t ? void 0 : t.nodes) ||
void 0 === n
? void 0
: n.length)
)
return;
t.nodes.forEach(function (t) {
t.layoutOrder = e;
});
})(l, e),
u.init(l),
o.emit("beforesublayout", { type: a }),
u.execute(),
u.isCustomLayout && t.onLayoutEnd && t.onLayoutEnd(),
n.layoutMethods.push(u);
});
}),
(e.prototype.updateLayoutMethod = function (t, e) {
var n = this;
return new Promise(function (r, i) {
var o = n.graph,
a = null == e ? void 0 : e.type;
e.onLayoutEnd = function () {
o.emit("aftersublayout", { type: a }), r();
};
var s = n.filterLayoutData(n.data, e);
t.init(s),
t.updateCfg(e),
o.emit("beforesublayout", { type: a }),
t.execute(),
t.isCustomLayout && e.onLayoutEnd && e.onLayoutEnd();
});
}),
(e.prototype.adjustPipesBox = function (t, e) {
var n = this;
return new Promise(function (r) {
var i = t.nodes;
(null == i ? void 0 : i.length) || r(),
Yt.includes(e) ||
(console.warn(
"The adjust type " +
e +
" is not supported yet, please assign it with 'force', 'grid', or 'circular'.",
),
r());
var o = {
center: n.layoutCfg.center,
nodeSize: function (t) {
return Math.max(t.height, t.width);
},
preventOverlap: !0,
onLayoutEnd: function () {},
},
s = n.getLayoutBBox(i),
c = s.groupNodes,
u = s.layoutNodes,
h = Object(a.clone)(u);
(o.onLayoutEnd = function () {
null == u ||
u.forEach(function (t, e) {
var n,
r,
i,
o =
t.x -
(null === (n = h[e]) || void 0 === n ? void 0 : n.x),
a =
t.y -
(null === (r = h[e]) || void 0 === r ? void 0 : r.y);
null === (i = c[e]) ||
void 0 === i ||
i.forEach(function (t) {
(t.x += o), (t.y += a);
});
}),
r();
}),
new Ft.a(o).layout({ nodes: u });
});
}),
(e.prototype.destroy = function () {
this.destoryLayoutMethods(),
(this.destroyed = !0),
this.graph.set("layout", void 0),
(this.layoutCfg = void 0),
(this.layoutType = void 0),
(this.layoutMethods = void 0),
(this.graph = null);
}),
e
);
})(Bt.c);
var zt = n(43),
Wt = function (t, e, n) {
return (
n[t] &&
console.warn(
"The graph with the name " +
t +
" exists already, it will be overridden",
),
(n[t] = e(n)),
n
);
},
qt = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
n.get("renderer").startsWith("mini") && n.set("context", e.context),
t.prototype.init.call(n);
var r = n.get("defaultNode");
return (
r || n.set("defaultNode", { type: "circle" }),
r.type || ((r.type = "circle"), n.set("defaultNode", r)),
(n.destroyed = !1),
n
);
}
return (
Object(i.c)(e, t),
(e.prototype.init = function () {}),
(e.prototype.emitEvent = function (t) {
var e = this.get("canvas");
(t.type = t.type.toLowerCase()), e.registerEventCallback(t);
}),
(e.prototype.initLayoutController = function () {
var t = new Xt(this);
this.set({ layoutController: t });
}),
(e.prototype.initEventController = function () {
var t = new Rt(this);
if (
(this.set({ eventController: t }),
!this.get("renderer").startsWith("mini"))
) {
var e = this.get("canvas"),
n = e.get("el");
"touchstart touchmove touchend touchcancel"
.split(" ")
.forEach(function (t) {
n.addEventListener(t, e.registerEventCallback.bind(e), !1);
});
}
}),
(e.prototype.initCanvas = function () {
var t = this.get("container");
null !== t &&
"string" == typeof t &&
((t = document.getElementById(t)), this.set("container", t));
var e = this.get("renderer");
if (!t && !e.startsWith("mini"))
throw new Error("invalid container");
var n = this.get("width"),
r = this.get("height"),
i = {
container: t,
context: this.get("context"),
width: n,
height: r,
renderer: e,
fitView: this.get("fitView"),
},
o = this.get("pixelRatio");
o && (i.pixelRatio = o);
var a = new Tt(i);
this.set("canvas", a);
}),
(e.prototype.initPlugins = function () {
var t = this;
Object(a.each)(t.get("plugins"), function (e) {
!e.destroyed && e.initPlugin && e.initPlugin(t);
});
}),
(e.prototype.toDataURL = function (t, e) {
var n = this.get("canvas"),
r = n.getRenderer(),
i = n.get("el");
t || (t = "image/png");
var o = "";
if ("svg" === r) {
var a = i.cloneNode(!0),
s = document.implementation.createDocumentType(
"svg",
"-//W3C//DTD SVG 1.1//EN",
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd",
),
c = document.implementation.createDocument(
"http://www.w3.org/2000/svg",
"svg",
s,
);
c.replaceChild(a, c.documentElement);
var u = new XMLSerializer().serializeToString(c);
o = "data:image/svg+xml;charset=utf8," + encodeURIComponent(u);
} else {
var h = void 0,
l = i.getContext("2d"),
f = this.get("width"),
d = this.get("height"),
p = void 0;
if (e) {
var g =
"undefined" != typeof window ? window.devicePixelRatio : 1;
(h = l.getImageData(0, 0, f * g, d * g)),
(p = l.globalCompositeOperation),
(l.globalCompositeOperation = "destination-over"),
(l.fillStyle = e),
l.fillRect(0, 0, f, d);
}
(o = i.toDataURL(t)),
e &&
(l.clearRect(0, 0, f, d),
l.putImageData(h, 0, 0),
(l.globalCompositeOperation = p));
}
return o;
}),
(e.prototype.toFullDataURL = function (t, e, n) {
var r = this.get("group").getCanvasBBox(),
i = r.height,
o = r.width,
s = this.get("renderer"),
c = Object(zt.a)(''),
u = n ? n.backgroundColor : void 0,
h = n ? n.padding : void 0;
h
? Object(a.isNumber)(h) && (h = [h, h, h, h])
: (h = [0, 0, 0, 0]);
var l = i + h[0] + h[2],
f = o + h[1] + h[3],
d = new Tt({ container: c, height: l, width: f, quickHit: !0 }),
p = this.get("group").clone(),
g = Object(a.clone)(p.getMatrix());
g || (g = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var v = (r.maxX + r.minX) / 2,
y = (r.maxY + r.minY) / 2;
Nt.a.translate(g, g, [-v, -y]),
Nt.a.translate(g, g, [o / 2 + h[3], i / 2 + h[0]]),
p.resetMatrix(),
p.setMatrix(g),
d.add(p);
var m = d.get("el"),
b = "";
e || (e = "image/png"),
setTimeout(function () {
if ("svg" === s) {
var n = m.cloneNode(!0),
r = document.implementation.createDocumentType(
"svg",
"-//W3C//DTD SVG 1.1//EN",
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd",
),
i = document.implementation.createDocument(
"http://www.w3.org/2000/svg",
"svg",
r,
);
i.replaceChild(n, i.documentElement);
var o = new XMLSerializer().serializeToString(i);
b =
"data:image/svg+xml;charset=utf8," +
encodeURIComponent(o);
} else {
var a = void 0,
c = m.getContext("2d"),
h = void 0;
if (u) {
var d =
"undefined" != typeof window
? window.devicePixelRatio
: 1;
(a = c.getImageData(0, 0, f * d, l * d)),
(h = c.globalCompositeOperation),
(c.globalCompositeOperation = "destination-over"),
(c.fillStyle = u),
c.fillRect(0, 0, f, l);
}
(b = m.toDataURL(e)),
u &&
(c.clearRect(0, 0, f, l),
c.putImageData(a, 0, 0),
(c.globalCompositeOperation = h));
}
t && t(b);
}, 16);
}),
(e.prototype.downloadFullImage = function (t, e, n) {
var r = this,
i = this.get("group").getCanvasBBox(),
o = i.height,
s = i.width,
c = this.get("renderer"),
u = Object(zt.a)(''),
h = n ? n.backgroundColor : void 0,
l = n ? n.padding : void 0;
l
? Object(a.isNumber)(l) && (l = [l, l, l, l])
: (l = [0, 0, 0, 0]);
var f = o + l[0] + l[2],
d = s + l[1] + l[3],
p = new Tt({ container: u, height: f, width: d }),
g = this.get("group").clone(),
v = Object(a.clone)(g.getMatrix());
v || (v = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var y = (i.maxX + i.minX) / 2,
m = (i.maxY + i.minY) / 2;
Nt.a.translate(v, v, [-y, -m]),
Nt.a.translate(v, v, [s / 2 + l[3], o / 2 + l[0]]),
g.resetMatrix(),
g.setMatrix(v),
p.add(g);
var b = p.get("el");
e || (e = "image/png"),
setTimeout(function () {
var n = "";
if ("svg" === c) {
var i = b.cloneNode(!0),
o = document.implementation.createDocumentType(
"svg",
"-//W3C//DTD SVG 1.1//EN",
"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd",
),
a = document.implementation.createDocument(
"http://www.w3.org/2000/svg",
"svg",
o,
);
a.replaceChild(i, a.documentElement);
var s = new XMLSerializer().serializeToString(a);
n =
"data:image/svg+xml;charset=utf8," +
encodeURIComponent(s);
} else {
var u = void 0,
l = b.getContext("2d"),
p = void 0;
if (h) {
var g =
"undefined" != typeof window
? window.devicePixelRatio
: 1;
(u = l.getImageData(0, 0, d * g, f * g)),
(p = l.globalCompositeOperation),
(l.globalCompositeOperation = "destination-over"),
(l.fillStyle = h),
l.fillRect(0, 0, d, f);
}
(n = b.toDataURL(e)),
h &&
(l.clearRect(0, 0, d, f),
l.putImageData(u, 0, 0),
(l.globalCompositeOperation = p));
}
var v = document.createElement("a"),
y =
(t || "graph") +
("svg" === c ? ".svg" : "." + e.split("/")[1]);
r.dataURLToImage(n, c, v, y);
var m = document.createEvent("MouseEvents");
m.initEvent("click", !1, !1), v.dispatchEvent(m);
}, 16);
}),
(e.prototype.downloadImage = function (t, e, n) {
var r = this,
i = this;
i.isAnimating() && i.stopAnimate();
var o = i.get("canvas").getRenderer();
e || (e = "image/png");
var a = (t || "graph") + ("svg" === o ? ".svg" : e.split("/")[1]),
s = document.createElement("a");
setTimeout(function () {
var t = i.toDataURL(e, n);
r.dataURLToImage(t, o, s, a);
var c = document.createEvent("MouseEvents");
c.initEvent("click", !1, !1), s.dispatchEvent(c);
}, 16);
}),
(e.prototype.dataURLToImage = function (t, e, n, r) {
if ("undefined" != typeof window)
if (window.Blob && window.URL && "svg" !== e) {
var i = t.split(","),
o = "";
if (i && i.length > 0) {
var a = i[0].match(/:(.*?);/);
a && a.length >= 2 && (o = a[1]);
}
for (
var s = atob(i[1]), c = s.length, u = new Uint8Array(c);
c--;
)
u[c] = s.charCodeAt(c);
var h = new Blob([u], { type: o });
window.navigator.msSaveBlob
? window.navigator.msSaveBlob(h, r)
: n.addEventListener("click", function () {
(n.download = r),
(n.href = window.URL.createObjectURL(h));
});
} else
n.addEventListener("click", function () {
(n.download = r), (n.href = t);
});
}),
(e.prototype.addPlugin = function (t) {
t.destroyed || (this.get("plugins").push(t), t.initPlugin(this));
}),
(e.prototype.removePlugin = function (t) {
var e = this.get("plugins"),
n = e.indexOf(t);
n >= 0 && (t.destroyPlugin(), e.splice(n, 1));
}),
(e.prototype.isMiniNative = function () {
return "mini-native" === this.get("renderer");
}),
(e.prototype.isMini = function () {
return this.get("renderer").startsWith("mini");
}),
(e.prototype.isBrowser = function () {
return "canvas" === this.get("renderer");
}),
(e.prototype.setImageWaterMarker = function (t, e, n) {
var r = this,
i = Object(a.deepMix)({}, Lt.a.imageWaterMarkerConfig, e),
o = i.width,
s = i.height,
c = i.image,
u = c.rotate,
h = (c.x, c.y, c.width),
l = c.height;
if ((this.isMini() && this.isMiniNative(), this.isMiniNative())) {
(n.width = o || this.get("width")),
(n.height = s || this.get("height"));
var f = n.getContext("2d"),
d = (0, this.get("extra").createImage)();
(d.crossOrigin = "anonymous"),
(d.src = t),
(d.onload = function () {
if (!r.destroyed) {
var t = h / d.width,
e = l / d.height;
f.rotate((-u * Math.PI) / 180);
var i = f.createPattern(d, "repeat");
(f.fillStyle = i),
f.scale(t, e),
f.fillRect(
2 * -r.get("width"),
-r.get("height"),
10 * r.get("width"),
10 * r.get("height"),
),
r
.get("waterGroup")
.addShape("image", { attrs: { img: n } });
}
});
}
if (this.isBrowser()) {
var p = document.createElement("canvas");
(p.width = o || this.get("width")),
(p.height = s || this.get("height"));
var g = p.getContext("2d"),
v = new Image();
(v.crossOrigin = "anonymous"),
(v.src = t),
(v.onload = function () {
if (!r.destroyed) {
var t = h / v.width,
e = l / v.height;
g.rotate((-u * Math.PI) / 180);
var n = g.createPattern(v, "repeat");
(g.fillStyle = n),
g.scale(t, e),
g.fillRect(
2 * -r.get("width"),
-r.get("height"),
10 * r.get("width"),
10 * r.get("height"),
);
var i = p.toDataURL();
r.get("waterGroup").addShape("image", {
attrs: { img: i },
});
}
});
}
}),
(e.prototype.setTextWaterMarker = function (t, e) {
var n = this.get("container");
Object(a.isString)(n) && (n = document.getElementById(n)),
n.style.position || (n.style.position = "relative");
var r = this.get("graphWaterMarker"),
i = Object(a.deepMix)({}, Lt.a.textWaterMarkerConfig, e),
o = i.width,
s = i.height,
c = i.compatible,
u = i.text;
if (!r) {
var h = { container: n, width: o, height: s, capture: !1 },
l = this.get("pixelRatio");
l && (h.pixelRatio = l),
(r = new Tt(h)),
this.set("graphWaterMarker", r);
}
r.get("el").style.display = "none";
var f = r.get("context"),
d = u.rotate,
p = u.fill,
g = u.fontFamily,
v = u.fontSize,
y = u.baseline,
m = u.x,
b = u.y,
x = u.lineHeight;
f.rotate((-d * Math.PI) / 180),
(f.font = v + "px " + g),
(f.fillStyle = p),
(f.textBaseline = y);
for (var w = t.length - 1; w >= 0; w--)
f.fillText(t[w], m, b + w * x);
if ((f.rotate((d * Math.PI) / 180), c))
n.style.cssText =
"background-image: url(" +
r.get("el").toDataURL("image/png") +
");background-repeat:repeat;";
else {
var S = document.querySelector(".g6-graph-watermarker");
S ||
((S = document.createElement("div")).className =
"g6-graph-watermarker"),
(S.style.cssText =
"background-image: url(" +
r.get("el").toDataURL("image/png") +
");background-repeat:repeat;position:absolute;top:0;bottom:0;left:0;right:0;pointer-events:none;z-index:99;"),
n.appendChild(S);
}
}),
(e.prototype.destroy = function () {
Object(a.each)(this.get("plugins"), function (t) {
t.destroyPlugin();
});
var e = this.get("tooltips");
if (e)
for (var n = 0; n < e.length; n++) {
var r = e[n];
if (r) {
var i = r.parentElement;
i && i.removeChild(r);
}
}
this.get("eventController").destroy(),
this.get("layoutController").destroy(),
this.get("graphWaterMarker") &&
this.get("graphWaterMarker").destroy(),
"undefined" != typeof document &&
document.querySelector &&
document.querySelector(".g6-graph-watermarker") &&
document.querySelector(".g6-graph-watermarker").remove(),
t.prototype.destroy.call(this);
}),
(e.prototype.initGroups = function () {
var t = this.get("canvas"),
e = t.addGroup({
id: "root",
className: Lt.a.rootContainerClassName,
}),
n = t.addGroup({
id: "water",
className: Lt.a.waterContainerClassName,
});
if (this.get("groupByTypes")) {
var r = e.addGroup({
id: "edge",
className: Lt.a.edgeContainerClassName,
}),
i = e.addGroup({
id: "node",
className: Lt.a.nodeContainerClassName,
}),
o = e.addGroup({
id: "combo",
className: Lt.a.comboContainerClassName,
});
o.toBack(),
this.set({ nodeGroup: i, edgeGroup: r, comboGroup: o });
}
var a = t.addGroup({
id: "uiGroup",
className: Lt.a.uiContainerClassName,
}),
s = e.addGroup({
id: "delegate",
className: Lt.a.delegateContainerClassName,
});
this.set({ delegateGroup: s }),
this.set("group", e),
this.set("uiGroup", a),
this.set("waterGroup", n);
}),
e
);
})(Bt.b);
e.a = qt;
},
75: function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "mixColor", function () {
return B;
}),
n.d(e, "getColorsWithSubjectColor", function () {
return L;
}),
n.d(e, "getColorSetsBySubjectColors", function () {
return D;
});
var r = n(44),
i = n.n(r);
function o(t, e) {
(function (t) {
return (
"string" == typeof t && -1 !== t.indexOf(".") && 1 === parseFloat(t)
);
})(t) && (t = "100%");
var n = (function (t) {
return "string" == typeof t && -1 !== t.indexOf("%");
})(t);
return (
(t = 360 === e ? t : Math.min(e, Math.max(0, parseFloat(t)))),
n && (t = parseInt(String(t * e), 10) / 100),
Math.abs(t - e) < 1e-6
? 1
: (t =
360 === e
? (t < 0 ? (t % e) + e : t % e) / parseFloat(String(e))
: (t % e) / parseFloat(String(e)))
);
}
function a(t) {
return Math.min(1, Math.max(0, t));
}
function s(t) {
return (t = parseFloat(t)), (isNaN(t) || t < 0 || t > 1) && (t = 1), t;
}
function c(t) {
return t <= 1 ? "".concat(100 * Number(t), "%") : t;
}
function u(t) {
return 1 === t.length ? "0" + t : String(t);
}
function h(t, e, n) {
(t = o(t, 255)), (e = o(e, 255)), (n = o(n, 255));
var r = Math.max(t, e, n),
i = Math.min(t, e, n),
a = 0,
s = 0,
c = (r + i) / 2;
if (r === i) (s = 0), (a = 0);
else {
var u = r - i;
switch (((s = c > 0.5 ? u / (2 - r - i) : u / (r + i)), r)) {
case t:
a = (e - n) / u + (e < n ? 6 : 0);
break;
case e:
a = (n - t) / u + 2;
break;
case n:
a = (t - e) / u + 4;
}
a /= 6;
}
return { h: a, s: s, l: c };
}
function l(t, e, n) {
return (
n < 0 && (n += 1),
n > 1 && (n -= 1),
n < 1 / 6
? t + 6 * n * (e - t)
: n < 0.5
? e
: n < 2 / 3
? t + (e - t) * (2 / 3 - n) * 6
: t
);
}
function f(t, e, n) {
(t = o(t, 255)), (e = o(e, 255)), (n = o(n, 255));
var r = Math.max(t, e, n),
i = Math.min(t, e, n),
a = 0,
s = r,
c = r - i,
u = 0 === r ? 0 : c / r;
if (r === i) a = 0;
else {
switch (r) {
case t:
a = (e - n) / c + (e < n ? 6 : 0);
break;
case e:
a = (n - t) / c + 2;
break;
case n:
a = (t - e) / c + 4;
}
a /= 6;
}
return { h: a, s: u, v: s };
}
function d(t, e, n, r) {
var i = [
u(Math.round(t).toString(16)),
u(Math.round(e).toString(16)),
u(Math.round(n).toString(16)),
];
return r &&
i[0].startsWith(i[0].charAt(1)) &&
i[1].startsWith(i[1].charAt(1)) &&
i[2].startsWith(i[2].charAt(1))
? i[0].charAt(0) + i[1].charAt(0) + i[2].charAt(0)
: i.join("");
}
function p(t) {
return Math.round(255 * parseFloat(t)).toString(16);
}
function g(t) {
return v(t) / 255;
}
function v(t) {
return parseInt(t, 16);
}
var y = {
aliceblue: "#f0f8ff",
antiquewhite: "#faebd7",
aqua: "#00ffff",
aquamarine: "#7fffd4",
azure: "#f0ffff",
beige: "#f5f5dc",
bisque: "#ffe4c4",
black: "#000000",
blanchedalmond: "#ffebcd",
blue: "#0000ff",
blueviolet: "#8a2be2",
brown: "#a52a2a",
burlywood: "#deb887",
cadetblue: "#5f9ea0",
chartreuse: "#7fff00",
chocolate: "#d2691e",
coral: "#ff7f50",
cornflowerblue: "#6495ed",
cornsilk: "#fff8dc",
crimson: "#dc143c",
cyan: "#00ffff",
darkblue: "#00008b",
darkcyan: "#008b8b",
darkgoldenrod: "#b8860b",
darkgray: "#a9a9a9",
darkgreen: "#006400",
darkgrey: "#a9a9a9",
darkkhaki: "#bdb76b",
darkmagenta: "#8b008b",
darkolivegreen: "#556b2f",
darkorange: "#ff8c00",
darkorchid: "#9932cc",
darkred: "#8b0000",
darksalmon: "#e9967a",
darkseagreen: "#8fbc8f",
darkslateblue: "#483d8b",
darkslategray: "#2f4f4f",
darkslategrey: "#2f4f4f",
darkturquoise: "#00ced1",
darkviolet: "#9400d3",
deeppink: "#ff1493",
deepskyblue: "#00bfff",
dimgray: "#696969",
dimgrey: "#696969",
dodgerblue: "#1e90ff",
firebrick: "#b22222",
floralwhite: "#fffaf0",
forestgreen: "#228b22",
fuchsia: "#ff00ff",
gainsboro: "#dcdcdc",
ghostwhite: "#f8f8ff",
goldenrod: "#daa520",
gold: "#ffd700",
gray: "#808080",
green: "#008000",
greenyellow: "#adff2f",
grey: "#808080",
honeydew: "#f0fff0",
hotpink: "#ff69b4",
indianred: "#cd5c5c",
indigo: "#4b0082",
ivory: "#fffff0",
khaki: "#f0e68c",
lavenderblush: "#fff0f5",
lavender: "#e6e6fa",
lawngreen: "#7cfc00",
lemonchiffon: "#fffacd",
lightblue: "#add8e6",
lightcoral: "#f08080",
lightcyan: "#e0ffff",
lightgoldenrodyellow: "#fafad2",
lightgray: "#d3d3d3",
lightgreen: "#90ee90",
lightgrey: "#d3d3d3",
lightpink: "#ffb6c1",
lightsalmon: "#ffa07a",
lightseagreen: "#20b2aa",
lightskyblue: "#87cefa",
lightslategray: "#778899",
lightslategrey: "#778899",
lightsteelblue: "#b0c4de",
lightyellow: "#ffffe0",
lime: "#00ff00",
limegreen: "#32cd32",
linen: "#faf0e6",
magenta: "#ff00ff",
maroon: "#800000",
mediumaquamarine: "#66cdaa",
mediumblue: "#0000cd",
mediumorchid: "#ba55d3",
mediumpurple: "#9370db",
mediumseagreen: "#3cb371",
mediumslateblue: "#7b68ee",
mediumspringgreen: "#00fa9a",
mediumturquoise: "#48d1cc",
mediumvioletred: "#c71585",
midnightblue: "#191970",
mintcream: "#f5fffa",
mistyrose: "#ffe4e1",
moccasin: "#ffe4b5",
navajowhite: "#ffdead",
navy: "#000080",
oldlace: "#fdf5e6",
olive: "#808000",
olivedrab: "#6b8e23",
orange: "#ffa500",
orangered: "#ff4500",
orchid: "#da70d6",
palegoldenrod: "#eee8aa",
palegreen: "#98fb98",
paleturquoise: "#afeeee",
palevioletred: "#db7093",
papayawhip: "#ffefd5",
peachpuff: "#ffdab9",
peru: "#cd853f",
pink: "#ffc0cb",
plum: "#dda0dd",
powderblue: "#b0e0e6",
purple: "#800080",
rebeccapurple: "#663399",
red: "#ff0000",
rosybrown: "#bc8f8f",
royalblue: "#4169e1",
saddlebrown: "#8b4513",
salmon: "#fa8072",
sandybrown: "#f4a460",
seagreen: "#2e8b57",
seashell: "#fff5ee",
sienna: "#a0522d",
silver: "#c0c0c0",
skyblue: "#87ceeb",
slateblue: "#6a5acd",
slategray: "#708090",
slategrey: "#708090",
snow: "#fffafa",
springgreen: "#00ff7f",
steelblue: "#4682b4",
tan: "#d2b48c",
teal: "#008080",
thistle: "#d8bfd8",
tomato: "#ff6347",
turquoise: "#40e0d0",
violet: "#ee82ee",
wheat: "#f5deb3",
white: "#ffffff",
whitesmoke: "#f5f5f5",
yellow: "#ffff00",
yellowgreen: "#9acd32",
};
function m(t) {
return (m =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function b(t) {
var e,
n,
r,
i = { r: 0, g: 0, b: 0 },
a = 1,
u = null,
h = null,
f = null,
d = !1,
p = !1;
return (
"string" == typeof t &&
(t = (function (t) {
if (0 === (t = t.trim().toLowerCase()).length) return !1;
var e = !1;
if (y[t]) (t = y[t]), (e = !0);
else if ("transparent" === t)
return { r: 0, g: 0, b: 0, a: 0, format: "name" };
var n = O.rgb.exec(t);
if (n) return { r: n[1], g: n[2], b: n[3] };
if ((n = O.rgba.exec(t)))
return { r: n[1], g: n[2], b: n[3], a: n[4] };
if ((n = O.hsl.exec(t))) return { h: n[1], s: n[2], l: n[3] };
if ((n = O.hsla.exec(t)))
return { h: n[1], s: n[2], l: n[3], a: n[4] };
if ((n = O.hsv.exec(t))) return { h: n[1], s: n[2], v: n[3] };
if ((n = O.hsva.exec(t)))
return { h: n[1], s: n[2], v: n[3], a: n[4] };
if ((n = O.hex8.exec(t)))
return {
r: v(n[1]),
g: v(n[2]),
b: v(n[3]),
a: g(n[4]),
format: e ? "name" : "hex8",
};
if ((n = O.hex6.exec(t)))
return {
r: v(n[1]),
g: v(n[2]),
b: v(n[3]),
format: e ? "name" : "hex",
};
if ((n = O.hex4.exec(t)))
return {
r: v(n[1] + n[1]),
g: v(n[2] + n[2]),
b: v(n[3] + n[3]),
a: g(n[4] + n[4]),
format: e ? "name" : "hex8",
};
if ((n = O.hex3.exec(t)))
return {
r: v(n[1] + n[1]),
g: v(n[2] + n[2]),
b: v(n[3] + n[3]),
format: e ? "name" : "hex",
};
return !1;
})(t)),
"object" === m(t) &&
(M(t.r) && M(t.g) && M(t.b)
? ((e = t.r),
(n = t.g),
(r = t.b),
(i = {
r: 255 * o(e, 255),
g: 255 * o(n, 255),
b: 255 * o(r, 255),
}),
(d = !0),
(p = "%" === String(t.r).substr(-1) ? "prgb" : "rgb"))
: M(t.h) && M(t.s) && M(t.v)
? ((u = c(t.s)),
(h = c(t.v)),
(i = (function (t, e, n) {
(t = 6 * o(t, 360)), (e = o(e, 100)), (n = o(n, 100));
var r = Math.floor(t),
i = t - r,
a = n * (1 - e),
s = n * (1 - i * e),
c = n * (1 - (1 - i) * e),
u = r % 6;
return {
r: 255 * [n, s, a, a, c, n][u],
g: 255 * [c, n, n, s, a, a][u],
b: 255 * [a, a, c, n, n, s][u],
};
})(t.h, u, h)),
(d = !0),
(p = "hsv"))
: M(t.h) &&
M(t.s) &&
M(t.l) &&
((u = c(t.s)),
(f = c(t.l)),
(i = (function (t, e, n) {
var r, i, a;
if (
((t = o(t, 360)), (e = o(e, 100)), (n = o(n, 100)), 0 === e)
)
(i = n), (a = n), (r = n);
else {
var s = n < 0.5 ? n * (1 + e) : n + e - n * e,
c = 2 * n - s;
(r = l(c, s, t + 1 / 3)),
(i = l(c, s, t)),
(a = l(c, s, t - 1 / 3));
}
return { r: 255 * r, g: 255 * i, b: 255 * a };
})(t.h, u, f)),
(d = !0),
(p = "hsl")),
Object.prototype.hasOwnProperty.call(t, "a") && (a = t.a)),
(a = s(a)),
{
ok: d,
format: t.format || p,
r: Math.min(255, Math.max(i.r, 0)),
g: Math.min(255, Math.max(i.g, 0)),
b: Math.min(255, Math.max(i.b, 0)),
a: a,
}
);
}
var x = "(?:"
.concat("[-\\+]?\\d*\\.\\d+%?", ")|(?:")
.concat("[-\\+]?\\d+%?", ")"),
w = "[\\s|\\(]+("
.concat(x, ")[,|\\s]+(")
.concat(x, ")[,|\\s]+(")
.concat(x, ")\\s*\\)?"),
S = "[\\s|\\(]+("
.concat(x, ")[,|\\s]+(")
.concat(x, ")[,|\\s]+(")
.concat(x, ")[,|\\s]+(")
.concat(x, ")\\s*\\)?"),
O = {
CSS_UNIT: new RegExp(x),
rgb: new RegExp("rgb" + w),
rgba: new RegExp("rgba" + S),
hsl: new RegExp("hsl" + w),
hsla: new RegExp("hsla" + S),
hsv: new RegExp("hsv" + w),
hsva: new RegExp("hsva" + S),
hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
};
function M(t) {
return Boolean(O.CSS_UNIT.exec(String(t)));
}
var k = (function () {
function t(e, n) {
var r;
if (
(void 0 === e && (e = ""), void 0 === n && (n = {}), e instanceof t)
)
return e;
"number" == typeof e &&
(e = (function (t) {
return { r: t >> 16, g: (65280 & t) >> 8, b: 255 & t };
})(e)),
(this.originalInput = e);
var i = b(e);
(this.originalInput = e),
(this.r = i.r),
(this.g = i.g),
(this.b = i.b),
(this.a = i.a),
(this.roundA = Math.round(100 * this.a) / 100),
(this.format =
null !== (r = n.format) && void 0 !== r ? r : i.format),
(this.gradientType = n.gradientType),
this.r < 1 && (this.r = Math.round(this.r)),
this.g < 1 && (this.g = Math.round(this.g)),
this.b < 1 && (this.b = Math.round(this.b)),
(this.isValid = i.ok);
}
return (
(t.prototype.isDark = function () {
return this.getBrightness() < 128;
}),
(t.prototype.isLight = function () {
return !this.isDark();
}),
(t.prototype.getBrightness = function () {
var t = this.toRgb();
return (299 * t.r + 587 * t.g + 114 * t.b) / 1e3;
}),
(t.prototype.getLuminance = function () {
var t = this.toRgb(),
e = t.r / 255,
n = t.g / 255,
r = t.b / 255;
return (
0.2126 *
(e <= 0.03928
? e / 12.92
: Math.pow((e + 0.055) / 1.055, 2.4)) +
0.7152 *
(n <= 0.03928
? n / 12.92
: Math.pow((n + 0.055) / 1.055, 2.4)) +
0.0722 *
(r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4))
);
}),
(t.prototype.getAlpha = function () {
return this.a;
}),
(t.prototype.setAlpha = function (t) {
return (
(this.a = s(t)),
(this.roundA = Math.round(100 * this.a) / 100),
this
);
}),
(t.prototype.toHsv = function () {
var t = f(this.r, this.g, this.b);
return { h: 360 * t.h, s: t.s, v: t.v, a: this.a };
}),
(t.prototype.toHsvString = function () {
var t = f(this.r, this.g, this.b),
e = Math.round(360 * t.h),
n = Math.round(100 * t.s),
r = Math.round(100 * t.v);
return 1 === this.a
? "hsv(".concat(e, ", ").concat(n, "%, ").concat(r, "%)")
: "hsva("
.concat(e, ", ")
.concat(n, "%, ")
.concat(r, "%, ")
.concat(this.roundA, ")");
}),
(t.prototype.toHsl = function () {
var t = h(this.r, this.g, this.b);
return { h: 360 * t.h, s: t.s, l: t.l, a: this.a };
}),
(t.prototype.toHslString = function () {
var t = h(this.r, this.g, this.b),
e = Math.round(360 * t.h),
n = Math.round(100 * t.s),
r = Math.round(100 * t.l);
return 1 === this.a
? "hsl(".concat(e, ", ").concat(n, "%, ").concat(r, "%)")
: "hsla("
.concat(e, ", ")
.concat(n, "%, ")
.concat(r, "%, ")
.concat(this.roundA, ")");
}),
(t.prototype.toHex = function (t) {
return void 0 === t && (t = !1), d(this.r, this.g, this.b, t);
}),
(t.prototype.toHexString = function (t) {
return void 0 === t && (t = !1), "#" + this.toHex(t);
}),
(t.prototype.toHex8 = function (t) {
return (
void 0 === t && (t = !1),
(function (t, e, n, r, i) {
var o = [
u(Math.round(t).toString(16)),
u(Math.round(e).toString(16)),
u(Math.round(n).toString(16)),
u(p(r)),
];
return i &&
o[0].startsWith(o[0].charAt(1)) &&
o[1].startsWith(o[1].charAt(1)) &&
o[2].startsWith(o[2].charAt(1)) &&
o[3].startsWith(o[3].charAt(1))
? o[0].charAt(0) +
o[1].charAt(0) +
o[2].charAt(0) +
o[3].charAt(0)
: o.join("");
})(this.r, this.g, this.b, this.a, t)
);
}),
(t.prototype.toHex8String = function (t) {
return void 0 === t && (t = !1), "#" + this.toHex8(t);
}),
(t.prototype.toRgb = function () {
return {
r: Math.round(this.r),
g: Math.round(this.g),
b: Math.round(this.b),
a: this.a,
};
}),
(t.prototype.toRgbString = function () {
var t = Math.round(this.r),
e = Math.round(this.g),
n = Math.round(this.b);
return 1 === this.a
? "rgb(".concat(t, ", ").concat(e, ", ").concat(n, ")")
: "rgba("
.concat(t, ", ")
.concat(e, ", ")
.concat(n, ", ")
.concat(this.roundA, ")");
}),
(t.prototype.toPercentageRgb = function () {
var t = function (t) {
return "".concat(Math.round(100 * o(t, 255)), "%");
};
return { r: t(this.r), g: t(this.g), b: t(this.b), a: this.a };
}),
(t.prototype.toPercentageRgbString = function () {
var t = function (t) {
return Math.round(100 * o(t, 255));
};
return 1 === this.a
? "rgb("
.concat(t(this.r), "%, ")
.concat(t(this.g), "%, ")
.concat(t(this.b), "%)")
: "rgba("
.concat(t(this.r), "%, ")
.concat(t(this.g), "%, ")
.concat(t(this.b), "%, ")
.concat(this.roundA, ")");
}),
(t.prototype.toName = function () {
if (0 === this.a) return "transparent";
if (this.a < 1) return !1;
for (
var t = "#" + d(this.r, this.g, this.b, !1),
e = 0,
n = Object.entries(y);
e < n.length;
e++
) {
var r = n[e],
i = r[0];
if (t === r[1]) return i;
}
return !1;
}),
(t.prototype.toString = function (t) {
var e = Boolean(t);
t = null != t ? t : this.format;
var n = !1,
r = this.a < 1 && this.a >= 0;
return e || !r || (!t.startsWith("hex") && "name" !== t)
? ("rgb" === t && (n = this.toRgbString()),
"prgb" === t && (n = this.toPercentageRgbString()),
("hex" !== t && "hex6" !== t) || (n = this.toHexString()),
"hex3" === t && (n = this.toHexString(!0)),
"hex4" === t && (n = this.toHex8String(!0)),
"hex8" === t && (n = this.toHex8String()),
"name" === t && (n = this.toName()),
"hsl" === t && (n = this.toHslString()),
"hsv" === t && (n = this.toHsvString()),
n || this.toHexString())
: "name" === t && 0 === this.a
? this.toName()
: this.toRgbString();
}),
(t.prototype.toNumber = function () {
return (
(Math.round(this.r) << 16) +
(Math.round(this.g) << 8) +
Math.round(this.b)
);
}),
(t.prototype.clone = function () {
return new t(this.toString());
}),
(t.prototype.lighten = function (e) {
void 0 === e && (e = 10);
var n = this.toHsl();
return (n.l += e / 100), (n.l = a(n.l)), new t(n);
}),
(t.prototype.brighten = function (e) {
void 0 === e && (e = 10);
var n = this.toRgb();
return (
(n.r = Math.max(
0,
Math.min(255, n.r - Math.round((-e / 100) * 255)),
)),
(n.g = Math.max(
0,
Math.min(255, n.g - Math.round((-e / 100) * 255)),
)),
(n.b = Math.max(
0,
Math.min(255, n.b - Math.round((-e / 100) * 255)),
)),
new t(n)
);
}),
(t.prototype.darken = function (e) {
void 0 === e && (e = 10);
var n = this.toHsl();
return (n.l -= e / 100), (n.l = a(n.l)), new t(n);
}),
(t.prototype.tint = function (t) {
return void 0 === t && (t = 10), this.mix("white", t);
}),
(t.prototype.shade = function (t) {
return void 0 === t && (t = 10), this.mix("black", t);
}),
(t.prototype.desaturate = function (e) {
void 0 === e && (e = 10);
var n = this.toHsl();
return (n.s -= e / 100), (n.s = a(n.s)), new t(n);
}),
(t.prototype.saturate = function (e) {
void 0 === e && (e = 10);
var n = this.toHsl();
return (n.s += e / 100), (n.s = a(n.s)), new t(n);
}),
(t.prototype.greyscale = function () {
return this.desaturate(100);
}),
(t.prototype.spin = function (e) {
var n = this.toHsl(),
r = (n.h + e) % 360;
return (n.h = r < 0 ? 360 + r : r), new t(n);
}),
(t.prototype.mix = function (e, n) {
void 0 === n && (n = 50);
var r = this.toRgb(),
i = new t(e).toRgb(),
o = n / 100;
return new t({
r: (i.r - r.r) * o + r.r,
g: (i.g - r.g) * o + r.g,
b: (i.b - r.b) * o + r.b,
a: (i.a - r.a) * o + r.a,
});
}),
(t.prototype.analogous = function (e, n) {
void 0 === e && (e = 6), void 0 === n && (n = 30);
var r = this.toHsl(),
i = 360 / n,
o = [this];
for (r.h = (r.h - ((i * e) >> 1) + 720) % 360; --e; )
(r.h = (r.h + i) % 360), o.push(new t(r));
return o;
}),
(t.prototype.complement = function () {
var e = this.toHsl();
return (e.h = (e.h + 180) % 360), new t(e);
}),
(t.prototype.monochromatic = function (e) {
void 0 === e && (e = 6);
for (
var n = this.toHsv(),
r = n.h,
i = n.s,
o = n.v,
a = [],
s = 1 / e;
e--;
)
a.push(new t({ h: r, s: i, v: o })), (o = (o + s) % 1);
return a;
}),
(t.prototype.splitcomplement = function () {
var e = this.toHsl(),
n = e.h;
return [
this,
new t({ h: (n + 72) % 360, s: e.s, l: e.l }),
new t({ h: (n + 216) % 360, s: e.s, l: e.l }),
];
}),
(t.prototype.onBackground = function (e) {
var n = this.toRgb(),
r = new t(e).toRgb();
return new t({
r: r.r + (n.r - r.r) * n.a,
g: r.g + (n.g - r.g) * n.a,
b: r.b + (n.b - r.b) * n.a,
});
}),
(t.prototype.triad = function () {
return this.polyad(3);
}),
(t.prototype.tetrad = function () {
return this.polyad(4);
}),
(t.prototype.polyad = function (e) {
for (
var n = this.toHsl(), r = n.h, i = [this], o = 360 / e, a = 1;
a < e;
a++
)
i.push(new t({ h: (r + a * o) % 360, s: n.s, l: n.l }));
return i;
}),
(t.prototype.equals = function (e) {
return this.toRgbString() === new t(e).toRgbString();
}),
t
);
})();
var C = [
{ index: 7, opacity: 0.15 },
{ index: 6, opacity: 0.25 },
{ index: 5, opacity: 0.3 },
{ index: 5, opacity: 0.45 },
{ index: 5, opacity: 0.65 },
{ index: 5, opacity: 0.85 },
{ index: 4, opacity: 0.9 },
{ index: 3, opacity: 0.95 },
{ index: 2, opacity: 0.97 },
{ index: 1, opacity: 0.98 },
];
function E(t, e, n) {
var r;
return (
(r =
Math.round(t.h) >= 60 && Math.round(t.h) <= 240
? n
? Math.round(t.h) - 2 * e
: Math.round(t.h) + 2 * e
: n
? Math.round(t.h) + 2 * e
: Math.round(t.h) - 2 * e) < 0
? (r += 360)
: r >= 360 && (r -= 360),
r
);
}
function j(t, e, n) {
return 0 === t.h && 0 === t.s
? t.s
: ((r = n ? t.s - 0.16 * e : 4 === e ? t.s + 0.16 : t.s + 0.05 * e) >
1 && (r = 1),
n && 5 === e && r > 0.1 && (r = 0.1),
r < 0.06 && (r = 0.06),
Number(r.toFixed(2)));
var r;
}
function P(t, e, n) {
var r;
return (
(r = n ? t.v + 0.05 * e : t.v - 0.15 * e) > 1 && (r = 1),
Number(r.toFixed(2))
);
}
function A(t) {
for (
var e =
arguments.length > 1 && void 0 !== arguments[1]
? arguments[1]
: {},
n = [],
r = new k(t),
i = 5;
i > 0;
i -= 1
) {
var o = r.toHsv(),
a = new k({
h: E(o, i, !0),
s: j(o, i, !0),
v: P(o, i, !0),
}).toHexString();
n.push(a);
}
n.push(r.toHexString());
for (var s = 1; s <= 4; s += 1) {
var c = r.toHsv(),
u = new k({ h: E(c, s), s: j(c, s), v: P(c, s) }).toHexString();
n.push(u);
}
return "dark" === e.theme
? C.map(function (t) {
var r = t.index,
i = t.opacity;
return new k(e.backgroundColor || "#141414")
.mix(n[r], 100 * i)
.toHexString();
})
: n;
}
var I = {
red: "#F5222D",
volcano: "#FA541C",
orange: "#FA8C16",
gold: "#FAAD14",
yellow: "#FADB14",
lime: "#A0D911",
green: "#52C41A",
cyan: "#13C2C2",
blue: "#1890FF",
geekblue: "#2F54EB",
purple: "#722ED1",
magenta: "#EB2F96",
grey: "#666666",
},
T = {},
N = {};
Object.keys(I).forEach(function (t) {
(T[t] = A(I[t])),
(T[t].primary = T[t][5]),
(N[t] = A(I[t], { theme: "dark", backgroundColor: "#141414" })),
(N[t].primary = N[t][5]);
});
T.red,
T.volcano,
T.gold,
T.orange,
T.yellow,
T.lime,
T.green,
T.cyan,
T.blue,
T.geekblue,
T.purple,
T.magenta,
T.grey;
var B = function (t, e, n) {
var r = i()(t),
o = i()(e);
return i()([
(1 - n) * r.red() + n * o.red(),
(1 - n) * r.green() + n * o.green(),
(1 - n) * r.blue() + n * o.blue(),
]).rgb();
},
L = function (t, e, n, r) {
return (
void 0 === e && (e = "#fff"),
void 0 === n && (n = "default"),
void 0 === r && (r = "rgb(150, 150, 150)"),
"default" === n
? (function (t, e, n) {
void 0 === e && (e = "#fff"),
void 0 === n && (n = "rgb(150, 150, 150)");
var r = B(e, t, 0.05).rgb().toString(),
o = B(e, t, 0.1).rgb().toString(),
a = B(e, t, 0.2).rgb().toString(),
s = B(e, t, 0.4).rgb().toString(),
c = B(e, n, 0.02).rgb().toString(),
u = B(e, n, 0.05).rgb().toString(),
h = B(e, n, 0.1).rgb().toString(),
l = B(e, n, 0.2).rgb().toString(),
f = B(e, n, 0.3).rgb().toString(),
d = A(t, { theme: "default", backgroundColor: e }),
p = i()(t).hex().toLowerCase(),
g = d.indexOf(p),
v = t;
return (
-1 !== g && (v = d[g + 1]),
{
mainStroke: t,
mainFill: o,
activeStroke: t,
activeFill: r,
inactiveStroke: s,
inactiveFill: r,
selectedStroke: t,
selectedFill: e,
highlightStroke: v,
highlightFill: a,
disableStroke: f,
disableFill: u,
edgeMainStroke: f,
edgeActiveStroke: t,
edgeInactiveStroke: l,
edgeSelectedStroke: t,
edgeHighlightStroke: t,
edgeDisableStroke: h,
comboMainStroke: f,
comboMainFill: c,
comboActiveStroke: t,
comboActiveFill: r,
comboInactiveStroke: f,
comboInactiveFill: c,
comboSelectedStroke: t,
comboSelectedFill: c,
comboHighlightStroke: v,
comboHighlightFill: c,
comboDisableStroke: l,
comboDisableFill: u,
}
);
})(t, e, "rgb(150, 150, 150)")
: (function (t, e, n) {
void 0 === e && (e = "#fff"), void 0 === n && (n = "#777");
var r = B(e, t, 0.2).rgb().toString(),
o = B(e, t, 0.3).rgb().toString(),
a = B(e, t, 0.6).rgb().toString(),
s = B(e, t, 0.8).rgb().toString(),
c = B(e, n, 0.2).rgb().toString(),
u = B(e, n, 0.25).rgb().toString(),
h = B(e, n, 0.3).rgb().toString(),
l = B(e, n, 0.4).rgb().toString(),
f = B(e, n, 0.5).rgb().toString(),
d = A(t, { theme: "dark", backgroundColor: e }),
p = i()(t).hex().toLowerCase(),
g = d.indexOf(p),
v = t;
return (
-1 !== g && (v = d[g + 1]),
{
mainStroke: s,
mainFill: r,
activeStroke: t,
activeFill: o,
inactiveStroke: s,
inactiveFill: r,
selectedStroke: t,
selectedFill: r,
highlightStroke: t,
highlightFill: a,
disableStroke: f,
disableFill: u,
edgeMainStroke: n,
edgeActiveStroke: t,
edgeInactiveStroke: n,
edgeSelectedStroke: t,
edgeHighlightStroke: t,
edgeDisableStroke: h,
comboMainStroke: l,
comboMainFill: u,
comboActiveStroke: t,
comboActiveFill: c,
comboInactiveStroke: l,
comboInactiveFill: u,
comboSelectedStroke: t,
comboSelectedFill: c,
comboHighlightStroke: v,
comboHighlightFill: u,
comboDisableStroke: l,
comboDisableFill: c,
}
);
})(t, e, "#777")
);
},
D = function (t, e, n, r) {
void 0 === e && (e = "#fff"),
void 0 === n && (n = "default"),
void 0 === r && (r = "rgb(150, 150, 150)");
var i = [];
return (
t.forEach(function (t) {
i.push(L(t, e, n, r));
}),
i
);
};
},
76: function (t, e, n) {
"use strict";
function r(t) {
return (r =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function i(t) {
return (i =
"function" == typeof Symbol && "symbol" == r(Symbol.iterator)
? function (t) {
return r(t);
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: r(t);
})(t);
}
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.clearAnimationFrame = function (t) {
return o.clearAnimationFrame
? o.clearAnimationFrame(t)
: ("object" ===
("undefined" == typeof window ? "undefined" : i(window)) &&
window.cancelAnimationFrame
? window.cancelAnimationFrame
: clearTimeout)(t);
}),
(e.requestAnimationFrame = function (t) {
return o.requestAnimationFrame
? o.requestAnimationFrame(t)
: ("object" ===
("undefined" == typeof window ? "undefined" : i(window)) &&
window.requestAnimationFrame
? window.requestAnimationFrame
: function (t) {
return setTimeout(t, 16);
})(t);
}),
(e.setExtraFunction = function (t) {
void 0 === t && (t = {}), (t = t);
});
var o = {};
},
77: function (t, e) {
function n(t) {
return (n =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var r;
r = (function () {
return this;
})();
try {
r = r || new Function("return this")();
} catch (t) {
"object" === ("undefined" == typeof window ? "undefined" : n(window)) &&
(r = window);
}
t.exports = r;
},
78: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.Layouts = e.Layout = void 0);
var r = n(51),
i = (function () {
function t(t) {
var e = r.getLayoutByName(t.type);
this.layoutInstance = new e(t);
}
return (
(t.prototype.layout = function (t) {
return this.layoutInstance.layout(t);
}),
(t.prototype.updateCfg = function (t) {
this.layoutInstance.updateCfg(t);
}),
(t.prototype.init = function (t) {
this.layoutInstance.init(t);
}),
(t.prototype.execute = function () {
this.layoutInstance.execute();
}),
(t.prototype.getDefaultCfg = function () {
return this.layoutInstance.getDefaultCfg();
}),
(t.prototype.destroy = function () {
return this.layoutInstance.destroy();
}),
t
);
})();
(e.Layout = i),
(e.Layouts = new Proxy(
{},
{
get: function (t, e) {
return r.getLayoutByName(e);
},
set: function (t, e, n) {
return r.registerLayout(e, n), !0;
},
},
));
},
97: function (t, e, n) {
"use strict";
var r = n(1),
i = n(2),
o = (n(6), n(27)),
a = n(74),
s = n(26),
c = n(18),
u = n(32),
h =
(n(395),
n(396),
n(101),
n(102),
{
version: c.a.version,
Graph: a.a,
Util: u.a,
Layout: s.a,
Layouts: s.b,
registerLayout: s.c,
unRegisterLayout: s.d,
Global: c.a,
registerBehavior: i.i,
registerCombo: i.j,
registerEdge: i.k,
registerNode: i.l,
Algorithm: o,
Arrow: i.d,
Marker: i.f,
Shape: i.g,
});
var l,
f =
((l = a.b),
function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
return l.apply(null, Object(r.g)(t, [h]));
});
(h.registerGraph = f), (e.default = h);
},
98: function (t, e, n) {
"use strict";
Object.defineProperty(e, "__esModule", { value: !0 }),
(e.assembleFont =
e.getTextWidth =
e.getLineSpaceing =
e.getTextHeight =
void 0);
var r = n(179),
i = n(180);
function o(t, e) {
return e ? e - t : 0.14 * t;
}
(e.getTextHeight = function (t, e, n) {
var i = 1;
return (
(0, r.isString)(t) && (i = t.split("\n").length),
i > 1 ? e * i + o(e, n) * (i - 1) : e
);
}),
(e.getLineSpaceing = o),
(e.getTextWidth = function (t, e) {
var n = (0, i.getOffScreenContext)(),
o = 0;
if ((0, r.isNil)(t) || "" === t) return o;
if (
(n.save(), (n.font = e), (0, r.isString)(t) && t.includes("\n"))
) {
var a = t.split("\n");
(0, r.each)(a, function (t) {
var e = n.measureText(t).width;
o < e && (o = e);
});
} else o = n.measureText(t).width;
return n.restore(), o;
}),
(e.assembleFont = function (t) {
var e = t.fontSize,
n = t.fontFamily,
r = t.fontWeight;
return [t.fontStyle, t.fontVariant, r, e + "px", n].join(" ").trim();
});
},
}).default;
});
//# sourceMappingURL=index.js.map
================================================
FILE: packages/examples-uniapp/index.html
================================================
================================================
FILE: packages/examples-uniapp/main.js
================================================
import App from "./App";
// #ifndef VUE3
import Vue from "vue";
Vue.config.productionTip = false;
App.mpType = "app";
const app = new Vue({
...App,
});
app.$mount();
// #endif
// #ifdef VUE3
import { createSSRApp } from "vue";
export function createApp() {
const app = createSSRApp(App);
return {
app,
};
}
// #endif
================================================
FILE: packages/examples-uniapp/manifest.json
================================================
{
"name": "test",
"appid": "",
"description": "",
"versionName": "1.0.0",
"versionCode": "100",
"transformPx": false,
/* 5+App特有相关 */
"app-plus": {
"usingComponents": true,
"nvueStyleCompiler": "uni-app",
"compilerVersion": 3,
"splashscreen": {
"alwaysShowBeforeRender": true,
"waiting": true,
"autoclose": true,
"delay": 0
},
/* 模块配置 */
"modules": {},
/* 应用发布信息 */
"distribute": {
/* android打包配置 */
"android": {
"permissions": [
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
"",
""
]
},
/* ios打包配置 */
"ios": {},
/* SDK配置 */
"sdkConfigs": {}
}
},
/* 快应用特有相关 */
"quickapp": {},
/* 小程序特有相关 */
"mp-weixin": {
"appid": "",
"setting": {
"urlCheck": false
},
"usingComponents": true
},
"mp-alipay": {
"usingComponents": true
},
"mp-baidu": {
"usingComponents": true
},
"mp-toutiao": {
"usingComponents": true
},
"uniStatistics": {
"enable": false
},
"vueVersion": "2"
}
================================================
FILE: packages/examples-uniapp/pages/index/index.vue
================================================
{{ title }}
================================================
FILE: packages/examples-uniapp/pages.json
================================================
{
"pages": [
//pages数组中第一项表示应用启动页，参考：https://uniapp.dcloud.io/collocation/pages
{
"path": "pages/index/index",
"style": {
"navigationBarTitleText": "uni-app"
}
}
],
"globalStyle": {
"navigationBarTextStyle": "black",
"navigationBarTitleText": "uni-app",
"navigationBarBackgroundColor": "#F8F8F8",
"backgroundColor": "#F8F8F8"
}
}
================================================
FILE: packages/examples-uniapp/uni.scss
================================================
/**
* 这里是uni-app内置的常用样式变量
*
* uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量
* 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App
*
*/
/**
* 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能
*
* 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件
*/
/* 颜色变量 */
/* 行为相关颜色 */
$uni-color-primary: #007aff;
$uni-color-success: #4cd964;
$uni-color-warning: #f0ad4e;
$uni-color-error: #dd524d;
/* 文字基本颜色 */
$uni-text-color: #333; //基本色
$uni-text-color-inverse: #fff; //反色
$uni-text-color-grey: #999; //辅助灰色，如加载更多的提示信息
$uni-text-color-placeholder: #808080;
$uni-text-color-disable: #c0c0c0;
/* 背景颜色 */
$uni-bg-color: #ffffff;
$uni-bg-color-grey: #f8f8f8;
$uni-bg-color-hover: #f1f1f1; //点击状态颜色
$uni-bg-color-mask: rgba(0, 0, 0, 0.4); //遮罩颜色
/* 边框颜色 */
$uni-border-color: #c8c7cc;
/* 尺寸变量 */
/* 文字尺寸 */
$uni-font-size-sm: 12px;
$uni-font-size-base: 14px;
$uni-font-size-lg: 16;
/* 图片尺寸 */
$uni-img-size-sm: 20px;
$uni-img-size-base: 26px;
$uni-img-size-lg: 40px;
/* Border Radius */
$uni-border-radius-sm: 2px;
$uni-border-radius-base: 3px;
$uni-border-radius-lg: 6px;
$uni-border-radius-circle: 50%;
/* 水平间距 */
$uni-spacing-row-sm: 5px;
$uni-spacing-row-base: 10px;
$uni-spacing-row-lg: 15px;
/* 垂直间距 */
$uni-spacing-col-sm: 4px;
$uni-spacing-col-base: 8px;
$uni-spacing-col-lg: 12px;
/* 透明度 */
$uni-opacity-disabled: 0.3; // 组件禁用态的透明度
/* 文章场景相关 */
$uni-color-title: #2c405a; // 文章标题颜色
$uni-font-size-title: 20px;
$uni-color-subtitle: #555555; // 二级标题颜色
$uni-font-size-subtitle: 26px;
$uni-color-paragraph: #3f536e; // 文章段落颜色
$uni-font-size-paragraph: 15px;
================================================
FILE: packages/examples-wx/app.js
================================================
App({});
================================================
FILE: packages/examples-wx/app.json
================================================
{
"pages": ["pages/index/index"],
"subpackages": [
{
"root": "package-animation",
"pages": [
"pages/animation/change-position-default/index",
"pages/animation/custom-animate-position/index",
"pages/animation/edge-edge/index",
"pages/animation/edge-line-growth/index",
"pages/animation/node-node/index",
"pages/animation/point-in-line/index",
"pages/animation/state-change-hover/index"
]
},
{
"root": "package-elements",
"name": "package-elements",
"pages": [
"pages/elements/diamond/index",
"pages/elements/cubic2/index",
"pages/elements/point-chart/index",
"pages/elements/card/index",
"pages/elements/bar-chart/index",
"pages/elements/rect/index",
"pages/elements/donut/index",
"pages/elements/edge-mul-label/index",
"pages/elements/mode-rect/index",
"pages/elements/polyline3/index",
"pages/elements/c-circle/index",
"pages/elements/triangle/index",
"pages/elements/polyline2/index",
"pages/elements/label-len/index",
"pages/elements/pie-chart/index",
"pages/elements/image/index",
"pages/elements/cubic1/index",
"pages/elements/star/index",
"pages/elements/card-node/index",
"pages/elements/multi-edges/index",
"pages/elements/extra-shape/index",
"pages/elements/label-len1/index",
"pages/elements/line-chart/index",
"pages/elements/edge-bg/index",
"pages/elements/stack-chart/index",
"pages/elements/rect-with-combo/index",
"pages/elements/custom-polyline/index",
"pages/elements/list/index",
"pages/elements/c-rect/index",
"pages/elements/circle-with-combo/index",
"pages/elements/circle/index",
"pages/elements/custom-arrows/index",
"pages/elements/ellipse/index",
"pages/elements/area-chart/index",
"pages/elements/custom-polyline2/index",
"pages/elements/arc/index",
"pages/elements/built-in-arrows/index",
"pages/elements/node-bg/index",
"pages/elements/loop/index",
"pages/elements/polyline1/index"
]
},
{
"root": "package-general-graph",
"name": "package-general-graph",
"pages": [
"pages/general-graph/degree-circular/index",
"pages/general-graph/force-bubbles/index",
"pages/general-graph/layout-timing/index",
"pages/general-graph/subgraph-layout/index",
"pages/general-graph/circular-configuration-translate/index",
"pages/general-graph/basic-arc-diagram/index",
"pages/general-graph/division-circular/index",
"pages/general-graph/data-change/index",
"pages/general-graph/basic-grid/index",
"pages/general-graph/fruchterman/index",
"pages/general-graph/dagre-configuration-translate/index",
"pages/general-graph/basic-force-directed/index",
"pages/general-graph/sublayout-pipes/index",
"pages/general-graph/sort-radial/index",
"pages/general-graph/basic-concentric/index",
"pages/general-graph/prevent-overlap-unstrict-radial/index",
"pages/general-graph/dagre-UL/index",
"pages/general-graph/force-directed-force-clustering/index",
"pages/general-graph/basic-radial/index",
"pages/general-graph/basic-MDS/index",
"pages/general-graph/force-directed-functional-params/index",
"pages/general-graph/fruchterman-clustering/index",
"pages/general-graph/force-directed-configuration-translate/index",
"pages/general-graph/force-constrained-in-rect/index",
"pages/general-graph/fruchterman-configuration-translate/index",
"pages/general-graph/basic-FA2/index",
"pages/general-graph/interact-radial/index",
"pages/general-graph/cluster-grid/index",
"pages/general-graph/basic-circular/index",
"pages/general-graph/basic-dagre/index",
"pages/general-graph/spiral-circular/index",
"pages/general-graph/custom-bi-graph/index",
"pages/general-graph/dagre/index",
"pages/general-graph/dagre-combo/index",
"pages/general-graph/prevent-overlap-radial/index",
"pages/general-graph/radial-configuration-translate/index",
"pages/general-graph/layoutTranslate/index",
"pages/general-graph/basic-combo-force/index",
"pages/general-graph/force-directed-prevent-overlap/index",
"pages/general-graph/basic-force-directed-drag-fix/index",
"pages/general-graph/circular-arc-diagram/index"
]
},
{
"root": "package-interactive",
"name": "package-interactive",
"pages": [
"pages/interactive/move/index",
"pages/interactive/hide-item/index",
"pages/interactive/activate-relations/index",
"pages/interactive/hull/index",
"pages/interactive/combo-rect/index",
"pages/interactive/fix-item/index",
"pages/interactive/canvas-two-fingers/index",
"pages/interactive/add-child/index",
"pages/interactive/combo-circle/index",
"pages/interactive/change-data/index",
"pages/interactive/move-animate/index",
"pages/interactive/drag-subtree/index",
"pages/interactive/collapse-slibing/index",
"pages/interactive/set-mode/index",
"pages/interactive/partial-node/index",
"pages/interactive/change-members/index",
"pages/interactive/highlight-dark/index"
]
},
{
"root": "package-scene-case",
"name": "package-scene-case",
"pages": [
"pages/scene-case/sankey/index",
"pages/scene-case/knowledge-tree-graph/index",
"pages/scene-case/metro-lines/index",
"pages/scene-case/decision-tree/index",
"pages/scene-case/custom-flow/index",
"pages/scene-case/donut-transfer/index",
"pages/scene-case/mind-map/index"
]
},
{
"root": "package-tree-graph",
"name": "package-tree-graph",
"pages": [
"pages/tree-graph/compact-box/index",
"pages/tree-graph/custom-side-mind-map/index",
"pages/tree-graph/compact-box-left-align/index",
"pages/tree-graph/basic-dendrogram/index",
"pages/tree-graph/left-mind-map/index",
"pages/tree-graph/file-system/index",
"pages/tree-graph/custom-tree/index",
"pages/tree-graph/radial-dendrogram/index",
"pages/tree-graph/custom-edge-tree/index",
"pages/tree-graph/tb-dendrogram/index",
"pages/tree-graph/intend-align-top/index",
"pages/tree-graph/tb-compact-box/index",
"pages/tree-graph/radial-compact-box/index",
"pages/tree-graph/mind-map/index",
"pages/tree-graph/tree-edge-label/index",
"pages/tree-graph/h-intended/index",
"pages/tree-graph/right-mind-map/index"
]
},
{
"root": "package-plugin",
"name": "package-plugin",
"pages": [
"pages/plugin/edge-filter/index",
"pages/plugin/fish-eye/index",
"pages/plugin/legend/index",
"pages/plugin/time-bar/index",
"pages/plugin/tool-tip/index",
"pages/plugin/zoom-slider/index",
"pages/plugin/bundling/index",
"pages/plugin/menu/index",
"pages/plugin/snap-line/index",
"pages/plugin/mini-map/index"
]
}
],
"window": {
"backgroundTextStyle": "light",
"navigationBarBackgroundColor": "#fff",
"navigationBarTitleText": "Weixin",
"navigationBarTextStyle": "black"
},
"style": "v2",
"sitemapLocation": "sitemap.json"
}
================================================
FILE: packages/examples-wx/app.wxss
================================================
/**app.wxss**/
.container {
height: 100%;
display: flex;
flex-direction: column;
align-items: center;
justify-content: space-between;
padding: 200rpx 0;
box-sizing: border-box;
}
================================================
FILE: packages/examples-wx/components/wx.js
================================================
Component({
data: {},
properties: {
style: {
type: String,
value: "",
},
width: {
type: Number,
value: 100,
},
height: {
type: Number,
value: 100,
},
onInit: {
type: Function,
value: function value() {},
},
onTouchEvent: {
type: Function,
value: function value() {},
},
onError: {
type: Function,
value: function value() {},
},
pixelRatio: {
type: Number,
value: 1,
},
},
ready: function ready() {
const _this = this;
const query = wx.createSelectorQuery().in(this);
query
.select("#g6-canvas")
.fields({
node: true,
size: true,
})
.exec((ret) => {
const canvas = ret[0].node;
canvas.width = _this.data.width * _this.data.pixelRatio;
canvas.height = _this.data.height * _this.data.pixelRatio;
_this.rect = {
width: _this.data.width * _this.data.pixelRatio,
height: _this.data.height * _this.data.pixelRatio,
left: canvas._left,
top: canvas._top,
};
_this.ctx = canvas.getContext("2d");
_this.triggerEvent("onInit", {
ctx: _this.ctx,
rect: _this.rect,
canvas,
renderer: "mini-native",
});
// _this.data.onInit(_this.ctx, _this.rect, canvas, 'mini-native');
});
},
methods: {
error: function error(e) {
this.data.onError(e);
},
ontouch: function ontouch(e) {
let i = 0;
for (i = 0; i < e.touches.length; i++) {
modifyEvent(e.touches[i], this.data.pixelRatio);
}
for (i = 0; i < e.changedTouches.length; i++) {
modifyEvent(e.changedTouches[i], this.data.pixelRatio);
}
this.triggerEvent("onTouchEvent", e);
},
},
});
function modifyEvent(touchEvent = {}, pixelRatio) {
touchEvent.clientX = touchEvent.x * pixelRatio;
touchEvent.clientY = touchEvent.y * pixelRatio;
touchEvent.pageX = touchEvent.x * pixelRatio;
touchEvent.pageY = touchEvent.y * pixelRatio;
}
================================================
FILE: packages/examples-wx/components/wx.json
================================================
{
"component": true,
"usingComponents": {}
}
================================================
FILE: packages/examples-wx/components/wx.wxml
================================================
================================================
FILE: packages/examples-wx/components/wx.wxss
================================================
/* components/wx.wxss */
================================================
FILE: packages/examples-wx/miniprogram_npm/@antv/f6-plugin/f6Plugin.js
================================================
!(function (t, e) {
"object" == typeof exports && "object" == typeof module
? (module.exports = e())
: "function" == typeof define && define.amd
? define([], e)
: "object" == typeof exports
? (exports.f6ui = e())
: (t.f6ui = e());
})(this, function () {
return (function (t) {
var e = {};
function n(r) {
if (e[r]) return e[r].exports;
var i = (e[r] = { i: r, l: !1, exports: {} });
return t[r].call(i.exports, i, i.exports, n), (i.l = !0), i.exports;
}
return (
(n.m = t),
(n.c = e),
(n.d = function (t, e, r) {
n.o(t, e) || Object.defineProperty(t, e, { enumerable: !0, get: r });
}),
(n.r = function (t) {
"undefined" != typeof Symbol &&
Symbol.toStringTag &&
Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }),
Object.defineProperty(t, "__esModule", { value: !0 });
}),
(n.t = function (t, e) {
if ((1 & e && (t = n(t)), 8 & e)) return t;
if (4 & e && "object" == typeof t && t && t.__esModule) return t;
var r = Object.create(null);
if (
(n.r(r),
Object.defineProperty(r, "default", { enumerable: !0, value: t }),
2 & e && "string" != typeof t)
)
for (var i in t)
n.d(
r,
i,
function (e) {
return t[e];
}.bind(null, i),
);
return r;
}),
(n.n = function (t) {
var e =
t && t.__esModule
? function () {
return t.default;
}
: function () {
return t;
};
return n.d(e, "a", e), e;
}),
(n.o = function (t, e) {
return Object.prototype.hasOwnProperty.call(t, e);
}),
(n.p = ""),
n((n.s = 33))
);
})([
function (t, e, n) {
"use strict";
n.d(e, "i", function () {
return m;
}),
n.d(e, "k", function () {
return w;
}),
n.d(e, "y", function () {
return O;
}),
n.d(e, "f", function () {
return i;
}),
n.d(e, "j", function () {
return S;
}),
n.d(e, "K", function () {
return C;
}),
n.d(e, "g", function () {
return j;
}),
n.d(e, "u", function () {
return E;
}),
n.d(e, "A", function () {
return y;
}),
n.d(e, "B", function () {
return v;
}),
n.d(e, "D", function () {
return N;
}),
n.d(e, "H", function () {
return P;
}),
n.d(e, "J", function () {
return B;
}),
n.d(e, "m", function () {
return c;
}),
n.d(e, "n", function () {
return D;
}),
n.d(e, "o", function () {
return _;
}),
n.d(e, "r", function () {
return s;
}),
n.d(e, "s", function () {
return u;
}),
n.d(e, "t", function () {
return k;
}),
n.d(e, "v", function () {
return l;
}),
n.d(e, "w", function () {
return g;
}),
n.d(e, "x", function () {
return x;
}),
n.d(e, "b", function () {
return W;
}),
n.d(e, "c", function () {
return G;
}),
n.d(e, "d", function () {
return H;
}),
n.d(e, "e", function () {
return d;
}),
n.d(e, "l", function () {
return V;
}),
n.d(e, "p", function () {
return Z;
}),
n.d(e, "q", function () {
return K;
}),
n.d(e, "z", function () {
return Q;
}),
n.d(e, "C", function () {
return z;
}),
n.d(e, "a", function () {
return z;
}),
n.d(e, "h", function () {
return $;
}),
n.d(e, "G", function () {
return J;
}),
n.d(e, "I", function () {
return et;
}),
n.d(e, "E", function () {
return nt;
}),
n.d(e, "F", function () {
return rt;
});
var r = function (t) {
return null !== t && "function" != typeof t && isFinite(t.length);
},
i = function (t, e) {
if (!r(t)) return t;
for (var n = [], i = 0; i < t.length; i++) {
var o = t[i];
e(o, i) && n.push(o);
}
return n;
},
o = {}.toString,
a = function (t, e) {
return o.call(t) === "[object " + e + "]";
},
s = function (t) {
return a(t, "Function");
},
u = function (t) {
return null == t;
},
c = function (t) {
return Array.isArray ? Array.isArray(t) : a(t, "Array");
};
function h(t) {
return (h =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var l = function (t) {
var e = h(t);
return (null !== t && "object" === e) || "function" === e;
};
var d = function (t, e) {
if (t)
if (c(t))
for (var n = 0, r = t.length; n < r && !1 !== e(t[n], n); n++);
else if (l(t))
for (var i in t)
if (t.hasOwnProperty(i) && !1 === e(t[i], i)) break;
};
Object.keys;
function f(t) {
return (f =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var p = function (t) {
return "object" === f(t) && null !== t;
},
g = function (t) {
if (!p(t) || !a(t, "Object")) return !1;
if (null === Object.getPrototypeOf(t)) return !0;
for (var e = t; null !== Object.getPrototypeOf(e); )
e = Object.getPrototypeOf(e);
return Object.getPrototypeOf(t) === e;
};
var y = function (t) {
if (c(t))
return t.reduce(function (t, e) {
return Math.max(t, e);
}, t[0]);
},
v = function (t) {
if (c(t))
return t.reduce(function (t, e) {
return Math.min(t, e);
}, t[0]);
},
m = function (t) {
var e = t.filter(function (t) {
return !isNaN(t);
});
if (!e.length) return { min: 0, max: 0 };
if (c(t[0])) {
for (var n = [], r = 0; r < t.length; r++) n = n.concat(t[r]);
e = n;
}
var i = y(e);
return { min: v(e), max: i };
},
b = Array.prototype,
x =
(b.splice,
b.indexOf,
Array.prototype.splice,
function (t) {
return a(t, "String");
});
function w(t) {
if (r(t)) return t[0];
}
function O(t) {
if (r(t)) {
return t[t.length - 1];
}
}
var M = Object.prototype.hasOwnProperty;
var S = function (t, e) {
if (!e || !c(t)) return {};
for (
var n,
r = {},
i = s(e)
? e
: function (t) {
return t[e];
},
o = 0;
o < t.length;
o++
) {
var a = t[o];
(n = i(a)), M.call(r, n) ? r[n].push(a) : (r[n] = [a]);
}
return r;
};
var C = function (t, e) {
if (t["_wrap_" + e]) return t["_wrap_" + e];
var n = function (n) {
t[e](n);
};
return (t["_wrap_" + e] = n), n;
};
var j = function (t, e) {
var n = e.toString(),
r = n.indexOf(".");
if (-1 === r) return Math.round(t);
var i = n.substr(r + 1).length;
return i > 20 && (i = 20), parseFloat(t.toFixed(i));
},
k = function (t) {
return a(t, "Number");
};
Number.isInteger && Number.isInteger;
function E(t, e, n) {
return void 0 === n && (n = 1e-5), Math.abs(t - e) < n;
}
var N = function (t, e) {
return ((t % e) + e) % e;
},
T = (Math.PI, parseInt, Math.PI / 180),
P = function (t) {
return T * t;
},
I =
(Object.values,
function (t) {
return u(t) ? "" : t.toString();
});
var B = function (t) {
var e = I(t);
return e.charAt(0).toUpperCase() + e.substring(1);
},
A = {}.toString,
L = function (t) {
return A.call(t)
.replace(/^\[object /, "")
.replace(/]$/, "");
},
D = function (t) {
return a(t, "Boolean");
},
_ = function (t) {
return a(t, "Date");
},
R = Object.prototype,
Y = function (t) {
var e = t && t.constructor;
return t === (("function" == typeof e && e.prototype) || R);
};
function F(t, e) {
for (var n in e)
e.hasOwnProperty(n) &&
"constructor" !== n &&
void 0 !== e[n] &&
(t[n] = e[n]);
}
function z(t, e, n, r) {
return e && F(t, e), n && F(t, n), r && F(t, r), t;
}
function X(t) {
return (X =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var W = function t(e) {
if ("object" !== X(e) || null === e) return e;
var n;
if (c(e)) {
n = [];
for (var r = 0, i = e.length; r < i; r++)
"object" === X(e[r]) && null != e[r]
? (n[r] = t(e[r]))
: (n[r] = e[r]);
} else
for (var o in ((n = {}), e))
"object" === X(e[o]) && null != e[o]
? (n[o] = t(e[o]))
: (n[o] = e[o]);
return n;
};
var G = function (t, e, n) {
var r;
return function () {
var i = this,
o = arguments,
a = function () {
(r = null), n || t.apply(i, o);
},
s = n && !r;
clearTimeout(r), (r = setTimeout(a, e)), s && t.apply(i, o);
};
};
function q(t, e, n, r) {
for (var i in ((n = n || 0), (r = r || 5), e))
if (e.hasOwnProperty(i)) {
var o = e[i];
null !== o && g(o)
? (g(t[i]) || (t[i] = {}),
n < r ? q(t[i], o, n + 1, r) : (t[i] = e[i]))
: c(o)
? ((t[i] = []), (t[i] = t[i].concat(o)))
: void 0 !== o && (t[i] = o);
}
}
var H = function (t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
for (var r = 0; r < e.length; r += 1) q(t, e[r]);
return t;
},
V = function (t, e) {
if (!r(t)) return -1;
var n = Array.prototype.indexOf;
if (n) return n.call(t, e);
for (var i = -1, o = 0; o < t.length; o++)
if (t[o] === e) {
i = o;
break;
}
return i;
},
U = Object.prototype.hasOwnProperty;
var Z = function (t) {
if (u(t)) return !0;
if (r(t)) return !t.length;
var e = L(t);
if ("Map" === e || "Set" === e) return !t.size;
if (Y(t)) return !Object.keys(t).length;
for (var n in t) if (U.call(t, n)) return !1;
return !0;
},
K = function t(e, n) {
if (e === n) return !0;
if (!e || !n) return !1;
if (x(e) || x(n)) return !1;
if (r(e) || r(n)) {
if (e.length !== n.length) return !1;
for (var i = !0, o = 0; o < e.length && (i = t(e[o], n[o])); o++);
return i;
}
if (p(e) || p(n)) {
var a = Object.keys(e),
s = Object.keys(n);
if (a.length !== s.length) return !1;
for (i = !0, o = 0; o < a.length && (i = t(e[a[o]], n[a[o]])); o++);
return i;
}
return !1;
},
Q = function (t, e) {
if (!r(t)) return t;
for (var n = [], i = 0; i < t.length; i++) {
var o = t[i];
n.push(e(o, i));
}
return n;
},
$ = function (t, e, n) {
for (var r = 0, i = x(e) ? e.split(".") : e; t && r < i.length; )
t = t[i[r++]];
return void 0 === t || r < i.length ? n : t;
},
J =
(Object.prototype.hasOwnProperty,
function (t, e, n) {
var r,
i,
o,
a,
s = 0;
n || (n = {});
var u = function () {
(s = !1 === n.leading ? 0 : Date.now()),
(r = null),
(a = t.apply(i, o)),
r || (i = o = null);
},
c = function () {
var c = Date.now();
s || !1 !== n.leading || (s = c);
var h = e - (c - s);
return (
(i = this),
(o = arguments),
h <= 0 || h > e
? (r && (clearTimeout(r), (r = null)),
(s = c),
(a = t.apply(i, o)),
r || (i = o = null))
: r || !1 === n.trailing || (r = setTimeout(u, h)),
a
);
};
return (
(c.cancel = function () {
clearTimeout(r), (s = 0), (r = i = o = null);
}),
c
);
}),
tt = {},
et = function (t) {
return tt[(t = t || "g")] ? (tt[t] += 1) : (tt[t] = 1), t + tt[t];
},
nt = function () {};
function rt(t) {
return u(t) ? 0 : r(t) ? t.length : Object.keys(t).length;
}
!(function () {
function t() {
this.map = {};
}
(t.prototype.has = function (t) {
return void 0 !== this.map[t];
}),
(t.prototype.get = function (t, e) {
var n = this.map[t];
return void 0 === n ? e : n;
}),
(t.prototype.set = function (t, e) {
this.map[t] = e;
}),
(t.prototype.clear = function () {
this.map = {};
}),
(t.prototype.delete = function (t) {
delete this.map[t];
}),
(t.prototype.size = function () {
return Object.keys(this.map).length;
});
})();
},
function (t, e, n) {
"use strict";
n.d(e, "c", function () {
return i;
}),
n.d(e, "a", function () {
return o;
}),
n.d(e, "e", function () {
return a;
}),
n.d(e, "b", function () {
return s;
}),
n.d(e, "d", function () {
return u;
}),
n.d(e, "g", function () {
return c;
}),
n.d(e, "f", function () {
return h;
});
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
var r = function (t, e) {
return (r =
Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array &&
function (t, e) {
t.__proto__ = e;
}) ||
function (t, e) {
for (var n in e)
Object.prototype.hasOwnProperty.call(e, n) && (t[n] = e[n]);
})(t, e);
};
function i(t, e) {
if ("function" != typeof e && null !== e)
throw new TypeError(
"Class extends value " +
String(e) +
" is not a constructor or null",
);
function n() {
this.constructor = t;
}
r(t, e),
(t.prototype =
null === e
? Object.create(e)
: ((n.prototype = e.prototype), new n()));
}
var o = function () {
return (o =
Object.assign ||
function (t) {
for (var e, n = 1, r = arguments.length; n < r; n++)
for (var i in (e = arguments[n]))
Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]);
return t;
}).apply(this, arguments);
};
function a(t, e) {
var n = {};
for (var r in t)
Object.prototype.hasOwnProperty.call(t, r) &&
e.indexOf(r) < 0 &&
(n[r] = t[r]);
if (null != t && "function" == typeof Object.getOwnPropertySymbols) {
var i = 0;
for (r = Object.getOwnPropertySymbols(t); i < r.length; i++)
e.indexOf(r[i]) < 0 &&
Object.prototype.propertyIsEnumerable.call(t, r[i]) &&
(n[r[i]] = t[r[i]]);
}
return n;
}
function s(t, e, n, r) {
return new (n || (n = Promise))(function (i, o) {
function a(t) {
try {
u(r.next(t));
} catch (t) {
o(t);
}
}
function s(t) {
try {
u(r.throw(t));
} catch (t) {
o(t);
}
}
function u(t) {
var e;
t.done
? i(t.value)
: ((e = t.value),
e instanceof n
? e
: new n(function (t) {
t(e);
})).then(a, s);
}
u((r = r.apply(t, e || [])).next());
});
}
function u(t, e) {
var n,
r,
i,
o,
a = {
label: 0,
sent: function () {
if (1 & i[0]) throw i[1];
return i[1];
},
trys: [],
ops: [],
};
return (
(o = { next: s(0), throw: s(1), return: s(2) }),
"function" == typeof Symbol &&
(o[Symbol.iterator] = function () {
return this;
}),
o
);
function s(o) {
return function (s) {
return (function (o) {
if (n) throw new TypeError("Generator is already executing.");
for (; a; )
try {
if (
((n = 1),
r &&
(i =
2 & o[0]
? r.return
: o[0]
? r.throw || ((i = r.return) && i.call(r), 0)
: r.next) &&
!(i = i.call(r, o[1])).done)
)
return i;
switch (((r = 0), i && (o = [2 & o[0], i.value]), o[0])) {
case 0:
case 1:
i = o;
break;
case 4:
return a.label++, { value: o[1], done: !1 };
case 5:
a.label++, (r = o[1]), (o = [0]);
continue;
case 7:
(o = a.ops.pop()), a.trys.pop();
continue;
default:
if (
!((i = a.trys),
(i = i.length > 0 && i[i.length - 1]) ||
(6 !== o[0] && 2 !== o[0]))
) {
a = 0;
continue;
}
if (3 === o[0] && (!i || (o[1] > i[0] && o[1] < i[3]))) {
a.label = o[1];
break;
}
if (6 === o[0] && a.label < i[1]) {
(a.label = i[1]), (i = o);
break;
}
if (i && a.label < i[2]) {
(a.label = i[2]), a.ops.push(o);
break;
}
i[2] && a.ops.pop(), a.trys.pop();
continue;
}
o = e.call(t, a);
} catch (t) {
(o = [6, t]), (r = 0);
} finally {
n = i = 0;
}
if (5 & o[0]) throw o[1];
return { value: o[0] ? o[1] : void 0, done: !0 };
})([o, s]);
};
}
}
Object.create;
function c() {
for (var t = 0, e = 0, n = arguments.length; e < n; e++)
t += arguments[e].length;
var r = Array(t),
i = 0;
for (e = 0; e < n; e++)
for (var o = arguments[e], a = 0, s = o.length; a < s; a++, i++)
r[i] = o[a];
return r;
}
function h(t, e, n) {
if (n || 2 === arguments.length)
for (var r, i = 0, o = e.length; i < o; i++)
(!r && i in e) ||
(r || (r = Array.prototype.slice.call(e, 0, i)), (r[i] = e[i]));
return t.concat(r || e);
}
Object.create;
},
function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return r;
}),
n.d(e, "c", function () {
return Y;
}),
n.d(e, "d", function () {
return i;
}),
n.d(e, "a", function () {
return o;
});
var r = {};
n.r(r),
n.d(r, "create", function () {
return s;
}),
n.d(r, "fromMat4", function () {
return u;
}),
n.d(r, "clone", function () {
return c;
}),
n.d(r, "copy", function () {
return h;
}),
n.d(r, "fromValues", function () {
return l;
}),
n.d(r, "set", function () {
return d;
}),
n.d(r, "identity", function () {
return f;
}),
n.d(r, "transpose", function () {
return p;
}),
n.d(r, "invert", function () {
return g;
}),
n.d(r, "adjoint", function () {
return y;
}),
n.d(r, "determinant", function () {
return v;
}),
n.d(r, "multiply", function () {
return m;
}),
n.d(r, "translate", function () {
return b;
}),
n.d(r, "rotate", function () {
return x;
}),
n.d(r, "scale", function () {
return w;
}),
n.d(r, "fromTranslation", function () {
return O;
}),
n.d(r, "fromRotation", function () {
return M;
}),
n.d(r, "fromScaling", function () {
return S;
}),
n.d(r, "fromMat2d", function () {
return C;
}),
n.d(r, "fromQuat", function () {
return j;
}),
n.d(r, "normalFromMat4", function () {
return k;
}),
n.d(r, "projection", function () {
return E;
}),
n.d(r, "str", function () {
return N;
}),
n.d(r, "frob", function () {
return T;
}),
n.d(r, "add", function () {
return P;
}),
n.d(r, "subtract", function () {
return I;
}),
n.d(r, "multiplyScalar", function () {
return B;
}),
n.d(r, "multiplyScalarAndAdd", function () {
return A;
}),
n.d(r, "exactEquals", function () {
return L;
}),
n.d(r, "equals", function () {
return D;
}),
n.d(r, "mul", function () {
return _;
}),
n.d(r, "sub", function () {
return R;
});
var i = {};
n.r(i),
n.d(i, "create", function () {
return F;
}),
n.d(i, "clone", function () {
return z;
}),
n.d(i, "length", function () {
return X;
}),
n.d(i, "fromValues", function () {
return W;
}),
n.d(i, "copy", function () {
return G;
}),
n.d(i, "set", function () {
return q;
}),
n.d(i, "add", function () {
return H;
}),
n.d(i, "subtract", function () {
return V;
}),
n.d(i, "multiply", function () {
return U;
}),
n.d(i, "divide", function () {
return Z;
}),
n.d(i, "ceil", function () {
return K;
}),
n.d(i, "floor", function () {
return Q;
}),
n.d(i, "min", function () {
return $;
}),
n.d(i, "max", function () {
return J;
}),
n.d(i, "round", function () {
return tt;
}),
n.d(i, "scale", function () {
return et;
}),
n.d(i, "scaleAndAdd", function () {
return nt;
}),
n.d(i, "distance", function () {
return rt;
}),
n.d(i, "squaredDistance", function () {
return it;
}),
n.d(i, "squaredLength", function () {
return ot;
}),
n.d(i, "negate", function () {
return at;
}),
n.d(i, "inverse", function () {
return st;
}),
n.d(i, "normalize", function () {
return ut;
}),
n.d(i, "dot", function () {
return ct;
}),
n.d(i, "cross", function () {
return ht;
}),
n.d(i, "lerp", function () {
return lt;
}),
n.d(i, "hermite", function () {
return dt;
}),
n.d(i, "bezier", function () {
return ft;
}),
n.d(i, "random", function () {
return pt;
}),
n.d(i, "transformMat4", function () {
return gt;
}),
n.d(i, "transformMat3", function () {
return yt;
}),
n.d(i, "transformQuat", function () {
return vt;
}),
n.d(i, "rotateX", function () {
return mt;
}),
n.d(i, "rotateY", function () {
return bt;
}),
n.d(i, "rotateZ", function () {
return xt;
}),
n.d(i, "angle", function () {
return wt;
}),
n.d(i, "zero", function () {
return Ot;
}),
n.d(i, "str", function () {
return Mt;
}),
n.d(i, "exactEquals", function () {
return St;
}),
n.d(i, "equals", function () {
return Ct;
}),
n.d(i, "sub", function () {
return kt;
}),
n.d(i, "mul", function () {
return Et;
}),
n.d(i, "div", function () {
return Nt;
}),
n.d(i, "dist", function () {
return Tt;
}),
n.d(i, "sqrDist", function () {
return Pt;
}),
n.d(i, "len", function () {
return It;
}),
n.d(i, "sqrLen", function () {
return Bt;
}),
n.d(i, "forEach", function () {
return At;
});
var o = {};
n.r(o),
n.d(o, "leftTranslate", function () {
return Lt;
}),
n.d(o, "leftRotate", function () {
return Dt;
}),
n.d(o, "leftScale", function () {
return _t;
}),
n.d(o, "transform", function () {
return Rt;
}),
n.d(o, "direction", function () {
return Yt;
}),
n.d(o, "angleTo", function () {
return Ft;
}),
n.d(o, "vertical", function () {
return zt;
});
var a = n(4);
function s() {
var t = new a.a(9);
return (
a.a != Float32Array &&
((t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0)),
(t[0] = 1),
(t[4] = 1),
(t[8] = 1),
t
);
}
function u(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = e[2]),
(t[3] = e[4]),
(t[4] = e[5]),
(t[5] = e[6]),
(t[6] = e[8]),
(t[7] = e[9]),
(t[8] = e[10]),
t
);
}
function c(t) {
var e = new a.a(9);
return (
(e[0] = t[0]),
(e[1] = t[1]),
(e[2] = t[2]),
(e[3] = t[3]),
(e[4] = t[4]),
(e[5] = t[5]),
(e[6] = t[6]),
(e[7] = t[7]),
(e[8] = t[8]),
e
);
}
function h(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = e[2]),
(t[3] = e[3]),
(t[4] = e[4]),
(t[5] = e[5]),
(t[6] = e[6]),
(t[7] = e[7]),
(t[8] = e[8]),
t
);
}
function l(t, e, n, r, i, o, s, u, c) {
var h = new a.a(9);
return (
(h[0] = t),
(h[1] = e),
(h[2] = n),
(h[3] = r),
(h[4] = i),
(h[5] = o),
(h[6] = s),
(h[7] = u),
(h[8] = c),
h
);
}
function d(t, e, n, r, i, o, a, s, u, c) {
return (
(t[0] = e),
(t[1] = n),
(t[2] = r),
(t[3] = i),
(t[4] = o),
(t[5] = a),
(t[6] = s),
(t[7] = u),
(t[8] = c),
t
);
}
function f(t) {
return (
(t[0] = 1),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = 1),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function p(t, e) {
if (t === e) {
var n = e[1],
r = e[2],
i = e[5];
(t[1] = e[3]),
(t[2] = e[6]),
(t[3] = n),
(t[5] = e[7]),
(t[6] = r),
(t[7] = i);
} else
(t[0] = e[0]),
(t[1] = e[3]),
(t[2] = e[6]),
(t[3] = e[1]),
(t[4] = e[4]),
(t[5] = e[7]),
(t[6] = e[2]),
(t[7] = e[5]),
(t[8] = e[8]);
return t;
}
function g(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
u = e[6],
c = e[7],
h = e[8],
l = h * a - s * c,
d = -h * o + s * u,
f = c * o - a * u,
p = n * l + r * d + i * f;
return p
? ((p = 1 / p),
(t[0] = l * p),
(t[1] = (-h * r + i * c) * p),
(t[2] = (s * r - i * a) * p),
(t[3] = d * p),
(t[4] = (h * n - i * u) * p),
(t[5] = (-s * n + i * o) * p),
(t[6] = f * p),
(t[7] = (-c * n + r * u) * p),
(t[8] = (a * n - r * o) * p),
t)
: null;
}
function y(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
u = e[6],
c = e[7],
h = e[8];
return (
(t[0] = a * h - s * c),
(t[1] = i * c - r * h),
(t[2] = r * s - i * a),
(t[3] = s * u - o * h),
(t[4] = n * h - i * u),
(t[5] = i * o - n * s),
(t[6] = o * c - a * u),
(t[7] = r * u - n * c),
(t[8] = n * a - r * o),
t
);
}
function v(t) {
var e = t[0],
n = t[1],
r = t[2],
i = t[3],
o = t[4],
a = t[5],
s = t[6],
u = t[7],
c = t[8];
return e * (c * o - a * u) + n * (-c * i + a * s) + r * (u * i - o * s);
}
function m(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
u = e[5],
c = e[6],
h = e[7],
l = e[8],
d = n[0],
f = n[1],
p = n[2],
g = n[3],
y = n[4],
v = n[5],
m = n[6],
b = n[7],
x = n[8];
return (
(t[0] = d * r + f * a + p * c),
(t[1] = d * i + f * s + p * h),
(t[2] = d * o + f * u + p * l),
(t[3] = g * r + y * a + v * c),
(t[4] = g * i + y * s + v * h),
(t[5] = g * o + y * u + v * l),
(t[6] = m * r + b * a + x * c),
(t[7] = m * i + b * s + x * h),
(t[8] = m * o + b * u + x * l),
t
);
}
function b(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
u = e[5],
c = e[6],
h = e[7],
l = e[8],
d = n[0],
f = n[1];
return (
(t[0] = r),
(t[1] = i),
(t[2] = o),
(t[3] = a),
(t[4] = s),
(t[5] = u),
(t[6] = d * r + f * a + c),
(t[7] = d * i + f * s + h),
(t[8] = d * o + f * u + l),
t
);
}
function x(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = e[3],
s = e[4],
u = e[5],
c = e[6],
h = e[7],
l = e[8],
d = Math.sin(n),
f = Math.cos(n);
return (
(t[0] = f * r + d * a),
(t[1] = f * i + d * s),
(t[2] = f * o + d * u),
(t[3] = f * a - d * r),
(t[4] = f * s - d * i),
(t[5] = f * u - d * o),
(t[6] = c),
(t[7] = h),
(t[8] = l),
t
);
}
function w(t, e, n) {
var r = n[0],
i = n[1];
return (
(t[0] = r * e[0]),
(t[1] = r * e[1]),
(t[2] = r * e[2]),
(t[3] = i * e[3]),
(t[4] = i * e[4]),
(t[5] = i * e[5]),
(t[6] = e[6]),
(t[7] = e[7]),
(t[8] = e[8]),
t
);
}
function O(t, e) {
return (
(t[0] = 1),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = 1),
(t[5] = 0),
(t[6] = e[0]),
(t[7] = e[1]),
(t[8] = 1),
t
);
}
function M(t, e) {
var n = Math.sin(e),
r = Math.cos(e);
return (
(t[0] = r),
(t[1] = n),
(t[2] = 0),
(t[3] = -n),
(t[4] = r),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function S(t, e) {
return (
(t[0] = e[0]),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = e[1]),
(t[5] = 0),
(t[6] = 0),
(t[7] = 0),
(t[8] = 1),
t
);
}
function C(t, e) {
return (
(t[0] = e[0]),
(t[1] = e[1]),
(t[2] = 0),
(t[3] = e[2]),
(t[4] = e[3]),
(t[5] = 0),
(t[6] = e[4]),
(t[7] = e[5]),
(t[8] = 1),
t
);
}
function j(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = n + n,
s = r + r,
u = i + i,
c = n * a,
h = r * a,
l = r * s,
d = i * a,
f = i * s,
p = i * u,
g = o * a,
y = o * s,
v = o * u;
return (
(t[0] = 1 - l - p),
(t[3] = h - v),
(t[6] = d + y),
(t[1] = h + v),
(t[4] = 1 - c - p),
(t[7] = f - g),
(t[2] = d - y),
(t[5] = f + g),
(t[8] = 1 - c - l),
t
);
}
function k(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = e[3],
a = e[4],
s = e[5],
u = e[6],
c = e[7],
h = e[8],
l = e[9],
d = e[10],
f = e[11],
p = e[12],
g = e[13],
y = e[14],
v = e[15],
m = n * s - r * a,
b = n * u - i * a,
x = n * c - o * a,
w = r * u - i * s,
O = r * c - o * s,
M = i * c - o * u,
S = h * g - l * p,
C = h * y - d * p,
j = h * v - f * p,
k = l * y - d * g,
E = l * v - f * g,
N = d * v - f * y,
T = m * N - b * E + x * k + w * j - O * C + M * S;
return T
? ((T = 1 / T),
(t[0] = (s * N - u * E + c * k) * T),
(t[1] = (u * j - a * N - c * C) * T),
(t[2] = (a * E - s * j + c * S) * T),
(t[3] = (i * E - r * N - o * k) * T),
(t[4] = (n * N - i * j + o * C) * T),
(t[5] = (r * j - n * E - o * S) * T),
(t[6] = (g * M - y * O + v * w) * T),
(t[7] = (y * x - p * M - v * b) * T),
(t[8] = (p * O - g * x + v * m) * T),
t)
: null;
}
function E(t, e, n) {
return (
(t[0] = 2 / e),
(t[1] = 0),
(t[2] = 0),
(t[3] = 0),
(t[4] = -2 / n),
(t[5] = 0),
(t[6] = -1),
(t[7] = 1),
(t[8] = 1),
t
);
}
function N(t) {
return (
"mat3(" +
t[0] +
", " +
t[1] +
", " +
t[2] +
", " +
t[3] +
", " +
t[4] +
", " +
t[5] +
", " +
t[6] +
", " +
t[7] +
", " +
t[8] +
")"
);
}
function T(t) {
return Math.hypot(t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8]);
}
function P(t, e, n) {
return (
(t[0] = e[0] + n[0]),
(t[1] = e[1] + n[1]),
(t[2] = e[2] + n[2]),
(t[3] = e[3] + n[3]),
(t[4] = e[4] + n[4]),
(t[5] = e[5] + n[5]),
(t[6] = e[6] + n[6]),
(t[7] = e[7] + n[7]),
(t[8] = e[8] + n[8]),
t
);
}
function I(t, e, n) {
return (
(t[0] = e[0] - n[0]),
(t[1] = e[1] - n[1]),
(t[2] = e[2] - n[2]),
(t[3] = e[3] - n[3]),
(t[4] = e[4] - n[4]),
(t[5] = e[5] - n[5]),
(t[6] = e[6] - n[6]),
(t[7] = e[7] - n[7]),
(t[8] = e[8] - n[8]),
t
);
}
function B(t, e, n) {
return (
(t[0] = e[0] * n),
(t[1] = e[1] * n),
(t[2] = e[2] * n),
(t[3] = e[3] * n),
(t[4] = e[4] * n),
(t[5] = e[5] * n),
(t[6] = e[6] * n),
(t[7] = e[7] * n),
(t[8] = e[8] * n),
t
);
}
function A(t, e, n, r) {
return (
(t[0] = e[0] + n[0] * r),
(t[1] = e[1] + n[1] * r),
(t[2] = e[2] + n[2] * r),
(t[3] = e[3] + n[3] * r),
(t[4] = e[4] + n[4] * r),
(t[5] = e[5] + n[5] * r),
(t[6] = e[6] + n[6] * r),
(t[7] = e[7] + n[7] * r),
(t[8] = e[8] + n[8] * r),
t
);
}
function L(t, e) {
return (
t[0] === e[0] &&
t[1] === e[1] &&
t[2] === e[2] &&
t[3] === e[3] &&
t[4] === e[4] &&
t[5] === e[5] &&
t[6] === e[6] &&
t[7] === e[7] &&
t[8] === e[8]
);
}
function D(t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = t[3],
s = t[4],
u = t[5],
c = t[6],
h = t[7],
l = t[8],
d = e[0],
f = e[1],
p = e[2],
g = e[3],
y = e[4],
v = e[5],
m = e[6],
b = e[7],
x = e[8];
return (
Math.abs(n - d) <= a.b * Math.max(1, Math.abs(n), Math.abs(d)) &&
Math.abs(r - f) <= a.b * Math.max(1, Math.abs(r), Math.abs(f)) &&
Math.abs(i - p) <= a.b * Math.max(1, Math.abs(i), Math.abs(p)) &&
Math.abs(o - g) <= a.b * Math.max(1, Math.abs(o), Math.abs(g)) &&
Math.abs(s - y) <= a.b * Math.max(1, Math.abs(s), Math.abs(y)) &&
Math.abs(u - v) <= a.b * Math.max(1, Math.abs(u), Math.abs(v)) &&
Math.abs(c - m) <= a.b * Math.max(1, Math.abs(c), Math.abs(m)) &&
Math.abs(h - b) <= a.b * Math.max(1, Math.abs(h), Math.abs(b)) &&
Math.abs(l - x) <= a.b * Math.max(1, Math.abs(l), Math.abs(x))
);
}
var _ = m,
R = I,
Y = n(9);
function F() {
var t = new a.a(3);
return a.a != Float32Array && ((t[0] = 0), (t[1] = 0), (t[2] = 0)), t;
}
function z(t) {
var e = new a.a(3);
return (e[0] = t[0]), (e[1] = t[1]), (e[2] = t[2]), e;
}
function X(t) {
var e = t[0],
n = t[1],
r = t[2];
return Math.hypot(e, n, r);
}
function W(t, e, n) {
var r = new a.a(3);
return (r[0] = t), (r[1] = e), (r[2] = n), r;
}
function G(t, e) {
return (t[0] = e[0]), (t[1] = e[1]), (t[2] = e[2]), t;
}
function q(t, e, n, r) {
return (t[0] = e), (t[1] = n), (t[2] = r), t;
}
function H(t, e, n) {
return (
(t[0] = e[0] + n[0]), (t[1] = e[1] + n[1]), (t[2] = e[2] + n[2]), t
);
}
function V(t, e, n) {
return (
(t[0] = e[0] - n[0]), (t[1] = e[1] - n[1]), (t[2] = e[2] - n[2]), t
);
}
function U(t, e, n) {
return (
(t[0] = e[0] * n[0]), (t[1] = e[1] * n[1]), (t[2] = e[2] * n[2]), t
);
}
function Z(t, e, n) {
return (
(t[0] = e[0] / n[0]), (t[1] = e[1] / n[1]), (t[2] = e[2] / n[2]), t
);
}
function K(t, e) {
return (
(t[0] = Math.ceil(e[0])),
(t[1] = Math.ceil(e[1])),
(t[2] = Math.ceil(e[2])),
t
);
}
function Q(t, e) {
return (
(t[0] = Math.floor(e[0])),
(t[1] = Math.floor(e[1])),
(t[2] = Math.floor(e[2])),
t
);
}
function $(t, e, n) {
return (
(t[0] = Math.min(e[0], n[0])),
(t[1] = Math.min(e[1], n[1])),
(t[2] = Math.min(e[2], n[2])),
t
);
}
function J(t, e, n) {
return (
(t[0] = Math.max(e[0], n[0])),
(t[1] = Math.max(e[1], n[1])),
(t[2] = Math.max(e[2], n[2])),
t
);
}
function tt(t, e) {
return (
(t[0] = Math.round(e[0])),
(t[1] = Math.round(e[1])),
(t[2] = Math.round(e[2])),
t
);
}
function et(t, e, n) {
return (t[0] = e[0] * n), (t[1] = e[1] * n), (t[2] = e[2] * n), t;
}
function nt(t, e, n, r) {
return (
(t[0] = e[0] + n[0] * r),
(t[1] = e[1] + n[1] * r),
(t[2] = e[2] + n[2] * r),
t
);
}
function rt(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1],
i = e[2] - t[2];
return Math.hypot(n, r, i);
}
function it(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1],
i = e[2] - t[2];
return n * n + r * r + i * i;
}
function ot(t) {
var e = t[0],
n = t[1],
r = t[2];
return e * e + n * n + r * r;
}
function at(t, e) {
return (t[0] = -e[0]), (t[1] = -e[1]), (t[2] = -e[2]), t;
}
function st(t, e) {
return (t[0] = 1 / e[0]), (t[1] = 1 / e[1]), (t[2] = 1 / e[2]), t;
}
function ut(t, e) {
var n = e[0],
r = e[1],
i = e[2],
o = n * n + r * r + i * i;
return (
o > 0 && (o = 1 / Math.sqrt(o)),
(t[0] = e[0] * o),
(t[1] = e[1] * o),
(t[2] = e[2] * o),
t
);
}
function ct(t, e) {
return t[0] * e[0] + t[1] * e[1] + t[2] * e[2];
}
function ht(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = n[0],
s = n[1],
u = n[2];
return (
(t[0] = i * u - o * s),
(t[1] = o * a - r * u),
(t[2] = r * s - i * a),
t
);
}
function lt(t, e, n, r) {
var i = e[0],
o = e[1],
a = e[2];
return (
(t[0] = i + r * (n[0] - i)),
(t[1] = o + r * (n[1] - o)),
(t[2] = a + r * (n[2] - a)),
t
);
}
function dt(t, e, n, r, i, o) {
var a = o * o,
s = a * (2 * o - 3) + 1,
u = a * (o - 2) + o,
c = a * (o - 1),
h = a * (3 - 2 * o);
return (
(t[0] = e[0] * s + n[0] * u + r[0] * c + i[0] * h),
(t[1] = e[1] * s + n[1] * u + r[1] * c + i[1] * h),
(t[2] = e[2] * s + n[2] * u + r[2] * c + i[2] * h),
t
);
}
function ft(t, e, n, r, i, o) {
var a = 1 - o,
s = a * a,
u = o * o,
c = s * a,
h = 3 * o * s,
l = 3 * u * a,
d = u * o;
return (
(t[0] = e[0] * c + n[0] * h + r[0] * l + i[0] * d),
(t[1] = e[1] * c + n[1] * h + r[1] * l + i[1] * d),
(t[2] = e[2] * c + n[2] * h + r[2] * l + i[2] * d),
t
);
}
function pt(t, e) {
e = e || 1;
var n = 2 * a.c() * Math.PI,
r = 2 * a.c() - 1,
i = Math.sqrt(1 - r * r) * e;
return (
(t[0] = Math.cos(n) * i), (t[1] = Math.sin(n) * i), (t[2] = r * e), t
);
}
function gt(t, e, n) {
var r = e[0],
i = e[1],
o = e[2],
a = n[3] * r + n[7] * i + n[11] * o + n[15];
return (
(a = a || 1),
(t[0] = (n[0] * r + n[4] * i + n[8] * o + n[12]) / a),
(t[1] = (n[1] * r + n[5] * i + n[9] * o + n[13]) / a),
(t[2] = (n[2] * r + n[6] * i + n[10] * o + n[14]) / a),
t
);
}
function yt(t, e, n) {
var r = e[0],
i = e[1],
o = e[2];
return (
(t[0] = r * n[0] + i * n[3] + o * n[6]),
(t[1] = r * n[1] + i * n[4] + o * n[7]),
(t[2] = r * n[2] + i * n[5] + o * n[8]),
t
);
}
function vt(t, e, n) {
var r = n[0],
i = n[1],
o = n[2],
a = n[3],
s = e[0],
u = e[1],
c = e[2],
h = i * c - o * u,
l = o * s - r * c,
d = r * u - i * s,
f = i * d - o * l,
p = o * h - r * d,
g = r * l - i * h,
y = 2 * a;
return (
(h *= y),
(l *= y),
(d *= y),
(f *= 2),
(p *= 2),
(g *= 2),
(t[0] = s + h + f),
(t[1] = u + l + p),
(t[2] = c + d + g),
t
);
}
function mt(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[0]),
(o[1] = i[1] * Math.cos(r) - i[2] * Math.sin(r)),
(o[2] = i[1] * Math.sin(r) + i[2] * Math.cos(r)),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function bt(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[2] * Math.sin(r) + i[0] * Math.cos(r)),
(o[1] = i[1]),
(o[2] = i[2] * Math.cos(r) - i[0] * Math.sin(r)),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function xt(t, e, n, r) {
var i = [],
o = [];
return (
(i[0] = e[0] - n[0]),
(i[1] = e[1] - n[1]),
(i[2] = e[2] - n[2]),
(o[0] = i[0] * Math.cos(r) - i[1] * Math.sin(r)),
(o[1] = i[0] * Math.sin(r) + i[1] * Math.cos(r)),
(o[2] = i[2]),
(t[0] = o[0] + n[0]),
(t[1] = o[1] + n[1]),
(t[2] = o[2] + n[2]),
t
);
}
function wt(t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = e[0],
a = e[1],
s = e[2],
u =
Math.sqrt(n * n + r * r + i * i) * Math.sqrt(o * o + a * a + s * s),
c = u && ct(t, e) / u;
return Math.acos(Math.min(Math.max(c, -1), 1));
}
function Ot(t) {
return (t[0] = 0), (t[1] = 0), (t[2] = 0), t;
}
function Mt(t) {
return "vec3(" + t[0] + ", " + t[1] + ", " + t[2] + ")";
}
function St(t, e) {
return t[0] === e[0] && t[1] === e[1] && t[2] === e[2];
}
function Ct(t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = e[0],
s = e[1],
u = e[2];
return (
Math.abs(n - o) <= a.b * Math.max(1, Math.abs(n), Math.abs(o)) &&
Math.abs(r - s) <= a.b * Math.max(1, Math.abs(r), Math.abs(s)) &&
Math.abs(i - u) <= a.b * Math.max(1, Math.abs(i), Math.abs(u))
);
}
var jt,
kt = V,
Et = U,
Nt = Z,
Tt = rt,
Pt = it,
It = X,
Bt = ot,
At =
((jt = F()),
function (t, e, n, r, i, o) {
var a, s;
for (
e || (e = 3),
n || (n = 0),
s = r ? Math.min(r * e + n, t.length) : t.length,
a = n;
a < s;
a += e
)
(jt[0] = t[a]),
(jt[1] = t[a + 1]),
(jt[2] = t[a + 2]),
i(jt, jt, o),
(t[a] = jt[0]),
(t[a + 1] = jt[1]),
(t[a + 2] = jt[2]);
return t;
});
function Lt(t, e, n) {
var i = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return r.fromTranslation(i, n), r.multiply(t, i, e);
}
function Dt(t, e, n) {
var i = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return r.fromRotation(i, n), r.multiply(t, i, e);
}
function _t(t, e, n) {
var i = [0, 0, 0, 0, 0, 0, 0, 0, 0];
return r.fromScaling(i, n), r.multiply(t, i, e);
}
function Rt(t, e) {
for (
var n,
i,
o,
a = t ? [].concat(t) : [1, 0, 0, 0, 1, 0, 0, 0, 1],
s = 0,
u = e.length;
s < u;
s++
) {
var c = e[s];
switch (c[0]) {
case "t":
Lt(a, a, [c[1], c[2]]);
break;
case "s":
_t(a, a, [c[1], c[2]]);
break;
case "r":
Dt(a, a, c[1]);
break;
case "m":
(n = a), (i = a), (o = c[1]), r.multiply(n, o, i);
}
}
return a;
}
function Yt(t, e) {
return t[0] * e[1] - e[0] * t[1];
}
function Ft(t, e, n) {
var r = Y.angle(t, e),
i = Yt(t, e) >= 0;
return n ? (i ? 2 * Math.PI - r : r) : i ? r : 2 * Math.PI - r;
}
function zt(t, e, n) {
return (
n
? ((t[0] = e[1]), (t[1] = -1 * e[0]))
: ((t[0] = -1 * e[1]), (t[1] = e[0])),
t
);
}
},
function (t, e, n) {
"use strict";
n.d(e, "j", function () {
return i;
}),
n.d(e, "c", function () {
return o;
}),
n.d(e, "g", function () {
return a;
}),
n.d(e, "b", function () {
return s;
});
var r = n(0);
function i(t, e) {
var n = t.indexOf(e);
-1 !== n && t.splice(n, 1);
}
n.d(e, "e", function () {
return r.s;
}),
n.d(e, "d", function () {
return r.r;
}),
n.d(e, "h", function () {
return r.x;
}),
n.d(e, "f", function () {
return r.v;
}),
n.d(e, "i", function () {
return r.C;
}),
n.d(e, "a", function () {
return r.e;
}),
n.d(e, "k", function () {
return r.J;
});
var o = "undefined" != typeof window && void 0 !== window.document;
function a(t, e) {
if (t.isCanvas()) return !0;
for (var n = e.getParent(), r = !1; n; ) {
if (n === t) {
r = !0;
break;
}
n = n.getParent();
}
return r;
}
function s(t) {
return t.cfg.visible && t.cfg.capture;
}
},
function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return r;
}),
n.d(e, "a", function () {
return i;
}),
n.d(e, "c", function () {
return o;
});
var r = 1e-6,
i = "undefined" != typeof Float32Array ? Float32Array : Array,
o = Math.random;
Math.PI;
Math.hypot ||
(Math.hypot = function () {
for (var t = 0, e = arguments.length; e--; )
t += arguments[e] * arguments[e];
return Math.sqrt(t);
});
},
function (t, e, n) {
"use strict";
function r(t, e) {
var n = [],
r = t[0],
i = t[1],
o = t[2],
a = t[3],
s = t[4],
u = t[5],
c = t[6],
h = t[7],
l = t[8],
d = e[0],
f = e[1],
p = e[2],
g = e[3],
y = e[4],
v = e[5],
m = e[6],
b = e[7],
x = e[8];
return (
(n[0] = d * r + f * a + p * c),
(n[1] = d * i + f * s + p * h),
(n[2] = d * o + f * u + p * l),
(n[3] = g * r + y * a + v * c),
(n[4] = g * i + y * s + v * h),
(n[5] = g * o + y * u + v * l),
(n[6] = m * r + b * a + x * c),
(n[7] = m * i + b * s + x * h),
(n[8] = m * o + b * u + x * l),
n
);
}
function i(t, e) {
var n = [],
r = e[0],
i = e[1];
return (
(n[0] = t[0] * r + t[3] * i + t[6]),
(n[1] = t[1] * r + t[4] * i + t[7]),
n
);
}
function o(t) {
var e = [],
n = t[0],
r = t[1],
i = t[2],
o = t[3],
a = t[4],
s = t[5],
u = t[6],
c = t[7],
h = t[8],
l = h * a - s * c,
d = -h * o + s * u,
f = c * o - a * u,
p = n * l + r * d + i * f;
return p
? ((p = 1 / p),
(e[0] = l * p),
(e[1] = (-h * r + i * c) * p),
(e[2] = (s * r - i * a) * p),
(e[3] = d * p),
(e[4] = (h * n - i * u) * p),
(e[5] = (-s * n + i * o) * p),
(e[6] = f * p),
(e[7] = (-c * n + r * u) * p),
(e[8] = (a * n - r * o) * p),
e)
: null;
}
n.d(e, "b", function () {
return r;
}),
n.d(e, "c", function () {
return i;
}),
n.d(e, "a", function () {
return o;
});
},
function (t, e, n) {
"use strict";
n.d(e, "a", function () {
return h;
}),
n.d(e, "b", function () {
return f;
}),
n.d(e, "c", function () {
return s;
});
var r = n(0),
i = "\t\n\v\f\r \u2028\u2029",
o = new RegExp(
"([a-z])[" +
i +
",]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[" +
i +
"]*,?[" +
i +
"]*)+)",
"ig",
),
a = new RegExp(
"(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[" + i + "]*,?[" + i + "]*",
"ig",
),
s = function (t) {
if (!t) return null;
if (Object(r.m)(t)) return t;
var e = {
a: 7,
c: 6,
o: 2,
h: 1,
l: 2,
m: 2,
r: 4,
q: 4,
s: 4,
t: 2,
v: 1,
u: 3,
z: 0,
},
n = [];
return (
String(t).replace(o, function (r, i, o) {
var s = [],
u = i.toLowerCase();
if (
(o.replace(a, function (t, e) {
e && s.push(+e);
}),
"m" === u &&
s.length > 2 &&
(n.push([i].concat(s.splice(0, 2))),
(u = "l"),
(i = "m" === i ? "l" : "L")),
"o" === u && 1 === s.length && n.push([i, s[0]]),
"r" === u)
)
n.push([i].concat(s));
else
for (
;
s.length >= e[u] &&
(n.push([i].concat(s.splice(0, e[u]))), e[u]);
);
return t;
}),
n
);
};
var u = function (t, e) {
if (t.length !== e.length) return !1;
var n = !0;
return (
Object(r.e)(t, function (t, r) {
if (t !== e[r]) return (n = !1), !1;
}),
n
);
};
function c(t, e, n) {
var r = null,
i = n;
return (
e < i && ((i = e), (r = "add")),
t < i && ((i = t), (r = "del")),
{ type: r, min: i }
);
}
var h = function (t, e) {
var n = (function (t, e) {
var n,
r,
i = t.length,
o = e.length,
a = 0;
if (0 === i || 0 === o) return null;
for (var s = [], h = 0; h <= i; h++)
(s[h] = []), (s[h][0] = { min: h });
for (var l = 0; l <= o; l++) s[0][l] = { min: l };
for (h = 1; h <= i; h++) {
n = t[h - 1];
for (l = 1; l <= o; l++) {
(r = e[l - 1]), (a = u(n, r) ? 0 : 1);
var d = s[h - 1][l].min + 1,
f = s[h][l - 1].min + 1,
p = s[h - 1][l - 1].min + a;
s[h][l] = c(d, f, p);
}
}
return s;
})(t, e),
r = t.length,
i = e.length,
o = [],
a = 1,
s = 1;
if (n[r][i].min !== r) {
for (var h = 1; h <= r; h++) {
var l = n[h][h].min;
s = h;
for (var d = a; d <= i; d++)
n[h][d].min < l && ((l = n[h][d].min), (s = d));
(a = s),
n[h][a].type && o.push({ index: h - 1, type: n[h][a].type });
}
for (h = o.length - 1; h >= 0; h--)
(a = o[h].index),
"add" === o[h].type
? t.splice(a, 0, [].concat(t[a]))
: t.splice(a, 1);
}
var f = i - (r = t.length);
if (r < i)
for (h = 0; h < f; h++)
"z" === t[r - 1][0] || "Z" === t[r - 1][0]
? t.splice(r - 2, 0, t[r - 2])
: t.push(t[r - 1]),
(r += 1);
return t;
};
function l(t, e, n) {
for (
var r, i = [].concat(t), o = 1 / (n + 1), a = d(e)[0], s = 1;
s <= n;
s++
)
(o *= s),
0 === (r = Math.floor(t.length * o))
? i.unshift([
a[0] * o + t[r][0] * (1 - o),
a[1] * o + t[r][1] * (1 - o),
])
: i.splice(r, 0, [
a[0] * o + t[r][0] * (1 - o),
a[1] * o + t[r][1] * (1 - o),
]);
return i;
}
function d(t) {
var e = [];
switch (t[0]) {
case "M":
case "L":
e.push([t[1], t[2]]);
break;
case "A":
e.push([t[6], t[7]]);
break;
case "Q":
e.push([t[3], t[4]]), e.push([t[1], t[2]]);
break;
case "T":
e.push([t[1], t[2]]);
break;
case "C":
e.push([t[5], t[6]]), e.push([t[1], t[2]]), e.push([t[3], t[4]]);
break;
case "S":
e.push([t[3], t[4]]), e.push([t[1], t[2]]);
break;
case "H":
case "V":
e.push([t[1], t[1]]);
}
return e;
}
var f = function (t, e) {
if (t.length <= 1) return t;
for (var n, r = 0; r < e.length; r++)
if (t[r][0] !== e[r][0])
switch (((n = d(t[r])), e[r][0])) {
case "M":
t[r] = ["M"].concat(n[0]);
break;
case "L":
t[r] = ["L"].concat(n[0]);
break;
case "A":
(t[r] = [].concat(e[r])),
(t[r][6] = n[0][0]),
(t[r][7] = n[0][1]);
break;
case "Q":
if (n.length < 2) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = l(n, t[r - 1], 1);
}
t[r] = ["Q"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
case "T":
t[r] = ["T"].concat(n[0]);
break;
case "C":
if (n.length < 3) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = l(n, t[r - 1], 2);
}
t[r] = ["C"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
case "S":
if (n.length < 2) {
if (!(r > 0)) {
t[r] = e[r];
break;
}
n = l(n, t[r - 1], 1);
}
t[r] = ["S"].concat(
n.reduce(function (t, e) {
return t.concat(e);
}, []),
);
break;
default:
t[r] = e[r];
}
return t;
};
},
function (t, e, n) {
"use strict";
n.d(e, "a", function () {
return s;
}),
n.d(e, "b", function () {
return l;
}),
n.d(e, "c", function () {
return m;
});
var r = n(0),
i = /[MLHVQTCSAZ]([^MLHVQTCSAZ]*)/gi,
o = /[^\s\,]+/gi;
var a = function (t) {
var e = t || [];
return Object(r.m)(e)
? e
: Object(r.x)(e)
? ((e = e.match(i)),
Object(r.e)(e, function (t, n) {
if ((t = t.match(o))[0].length > 1) {
var i = t[0].charAt(0);
t.splice(1, 0, t[0].substr(1)), (t[0] = i);
}
Object(r.e)(t, function (e, n) {
isNaN(e) || (t[n] = +e);
}),
(e[n] = t);
}),
e)
: void 0;
};
function s(t, e) {
for (var n = [], r = 0, i = t.length; i - 2 * !e > r; r += 2) {
var o = [
{ x: +t[r - 2], y: +t[r - 1] },
{ x: +t[r], y: +t[r + 1] },
{ x: +t[r + 2], y: +t[r + 3] },
{ x: +t[r + 4], y: +t[r + 5] },
];
e
? r
? i - 4 === r
? (o[3] = { x: +t[0], y: +t[1] })
: i - 2 === r &&
((o[2] = { x: +t[0], y: +t[1] }),
(o[3] = { x: +t[2], y: +t[3] }))
: (o[0] = { x: +t[i - 2], y: +t[i - 1] })
: i - 4 === r
? (o[3] = o[2])
: r || (o[0] = { x: +t[r], y: +t[r + 1] }),
n.push([
"C",
(-o[0].x + 6 * o[1].x + o[2].x) / 6,
(-o[0].y + 6 * o[1].y + o[2].y) / 6,
(o[1].x + 6 * o[2].x - o[3].x) / 6,
(o[1].y + 6 * o[2].y - o[3].y) / 6,
o[2].x,
o[2].y,
]);
}
return n;
}
var u = "\t\n\v\f\r \u2028\u2029",
c = new RegExp(
"([a-z])[" +
u +
",]*((-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?[" +
u +
"]*,?[" +
u +
"]*)+)",
"ig",
),
h = new RegExp(
"(-?\\d*\\.?\\d*(?:e[\\-+]?\\d+)?)[" + u + "]*,?[" + u + "]*",
"ig",
);
function l(t) {
if (!t) return null;
if (Object(r.m)(t)) return t;
var e = {
a: 7,
c: 6,
o: 2,
h: 1,
l: 2,
m: 2,
r: 4,
q: 4,
s: 4,
t: 2,
v: 1,
u: 3,
z: 0,
},
n = [];
return (
String(t).replace(c, function (t, r, i) {
var o = [],
a = r.toLowerCase();
if (
(i.replace(h, function (t, e) {
e && o.push(+e);
}),
"m" === a &&
o.length > 2 &&
(n.push([r].concat(o.splice(0, 2))),
(a = "l"),
(r = "m" === r ? "l" : "L")),
"o" === a && 1 === o.length && n.push([r, o[0]]),
"r" === a)
)
n.push([r].concat(o));
else
for (
;
o.length >= e[a] &&
(n.push([r].concat(o.splice(0, e[a]))), e[a]);
);
return "";
}),
n
);
}
function d(t) {
return Math.sqrt(t[0] * t[0] + t[1] * t[1]);
}
function f(t, e) {
return d(t) * d(e) ? (t[0] * e[0] + t[1] * e[1]) / (d(t) * d(e)) : 1;
}
function p(t, e) {
return (t[0] * e[1] < t[1] * e[0] ? -1 : 1) * Math.acos(f(t, e));
}
function g(t, e) {
return t[0] === e[0] && t[1] === e[1];
}
function y(t, e) {
var n = e[1],
i = e[2],
o = Object(r.D)(Object(r.H)(e[3]), 2 * Math.PI),
a = e[4],
s = e[5],
u = t[0],
c = t[1],
h = e[6],
l = e[7],
d = (Math.cos(o) * (u - h)) / 2 + (Math.sin(o) * (c - l)) / 2,
y = (-1 * Math.sin(o) * (u - h)) / 2 + (Math.cos(o) * (c - l)) / 2,
v = (d * d) / (n * n) + (y * y) / (i * i);
v > 1 && ((n *= Math.sqrt(v)), (i *= Math.sqrt(v)));
var m = n * n * (y * y) + i * i * (d * d),
b = m ? Math.sqrt((n * n * (i * i) - m) / m) : 1;
a === s && (b *= -1), isNaN(b) && (b = 0);
var x = i ? (b * n * y) / i : 0,
w = n ? (b * -i * d) / n : 0,
O = (u + h) / 2 + Math.cos(o) * x - Math.sin(o) * w,
M = (c + l) / 2 + Math.sin(o) * x + Math.cos(o) * w,
S = [(d - x) / n, (y - w) / i],
C = [(-1 * d - x) / n, (-1 * y - w) / i],
j = p([1, 0], S),
k = p(S, C);
return (
f(S, C) <= -1 && (k = Math.PI),
f(S, C) >= 1 && (k = 0),
0 === s && k > 0 && (k -= 2 * Math.PI),
1 === s && k < 0 && (k += 2 * Math.PI),
{
cx: O,
cy: M,
rx: g(t, [h, l]) ? 0 : n,
ry: g(t, [h, l]) ? 0 : i,
startAngle: j,
endAngle: j + k,
xRotation: o,
arcFlag: a,
sweepFlag: s,
}
);
}
function v(t, e) {
return [e[0] + (e[0] - t[0]), e[1] + (e[1] - t[1])];
}
function m(t) {
for (
var e = [],
n = null,
r = null,
i = null,
o = 0,
s = (t = a(t)).length,
u = 0;
u < s;
u++
) {
var c = t[u];
r = t[u + 1];
var h = c[0],
l = {
command: h,
prePoint: n,
params: c,
startTangent: null,
endTangent: null,
};
switch (h) {
case "M":
(i = [c[1], c[2]]), (o = u);
break;
case "A":
var d = y(n, c);
l.arcParams = d;
}
if ("Z" === h) (n = i), (r = t[o + 1]);
else {
var f = c.length;
n = [c[f - 2], c[f - 1]];
}
r && "Z" === r[0] && ((r = t[o]), e[o] && (e[o].prePoint = n)),
(l.currentPoint = n),
e[o] && g(n, e[o].currentPoint) && (e[o].prePoint = l.prePoint);
var p = r ? [r[r.length - 2], r[r.length - 1]] : null;
l.nextPoint = p;
var m = l.prePoint;
if (["L", "H", "V"].includes(h))
(l.startTangent = [m[0] - n[0], m[1] - n[1]]),
(l.endTangent = [n[0] - m[0], n[1] - m[1]]);
else if ("Q" === h) {
var b = [c[1], c[2]];
(l.startTangent = [m[0] - b[0], m[1] - b[1]]),
(l.endTangent = [n[0] - b[0], n[1] - b[1]]);
} else if ("T" === h) {
b = v((O = e[u - 1]).currentPoint, m);
"Q" === O.command
? ((l.command = "Q"),
(l.startTangent = [m[0] - b[0], m[1] - b[1]]),
(l.endTangent = [n[0] - b[0], n[1] - b[1]]))
: ((l.command = "TL"),
(l.startTangent = [m[0] - n[0], m[1] - n[1]]),
(l.endTangent = [n[0] - m[0], n[1] - m[1]]));
} else if ("C" === h) {
var x = [c[1], c[2]],
w = [c[3], c[4]];
(l.startTangent = [m[0] - x[0], m[1] - x[1]]),
(l.endTangent = [n[0] - w[0], n[1] - w[1]]);
} else if ("S" === h) {
var O;
(x = v((O = e[u - 1]).currentPoint, m)), (w = [c[1], c[2]]);
"C" === O.command
? ((l.command = "C"),
(l.startTangent = [m[0] - x[0], m[1] - x[1]]),
(l.endTangent = [n[0] - w[0], n[1] - w[1]]))
: ((l.command = "SQ"),
(l.startTangent = [m[0] - w[0], m[1] - w[1]]),
(l.endTangent = [n[0] - w[0], n[1] - w[1]]));
} else if ("A" === h) {
var M = 0.001,
S = l.arcParams || {},
C = S.cx,
j = void 0 === C ? 0 : C,
k = S.cy,
E = void 0 === k ? 0 : k,
N = S.rx,
T = void 0 === N ? 0 : N,
P = S.ry,
I = void 0 === P ? 0 : P,
B = S.sweepFlag,
A = void 0 === B ? 0 : B,
L = S.startAngle,
D = void 0 === L ? 0 : L,
_ = S.endAngle,
R = void 0 === _ ? 0 : _;
0 === A && (M *= -1);
var Y = T * Math.cos(D - M) + j,
F = I * Math.sin(D - M) + E;
l.startTangent = [Y - i[0], F - i[1]];
var z = T * Math.cos(D + R + M) + j,
X = I * Math.sin(D + R - M) + E;
l.endTangent = [m[0] - z, m[1] - X];
}
e.push(l);
}
return e;
}
},
function (t, e, n) {
"use strict";
n.d(e, "b", function () {
return o;
}),
n.d(e, "c", function () {
return a;
}),
n.d(e, "a", function () {
return s;
});
var r = n(3),
i = n(12);
function o(t, e, n) {
var i = 1;
return (
Object(r.h)(t) && (i = t.split("\n").length),
i > 1
? e * i +
(function (t, e) {
return e ? e - t : 0.14 * t;
})(e, n) *
(i - 1)
: e
);
}
function a(t, e) {
var n = Object(i.a)(),
o = 0;
if (Object(r.e)(t) || "" === t) return o;
if ((n.save(), (n.font = e), Object(r.h)(t) && t.includes("\n"))) {
var a = t.split("\n");
Object(r.a)(a, function (t) {
var e = n.measureText(t).width;
o < e && (o = e);
});
} else o = n.measureText(t).width;
return n.restore(), o;
}
function s(t) {
var e = t.fontSize,
n = t.fontFamily,
r = t.fontWeight;
return [t.fontStyle, t.fontVariant, r, e + "px", n].join(" ").trim();
}
},
function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "create", function () {
return i;
}),
n.d(e, "clone", function () {
return o;
}),
n.d(e, "fromValues", function () {
return a;
}),
n.d(e, "copy", function () {
return s;
}),
n.d(e, "set", function () {
return u;
}),
n.d(e, "add", function () {
return c;
}),
n.d(e, "subtract", function () {
return h;
}),
n.d(e, "multiply", function () {
return l;
}),
n.d(e, "divide", function () {
return d;
}),
n.d(e, "ceil", function () {
return f;
}),
n.d(e, "floor", function () {
return p;
}),
n.d(e, "min", function () {
return g;
}),
n.d(e, "max", function () {
return y;
}),
n.d(e, "round", function () {
return v;
}),
n.d(e, "scale", function () {
return m;
}),
n.d(e, "scaleAndAdd", function () {
return b;
}),
n.d(e, "distance", function () {
return x;
}),
n.d(e, "squaredDistance", function () {
return w;
}),
n.d(e, "length", function () {
return O;
}),
n.d(e, "squaredLength", function () {
return M;
}),
n.d(e, "negate", function () {
return S;
}),
n.d(e, "inverse", function () {
return C;
}),
n.d(e, "normalize", function () {
return j;
}),
n.d(e, "dot", function () {
return k;
}),
n.d(e, "cross", function () {
return E;
}),
n.d(e, "lerp", function () {
return N;
}),
n.d(e, "random", function () {
return T;
}),
n.d(e, "transformMat2", function () {
return P;
}),
n.d(e, "transformMat2d", function () {
return I;
}),
n.d(e, "transformMat3", function () {
return B;
}),
n.d(e, "transformMat4", function () {
return A;
}),
n.d(e, "rotate", function () {
return L;
}),
n.d(e, "angle", function () {
return D;
}),
n.d(e, "zero", function () {
return _;
}),
n.d(e, "str", function () {
return R;
}),
n.d(e, "exactEquals", function () {
return Y;
}),
n.d(e, "equals", function () {
return F;
}),
n.d(e, "len", function () {
return X;
}),
n.d(e, "sub", function () {
return W;
}),
n.d(e, "mul", function () {
return G;
}),
n.d(e, "div", function () {
return q;
}),
n.d(e, "dist", function () {
return H;
}),
n.d(e, "sqrDist", function () {
return V;
}),
n.d(e, "sqrLen", function () {
return U;
}),
n.d(e, "forEach", function () {
return Z;
});
var r = n(4);
function i() {
var t = new r.a(2);
return r.a != Float32Array && ((t[0] = 0), (t[1] = 0)), t;
}
function o(t) {
var e = new r.a(2);
return (e[0] = t[0]), (e[1] = t[1]), e;
}
function a(t, e) {
var n = new r.a(2);
return (n[0] = t), (n[1] = e), n;
}
function s(t, e) {
return (t[0] = e[0]), (t[1] = e[1]), t;
}
function u(t, e, n) {
return (t[0] = e), (t[1] = n), t;
}
function c(t, e, n) {
return (t[0] = e[0] + n[0]), (t[1] = e[1] + n[1]), t;
}
function h(t, e, n) {
return (t[0] = e[0] - n[0]), (t[1] = e[1] - n[1]), t;
}
function l(t, e, n) {
return (t[0] = e[0] * n[0]), (t[1] = e[1] * n[1]), t;
}
function d(t, e, n) {
return (t[0] = e[0] / n[0]), (t[1] = e[1] / n[1]), t;
}
function f(t, e) {
return (t[0] = Math.ceil(e[0])), (t[1] = Math.ceil(e[1])), t;
}
function p(t, e) {
return (t[0] = Math.floor(e[0])), (t[1] = Math.floor(e[1])), t;
}
function g(t, e, n) {
return (t[0] = Math.min(e[0], n[0])), (t[1] = Math.min(e[1], n[1])), t;
}
function y(t, e, n) {
return (t[0] = Math.max(e[0], n[0])), (t[1] = Math.max(e[1], n[1])), t;
}
function v(t, e) {
return (t[0] = Math.round(e[0])), (t[1] = Math.round(e[1])), t;
}
function m(t, e, n) {
return (t[0] = e[0] * n), (t[1] = e[1] * n), t;
}
function b(t, e, n, r) {
return (t[0] = e[0] + n[0] * r), (t[1] = e[1] + n[1] * r), t;
}
function x(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1];
return Math.hypot(n, r);
}
function w(t, e) {
var n = e[0] - t[0],
r = e[1] - t[1];
return n * n + r * r;
}
function O(t) {
var e = t[0],
n = t[1];
return Math.hypot(e, n);
}
function M(t) {
var e = t[0],
n = t[1];
return e * e + n * n;
}
function S(t, e) {
return (t[0] = -e[0]), (t[1] = -e[1]), t;
}
function C(t, e) {
return (t[0] = 1 / e[0]), (t[1] = 1 / e[1]), t;
}
function j(t, e) {
var n = e[0],
r = e[1],
i = n * n + r * r;
return (
i > 0 && (i = 1 / Math.sqrt(i)),
(t[0] = e[0] * i),
(t[1] = e[1] * i),
t
);
}
function k(t, e) {
return t[0] * e[0] + t[1] * e[1];
}
function E(t, e, n) {
var r = e[0] * n[1] - e[1] * n[0];
return (t[0] = t[1] = 0), (t[2] = r), t;
}
function N(t, e, n, r) {
var i = e[0],
o = e[1];
return (t[0] = i + r * (n[0] - i)), (t[1] = o + r * (n[1] - o)), t;
}
function T(t, e) {
e = e || 1;
var n = 2 * r.c() * Math.PI;
return (t[0] = Math.cos(n) * e), (t[1] = Math.sin(n) * e), t;
}
function P(t, e, n) {
var r = e[0],
i = e[1];
return (t[0] = n[0] * r + n[2] * i), (t[1] = n[1] * r + n[3] * i), t;
}
function I(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[2] * i + n[4]),
(t[1] = n[1] * r + n[3] * i + n[5]),
t
);
}
function B(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[3] * i + n[6]),
(t[1] = n[1] * r + n[4] * i + n[7]),
t
);
}
function A(t, e, n) {
var r = e[0],
i = e[1];
return (
(t[0] = n[0] * r + n[4] * i + n[12]),
(t[1] = n[1] * r + n[5] * i + n[13]),
t
);
}
function L(t, e, n, r) {
var i = e[0] - n[0],
o = e[1] - n[1],
a = Math.sin(r),
s = Math.cos(r);
return (t[0] = i * s - o * a + n[0]), (t[1] = i * a + o * s + n[1]), t;
}
function D(t, e) {
var n = t[0],
r = t[1],
i = e[0],
o = e[1],
a = Math.sqrt(n * n + r * r) * Math.sqrt(i * i + o * o),
s = a && (n * i + r * o) / a;
return Math.acos(Math.min(Math.max(s, -1), 1));
}
function _(t) {
return (t[0] = 0), (t[1] = 0), t;
}
function R(t) {
return "vec2(" + t[0] + ", " + t[1] + ")";
}
function Y(t, e) {
return t[0] === e[0] && t[1] === e[1];
}
function F(t, e) {
var n = t[0],
i = t[1],
o = e[0],
a = e[1];
return (
Math.abs(n - o) <= r.b * Math.max(1, Math.abs(n), Math.abs(o)) &&
Math.abs(i - a) <= r.b * Math.max(1, Math.abs(i), Math.abs(a))
);
}
var z,
X = O,
W = h,
G = l,
q = d,
H = x,
V = w,
U = M,
Z =
((z = i()),
function (t, e, n, r, i, o) {
var a, s;
for (
e || (e = 2),
n || (n = 0),
s = r ? Math.min(r * e + n, t.length) : t.length,
a = n;
a < s;
a += e
)
(z[0] = t[a]),
(z[1] = t[a + 1]),
i(z, z, o),
(t[a] = z[0]),
(t[a + 1] = z[1]);
return t;
});
},
function (t, e, n) {
"use strict";
var r = (function () {
function t(t, e) {
(this.bubbles = !0),
(this.target = null),
(this.currentTarget = null),
(this.delegateTarget = null),
(this.delegateObject = null),
(this.defaultPrevented = !1),
(this.propagationStopped = !1),
(this.shape = null),
(this.fromShape = null),
(this.toShape = null),
(this.propagationPath = []),
(this.type = t),
(this.name = t),
(this.originalEvent = e),
(this.timeStamp = e.timeStamp);
}
return (
(t.prototype.preventDefault = function () {
(this.defaultPrevented = !0),
this.originalEvent.preventDefault &&
this.originalEvent.preventDefault();
}),
(t.prototype.stopPropagation = function () {
this.propagationStopped = !0;
}),
(t.prototype.toString = function () {
return "[Event (type=" + this.type + ")]";
}),
(t.prototype.save = function () {}),
(t.prototype.restore = function () {}),
t
);
})();
e.a = r;
},
function (t, e, n) {
"use strict";
var r = n(1),
i = n(14),
o = n(3),
a = (function (t) {
function e(e) {
var n = t.call(this) || this;
n.destroyed = !1;
var r = n.getDefaultCfg();
return (n.cfg = Object(o.i)(r, e)), n;
}
return (
Object(r.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return {};
}),
(e.prototype.get = function (t) {
return this.cfg[t];
}),
(e.prototype.set = function (t, e) {
this.cfg[t] = e;
}),
(e.prototype.destroy = function () {
(this.cfg = { destroyed: !0 }), this.off(), (this.destroyed = !0);
}),
e
);
})(i.a);
e.a = a;
},
function (t, e, n) {
"use strict";
n.d(e, "a", function () {
return i;
});
var r = null;
function i() {
if (!r) {
var t = document.createElement("canvas");
(t.width = 1), (t.height = 1), (r = t.getContext("2d"));
}
return r;
}
},
function (t, e, n) {
"use strict";
n(6), n(17), n(18);
var r = n(10);
n.d(e, "Event", function () {
return r.a;
});
n(11), n(21), n(19), n(20), n(22);
var i = n(8);
n.d(e, "assembleFont", function () {
return i.a;
});
n(3), n(5), n(12);
},
function (t, e, n) {
"use strict";
var r = (function () {
function t() {
this._events = {};
}
return (
(t.prototype.on = function (t, e, n) {
return (
this._events[t] || (this._events[t] = []),
this._events[t].push({ callback: e, once: !!n }),
this
);
}),
(t.prototype.once = function (t, e) {
return this.on(t, e, !0), this;
}),
(t.prototype.emit = function (t) {
for (var e = this, n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
var i = this._events[t] || [],
o = this._events["*"] || [],
a = function (r) {
for (var i = r.length, o = 0; o < i; o++)
if (r[o]) {
var a = r[o],
s = a.callback;
a.once &&
(r.splice(o, 1),
0 === r.length && delete e._events[t],
i--,
o--),
s.apply(e, n);
}
};
a(i), a(o);
}),
(t.prototype.off = function (t, e) {
if (t)
if (e) {
for (
var n = this._events[t] || [], r = n.length, i = 0;
i < r;
i++
)
n[i].callback === e && (n.splice(i, 1), r--, i--);
0 === n.length && delete this._events[t];
} else delete this._events[t];
else this._events = {};
return this;
}),
(t.prototype.getEvents = function () {
return this._events;
}),
t
);
})();
e.a = r;
},
function (t, e, n) {
"use strict";
var r = n(1),
i = n(0),
o = n(16),
a = n(3),
s = {};
var u = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(r.c)(e, t),
(e.prototype.isCanvas = function () {
return !1;
}),
(e.prototype.getBBox = function () {
var t = 1 / 0,
e = -1 / 0,
n = 1 / 0,
r = -1 / 0,
o = [],
s = [],
u = this.getChildren().filter(function (t) {
return (
t.get("visible") &&
(!t.isGroup() || (t.isGroup() && t.getChildren().length > 0))
);
});
return (
u.length > 0
? (Object(a.a)(u, function (t) {
var e = t.getBBox();
o.push(e.minX, e.maxX), s.push(e.minY, e.maxY);
}),
(t = Object(i.B)(o)),
(e = Object(i.A)(o)),
(n = Object(i.B)(s)),
(r = Object(i.A)(s)))
: ((t = 0), (e = 0), (n = 0), (r = 0)),
{
x: t,
y: n,
minX: t,
minY: n,
maxX: e,
maxY: r,
width: e - t,
height: r - n,
}
);
}),
(e.prototype.getCanvasBBox = function () {
var t = 1 / 0,
e = -1 / 0,
n = 1 / 0,
r = -1 / 0,
o = [],
s = [],
u = this.getChildren().filter(function (t) {
return (
t.get("visible") &&
(!t.isGroup() || (t.isGroup() && t.getChildren().length > 0))
);
});
return (
u.length > 0
? (Object(a.a)(u, function (t) {
var e = t.getCanvasBBox();
o.push(e.minX, e.maxX), s.push(e.minY, e.maxY);
}),
(t = Object(i.B)(o)),
(e = Object(i.A)(o)),
(n = Object(i.B)(s)),
(r = Object(i.A)(s)))
: ((t = 0), (e = 0), (n = 0), (r = 0)),
{
x: t,
y: n,
minX: t,
minY: n,
maxX: e,
maxY: r,
width: e - t,
height: r - n,
}
);
}),
(e.prototype.getDefaultCfg = function () {
var e = t.prototype.getDefaultCfg.call(this);
return (e.children = []), e;
}),
(e.prototype.onAttrChange = function (e, n, r) {
if (
(t.prototype.onAttrChange.call(this, e, n, r), "matrix" === e)
) {
var i = this.getTotalMatrix();
this._applyChildrenMarix(i);
}
}),
(e.prototype.applyMatrix = function (e) {
var n = this.getTotalMatrix();
t.prototype.applyMatrix.call(this, e);
var r = this.getTotalMatrix();
r !== n && this._applyChildrenMarix(r);
}),
(e.prototype._applyChildrenMarix = function (t) {
var e = this.getChildren();
Object(a.a)(e, function (e) {
e.applyMatrix(t);
});
}),
(e.prototype.addShape = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
var n = t[0],
r = t[1];
Object(a.f)(n) ? (r = n) : (r.type = n);
var i = s[r.type];
i || ((i = Object(a.k)(r.type)), (s[r.type] = i));
var o = this.getShapeBase(),
u = new o[i](r);
return this.add(u), u;
}),
(e.prototype.addGroup = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
var n,
r = t[0],
i = t[1];
if (Object(a.d)(r)) n = new r(i || { parent: this });
else {
var o = r || {},
s = this.getGroupBase();
n = new s(o);
}
return this.add(n), n;
}),
(e.prototype.getCanvas = function () {
return this.isCanvas() ? this : this.get("canvas");
}),
(e.prototype.getShape = function (t, e, n) {
if (!Object(a.b)(this)) return null;
var r,
i = this.getChildren();
if (this.isCanvas()) r = this._findShape(i, t, e, n);
else {
var o = [t, e, 1];
(o = this.invertFromMatrix(o)),
this.isClipped(o[0], o[1]) ||
(r = this._findShape(i, o[0], o[1], n));
}
return r;
}),
(e.prototype._findShape = function (t, e, n, r) {
for (var i = null, o = t.length - 1; o >= 0; o--) {
var s = t[o];
if (
(Object(a.b)(s) &&
(s.isGroup()
? (i = s.getShape(e, n, r))
: s.isHit(e, n) && (i = s)),
i)
)
break;
}
return i;
}),
(e.prototype.add = function (t) {
var e = this.getCanvas(),
n = this.getChildren(),
r = this.get("timeline"),
i = t.getParent();
i &&
(function (t, e, n) {
void 0 === n && (n = !0),
n
? e.destroy()
: (e.set("parent", null), e.set("canvas", null)),
Object(a.j)(t.getChildren(), e);
})(i, t, !1),
t.set("parent", this),
e &&
(function t(e, n) {
if ((e.set("canvas", n), e.isGroup())) {
var r = e.get("children");
r.length &&
r.forEach(function (e) {
t(e, n);
});
}
})(t, e),
r &&
(function t(e, n) {
if ((e.set("timeline", n), e.isGroup())) {
var r = e.get("children");
r.length &&
r.forEach(function (e) {
t(e, n);
});
}
})(t, r),
n.push(t),
t.onCanvasChange("add"),
this._applyElementMatrix(t);
}),
(e.prototype._applyElementMatrix = function (t) {
var e = this.getTotalMatrix();
e && t.applyMatrix(e);
}),
(e.prototype.getChildren = function () {
return this.get("children");
}),
(e.prototype.sort = function () {
var t,
e = this.getChildren();
Object(a.a)(e, function (t, e) {
return (t._INDEX = e), t;
}),
e.sort(
((t = function (t, e) {
return t.get("zIndex") - e.get("zIndex");
}),
function (e, n) {
var r = t(e, n);
return 0 === r ? e._INDEX - n._INDEX : r;
}),
),
this.onCanvasChange("sort");
}),
(e.prototype.clear = function () {
if ((this.set("clearing", !0), !this.destroyed)) {
for (var t = this.getChildren(), e = t.length - 1; e >= 0; e--)
t[e].destroy();
this.set("children", []),
this.onCanvasChange("clear"),
this.set("clearing", !1);
}
}),
(e.prototype.destroy = function () {
this.get("destroyed") ||
(this.clear(), t.prototype.destroy.call(this));
}),
(e.prototype.getFirst = function () {
return this.getChildByIndex(0);
}),
(e.prototype.getLast = function () {
var t = this.getChildren();
return this.getChildByIndex(t.length - 1);
}),
(e.prototype.getChildByIndex = function (t) {
return this.getChildren()[t];
}),
(e.prototype.getCount = function () {
return this.getChildren().length;
}),
(e.prototype.contain = function (t) {
return this.getChildren().indexOf(t) > -1;
}),
(e.prototype.removeChild = function (t, e) {
void 0 === e && (e = !0), this.contain(t) && t.remove(e);
}),
(e.prototype.findAll = function (t) {
var e = [],
n = this.getChildren();
return (
Object(a.a)(n, function (n) {
t(n) && e.push(n), n.isGroup() && (e = e.concat(n.findAll(t)));
}),
e
);
}),
(e.prototype.find = function (t) {
var e = null,
n = this.getChildren();
return (
Object(a.a)(n, function (n) {
if ((t(n) ? (e = n) : n.isGroup() && (e = n.find(t)), e))
return !1;
}),
e
);
}),
(e.prototype.findById = function (t) {
return this.find(function (e) {
return e.get("id") === t;
});
}),
(e.prototype.findByClassName = function (t) {
return this.find(function (e) {
return e.get("className") === t;
});
}),
(e.prototype.findAllByName = function (t) {
return this.findAll(function (e) {
return e.get("name") === t;
});
}),
e
);
})(o.a);
e.a = u;
},
function (t, e, n) {
"use strict";
var r = n(1),
i = n(0),
o = n(2),
a = n(3),
s = n(5),
u = n(11),
c = o.a.transform,
h = ["zIndex", "capture", "visible", "type"],
l = ["repeat"];
function d(t, e) {
var n = {},
r = e.attrs;
for (var i in t) n[i] = r[i];
return n;
}
function f(t, e) {
var n = {},
r = e.attr();
return (
Object(i.e)(t, function (t, e) {
-1 !== l.indexOf(e) || Object(i.q)(r[e], t) || (n[e] = t);
}),
n
);
}
function p(t, e) {
if (e.onFrame) return t;
var n = e.startTime,
r = e.delay,
o = e.duration,
a = Object.prototype.hasOwnProperty;
return (
Object(i.e)(t, function (t) {
n + r < t.startTime + t.delay + t.duration &&
o > t.delay &&
Object(i.e)(e.toAttrs, function (e, n) {
a.call(t.toAttrs, n) &&
(delete t.toAttrs[n], delete t.fromAttrs[n]);
});
}),
t
);
}
var g = (function (t) {
function e(e) {
var n = t.call(this, e) || this;
n.attrs = {};
var r = n.getDefaultAttrs();
return (
Object(i.C)(r, e.attrs),
(n.attrs = r),
n.initAttrs(r),
n.initAnimate(),
n
);
}
return (
Object(r.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return { visible: !0, capture: !0, zIndex: 0 };
}),
(e.prototype.getDefaultAttrs = function () {
return { matrix: this.getDefaultMatrix(), opacity: 1 };
}),
(e.prototype.onCanvasChange = function (t) {}),
(e.prototype.initAttrs = function (t) {}),
(e.prototype.initAnimate = function () {
this.set("animable", !0), this.set("animating", !1);
}),
(e.prototype.isGroup = function () {
return !1;
}),
(e.prototype.getParent = function () {
return this.get("parent");
}),
(e.prototype.getCanvas = function () {
return this.get("canvas");
}),
(e.prototype.attr = function () {
for (var t, e = [], n = 0; n < arguments.length; n++)
e[n] = arguments[n];
var r = e[0],
o = e[1];
if (!r) return this.attrs;
if (Object(i.v)(r)) {
for (var a in r) this.setAttr(a, r[a]);
return this.afterAttrsChange(r), this;
}
return 2 === e.length
? (this.setAttr(r, o),
this.afterAttrsChange((((t = {})[r] = o), t)),
this)
: this.attrs[r];
}),
(e.prototype.isClipped = function (t, e) {
var n = this.getClip();
return n && !n.isHit(t, e);
}),
(e.prototype.setAttr = function (t, e) {
var n = this.attrs[t];
n !== e && ((this.attrs[t] = e), this.onAttrChange(t, e, n));
}),
(e.prototype.onAttrChange = function (t, e, n) {
"matrix" === t && this.set("totalMatrix", null);
}),
(e.prototype.afterAttrsChange = function (t) {
if (this.cfg.isClipShape) {
var e = this.cfg.applyTo;
e && e.onCanvasChange("clip");
} else this.onCanvasChange("attr");
}),
(e.prototype.show = function () {
return this.set("visible", !0), this.onCanvasChange("show"), this;
}),
(e.prototype.hide = function () {
return this.set("visible", !1), this.onCanvasChange("hide"), this;
}),
(e.prototype.setZIndex = function (t) {
this.set("zIndex", t);
var e = this.getParent();
return e && e.sort(), this;
}),
(e.prototype.toFront = function () {
var t = this.getParent();
if (t) {
var e = t.getChildren(),
n = (this.get("el"), e.indexOf(this));
e.splice(n, 1), e.push(this), this.onCanvasChange("zIndex");
}
}),
(e.prototype.toBack = function () {
var t = this.getParent();
if (t) {
var e = t.getChildren(),
n = (this.get("el"), e.indexOf(this));
e.splice(n, 1), e.unshift(this), this.onCanvasChange("zIndex");
}
}),
(e.prototype.remove = function (t) {
void 0 === t && (t = !0);
var e = this.getParent();
e
? (Object(a.j)(e.getChildren(), this),
e.get("clearing") || this.onCanvasChange("remove"))
: this.onCanvasChange("remove"),
t && this.destroy();
}),
(e.prototype.resetMatrix = function () {
this.attr("matrix", this.getDefaultMatrix()),
this.onCanvasChange("matrix");
}),
(e.prototype.getMatrix = function () {
return this.attr("matrix");
}),
(e.prototype.setMatrix = function (t) {
this.attr("matrix", t), this.onCanvasChange("matrix");
}),
(e.prototype.getTotalMatrix = function () {
var t = this.cfg.totalMatrix;
if (!t) {
var e = this.attr("matrix"),
n = this.cfg.parentMatrix;
(t = n && e ? Object(s.b)(n, e) : e || n),
this.set("totalMatrix", t);
}
return t;
}),
(e.prototype.applyMatrix = function (t) {
var e = this.attr("matrix"),
n = null;
(n = t && e ? Object(s.b)(t, e) : e || t),
this.set("totalMatrix", n),
this.set("parentMatrix", t);
}),
(e.prototype.getDefaultMatrix = function () {
return null;
}),
(e.prototype.applyToMatrix = function (t) {
var e = this.attr("matrix");
return e ? Object(s.c)(e, t) : t;
}),
(e.prototype.invertFromMatrix = function (t) {
var e = this.attr("matrix");
if (e) {
var n = Object(s.a)(e);
if (n) return Object(s.c)(n, t);
}
return t;
}),
(e.prototype.setClip = function (t) {
var e = this.getCanvas(),
n = null;
if (t) {
var r = this.getShapeBase()[Object(i.J)(t.type)];
r &&
(n = new r({
type: t.type,
isClipShape: !0,
applyTo: this,
attrs: t.attrs,
canvas: e,
}));
}
return this.set("clipShape", n), this.onCanvasChange("clip"), n;
}),
(e.prototype.getClip = function () {
var t = this.cfg.clipShape;
return t || null;
}),
(e.prototype.clone = function () {
var t = this,
e = this.attrs,
n = {};
Object(i.e)(e, function (t, r) {
Object(i.m)(e[r])
? (n[r] = (function (t) {
for (var e = [], n = 0; n < t.length; n++)
Object(i.m)(t[n])
? e.push([].concat(t[n]))
: e.push(t[n]);
return e;
})(e[r]))
: (n[r] = e[r]);
});
var r = new (0, this.constructor)({ attrs: n });
return (
Object(i.e)(h, function (e) {
r.set(e, t.get(e));
}),
r
);
}),
(e.prototype.destroy = function () {
this.destroyed ||
((this.attrs = {}), t.prototype.destroy.call(this));
}),
(e.prototype.isAnimatePaused = function () {
return this.get("_pause").isPaused;
}),
(e.prototype.animate = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
if (this.get("timeline") || this.get("canvas")) {
this.set("animating", !0);
var n = this.get("timeline");
n ||
((n = this.get("canvas").get("timeline")),
this.set("timeline", n));
var r = this.get("animations") || [];
n.timer || n.initTimer();
var o,
a,
s,
u,
c,
h = t[0],
l = t[1],
g = t[2],
y = void 0 === g ? "easeLinear" : g,
v = t[3],
m = void 0 === v ? i.E : v,
b = t[4],
x = void 0 === b ? 0 : b;
Object(i.r)(h)
? ((o = h), (h = {}))
: Object(i.v)(h) &&
h.onFrame &&
((o = h.onFrame), (a = h.repeat)),
Object(i.v)(l)
? ((l = (c = l).duration),
(y = c.easing || "easeLinear"),
(x = c.delay || 0),
(a = c.repeat || a || !1),
(m = c.callback || i.E),
(s = c.pauseCallback || i.E),
(u = c.resumeCallback || i.E))
: (Object(i.t)(m) && ((x = m), (m = null)),
Object(i.r)(y)
? ((m = y), (y = "easeLinear"))
: (y = y || "easeLinear"));
var w = f(h, this),
O = {
fromAttrs: d(w, this),
toAttrs: w,
duration: l,
easing: y,
repeat: a,
callback: m,
pauseCallback: s,
resumeCallback: u,
delay: x,
startTime: n.getTime(),
id: Object(i.I)(),
onFrame: o,
pathFormatted: !1,
};
r.length > 0 ? (r = p(r, O)) : n.addAnimator(this),
r.push(O),
this.set("animations", r),
this.set("_pause", { isPaused: !1 });
}
}),
(e.prototype.stopAnimate = function (t) {
var e = this;
void 0 === t && (t = !0);
var n = this.get("animations");
Object(i.e)(n, function (n) {
t && (n.onFrame ? e.attr(n.onFrame(1)) : e.attr(n.toAttrs)),
n.callback && n.callback();
}),
this.set("animating", !1),
this.set("animations", []);
}),
(e.prototype.pauseAnimate = function () {
var t = this.get("timeline"),
e = this.get("animations"),
n = t.getTime();
return (
Object(i.e)(e, function (t) {
(t._paused = !0),
(t._pauseTime = n),
t.pauseCallback && t.pauseCallback();
}),
this.set("_pause", { isPaused: !0, pauseTime: n }),
this
);
}),
(e.prototype.resumeAnimate = function () {
var t = this.get("timeline").getTime(),
e = this.get("animations"),
n = this.get("_pause").pauseTime;
return (
Object(i.e)(e, function (e) {
(e.startTime = e.startTime + (t - n)),
(e._paused = !1),
(e._pauseTime = null),
e.resumeCallback && e.resumeCallback();
}),
this.set("_pause", { isPaused: !1 }),
this.set("animations", e),
this
);
}),
(e.prototype.emitDelegation = function (t, e) {
var n,
r = this,
o = e.propagationPath;
this.getEvents();
"mouseenter" === t
? (n = e.fromShape)
: "mouseleave" === t && (n = e.toShape);
for (
var s = function (t) {
var s = o[t],
c = s.get("name");
if (c) {
if (
(s.isGroup() || (s.isCanvas && s.isCanvas())) &&
n &&
Object(a.g)(s, n)
)
return "break";
Object(i.m)(c)
? Object(i.e)(c, function (t) {
r.emitDelegateEvent(s, t, e);
})
: u.emitDelegateEvent(s, c, e);
}
},
u = this,
c = 0;
c < o.length;
c++
) {
if ("break" === s(c)) break;
}
}),
(e.prototype.emitDelegateEvent = function (t, e, n) {
var r = this.getEvents(),
i = e + ":" + n.type;
(r[i] || r["*"]) &&
((n.name = i),
(n.currentTarget = t),
(n.delegateTarget = this),
(n.delegateObject = t.get("delegateObject")),
this.emit(i, n));
}),
(e.prototype.translate = function (t, e) {
void 0 === t && (t = 0), void 0 === e && (e = 0);
var n = this.getMatrix(),
r = c(n, [["t", t, e]]);
return this.setMatrix(r), this;
}),
(e.prototype.move = function (t, e) {
var n = this.attr("x") || 0,
r = this.attr("y") || 0;
return this.translate(t - n, e - r), this;
}),
(e.prototype.moveTo = function (t, e) {
return this.move(t, e);
}),
(e.prototype.scale = function (t, e) {
var n = this.getMatrix(),
r = c(n, [["s", t, e || t]]);
return this.setMatrix(r), this;
}),
(e.prototype.rotate = function (t) {
var e = this.getMatrix(),
n = c(e, [["r", t]]);
return this.setMatrix(n), this;
}),
(e.prototype.rotateAtStart = function (t) {
var e = this.attr(),
n = e.x,
r = e.y,
i = this.getMatrix(),
o = c(i, [
["t", -n, -r],
["r", t],
["t", n, r],
]);
return this.setMatrix(o), this;
}),
(e.prototype.rotateAtPoint = function (t, e, n) {
var r = this.getMatrix(),
i = c(r, [
["t", -t, -e],
["r", n],
["t", t, e],
]);
return this.setMatrix(i), this;
}),
e
);
})(u.a);
e.a = g;
},
function (t, e) {},
function (t, e) {},
function (t, e, n) {
"use strict";
var r = n(1);
!(function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
Object(r.c)(e, t),
(e.prototype.isGroup = function () {
return !0;
}),
(e.prototype.isEntityGroup = function () {
return !1;
}),
(e.prototype.clone = function () {
for (
var e = t.prototype.clone.call(this),
n = this.getChildren(),
r = 0;
r < n.length;
r++
) {
var i = n[r];
e.add(i.clone());
}
return e;
});
})(n(15).a);
},
function (t, e, n) {
"use strict";
var r = n(1),
i = n(16),
o = n(5);
!(function (t) {
function e(e) {
return t.call(this, e) || this;
}
Object(r.c)(e, t),
(e.prototype._isInBBox = function (t, e) {
var n = this.getBBox();
return n.minX <= t && n.maxX >= t && n.minY <= e && n.maxY >= e;
}),
(e.prototype.afterAttrsChange = function (e) {
t.prototype.afterAttrsChange.call(this, e), this.clearCacheBBox();
}),
(e.prototype.getBBox = function () {
var t = this.cfg.bbox;
return t || ((t = this.calculateBBox()), this.set("bbox", t)), t;
}),
(e.prototype.getCanvasBBox = function () {
var t = this.cfg.canvasBBox;
return (
t ||
((t = this.calculateCanvasBBox()), this.set("canvasBBox", t)),
t
);
}),
(e.prototype.applyMatrix = function (e) {
t.prototype.applyMatrix.call(this, e), this.set("canvasBBox", null);
}),
(e.prototype.calculateCanvasBBox = function () {
var t = this.getBBox(),
e = this.getTotalMatrix(),
n = t.minX,
r = t.minY,
i = t.maxX,
a = t.maxY;
if (e) {
var s = Object(o.c)(e, [t.minX, t.minY]),
u = Object(o.c)(e, [t.maxX, t.minY]),
c = Object(o.c)(e, [t.minX, t.maxY]),
h = Object(o.c)(e, [t.maxX, t.maxY]);
(n = Math.min(s[0], u[0], c[0], h[0])),
(i = Math.max(s[0], u[0], c[0], h[0])),
(r = Math.min(s[1], u[1], c[1], h[1])),
(a = Math.max(s[1], u[1], c[1], h[1]));
}
var l = this.attrs;
if (l.shadowColor) {
var d = l.shadowBlur,
f = void 0 === d ? 0 : d,
p = l.shadowOffsetX,
g = void 0 === p ? 0 : p,
y = l.shadowOffsetY,
v = void 0 === y ? 0 : y,
m = n - f + g,
b = i + f + g,
x = r - f + v,
w = a + f + v;
(n = Math.min(n, m)),
(i = Math.max(i, b)),
(r = Math.min(r, x)),
(a = Math.max(a, w));
}
return {
x: n,
y: r,
minX: n,
minY: r,
maxX: i,
maxY: a,
width: i - n,
height: a - r,
};
}),
(e.prototype.clearCacheBBox = function () {
this.set("bbox", null), this.set("canvasBBox", null);
}),
(e.prototype.isClipShape = function () {
return this.get("isClipShape");
}),
(e.prototype.isInShape = function (t, e) {
return !1;
}),
(e.prototype.isOnlyHitBox = function () {
return !1;
}),
(e.prototype.isHit = function (t, e) {
var n = this.get("startArrowShape"),
r = this.get("endArrowShape"),
i = [t, e, 1],
o = (i = this.invertFromMatrix(i))[0],
a = i[1],
s = this._isInBBox(o, a);
if (this.isOnlyHitBox()) return s;
if (s && !this.isClipped(o, a)) {
if (this.isInShape(o, a)) return !0;
if (n && n.isHit(o, a)) return !0;
if (r && r.isHit(o, a)) return !0;
}
return !1;
});
})(i.a);
},
function (t, e, n) {
"use strict";
var r = {};
n.r(r),
n.d(r, "easeLinear", function () {
return k;
}),
n.d(r, "easeQuad", function () {
return T;
}),
n.d(r, "easeQuadIn", function () {
return E;
}),
n.d(r, "easeQuadOut", function () {
return N;
}),
n.d(r, "easeQuadInOut", function () {
return T;
}),
n.d(r, "easeCubic", function () {
return B;
}),
n.d(r, "easeCubicIn", function () {
return P;
}),
n.d(r, "easeCubicOut", function () {
return I;
}),
n.d(r, "easeCubicInOut", function () {
return B;
}),
n.d(r, "easePoly", function () {
return D;
}),
n.d(r, "easePolyIn", function () {
return A;
}),
n.d(r, "easePolyOut", function () {
return L;
}),
n.d(r, "easePolyInOut", function () {
return D;
}),
n.d(r, "easeSin", function () {
return z;
}),
n.d(r, "easeSinIn", function () {
return Y;
}),
n.d(r, "easeSinOut", function () {
return F;
}),
n.d(r, "easeSinInOut", function () {
return z;
}),
n.d(r, "easeExp", function () {
return q;
}),
n.d(r, "easeExpIn", function () {
return W;
}),
n.d(r, "easeExpOut", function () {
return G;
}),
n.d(r, "easeExpInOut", function () {
return q;
}),
n.d(r, "easeCircle", function () {
return U;
}),
n.d(r, "easeCircleIn", function () {
return H;
}),
n.d(r, "easeCircleOut", function () {
return V;
}),
n.d(r, "easeCircleInOut", function () {
return U;
}),
n.d(r, "easeBounce", function () {
return Q;
}),
n.d(r, "easeBounceIn", function () {
return K;
}),
n.d(r, "easeBounceOut", function () {
return Q;
}),
n.d(r, "easeBounceInOut", function () {
return $;
}),
n.d(r, "easeBack", function () {
return et;
}),
n.d(r, "easeBackIn", function () {
return J;
}),
n.d(r, "easeBackOut", function () {
return tt;
}),
n.d(r, "easeBackInOut", function () {
return et;
}),
n.d(r, "easeElastic", function () {
return it;
}),
n.d(r, "easeElasticIn", function () {
return rt;
}),
n.d(r, "easeElasticOut", function () {
return it;
}),
n.d(r, "easeElasticInOut", function () {
return ot;
});
var i = n(1),
o = n(24),
a = n(15),
s = n(3),
u = n(0);
function c(t) {
return (c =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var h,
l,
d = 0,
f = 0,
p = 0,
g = 0,
y = 0,
v = 0,
m =
"object" ===
("undefined" == typeof performance
? "undefined"
: c(performance)) && performance.now
? performance
: Date,
b =
"object" ===
("undefined" == typeof window ? "undefined" : c(window)) &&
window.requestAnimationFrame
? window.requestAnimationFrame.bind(window)
: function (t) {
setTimeout(t, 17);
};
function x() {
return y || (b(w), (y = m.now() + v));
}
function w() {
y = 0;
}
function O() {
this._call = this._time = this._next = null;
}
function M(t, e, n) {
var r = new O();
return r.restart(t, e, n), r;
}
function S() {
(y = (g = m.now()) + v), (d = f = 0);
try {
!(function () {
x(), ++d;
for (var t, e = h; e; )
(t = y - e._time) >= 0 && e._call.call(null, t), (e = e._next);
--d;
})();
} finally {
(d = 0),
(function () {
var t,
e,
n = h,
r = 1 / 0;
for (; n; )
n._call
? (r > n._time && (r = n._time), (t = n), (n = n._next))
: ((e = n._next),
(n._next = null),
(n = t ? (t._next = e) : (h = e)));
(l = t), j(r);
})(),
(y = 0);
}
}
function C() {
var t = m.now(),
e = t - g;
e > 1e3 && ((v -= e), (g = t));
}
function j(t) {
d ||
(f && (f = clearTimeout(f)),
t - y > 24
? (t < 1 / 0 && (f = setTimeout(S, t - m.now() - v)),
p && (p = clearInterval(p)))
: (p || ((g = m.now()), (p = setInterval(C, 1e3))), (d = 1), b(S)));
}
function k(t) {
return +t;
}
function E(t) {
return t * t;
}
function N(t) {
return t * (2 - t);
}
function T(t) {
return ((t *= 2) <= 1 ? t * t : --t * (2 - t) + 1) / 2;
}
function P(t) {
return t * t * t;
}
function I(t) {
return --t * t * t + 1;
}
function B(t) {
return ((t *= 2) <= 1 ? t * t * t : (t -= 2) * t * t + 2) / 2;
}
O.prototype = M.prototype = {
constructor: O,
restart: function (t, e, n) {
if ("function" != typeof t)
throw new TypeError("callback is not a function");
(n = (null == n ? x() : +n) + (null == e ? 0 : +e)),
this._next ||
l === this ||
(l ? (l._next = this) : (h = this), (l = this)),
(this._call = t),
(this._time = n),
j();
},
stop: function () {
this._call && ((this._call = null), (this._time = 1 / 0), j());
},
};
var A = (function t(e) {
function n(t) {
return Math.pow(t, e);
}
return (e = +e), (n.exponent = t), n;
})(3),
L = (function t(e) {
function n(t) {
return 1 - Math.pow(1 - t, e);
}
return (e = +e), (n.exponent = t), n;
})(3),
D = (function t(e) {
function n(t) {
return (
((t *= 2) <= 1 ? Math.pow(t, e) : 2 - Math.pow(2 - t, e)) / 2
);
}
return (e = +e), (n.exponent = t), n;
})(3),
_ = Math.PI,
R = _ / 2;
function Y(t) {
return 1 == +t ? 1 : 1 - Math.cos(t * R);
}
function F(t) {
return Math.sin(t * R);
}
function z(t) {
return (1 - Math.cos(_ * t)) / 2;
}
function X(t) {
return 1.0009775171065494 * (Math.pow(2, -10 * t) - 0.0009765625);
}
function W(t) {
return X(1 - +t);
}
function G(t) {
return 1 - X(t);
}
function q(t) {
return ((t *= 2) <= 1 ? X(1 - t) : 2 - X(t - 1)) / 2;
}
function H(t) {
return 1 - Math.sqrt(1 - t * t);
}
function V(t) {
return Math.sqrt(1 - --t * t);
}
function U(t) {
return (
((t *= 2) <= 1
? 1 - Math.sqrt(1 - t * t)
: Math.sqrt(1 - (t -= 2) * t) + 1) / 2
);
}
var Z = 7.5625;
function K(t) {
return 1 - Q(1 - t);
}
function Q(t) {
return (t = +t) < 4 / 11
? Z * t * t
: t < 8 / 11
? Z * (t -= 6 / 11) * t + 3 / 4
: t < 10 / 11
? Z * (t -= 9 / 11) * t + 15 / 16
: Z * (t -= 21 / 22) * t + 63 / 64;
}
function $(t) {
return ((t *= 2) <= 1 ? 1 - Q(1 - t) : Q(t - 1) + 1) / 2;
}
var J = (function t(e) {
function n(t) {
return (t = +t) * t * (e * (t - 1) + t);
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
tt = (function t(e) {
function n(t) {
return --t * t * ((t + 1) * e + t) + 1;
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
et = (function t(e) {
function n(t) {
return (
((t *= 2) < 1
? t * t * ((e + 1) * t - e)
: (t -= 2) * t * ((e + 1) * t + e) + 2) / 2
);
}
return (e = +e), (n.overshoot = t), n;
})(1.70158),
nt = 2 * Math.PI,
rt = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= nt);
function i(t) {
return e * X(-(--t)) * Math.sin((r - t) / n);
}
return (
(i.amplitude = function (e) {
return t(e, n * nt);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
it = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= nt);
function i(t) {
return 1 - e * X((t = +t)) * Math.sin((t + r) / n);
}
return (
(i.amplitude = function (e) {
return t(e, n * nt);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
ot = (function t(e, n) {
var r = Math.asin(1 / (e = Math.max(1, e))) * (n /= nt);
function i(t) {
return (
((t = 2 * t - 1) < 0
? e * X(-t) * Math.sin((r - t) / n)
: 2 - e * X(t) * Math.sin((r + t) / n)) / 2
);
}
return (
(i.amplitude = function (e) {
return t(e, n * nt);
}),
(i.period = function (n) {
return t(e, n);
}),
i
);
})(1, 0.3),
at = function (t, e, n) {
(t.prototype = e.prototype = n), (n.constructor = t);
};
function st(t, e) {
var n = Object.create(t.prototype);
for (var r in e) n[r] = e[r];
return n;
}
function ut() {}
var ct = "\\s*([+-]?\\d+)\\s*",
ht = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
lt = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
dt = /^#([0-9a-f]{3,8})$/,
ft = new RegExp("^rgb\\(" + [ct, ct, ct] + "\\)$"),
pt = new RegExp("^rgb\\(" + [lt, lt, lt] + "\\)$"),
gt = new RegExp("^rgba\\(" + [ct, ct, ct, ht] + "\\)$"),
yt = new RegExp("^rgba\\(" + [lt, lt, lt, ht] + "\\)$"),
vt = new RegExp("^hsl\\(" + [ht, lt, lt] + "\\)$"),
mt = new RegExp("^hsla\\(" + [ht, lt, lt, ht] + "\\)$"),
bt = {
aliceblue: 15792383,
antiquewhite: 16444375,
aqua: 65535,
aquamarine: 8388564,
azure: 15794175,
beige: 16119260,
bisque: 16770244,
black: 0,
blanchedalmond: 16772045,
blue: 255,
blueviolet: 9055202,
brown: 10824234,
burlywood: 14596231,
cadetblue: 6266528,
chartreuse: 8388352,
chocolate: 13789470,
coral: 16744272,
cornflowerblue: 6591981,
cornsilk: 16775388,
crimson: 14423100,
cyan: 65535,
darkblue: 139,
darkcyan: 35723,
darkgoldenrod: 12092939,
darkgray: 11119017,
darkgreen: 25600,
darkgrey: 11119017,
darkkhaki: 12433259,
darkmagenta: 9109643,
darkolivegreen: 5597999,
darkorange: 16747520,
darkorchid: 10040012,
darkred: 9109504,
darksalmon: 15308410,
darkseagreen: 9419919,
darkslateblue: 4734347,
darkslategray: 3100495,
darkslategrey: 3100495,
darkturquoise: 52945,
darkviolet: 9699539,
deeppink: 16716947,
deepskyblue: 49151,
dimgray: 6908265,
dimgrey: 6908265,
dodgerblue: 2003199,
firebrick: 11674146,
floralwhite: 16775920,
forestgreen: 2263842,
fuchsia: 16711935,
gainsboro: 14474460,
ghostwhite: 16316671,
gold: 16766720,
goldenrod: 14329120,
gray: 8421504,
green: 32768,
greenyellow: 11403055,
grey: 8421504,
honeydew: 15794160,
hotpink: 16738740,
indianred: 13458524,
indigo: 4915330,
ivory: 16777200,
khaki: 15787660,
lavender: 15132410,
lavenderblush: 16773365,
lawngreen: 8190976,
lemonchiffon: 16775885,
lightblue: 11393254,
lightcoral: 15761536,
lightcyan: 14745599,
lightgoldenrodyellow: 16448210,
lightgray: 13882323,
lightgreen: 9498256,
lightgrey: 13882323,
lightpink: 16758465,
lightsalmon: 16752762,
lightseagreen: 2142890,
lightskyblue: 8900346,
lightslategray: 7833753,
lightslategrey: 7833753,
lightsteelblue: 11584734,
lightyellow: 16777184,
lime: 65280,
limegreen: 3329330,
linen: 16445670,
magenta: 16711935,
maroon: 8388608,
mediumaquamarine: 6737322,
mediumblue: 205,
mediumorchid: 12211667,
mediumpurple: 9662683,
mediumseagreen: 3978097,
mediumslateblue: 8087790,
mediumspringgreen: 64154,
mediumturquoise: 4772300,
mediumvioletred: 13047173,
midnightblue: 1644912,
mintcream: 16121850,
mistyrose: 16770273,
moccasin: 16770229,
navajowhite: 16768685,
navy: 128,
oldlace: 16643558,
olive: 8421376,
olivedrab: 7048739,
orange: 16753920,
orangered: 16729344,
orchid: 14315734,
palegoldenrod: 15657130,
palegreen: 10025880,
paleturquoise: 11529966,
palevioletred: 14381203,
papayawhip: 16773077,
peachpuff: 16767673,
peru: 13468991,
pink: 16761035,
plum: 14524637,
powderblue: 11591910,
purple: 8388736,
rebeccapurple: 6697881,
red: 16711680,
rosybrown: 12357519,
royalblue: 4286945,
saddlebrown: 9127187,
salmon: 16416882,
sandybrown: 16032864,
seagreen: 3050327,
seashell: 16774638,
sienna: 10506797,
silver: 12632256,
skyblue: 8900331,
slateblue: 6970061,
slategray: 7372944,
slategrey: 7372944,
snow: 16775930,
springgreen: 65407,
steelblue: 4620980,
tan: 13808780,
teal: 32896,
thistle: 14204888,
tomato: 16737095,
turquoise: 4251856,
violet: 15631086,
wheat: 16113331,
white: 16777215,
whitesmoke: 16119285,
yellow: 16776960,
yellowgreen: 10145074,
};
function xt() {
return this.rgb().formatHex();
}
function wt() {
return this.rgb().formatRgb();
}
function Ot(t) {
var e, n;
return (
(t = (t + "").trim().toLowerCase()),
(e = dt.exec(t))
? ((n = e[1].length),
(e = parseInt(e[1], 16)),
6 === n
? Mt(e)
: 3 === n
? new kt(
((e >> 8) & 15) | ((e >> 4) & 240),
((e >> 4) & 15) | (240 & e),
((15 & e) << 4) | (15 & e),
1,
)
: 8 === n
? St(
(e >> 24) & 255,
(e >> 16) & 255,
(e >> 8) & 255,
(255 & e) / 255,
)
: 4 === n
? St(
((e >> 12) & 15) | ((e >> 8) & 240),
((e >> 8) & 15) | ((e >> 4) & 240),
((e >> 4) & 15) | (240 & e),
(((15 & e) << 4) | (15 & e)) / 255,
)
: null)
: (e = ft.exec(t))
? new kt(e[1], e[2], e[3], 1)
: (e = pt.exec(t))
? new kt(
(255 * e[1]) / 100,
(255 * e[2]) / 100,
(255 * e[3]) / 100,
1,
)
: (e = gt.exec(t))
? St(e[1], e[2], e[3], e[4])
: (e = yt.exec(t))
? St(
(255 * e[1]) / 100,
(255 * e[2]) / 100,
(255 * e[3]) / 100,
e[4],
)
: (e = vt.exec(t))
? Pt(e[1], e[2] / 100, e[3] / 100, 1)
: (e = mt.exec(t))
? Pt(e[1], e[2] / 100, e[3] / 100, e[4])
: bt.hasOwnProperty(t)
? Mt(bt[t])
: "transparent" === t
? new kt(NaN, NaN, NaN, 0)
: null
);
}
function Mt(t) {
return new kt((t >> 16) & 255, (t >> 8) & 255, 255 & t, 1);
}
function St(t, e, n, r) {
return r <= 0 && (t = e = n = NaN), new kt(t, e, n, r);
}
function Ct(t) {
return (
t instanceof ut || (t = Ot(t)),
t ? new kt((t = t.rgb()).r, t.g, t.b, t.opacity) : new kt()
);
}
function jt(t, e, n, r) {
return 1 === arguments.length
? Ct(t)
: new kt(t, e, n, null == r ? 1 : r);
}
function kt(t, e, n, r) {
(this.r = +t), (this.g = +e), (this.b = +n), (this.opacity = +r);
}
function Et() {
return "#" + Tt(this.r) + Tt(this.g) + Tt(this.b);
}
function Nt() {
var t = this.opacity;
return (
(1 === (t = isNaN(t) ? 1 : Math.max(0, Math.min(1, t)))
? "rgb("
: "rgba(") +
Math.max(0, Math.min(255, Math.round(this.r) || 0)) +
", " +
Math.max(0, Math.min(255, Math.round(this.g) || 0)) +
", " +
Math.max(0, Math.min(255, Math.round(this.b) || 0)) +
(1 === t ? ")" : ", " + t + ")")
);
}
function Tt(t) {
return (
((t = Math.max(0, Math.min(255, Math.round(t) || 0))) < 16
? "0"
: "") + t.toString(16)
);
}
function Pt(t, e, n, r) {
return (
r <= 0
? (t = e = n = NaN)
: n <= 0 || n >= 1
? (t = e = NaN)
: e <= 0 && (t = NaN),
new Bt(t, e, n, r)
);
}
function It(t) {
if (t instanceof Bt) return new Bt(t.h, t.s, t.l, t.opacity);
if ((t instanceof ut || (t = Ot(t)), !t)) return new Bt();
if (t instanceof Bt) return t;
var e = (t = t.rgb()).r / 255,
n = t.g / 255,
r = t.b / 255,
i = Math.min(e, n, r),
o = Math.max(e, n, r),
a = NaN,
s = o - i,
u = (o + i) / 2;
return (
s
? ((a =
e === o
? (n - r) / s + 6 * (n < r)
: n === o
? (r - e) / s + 2
: (e - n) / s + 4),
(s /= u < 0.5 ? o + i : 2 - o - i),
(a *= 60))
: (s = u > 0 && u < 1 ? 0 : a),
new Bt(a, s, u, t.opacity)
);
}
function Bt(t, e, n, r) {
(this.h = +t), (this.s = +e), (this.l = +n), (this.opacity = +r);
}
function At(t, e, n) {
return (
255 *
(t < 60
? e + ((n - e) * t) / 60
: t < 180
? n
: t < 240
? e + ((n - e) * (240 - t)) / 60
: e)
);
}
function Lt(t, e, n, r, i) {
var o = t * t,
a = o * t;
return (
((1 - 3 * t + 3 * o - a) * e +
(4 - 6 * o + 3 * a) * n +
(1 + 3 * t + 3 * o - 3 * a) * r +
a * i) /
6
);
}
at(ut, Ot, {
copy: function (t) {
return Object.assign(new this.constructor(), this, t);
},
displayable: function () {
return this.rgb().displayable();
},
hex: xt,
formatHex: xt,
formatHsl: function () {
return It(this).formatHsl();
},
formatRgb: wt,
toString: wt,
}),
at(
kt,
jt,
st(ut, {
brighter: function (t) {
return (
(t = null == t ? 1 / 0.7 : Math.pow(1 / 0.7, t)),
new kt(this.r * t, this.g * t, this.b * t, this.opacity)
);
},
darker: function (t) {
return (
(t = null == t ? 0.7 : Math.pow(0.7, t)),
new kt(this.r * t, this.g * t, this.b * t, this.opacity)
);
},
rgb: function () {
return this;
},
displayable: function () {
return (
-0.5 <= this.r &&
this.r < 255.5 &&
-0.5 <= this.g &&
this.g < 255.5 &&
-0.5 <= this.b &&
this.b < 255.5 &&
0 <= this.opacity &&
this.opacity <= 1
);
},
hex: Et,
formatHex: Et,
formatRgb: Nt,
toString: Nt,
}),
),
at(
Bt,
function (t, e, n, r) {
return 1 === arguments.length
? It(t)
: new Bt(t, e, n, null == r ? 1 : r);
},
st(ut, {
brighter: function (t) {
return (
(t = null == t ? 1 / 0.7 : Math.pow(1 / 0.7, t)),
new Bt(this.h, this.s, this.l * t, this.opacity)
);
},
darker: function (t) {
return (
(t = null == t ? 0.7 : Math.pow(0.7, t)),
new Bt(this.h, this.s, this.l * t, this.opacity)
);
},
rgb: function () {
var t = (this.h % 360) + 360 * (this.h < 0),
e = isNaN(t) || isNaN(this.s) ? 0 : this.s,
n = this.l,
r = n + (n < 0.5 ? n : 1 - n) * e,
i = 2 * n - r;
return new kt(
At(t >= 240 ? t - 240 : t + 120, i, r),
At(t, i, r),
At(t < 120 ? t + 240 : t - 120, i, r),
this.opacity,
);
},
displayable: function () {
return (
((0 <= this.s && this.s <= 1) || isNaN(this.s)) &&
0 <= this.l &&
this.l <= 1 &&
0 <= this.opacity &&
this.opacity <= 1
);
},
formatHsl: function () {
var t = this.opacity;
return (
(1 === (t = isNaN(t) ? 1 : Math.max(0, Math.min(1, t)))
? "hsl("
: "hsla(") +
(this.h || 0) +
", " +
100 * (this.s || 0) +
"%, " +
100 * (this.l || 0) +
"%" +
(1 === t ? ")" : ", " + t + ")")
);
},
}),
);
var Dt = function (t) {
return function () {
return t;
};
};
function _t(t, e) {
return function (n) {
return t + n * e;
};
}
function Rt(t) {
return 1 == (t = +t)
? Yt
: function (e, n) {
return n - e
? (function (t, e, n) {
return (
(t = Math.pow(t, n)),
(e = Math.pow(e, n) - t),
(n = 1 / n),
function (r) {
return Math.pow(t + r * e, n);
}
);
})(e, n, t)
: Dt(isNaN(e) ? n : e);
};
}
function Yt(t, e) {
var n = e - t;
return n ? _t(t, n) : Dt(isNaN(t) ? e : t);
}
var Ft = (function t(e) {
var n = Rt(e);
function r(t, e) {
var r = n((t = jt(t)).r, (e = jt(e)).r),
i = n(t.g, e.g),
o = n(t.b, e.b),
a = Yt(t.opacity, e.opacity);
return function (e) {
return (
(t.r = r(e)),
(t.g = i(e)),
(t.b = o(e)),
(t.opacity = a(e)),
t + ""
);
};
}
return (r.gamma = t), r;
})(1);
function zt(t) {
return function (e) {
var n,
r,
i = e.length,
o = new Array(i),
a = new Array(i),
s = new Array(i);
for (n = 0; n < i; ++n)
(r = jt(e[n])),
(o[n] = r.r || 0),
(a[n] = r.g || 0),
(s[n] = r.b || 0);
return (
(o = t(o)),
(a = t(a)),
(s = t(s)),
(r.opacity = 1),
function (t) {
return (r.r = o(t)), (r.g = a(t)), (r.b = s(t)), r + "";
}
);
};
}
zt(function (t) {
var e = t.length - 1;
return function (n) {
var r =
n <= 0 ? (n = 0) : n >= 1 ? ((n = 1), e - 1) : Math.floor(n * e),
i = t[r],
o = t[r + 1],
a = r > 0 ? t[r - 1] : 2 * i - o,
s = r < e - 1 ? t[r + 2] : 2 * o - i;
return Lt((n - r / e) * e, a, i, o, s);
};
}),
zt(function (t) {
var e = t.length;
return function (n) {
var r = Math.floor(((n %= 1) < 0 ? ++n : n) * e),
i = t[(r + e - 1) % e],
o = t[r % e],
a = t[(r + 1) % e],
s = t[(r + 2) % e];
return Lt((n - r / e) * e, i, o, a, s);
};
});
var Xt = function (t, e) {
e || (e = []);
var n,
r = t ? Math.min(e.length, t.length) : 0,
i = e.slice();
return function (o) {
for (n = 0; n < r; ++n) i[n] = t[n] * (1 - o) + e[n] * o;
return i;
};
};
function Wt(t) {
return ArrayBuffer.isView(t) && !(t instanceof DataView);
}
function Gt(t, e) {
var n,
r = e ? e.length : 0,
i = t ? Math.min(r, t.length) : 0,
o = new Array(i),
a = new Array(r);
for (n = 0; n < i; ++n) o[n] = Jt(t[n], e[n]);
for (; n < r; ++n) a[n] = e[n];
return function (t) {
for (n = 0; n < i; ++n) a[n] = o[n](t);
return a;
};
}
var qt = function (t, e) {
var n = new Date();
return (
(t = +t),
(e = +e),
function (r) {
return n.setTime(t * (1 - r) + e * r), n;
}
);
},
Ht = function (t, e) {
return (
(t = +t),
(e = +e),
function (n) {
return t * (1 - n) + e * n;
}
);
};
function Vt(t) {
return (Vt =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var Ut = function (t, e) {
var n,
r = {},
i = {};
for (n in ((null !== t && "object" === Vt(t)) || (t = {}),
(null !== e && "object" === Vt(e)) || (e = {}),
e))
n in t ? (r[n] = Jt(t[n], e[n])) : (i[n] = e[n]);
return function (t) {
for (n in r) i[n] = r[n](t);
return i;
};
},
Zt = /[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?/g,
Kt = new RegExp(Zt.source, "g");
var Qt = function (t, e) {
var n,
r,
i,
o = (Zt.lastIndex = Kt.lastIndex = 0),
a = -1,
s = [],
u = [];
for (t += "", e += ""; (n = Zt.exec(t)) && (r = Kt.exec(e)); )
(i = r.index) > o &&
((i = e.slice(o, i)), s[a] ? (s[a] += i) : (s[++a] = i)),
(n = n[0]) === (r = r[0])
? s[a]
? (s[a] += r)
: (s[++a] = r)
: ((s[++a] = null), u.push({ i: a, x: Ht(n, r) })),
(o = Kt.lastIndex);
return (
o < e.length && ((i = e.slice(o)), s[a] ? (s[a] += i) : (s[++a] = i)),
s.length < 2
? u[0]
? (function (t) {
return function (e) {
return t(e) + "";
};
})(u[0].x)
: (function (t) {
return function () {
return t;
};
})(e)
: ((e = u.length),
function (t) {
for (var n, r = 0; r < e; ++r) s[(n = u[r]).i] = n.x(t);
return s.join("");
})
);
};
function $t(t) {
return ($t =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var Jt = function (t, e) {
var n,
r = $t(e);
return null == e || "boolean" === r
? Dt(e)
: ("number" === r
? Ht
: "string" === r
? (n = Ot(e))
? ((e = n), Ft)
: Qt
: e instanceof Ot
? Ft
: e instanceof Date
? qt
: Wt(e)
? Xt
: Array.isArray(e)
? Gt
: ("function" != typeof e.valueOf &&
"function" != typeof e.toString) ||
isNaN(e)
? Ut
: Ht)(t, e);
},
te = n(6),
ee = [1, 0, 0, 0, 1, 0, 0, 0, 1];
function ne(t, e, n) {
var i,
o = e.startTime;
if (n < o + e.delay || e._paused) return !1;
var a = e.duration,
s = e.easing;
if (((n = n - o - e.delay), e.repeat)) (i = (n % a) / a), (i = r[s](i));
else {
if (!((i = n / a) < 1))
return e.onFrame ? t.attr(e.onFrame(1)) : t.attr(e.toAttrs), !0;
i = r[s](i);
}
if (e.onFrame) {
var c = e.onFrame(i);
t.attr(c);
} else
!(function (t, e, n) {
var r = {},
i = e.fromAttrs,
o = e.toAttrs;
if (!t.destroyed) {
var a, s, c, h;
for (var l in o)
if (!Object(u.q)(i[l], o[l]))
if ("path" === l) {
var d = o[l],
f = i[l];
d.length > f.length
? ((d = te.c(o[l])),
(f = te.c(i[l])),
(f = te.a(f, d)),
(f = te.b(f, d)),
(e.fromAttrs.path = f),
(e.toAttrs.path = d))
: e.pathFormatted ||
((d = te.c(o[l])),
(f = te.c(i[l])),
(f = te.b(f, d)),
(e.fromAttrs.path = f),
(e.toAttrs.path = d),
(e.pathFormatted = !0)),
(r[l] = []);
for (var p = 0; p < d.length; p++) {
for (
var g = d[p], y = f[p], v = [], m = 0;
m < g.length;
m++
)
Object(u.t)(g[m]) && y && Object(u.t)(y[m])
? ((a = Jt(y[m], g[m])), v.push(a(n)))
: v.push(g[m]);
r[l].push(v);
}
} else if ("matrix" === l) {
var b = ((c = i[l] || ee),
(Wt((h = o[l] || ee)) ? Xt : Gt)(c, h))(n);
r[l] = b;
} else
["fill", "stroke", "fillStyle", "strokeStyle"].includes(
l,
) && ((s = o[l]), /^[r,R,L,l]{1}[\s]*\(/.test(s))
? (r[l] = o[l])
: Object(u.r)(o[l]) ||
((a = Jt(i[l], o[l])), (r[l] = a(n)));
t.attr(r);
}
})(t, e, i);
return !1;
}
var re = (function () {
function t(t) {
(this.animators = []),
(this.current = 0),
(this.timer = null),
(this.canvas = t);
}
return (
(t.prototype.initTimer = function () {
var t,
e,
n,
r = this;
this.timer = M(function (i) {
if (((r.current = i), r.animators.length > 0)) {
for (var o = r.animators.length - 1; o >= 0; o--)
if ((t = r.animators[o]).destroyed) r.removeAnimator(o);
else {
if (!t.isAnimatePaused())
for (
var a = (e = t.get("animations")).length - 1;
a >= 0;
a--
)
(n = e[a]),
ne(t, n, i) &&
(e.splice(a, 1), !1, n.callback && n.callback());
0 === e.length && r.removeAnimator(o);
}
r.canvas.get("autoDraw") || r.canvas.draw();
}
});
}),
(t.prototype.addAnimator = function (t) {
this.animators.push(t);
}),
(t.prototype.removeAnimator = function (t) {
this.animators.splice(t, 1);
}),
(t.prototype.isAnimating = function () {
return !!this.animators.length;
}),
(t.prototype.stop = function () {
this.timer && this.timer.stop();
}),
(t.prototype.stopAllAnimations = function (t) {
void 0 === t && (t = !0),
this.animators.forEach(function (e) {
e.stopAnimate(t);
}),
(this.animators = []),
this.canvas.draw();
}),
(t.prototype.getTime = function () {
return this.current;
}),
t
);
})(),
ie = n(10),
oe = [
"mousedown",
"mouseup",
"dblclick",
"mouseout",
"mouseover",
"mousemove",
"mouseleave",
"mouseenter",
"touchstart",
"touchmove",
"touchend",
"dragenter",
"dragover",
"dragleave",
"drop",
"contextmenu",
"mousewheel",
];
function ae(t, e, n) {
(n.name = e),
(n.target = t),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
function se(t, e, n) {
if (n.bubbles) {
var r = void 0,
i = !1;
if (
("mouseenter" === e
? ((r = n.fromShape), (i = !0))
: "mouseleave" === e && ((i = !0), (r = n.toShape)),
t.isCanvas() && i)
)
return;
if (r && Object(s.g)(t, r)) return void (n.bubbles = !1);
(n.name = e),
(n.currentTarget = t),
(n.delegateTarget = t),
t.emit(e, n);
}
}
var ue = (function () {
function t(t) {
var e = this;
(this.draggingShape = null),
(this.dragging = !1),
(this.currentShape = null),
(this.mousedownShape = null),
(this.mousedownPoint = null),
(this._eventCallback = function (t) {
var n = t.type;
e._triggerEvent(n, t);
}),
(this._onDocumentMove = function (t) {
if (
e.canvas.get("el") !== t.target &&
(e.dragging || e.currentShape)
) {
var n = e._getPointInfo(t);
e.dragging && e._emitEvent("drag", t, n, e.draggingShape);
}
}),
(this._onDocumentMouseUp = function (t) {
if (e.canvas.get("el") !== t.target && e.dragging) {
var n = e._getPointInfo(t);
e.draggingShape && e._emitEvent("drop", t, n, null),
e._emitEvent("dragend", t, n, e.draggingShape),
e._afterDrag(e.draggingShape, n, t);
}
}),
(this.canvas = t.canvas);
}
return (
(t.prototype.init = function () {
this._bindEvents();
}),
(t.prototype._bindEvents = function () {
var t = this,
e = this.canvas.get("el");
Object(s.a)(oe, function (n) {
e.addEventListener(n, t._eventCallback);
}),
document &&
(document.addEventListener("mousemove", this._onDocumentMove),
document.addEventListener(
"mouseup",
this._onDocumentMouseUp,
));
}),
(t.prototype._clearEvents = function () {
var t = this,
e = this.canvas.get("el");
Object(s.a)(oe, function (n) {
e.removeEventListener(n, t._eventCallback);
}),
document &&
(document.removeEventListener(
"mousemove",
this._onDocumentMove,
),
document.removeEventListener(
"mouseup",
this._onDocumentMouseUp,
));
}),
(t.prototype._getEventObj = function (t, e, n, r, i, o) {
var a = new ie.a(t, e);
return (
(a.fromShape = i),
(a.toShape = o),
(a.x = n.x),
(a.y = n.y),
(a.clientX = n.clientX),
(a.clientY = n.clientY),
a.propagationPath.push(r),
a
);
}),
(t.prototype._getShape = function (t, e) {
return this.canvas.getShape(t.x, t.y, e);
}),
(t.prototype._getPointInfo = function (t) {
var e = this.canvas,
n = e.getClientByEvent(t),
r = e.getPointByEvent(t);
return { x: r.x, y: r.y, clientX: n.x, clientY: n.y };
}),
(t.prototype._triggerEvent = function (t, e) {
var n = this._getPointInfo(e),
r = this._getShape(n, e),
i = this["_on" + t],
o = !1;
if (i) i.call(this, n, r, e);
else {
var a = this.currentShape;
"mouseenter" === t || "dragenter" === t || "mouseover" === t
? (this._emitEvent(t, e, n, null, null, r),
r && this._emitEvent(t, e, n, r, null, r),
"mouseenter" === t &&
this.draggingShape &&
this._emitEvent("dragenter", e, n, null))
: "mouseleave" === t || "dragleave" === t || "mouseout" === t
? ((o = !0),
a && this._emitEvent(t, e, n, a, a, null),
this._emitEvent(t, e, n, null, a, null),
"mouseleave" === t &&
this.draggingShape &&
this._emitEvent("dragleave", e, n, null))
: this._emitEvent(t, e, n, r, null, null);
}
if ((o || (this.currentShape = r), r && !r.get("destroyed"))) {
var s = this.canvas;
s.get("el").style.cursor = r.attr("cursor") || s.get("cursor");
}
}),
(t.prototype._onmousedown = function (t, e, n) {
0 === n.button &&
((this.mousedownShape = e),
(this.mousedownPoint = t),
(this.mousedownTimeStamp = n.timeStamp)),
this._emitEvent("mousedown", n, t, e, null, null);
}),
(t.prototype._emitMouseoverEvents = function (t, e, n, r) {
var i = this.canvas.get("el");
n !== r &&
(n &&
(this._emitEvent("mouseout", t, e, n, n, r),
this._emitEvent("mouseleave", t, e, n, n, r),
(r && !r.get("destroyed")) ||
(i.style.cursor = this.canvas.get("cursor"))),
r &&
(this._emitEvent("mouseover", t, e, r, n, r),
this._emitEvent("mouseenter", t, e, r, n, r)));
}),
(t.prototype._emitDragoverEvents = function (t, e, n, r, i) {
r
? (r !== n &&
(n && this._emitEvent("dragleave", t, e, n, n, r),
this._emitEvent("dragenter", t, e, r, n, r)),
i || this._emitEvent("dragover", t, e, r))
: n && this._emitEvent("dragleave", t, e, n, n, r),
i && this._emitEvent("dragover", t, e, r);
}),
(t.prototype._afterDrag = function (t, e, n) {
t && (t.set("capture", !0), (this.draggingShape = null)),
(this.dragging = !1);
var r = this._getShape(e, n);
r !== t && this._emitMouseoverEvents(n, e, t, r),
(this.currentShape = r);
}),
(t.prototype._onmouseup = function (t, e, n) {
if (0 === n.button) {
var r = this.draggingShape;
this.dragging
? (r && this._emitEvent("drop", n, t, e),
this._emitEvent("dragend", n, t, r),
this._afterDrag(r, t, n))
: (this._emitEvent("mouseup", n, t, e),
e === this.mousedownShape &&
this._emitEvent("click", n, t, e),
(this.mousedownShape = null),
(this.mousedownPoint = null));
}
}),
(t.prototype._ondragover = function (t, e, n) {
n.preventDefault();
var r = this.currentShape;
this._emitDragoverEvents(n, t, r, e, !0);
}),
(t.prototype._onmousemove = function (t, e, n) {
var r = this.canvas,
i = this.currentShape,
o = this.draggingShape;
if (this.dragging)
o && this._emitDragoverEvents(n, t, i, e, !1),
this._emitEvent("drag", n, t, o);
else {
var a = this.mousedownPoint;
if (a) {
var s = this.mousedownShape,
u = n.timeStamp - this.mousedownTimeStamp,
c = a.clientX - t.clientX,
h = a.clientY - t.clientY;
u > 120 || c * c + h * h > 40
? s && s.get("draggable")
? ((o = this.mousedownShape).set("capture", !1),
(this.draggingShape = o),
(this.dragging = !0),
this._emitEvent("dragstart", n, t, o),
(this.mousedownShape = null),
(this.mousedownPoint = null))
: !s && r.get("draggable")
? ((this.dragging = !0),
this._emitEvent("dragstart", n, t, null),
(this.mousedownShape = null),
(this.mousedownPoint = null))
: (this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e))
: (this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e));
} else
this._emitMouseoverEvents(n, t, i, e),
this._emitEvent("mousemove", n, t, e);
}
}),
(t.prototype._emitEvent = function (t, e, n, r, i, o) {
var a = this._getEventObj(t, e, n, r, i, o);
if (r) {
(a.shape = r), ae(r, t, a);
for (var s = r.getParent(); s; )
s.emitDelegation(t, a),
a.propagationStopped || se(s, t, a),
a.propagationPath.push(s),
(s = s.getParent());
} else {
ae(this.canvas, t, a);
}
}),
(t.prototype.destroy = function () {
this._clearEvents(),
(this.canvas = null),
(this.currentShape = null),
(this.draggingShape = null),
(this.mousedownPoint = null),
(this.mousedownShape = null),
(this.mousedownTimeStamp = null);
}),
t
);
})(),
ce = Object(o.a)(),
he = ce && "firefox" === ce.name;
!(function (t) {
function e(e) {
var n = t.call(this, e) || this;
return (
n.initContainer(), n.initDom(), n.initEvents(), n.initTimeline(), n
);
}
Object(i.c)(e, t),
(e.prototype.getDefaultCfg = function () {
var e = t.prototype.getDefaultCfg.call(this);
return (e.cursor = "default"), (e.supportCSSTransform = !1), e;
}),
(e.prototype.initContainer = function () {
var t = this.get("container");
Object(s.h)(t) &&
((t = document.getElementById(t)), this.set("container", t));
}),
(e.prototype.initDom = function () {
var t = this.createDom();
this.set("el", t),
this.get("container").appendChild(t),
this.setDOMSize(this.get("width"), this.get("height"));
}),
(e.prototype.initEvents = function () {
var t = new ue({ canvas: this });
t.init(), this.set("eventController", t);
}),
(e.prototype.initTimeline = function () {
var t = new re(this);
this.set("timeline", t);
}),
(e.prototype.setDOMSize = function (t, e) {
var n = this.get("el");
s.c && ((n.style.width = t + "px"), (n.style.height = e + "px"));
}),
(e.prototype.changeSize = function (t, e) {
this.setDOMSize(t, e),
this.set("width", t),
this.set("height", e),
this.onCanvasChange("changeSize");
}),
(e.prototype.getRenderer = function () {
return this.get("renderer");
}),
(e.prototype.getCursor = function () {
return this.get("cursor");
}),
(e.prototype.setCursor = function (t) {
this.set("cursor", t);
var e = this.get("el");
s.c && e && (e.style.cursor = t);
}),
(e.prototype.getPointByEvent = function (t) {
if (this.get("supportCSSTransform")) {
if (he && !Object(s.e)(t.layerX) && t.layerX !== t.offsetX)
return { x: t.layerX, y: t.layerY };
if (!Object(s.e)(t.offsetX))
return { x: t.offsetX, y: t.offsetY };
}
var e = this.getClientByEvent(t),
n = e.x,
r = e.y;
return this.getPointByClient(n, r);
}),
(e.prototype.getClientByEvent = function (t) {
var e = t;
return (
t.touches &&
(e =
"touchend" === t.type ? t.changedTouches[0] : t.touches[0]),
{ x: e.clientX, y: e.clientY }
);
}),
(e.prototype.getPointByClient = function (t, e) {
var n = this.get("el").getBoundingClientRect();
return { x: t - n.left, y: e - n.top };
}),
(e.prototype.getClientByPoint = function (t, e) {
var n = this.get("el").getBoundingClientRect();
return { x: t + n.left, y: e + n.top };
}),
(e.prototype.draw = function () {}),
(e.prototype.removeDom = function () {
var t = this.get("el");
t.parentNode.removeChild(t);
}),
(e.prototype.clearEvents = function () {
this.get("eventController").destroy();
}),
(e.prototype.isCanvas = function () {
return !0;
}),
(e.prototype.getParent = function () {
return null;
}),
(e.prototype.destroy = function () {
var e = this.get("timeline");
this.get("destroyed") ||
(this.clear(),
e && e.stop(),
this.clearEvents(),
this.removeDom(),
t.prototype.destroy.call(this));
});
})(a.a);
},
function (t, e, n) {
"use strict";
var r = {};
n.r(r),
n.d(r, "distance", function () {
return h;
}),
n.d(r, "isNumberEqual", function () {
return l;
}),
n.d(r, "getBBoxByArray", function () {
return d;
}),
n.d(r, "getBBoxRange", function () {
return f;
}),
n.d(r, "piMod", function () {
return p;
});
var i = new Map();
function o(t, e) {
i.set(t, e);
}
var a = function (t) {
var e = t.attr();
return { x: e.x, y: e.y, width: e.width, height: e.height };
},
s = function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.r;
return { x: n - i, y: r - i, width: 2 * i, height: 2 * i };
};
function u(t) {
return Math.min.apply(null, t);
}
function c(t) {
return Math.max.apply(null, t);
}
function h(t, e, n, r) {
var i = t - n,
o = e - r;
return Math.sqrt(i * i + o * o);
}
function l(t, e) {
return Math.abs(t - e) < 0.001;
}
function d(t, e) {
var n = u(t),
r = u(e);
return { x: n, y: r, width: c(t) - n, height: c(e) - r };
}
function f(t, e, n, r) {
return {
minX: u([t, n]),
maxX: c([t, n]),
minY: u([e, r]),
maxY: c([e, r]),
};
}
function p(t) {
return (t + 2 * Math.PI) % (2 * Math.PI);
}
n(9);
function g(t, e, n, r) {
var i = 1 - r;
return i * i * t + 2 * r * i * e + r * r * n;
}
function y(t, e, n) {
var r = t + n - 2 * e;
if (l(r, 0)) return [0.5];
var i = (t - e) / r;
return i <= 1 && i >= 0 ? [i] : [];
}
var v = function (t, e, n, r, i, o) {
var a = y(t, n, i)[0],
s = y(e, r, o)[0],
u = [t, i],
c = [e, o];
return (
void 0 !== a && u.push(g(t, n, i, a)),
void 0 !== s && c.push(g(e, r, o, s)),
d(u, c)
);
};
function m(t, e, n, r, i) {
var o = 1 - i;
return (
o * o * o * t + 3 * e * i * o * o + 3 * n * i * i * o + r * i * i * i
);
}
function b(t, e, n, r) {
var i,
o,
a,
s = -3 * t + 9 * e - 9 * n + 3 * r,
u = 6 * t - 12 * e + 6 * n,
c = 3 * e - 3 * t,
h = [];
if (l(s, 0)) l(u, 0) || ((i = -c / u) >= 0 && i <= 1 && h.push(i));
else {
var d = u * u - 4 * s * c;
l(d, 0)
? h.push(-u / (2 * s))
: d > 0 &&
((o = (-u - (a = Math.sqrt(d))) / (2 * s)),
(i = (-u + a) / (2 * s)) >= 0 && i <= 1 && h.push(i),
o >= 0 && o <= 1 && h.push(o));
}
return h;
}
var x = function (t, e, n, r, i, o, a, s) {
for (
var u = [t, a],
c = [e, s],
h = b(t, n, i, a),
l = b(e, r, o, s),
f = 0;
f < h.length;
f++
)
u.push(m(t, n, i, a, h[f]));
for (f = 0; f < l.length; f++) c.push(m(e, r, o, s, l[f]));
return d(u, c);
};
function w(t, e, n, r, i, o) {
return (
n * Math.cos(i) * Math.cos(o) - r * Math.sin(i) * Math.sin(o) + t
);
}
function O(t, e, n, r, i, o) {
return (
n * Math.sin(i) * Math.cos(o) + r * Math.cos(i) * Math.sin(o) + e
);
}
var M = function (t, e, n, r, i, o, a) {
for (
var s = (function (t, e, n) {
return Math.atan((-e / t) * Math.tan(n));
})(n, r, i),
u = 1 / 0,
c = -1 / 0,
h = [o, a],
l = 2 * -Math.PI;
l <= 2 * Math.PI;
l += Math.PI
) {
var d = s + l;
o < a ? o < d && d < a && h.push(d) : a < d && d < o && h.push(d);
}
for (l = 0; l < h.length; l++) {
var f = w(t, 0, n, r, i, h[l]);
f < u && (u = f), f > c && (c = f);
}
var p = (function (t, e, n) {
return Math.atan(e / (t * Math.tan(n)));
})(n, r, i),
g = 1 / 0,
y = -1 / 0,
v = [o, a];
for (l = 2 * -Math.PI; l <= 2 * Math.PI; l += Math.PI) {
var m = p + l;
o < a ? o < m && m < a && v.push(m) : a < m && m < o && v.push(m);
}
for (l = 0; l < v.length; l++) {
var b = O(0, e, n, r, i, v[l]);
b < g && (g = b), b > y && (y = b);
}
return { x: u, y: g, width: c - u, height: y - g };
};
function S(t, e) {
return t && e
? {
minX: Math.min(t.minX, e.minX),
minY: Math.min(t.minY, e.minY),
maxX: Math.max(t.maxX, e.maxX),
maxY: Math.max(t.maxY, e.maxY),
}
: t || e;
}
function C(t, e) {
var n = t.get("startArrowShape"),
r = t.get("endArrowShape");
return (
n && (e = S(e, n.getCanvasBBox())),
r && (e = S(e, r.getCanvasBBox())),
e
);
}
var j = n(8),
k = n(7),
E = n(0);
function N(t, e) {
var n = t.prePoint,
r = t.currentPoint,
i = t.nextPoint,
o = Math.pow(r[0] - n[0], 2) + Math.pow(r[1] - n[1], 2),
a = Math.pow(r[0] - i[0], 2) + Math.pow(r[1] - i[1], 2),
s = Math.pow(n[0] - i[0], 2) + Math.pow(n[1] - i[1], 2),
u = Math.acos((o + a - s) / (2 * Math.sqrt(o) * Math.sqrt(a)));
if (!u || 0 === Math.sin(u) || Object(E.u)(u, 0))
return { xExtra: 0, yExtra: 0 };
var c = Math.abs(Math.atan2(i[1] - r[1], i[0] - r[0])),
h = Math.abs(Math.atan2(i[0] - r[0], i[1] - r[1]));
return (
(c = c > Math.PI / 2 ? Math.PI - c : c),
(h = h > Math.PI / 2 ? Math.PI - h : h),
{
xExtra:
Math.cos(u / 2 - c) * ((e / 2) * (1 / Math.sin(u / 2))) - e / 2 ||
0,
yExtra:
Math.cos(h - u / 2) * ((e / 2) * (1 / Math.sin(u / 2))) - e / 2 ||
0,
}
);
}
o("rect", a),
o("image", a),
o("circle", s),
o("marker", s),
o("polyline", function (t) {
for (
var e = t.attr().points, n = [], i = [], o = 0;
o < e.length;
o++
) {
var a = e[o];
n.push(a[0]), i.push(a[1]);
}
var s = r.getBBoxByArray(n, i),
u = s.x,
c = s.y,
h = { minX: u, minY: c, maxX: u + s.width, maxY: c + s.height };
return {
x: (h = C(t, h)).minX,
y: h.minY,
width: h.maxX - h.minX,
height: h.maxY - h.minY,
};
}),
o("polygon", function (t) {
for (
var e = t.attr().points, n = [], i = [], o = 0;
o < e.length;
o++
) {
var a = e[o];
n.push(a[0]), i.push(a[1]);
}
return r.getBBoxByArray(n, i);
}),
o("text", function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.text,
o = e.fontSize,
a = e.lineHeight,
s = e.font;
s || (s = Object(j.a)(e));
var u,
c = Object(j.c)(i, s);
if (c) {
var h = e.textAlign,
l = e.textBaseline,
d = Object(j.b)(i, o, a),
f = { x: n, y: r - d };
h &&
("end" === h || "right" === h
? (f.x -= c)
: "center" === h && (f.x -= c / 2)),
l &&
("top" === l ? (f.y += d) : "middle" === l && (f.y += d / 2)),
(u = { x: f.x, y: f.y, width: c, height: d });
} else u = { x: n, y: r, width: 0, height: 0 };
return u;
}),
o("path", function (t) {
var e = t.attr(),
n = e.path,
r = e.stroke ? e.lineWidth : 0,
i = (function (t, e) {
for (var n = [], r = [], i = [], o = 0; o < t.length; o++) {
var a = (g = t[o]).currentPoint,
s = g.params,
u = g.prePoint,
c = void 0;
switch (g.command) {
case "Q":
c = v(u[0], u[1], s[1], s[2], s[3], s[4]);
break;
case "C":
c = x(u[0], u[1], s[1], s[2], s[3], s[4], s[5], s[6]);
break;
case "A":
var h = g.arcParams;
c = M(
h.cx,
h.cy,
h.rx,
h.ry,
h.xRotation,
h.startAngle,
h.endAngle,
);
break;
default:
n.push(a[0]), r.push(a[1]);
}
c &&
((g.box = c),
n.push(c.x, c.x + c.width),
r.push(c.y, c.y + c.height)),
e &&
("L" === g.command || "M" === g.command) &&
g.prePoint &&
g.nextPoint &&
i.push(g);
}
(n = n.filter(function (t) {
return !Number.isNaN(t);
})),
(r = r.filter(function (t) {
return !Number.isNaN(t);
}));
var l = Object(E.B)(n),
d = Object(E.B)(r),
f = Object(E.A)(n),
p = Object(E.A)(r);
if (0 === i.length)
return { x: l, y: d, width: f - l, height: p - d };
for (o = 0; o < i.length; o++) {
var g;
(a = (g = i[o]).currentPoint)[0] === l
? (l -= N(g, e).xExtra)
: a[0] === f && (f += N(g, e).xExtra),
a[1] === d
? (d -= N(g, e).yExtra)
: a[1] === p && (p += N(g, e).yExtra);
}
return { x: l, y: d, width: f - l, height: p - d };
})(t.get("segments") || Object(k.c)(n), r),
o = i.x,
a = i.y,
s = { minX: o, minY: a, maxX: o + i.width, maxY: a + i.height };
return {
x: (s = C(t, s)).minX,
y: s.minY,
width: s.maxX - s.minX,
height: s.maxY - s.minY,
};
}),
o("line", function (t) {
var e = t.attr(),
n = e.x1,
r = e.y1,
i = e.x2,
o = e.y2,
a = {
minX: Math.min(n, i),
maxX: Math.max(n, i),
minY: Math.min(r, o),
maxY: Math.max(r, o),
};
return {
x: (a = C(t, a)).minX,
y: a.minY,
width: a.maxX - a.minX,
height: a.maxY - a.minY,
};
}),
o("ellipse", function (t) {
var e = t.attr(),
n = e.x,
r = e.y,
i = e.rx,
o = e.ry;
return { x: n - i, y: r - o, width: 2 * i, height: 2 * o };
});
},
function (t, e, n) {
var r, i, o;
function a(t) {
return (a =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
(i = []),
void 0 ===
(o =
"function" ==
typeof (r = function () {
var n = (function () {
var t = {
row: "left",
"row-reverse": "right",
column: "top",
"column-reverse": "bottom",
},
e = {
row: "right",
"row-reverse": "left",
column: "bottom",
"column-reverse": "top",
},
n = {
row: "left",
"row-reverse": "right",
column: "top",
"column-reverse": "bottom",
},
r = {
row: "width",
"row-reverse": "width",
column: "height",
"column-reverse": "height",
};
function i(t) {
return void 0 === t;
}
function o(t) {
return "row" === t || "row-reverse" === t;
}
function a(t, e) {
if (void 0 !== t.style.marginStart && o(e))
return t.style.marginStart;
var n = null;
switch (e) {
case "row":
n = t.style.marginLeft;
break;
case "row-reverse":
n = t.style.marginRight;
break;
case "column":
n = t.style.marginTop;
break;
case "column-reverse":
n = t.style.marginBottom;
}
return void 0 !== n
? n
: void 0 !== t.style.margin
? t.style.margin
: 0;
}
function s(t, e) {
if (void 0 !== t.style.marginEnd && o(e))
return t.style.marginEnd;
var n = null;
switch (e) {
case "row":
n = t.style.marginRight;
break;
case "row-reverse":
n = t.style.marginLeft;
break;
case "column":
n = t.style.marginBottom;
break;
case "column-reverse":
n = t.style.marginTop;
}
return null != n
? n
: void 0 !== t.style.margin
? t.style.margin
: 0;
}
function u(t, e) {
if (
void 0 !== t.style.borderStartWidth &&
t.style.borderStartWidth >= 0 &&
o(e)
)
return t.style.borderStartWidth;
var n = null;
switch (e) {
case "row":
n = t.style.borderLeftWidth;
break;
case "row-reverse":
n = t.style.borderRightWidth;
break;
case "column":
n = t.style.borderTopWidth;
break;
case "column-reverse":
n = t.style.borderBottomWidth;
}
return null != n && n >= 0
? n
: void 0 !== t.style.borderWidth && t.style.borderWidth >= 0
? t.style.borderWidth
: 0;
}
function c(t, e) {
if (
void 0 !== t.style.borderEndWidth &&
t.style.borderEndWidth >= 0 &&
o(e)
)
return t.style.borderEndWidth;
var n = null;
switch (e) {
case "row":
n = t.style.borderRightWidth;
break;
case "row-reverse":
n = t.style.borderLeftWidth;
break;
case "column":
n = t.style.borderBottomWidth;
break;
case "column-reverse":
n = t.style.borderTopWidth;
}
return null != n && n >= 0
? n
: void 0 !== t.style.borderWidth && t.style.borderWidth >= 0
? t.style.borderWidth
: 0;
}
function h(t, e) {
return (
(function (t, e) {
if (
void 0 !== t.style.paddingStart &&
t.style.paddingStart >= 0 &&
o(e)
)
return t.style.paddingStart;
var n = null;
switch (e) {
case "row":
n = t.style.paddingLeft;
break;
case "row-reverse":
n = t.style.paddingRight;
break;
case "column":
n = t.style.paddingTop;
break;
case "column-reverse":
n = t.style.paddingBottom;
}
return null != n && n >= 0
? n
: void 0 !== t.style.padding && t.style.padding >= 0
? t.style.padding
: 0;
})(t, e) + u(t, e)
);
}
function l(t, e) {
return (
(function (t, e) {
if (
void 0 !== t.style.paddingEnd &&
t.style.paddingEnd >= 0 &&
o(e)
)
return t.style.paddingEnd;
var n = null;
switch (e) {
case "row":
n = t.style.paddingRight;
break;
case "row-reverse":
n = t.style.paddingLeft;
break;
case "column":
n = t.style.paddingBottom;
break;
case "column-reverse":
n = t.style.paddingTop;
}
return null != n && n >= 0
? n
: void 0 !== t.style.padding && t.style.padding >= 0
? t.style.padding
: 0;
})(t, e) + c(t, e)
);
}
function d(t, e) {
return u(t, e) + c(t, e);
}
function f(t, e) {
return a(t, e) + s(t, e);
}
function p(t, e) {
return h(t, e) + l(t, e);
}
function g(t, e) {
return e.style.alignSelf
? e.style.alignSelf
: t.style.alignItems
? t.style.alignItems
: "stretch";
}
function y(t, e) {
if ("rtl" === e) {
if ("row" === t) return "row-reverse";
if ("row-reverse" === t) return "row";
}
return t;
}
function v(t) {
return t.style.position ? t.style.position : "relative";
}
function m(t) {
return "relative" === v(t) && t.style.flex > 0;
}
function b(t, e) {
return t.layout[r[e]] + f(t, e);
}
function x(t, e) {
return void 0 !== t.style[r[e]] && t.style[r[e]] >= 0;
}
function w(t, e) {
return void 0 !== t.style[e];
}
function O(t, e) {
return void 0 !== t.style[e] ? t.style[e] : 0;
}
function M(t, e, n) {
var r = {
row: t.style.minWidth,
"row-reverse": t.style.minWidth,
column: t.style.minHeight,
"column-reverse": t.style.minHeight,
}[e],
i = {
row: t.style.maxWidth,
"row-reverse": t.style.maxWidth,
column: t.style.maxHeight,
"column-reverse": t.style.maxHeight,
}[e],
o = n;
return (
void 0 !== i && i >= 0 && o > i && (o = i),
void 0 !== r && r >= 0 && o < r && (o = r),
o
);
}
function S(t, e) {
return t > e ? t : e;
}
function C(t, e) {
void 0 === t.layout[r[e]] &&
x(t, e) &&
(t.layout[r[e]] = S(M(t, e, t.style[r[e]]), p(t, e)));
}
function j(t, i, o) {
i.layout[e[o]] =
t.layout[r[o]] - i.layout[r[o]] - i.layout[n[o]];
}
function k(n, r) {
return void 0 !== n.style[t[r]] ? O(n, t[r]) : -O(n, e[r]);
}
function E(c, E, T) {
var P = (function (t, e) {
var n;
return (
"inherit" ===
(n = t.style.direction
? t.style.direction
: "inherit") && (n = void 0 === e ? "ltr" : e),
n
);
})(c, T),
I = y(
(function (t) {
return t.style.flexDirection
? t.style.flexDirection
: "column";
})(c),
P,
),
B = (function (t, e) {
return (function (t) {
return "column" === t || "column-reverse" === t;
})(t)
? y("row", e)
: "column";
})(I, P),
A = y("row", P);
C(c, I),
C(c, B),
(c.layout.direction = P),
(c.layout[t[I]] += a(c, I) + k(c, I)),
(c.layout[e[I]] += s(c, I) + k(c, I)),
(c.layout[t[B]] += a(c, B) + k(c, B)),
(c.layout[e[B]] += s(c, B) + k(c, B));
var L = c.children.length,
D = p(c, A);
if (
(function (t) {
return void 0 !== t.style.measure;
})(c)
) {
var _ = !i(c.layout[r[A]]),
R = void 0;
(R = x(c, A)
? c.style.width
: _
? c.layout[r[A]]
: E - f(c, A)),
(R -= D);
var Y = !x(c, A) && !_,
F = !x(c, "column") && i(c.layout[r.column]);
if (Y || F) {
var z = c.style.measure(R);
Y && (c.layout.width = z.width + D),
F && (c.layout.height = z.height + p(c, "column"));
}
if (0 === L) return;
}
var X,
W,
G,
q,
H = (function (t) {
return "wrap" === t.style.flexWrap;
})(c),
V = (function (t) {
return t.style.justifyContent
? t.style.justifyContent
: "flex-start";
})(c),
U = h(c, I),
Z = h(c, B),
K = p(c, I),
Q = p(c, B),
$ = !i(c.layout[r[I]]),
J = !i(c.layout[r[B]]),
tt = o(I),
et = null,
nt = null,
rt = void 0;
$ && (rt = c.layout[r[I]] - K);
for (
var it = 0, ot = 0, at = 0, st = 0, ut = 0, ct = 0;
ot < L;
) {
var ht,
lt = 0,
dt = 0,
ft = 0,
pt = 0,
gt = ($ && "flex-start" === V) || (!$ && "center" !== V),
yt = gt ? L : it,
vt = !0,
mt = L,
bt = null,
xt = null,
wt = U,
Ot = 0;
for (X = it; X < L; ++X) {
if (
(((G = c.children[X]).lineIndex = ct),
(G.nextAbsoluteChild = null),
(G.nextFlexChild = null),
"stretch" === (Pt = g(c, G)) &&
"relative" === v(G) &&
J &&
!x(G, B))
)
G.layout[r[B]] = S(
M(G, B, c.layout[r[B]] - Q - f(G, B)),
p(G, B),
);
else if ("absolute" === v(G))
for (
null === et && (et = G),
null !== nt && (nt.nextAbsoluteChild = G),
nt = G,
W = 0;
W < 2;
W++
)
(q = 0 !== W ? "row" : "column"),
!i(c.layout[r[q]]) &&
!x(G, q) &&
w(G, t[q]) &&
w(G, e[q]) &&
(G.layout[r[q]] = S(
M(
G,
q,
c.layout[r[q]] -
p(c, q) -
f(G, q) -
O(G, t[q]) -
O(G, e[q]),
),
p(G, q),
));
var Mt = 0;
if (
($ && m(G)
? (dt++,
(ft += G.style.flex),
null === bt && (bt = G),
null !== xt && (xt.nextFlexChild = G),
(xt = G),
(Mt = p(G, I) + f(G, I)))
: ((ht = void 0),
tt ||
(ht = x(c, A)
? c.layout[r[A]] - D
: E - f(c, A) - D),
0 === at && N(G, ht, P),
"relative" === v(G) && (pt++, (Mt = b(G, I)))),
H && $ && lt + Mt > rt && X !== it)
) {
pt--, (at = 1);
break;
}
gt &&
("relative" !== v(G) || m(G)) &&
((gt = !1), (yt = X)),
vt &&
("relative" !== v(G) ||
("stretch" !== Pt && "flex-start" !== Pt) ||
i(G.layout[r[B]])) &&
((vt = !1), (mt = X)),
gt &&
((G.layout[n[I]] += wt),
$ && j(c, G, I),
(wt += b(G, I)),
(Ot = S(Ot, M(G, B, b(G, B))))),
vt && ((G.layout[n[B]] += st + Z), J && j(c, G, B)),
(at = 0),
(lt += Mt),
(ot = X + 1);
}
var St = 0,
Ct = 0,
jt = 0;
if (((jt = $ ? rt - lt : S(lt, 0) - lt), 0 !== dt)) {
var kt,
Et,
Nt = jt / ft;
for (xt = bt; null !== xt; )
(kt = Nt * xt.style.flex + p(xt, I)) !==
(Et = M(xt, I, kt)) &&
((jt -= Et), (ft -= xt.style.flex)),
(xt = xt.nextFlexChild);
for (
(Nt = jt / ft) < 0 && (Nt = 0), xt = bt;
null !== xt;
)
(xt.layout[r[I]] = M(
xt,
I,
Nt * xt.style.flex + p(xt, I),
)),
(ht = void 0),
x(c, A)
? (ht = c.layout[r[A]] - D)
: tt || (ht = E - f(c, A) - D),
N(xt, ht, P),
(G = xt),
(xt = xt.nextFlexChild),
(G.nextFlexChild = null);
} else
"flex-start" !== V &&
("center" === V
? (St = jt / 2)
: "flex-end" === V
? (St = jt)
: "space-between" === V
? ((jt = S(jt, 0)),
(Ct = dt + pt - 1 != 0 ? jt / (dt + pt - 1) : 0))
: "space-around" === V &&
(St = (Ct = jt / (dt + pt)) / 2));
for (wt += St, X = yt; X < ot; ++X)
"absolute" === v((G = c.children[X])) && w(G, t[I])
? (G.layout[n[I]] = O(G, t[I]) + u(c, I) + a(G, I))
: ((G.layout[n[I]] += wt),
$ && j(c, G, I),
"relative" === v(G) &&
((wt += Ct + b(G, I)),
(Ot = S(Ot, M(G, B, b(G, B))))));
var Tt = c.layout[r[B]];
for (J || (Tt = S(M(c, B, Ot + Q), Q)), X = mt; X < ot; ++X)
if ("absolute" === v((G = c.children[X])) && w(G, t[B]))
G.layout[n[B]] = O(G, t[B]) + u(c, B) + a(G, B);
else {
var Pt,
It = Z;
if ("relative" === v(G))
if ("stretch" === (Pt = g(c, G)))
i(G.layout[r[B]]) &&
(G.layout[r[B]] = S(
M(G, B, Tt - Q - f(G, B)),
p(G, B),
));
else if ("flex-start" !== Pt) {
var Bt = Tt - Q - b(G, B);
It += "center" === Pt ? Bt / 2 : Bt;
}
(G.layout[n[B]] += st + It), J && j(c, G, B);
}
(st += Ot), (ut = S(ut, wt)), (ct += 1), (it = ot);
}
if (ct > 1 && J) {
var At = c.layout[r[B]] - Q,
Lt = At - st,
Dt = 0,
_t = Z,
Rt = (function (t) {
return t.style.alignContent
? t.style.alignContent
: "flex-start";
})(c);
"flex-end" === Rt
? (_t += Lt)
: "center" === Rt
? (_t += Lt / 2)
: "stretch" === Rt && At > st && (Dt = Lt / ct);
var Yt = 0;
for (X = 0; X < ct; ++X) {
var Ft = Yt,
zt = 0;
for (W = Ft; W < L; ++W)
if ("relative" === v((G = c.children[W]))) {
if (G.lineIndex !== X) break;
i(G.layout[r[B]]) ||
(zt = S(zt, G.layout[r[B]] + f(G, B)));
}
for (Yt = W, zt += Dt, W = Ft; W < Yt; ++W)
if ("relative" === v((G = c.children[W]))) {
var Xt = g(c, G);
if ("flex-start" === Xt)
G.layout[n[B]] = _t + a(G, B);
else if ("flex-end" === Xt)
G.layout[n[B]] = _t + zt - s(G, B) - G.layout[r[B]];
else if ("center" === Xt) {
var Wt = G.layout[r[B]];
G.layout[n[B]] = _t + (zt - Wt) / 2;
} else
"stretch" === Xt && (G.layout[n[B]] = _t + a(G, B));
}
_t += zt;
}
}
var Gt = !1,
qt = !1;
if (
($ ||
((c.layout[r[I]] = S(M(c, I, ut + l(c, I)), K)),
("row-reverse" !== I && "column-reverse" !== I) ||
(Gt = !0)),
J ||
((c.layout[r[B]] = S(M(c, B, st + Q), Q)),
("row-reverse" !== B && "column-reverse" !== B) ||
(qt = !0)),
Gt || qt)
)
for (X = 0; X < L; ++X)
(G = c.children[X]), Gt && j(c, G, I), qt && j(c, G, B);
for (nt = et; null !== nt; ) {
for (W = 0; W < 2; W++)
(q = 0 !== W ? "row" : "column"),
!i(c.layout[r[q]]) &&
!x(nt, q) &&
w(nt, t[q]) &&
w(nt, e[q]) &&
(nt.layout[r[q]] = S(
M(
nt,
q,
c.layout[r[q]] -
d(c, q) -
f(nt, q) -
O(nt, t[q]) -
O(nt, e[q]),
),
p(nt, q),
)),
w(nt, e[q]) &&
!w(nt, t[q]) &&
(nt.layout[t[q]] =
c.layout[r[q]] - nt.layout[r[q]] - O(nt, e[q]));
(G = nt),
(nt = nt.nextAbsoluteChild),
(G.nextAbsoluteChild = null);
}
}
function N(t, e, n) {
t.shouldUpdate = !0;
var r = t.style.direction || "ltr";
!t.isDirty &&
t.lastLayout &&
t.lastLayout.requestedHeight === t.layout.height &&
t.lastLayout.requestedWidth === t.layout.width &&
t.lastLayout.parentMaxWidth === e &&
t.lastLayout.direction === r
? ((t.layout.width = t.lastLayout.width),
(t.layout.height = t.lastLayout.height),
(t.layout.top = t.lastLayout.top),
(t.layout.left = t.lastLayout.left))
: (t.lastLayout || (t.lastLayout = {}),
(t.lastLayout.requestedWidth = t.layout.width),
(t.lastLayout.requestedHeight = t.layout.height),
(t.lastLayout.parentMaxWidth = e),
(t.lastLayout.direction = r),
t.children.forEach(function (t) {
(t.layout.width = void 0),
(t.layout.height = void 0),
(t.layout.top = 0),
(t.layout.left = 0);
}),
E(t, e, n),
(t.lastLayout.width = t.layout.width),
(t.lastLayout.height = t.layout.height),
(t.lastLayout.top = t.layout.top),
(t.lastLayout.left = t.layout.left));
}
return {
layoutNodeImpl: E,
computeLayout: N,
fillNodes: function t(e) {
return (
(e.layout && !e.isDirty) ||
(e.layout = {
width: void 0,
height: void 0,
top: 0,
left: 0,
right: 0,
bottom: 0,
}),
e.style || (e.style = {}),
e.children || (e.children = []),
e.children.forEach(t),
e
);
},
};
})();
return (
"object" === a(e) && (t.exports = n),
function (t) {
n.fillNodes(t), n.computeLayout(t);
}
);
})
? r.apply(e, i)
: r) || (t.exports = o);
},
function (t, e, n) {
"use strict";
(function (t) {
n.d(e, "a", function () {
return d;
});
var r = function () {
for (var t = 0, e = 0, n = arguments.length; e < n; e++)
t += arguments[e].length;
var r = Array(t),
i = 0;
for (e = 0; e < n; e++)
for (var o = arguments[e], a = 0, s = o.length; a < s; a++, i++)
r[i] = o[a];
return r;
},
i = function (t, e, n) {
(this.name = t),
(this.version = e),
(this.os = n),
(this.type = "browser");
},
o = function (e) {
(this.version = e),
(this.type = "node"),
(this.name = "node"),
(this.os = t.platform);
},
a = function (t, e, n, r) {
(this.name = t),
(this.version = e),
(this.os = n),
(this.bot = r),
(this.type = "bot-device");
},
s = function () {
(this.type = "bot"),
(this.bot = !0),
(this.name = "bot"),
(this.version = null),
(this.os = null);
},
u = function () {
(this.type = "react-native"),
(this.name = "react-native"),
(this.version = null),
(this.os = null);
},
c =
/(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask\ Jeeves\/Teoma|ia_archiver)/,
h = [
["aol", /AOLShield\/([0-9\._]+)/],
["edge", /Edge\/([0-9\._]+)/],
["edge-ios", /EdgiOS\/([0-9\._]+)/],
["yandexbrowser", /YaBrowser\/([0-9\._]+)/],
["kakaotalk", /KAKAOTALK\s([0-9\.]+)/],
["samsung", /SamsungBrowser\/([0-9\.]+)/],
["silk", /\bSilk\/([0-9._-]+)\b/],
["miui", /MiuiBrowser\/([0-9\.]+)$/],
["beaker", /BeakerBrowser\/([0-9\.]+)/],
["edge-chromium", /EdgA?\/([0-9\.]+)/],
[
"chromium-webview",
/(?!Chrom.*OPR)wv\).*Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/,
],
["chrome", /(?!Chrom.*OPR)Chrom(?:e|ium)\/([0-9\.]+)(:?\s|$)/],
["phantomjs", /PhantomJS\/([0-9\.]+)(:?\s|$)/],
["crios", /CriOS\/([0-9\.]+)(:?\s|$)/],
["firefox", /Firefox\/([0-9\.]+)(?:\s|$)/],
["fxios", /FxiOS\/([0-9\.]+)/],
["opera-mini", /Opera Mini.*Version\/([0-9\.]+)/],
["opera", /Opera\/([0-9\.]+)(?:\s|$)/],
["opera", /OPR\/([0-9\.]+)(:?\s|$)/],
["ie", /Trident\/7\.0.*rv\:([0-9\.]+).*\).*Gecko$/],
["ie", /MSIE\s([0-9\.]+);.*Trident\/[4-7].0/],
["ie", /MSIE\s(7\.0)/],
["bb10", /BB10;\sTouch.*Version\/([0-9\.]+)/],
["android", /Android\s([0-9\.]+)/],
["ios", /Version\/([0-9\._]+).*Mobile.*Safari.*/],
["safari", /Version\/([0-9\._]+).*Safari/],
["facebook", /FBAV\/([0-9\.]+)/],
["instagram", /Instagram\s([0-9\.]+)/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Mobile/],
["ios-webview", /AppleWebKit\/([0-9\.]+).*Gecko\)$/],
[
"searchbot",
/alexa|bot|crawl(er|ing)|facebookexternalhit|feedburner|google web preview|nagios|postrank|pingdom|slurp|spider|yahoo!|yandex/,
],
],
l = [
["iOS", /iP(hone|od|ad)/],
["Android OS", /Android/],
["BlackBerry OS", /BlackBerry|BB10/],
["Windows Mobile", /IEMobile/],
["Amazon OS", /Kindle/],
["Windows 3.11", /Win16/],
["Windows 95", /(Windows 95)|(Win95)|(Windows_95)/],
["Windows 98", /(Windows 98)|(Win98)/],
["Windows 2000", /(Windows NT 5.0)|(Windows 2000)/],
["Windows XP", /(Windows NT 5.1)|(Windows XP)/],
["Windows Server 2003", /(Windows NT 5.2)/],
["Windows Vista", /(Windows NT 6.0)/],
["Windows 7", /(Windows NT 6.1)/],
["Windows 8", /(Windows NT 6.2)/],
["Windows 8.1", /(Windows NT 6.3)/],
["Windows 10", /(Windows NT 10.0)/],
["Windows ME", /Windows ME/],
["Open BSD", /OpenBSD/],
["Sun OS", /SunOS/],
["Chrome OS", /CrOS/],
["Linux", /(Linux)|(X11)/],
["Mac OS", /(Mac_PowerPC)|(Macintosh)/],
["QNX", /QNX/],
["BeOS", /BeOS/],
["OS/2", /OS\/2/],
];
function d(e) {
return e
? p(e)
: "undefined" == typeof document &&
"undefined" != typeof navigator &&
"ReactNative" === navigator.product
? new u()
: "undefined" != typeof navigator
? p(navigator.userAgent)
: void 0 !== t && t.version
? new o(t.version.slice(1))
: null;
}
function f(t) {
return (
"" !== t &&
h.reduce(function (e, n) {
var r = n[0],
i = n[1];
if (e) return e;
var o = i.exec(t);
return !!o && [r, o];
}, !1)
);
}
function p(t) {
var e = f(t);
if (!e) return null;
var n = e[0],
o = e[1];
if ("searchbot" === n) return new s();
var u = o[1] && o[1].split(/[._]/).slice(0, 3);
u
? u.length < 3 &&
(u = r(
u,
(function (t) {
for (var e = [], n = 0; n < t; n++) e.push("0");
return e;
})(3 - u.length),
))
: (u = []);
var h = u.join("."),
d = (function (t) {
for (var e = 0, n = l.length; e < n; e++) {
var r = l[e],
i = r[0];
if (r[1].exec(t)) return i;
}
return null;
})(t),
p = c.exec(t);
return p && p[1] ? new a(n, h, d, p[1]) : new i(n, h, d);
}
}).call(this, n(32));
},
,
,
,
,
,
,
,
function (t, e) {
var n,
r,
i = (t.exports = {});
function o() {
throw new Error("setTimeout has not been defined");
}
function a() {
throw new Error("clearTimeout has not been defined");
}
function s(t) {
if (n === setTimeout) return setTimeout(t, 0);
if ((n === o || !n) && setTimeout)
return (n = setTimeout), setTimeout(t, 0);
try {
return n(t, 0);
} catch (e) {
try {
return n.call(null, t, 0);
} catch (e) {
return n.call(this, t, 0);
}
}
}
!(function () {
try {
n = "function" == typeof setTimeout ? setTimeout : o;
} catch (t) {
n = o;
}
try {
r = "function" == typeof clearTimeout ? clearTimeout : a;
} catch (t) {
r = a;
}
})();
var u,
c = [],
h = !1,
l = -1;
function d() {
h &&
u &&
((h = !1), u.length ? (c = u.concat(c)) : (l = -1), c.length && f());
}
function f() {
if (!h) {
var t = s(d);
h = !0;
for (var e = c.length; e; ) {
for (u = c, c = []; ++l < e; ) u && u[l].run();
(l = -1), (e = c.length);
}
(u = null),
(h = !1),
(function (t) {
if (r === clearTimeout) return clearTimeout(t);
if ((r === a || !r) && clearTimeout)
return (r = clearTimeout), clearTimeout(t);
try {
r(t);
} catch (e) {
try {
return r.call(null, t);
} catch (e) {
return r.call(this, t);
}
}
})(t);
}
}
function p(t, e) {
(this.fun = t), (this.array = e);
}
function g() {}
(i.nextTick = function (t) {
var e = new Array(arguments.length - 1);
if (arguments.length > 1)
for (var n = 1; n < arguments.length; n++) e[n - 1] = arguments[n];
c.push(new p(t, e)), 1 !== c.length || h || s(f);
}),
(p.prototype.run = function () {
this.fun.apply(null, this.array);
}),
(i.title = "browser"),
(i.browser = !0),
(i.env = {}),
(i.argv = []),
(i.version = ""),
(i.versions = {}),
(i.on = g),
(i.addListener = g),
(i.once = g),
(i.off = g),
(i.removeListener = g),
(i.removeAllListeners = g),
(i.emit = g),
(i.prependListener = g),
(i.prependOnceListener = g),
(i.listeners = function (t) {
return [];
}),
(i.binding = function (t) {
throw new Error("process.binding is not supported");
}),
(i.cwd = function () {
return "/";
}),
(i.chdir = function (t) {
throw new Error("process.chdir is not supported");
}),
(i.umask = function () {
return 0;
});
},
function (t, e, n) {
"use strict";
n.r(e),
n.d(e, "TimeBar", function () {
return $e;
}),
n.d(e, "SnapLine", function () {
return qi;
}),
n.d(e, "Tooltip", function () {
return Hi;
}),
n.d(e, "Legend", function () {
return Zi;
}),
n.d(e, "ZoomSlider", function () {
return Ki;
}),
n.d(e, "EdgeFilterLens", function () {
return Ji;
}),
n.d(e, "Fisheye", function () {
return eo;
}),
n.d(e, "MiniMap", function () {
return io;
}),
n.d(e, "Bundling", function () {
return so;
}),
n.d(e, "Menu", function () {
return uo;
});
var r = {};
n.r(r),
n.d(r, "default", function () {
return Ut;
}),
n.d(r, "assign", function () {
return Et;
}),
n.d(r, "format", function () {
return Ht;
}),
n.d(r, "parse", function () {
return Vt;
}),
n.d(r, "defaultI18n", function () {
return It;
}),
n.d(r, "setGlobalDateI18n", function () {
return At;
}),
n.d(r, "setGlobalDateMasks", function () {
return qt;
});
var i = {};
n.r(i),
n.d(i, "compare", function () {
return Sn;
}),
n.d(i, "getLineIntersect", function () {
return jn;
}),
n.d(i, "getRectIntersectByPoint", function () {
return kn;
}),
n.d(i, "getCircleIntersectByPoint", function () {
return En;
}),
n.d(i, "getEllipseIntersectByPoint", function () {
return Nn;
}),
n.d(i, "applyMatrix", function () {
return Tn;
}),
n.d(i, "invertMatrix", function () {
return Pn;
}),
n.d(i, "getCircleCenterByPoints", function () {
return In;
}),
n.d(i, "distance", function () {
return Bn;
}),
n.d(i, "scaleMatrix", function () {
return An;
}),
n.d(i, "floydWarshall", function () {
return Ln;
}),
n.d(i, "getAdjMatrix", function () {
return Dn;
}),
n.d(i, "translate", function () {
return _n;
}),
n.d(i, "move", function () {
return Rn;
}),
n.d(i, "scale", function () {
return Yn;
}),
n.d(i, "rotate", function () {
return Fn;
}),
n.d(i, "getDegree", function () {
return zn;
}),
n.d(i, "isPointInPolygon", function () {
return Wn;
}),
n.d(i, "intersectBBox", function () {
return Gn;
}),
n.d(i, "isPolygonsIntersect", function () {
return qn;
}),
n.d(i, "Line", function () {
return Hn;
}),
n.d(i, "getBBoxBoundLine", function () {
return Vn;
}),
n.d(i, "itemIntersectByLine", function () {
return Zn;
}),
n.d(i, "fractionToLine", function () {
return Kn;
}),
n.d(i, "getPointsCenter", function () {
return Qn;
}),
n.d(i, "squareDist", function () {
return $n;
}),
n.d(i, "pointLineSquareDist", function () {
return Jn;
}),
n.d(i, "isPointsOverlap", function () {
return tr;
}),
n.d(i, "pointRectSquareDist", function () {
return er;
}),
n.d(i, "pointLineDistance", function () {
return nr;
});
var o = {};
n.r(o),
n.d(o, "getBBox", function () {
return gr;
}),
n.d(o, "getLoopCfgs", function () {
return yr;
}),
n.d(o, "getLabelPosition", function () {
return vr;
}),
n.d(o, "traverseTree", function () {
return br;
}),
n.d(o, "traverseTreeUp", function () {
return xr;
}),
n.d(o, "getLetterWidth", function () {
return wr;
}),
n.d(o, "getTextSize", function () {
return Or;
}),
n.d(o, "plainCombosToTrees", function () {
return Mr;
}),
n.d(o, "reconstructTree", function () {
return Sr;
}),
n.d(o, "getComboBBox", function () {
return Cr;
}),
n.d(o, "shouldRefreshEdge", function () {
return jr;
}),
n.d(o, "cloneBesidesImg", function () {
return kr;
});
var a = {};
n.r(a),
n.d(a, "uniqueId", function () {
return Ir;
}),
n.d(a, "formatPadding", function () {
return Br;
}),
n.d(a, "cloneEvent", function () {
return Ar;
}),
n.d(a, "isViewportChanged", function () {
return Lr;
}),
n.d(a, "isNaN", function () {
return Dr;
}),
n.d(a, "calculationItemsBBox", function () {
return _r;
}),
n.d(a, "processParallelEdges", function () {
return Rr;
});
var s = {};
n.r(s),
n.d(s, "getSpline", function () {
return oi;
}),
n.d(s, "getControlPoint", function () {
return ai;
}),
n.d(s, "pointsToPolygon", function () {
return si;
}),
n.d(s, "pathToPoints", function () {
return ui;
}),
n.d(s, "getClosedSpline", function () {
return ci;
}),
n.d(s, "roundedHull", function () {
return fi;
}),
n.d(s, "paddedHull", function () {
return pi;
});
var u = {};
n.r(u),
n.d(u, "defaultSubjectColors", function () {
return Fi;
});
var c,
h = n(1);
function l(t) {
if (/^[-\+\.\d]+$/.test(t)) return Number(t);
if (/true|false/.test(t)) return Boolean(t);
if (/^\s*\[/.test(t))
try {
return JSON.parse(t);
} catch (e) {
throw new Error("解析数组" + t + "失败");
}
if (/^\s*\{/.test(t))
try {
return JSON.parse(t);
} catch (e) {
throw new Error("解析对象" + t + "失败");
}
return t;
}
function d(t) {
return (
c[t] ||
t.startsWith("rgb(") ||
t.startsWith("rgba(") ||
(t.startsWith("#") && !isNaN(Number("0x" + t.slice(1))))
);
}
function f(t, e) {
t &&
e &&
(t.attrs.id && e("id", t.attrs.id),
t.attrs.class &&
p(t.attrs.class, /\s+/g).forEach(function (t) {
return e("class", t);
}),
e("tagName", t.tagName));
}
function p(t, e) {
return e
? t.split(e).filter(function (t) {
return "" != t;
})
: [t];
}
function g(t, e) {
if (!t || !e) return !1;
var n = e.match(/(^[^\.#]+)/g),
r = e.match(/#[^\.#]+/g),
i = e.match(/\.[^\.#]+/g),
o = Object(h.f)(
Object(h.f)(Object(h.f)([], n || []), r || []),
i || [],
),
a = {};
f(t, function (t, e) {
switch (t) {
case "id":
a["#" + e] = 1;
break;
case "class":
a["." + e] = 1;
break;
case "tagName":
a["" + e] = 1;
}
});
for (var s = 0, u = o; s < u.length; s++) {
var c = u[s];
if (!a[c]) return !1;
}
return !0;
}
!(function (t) {
(t[(t.aliceblue = 0)] = "aliceblue"),
(t[(t.antiquewhite = 1)] = "antiquewhite"),
(t[(t.aqua = 2)] = "aqua"),
(t[(t.aquamarine = 3)] = "aquamarine"),
(t[(t.azure = 4)] = "azure"),
(t[(t.beige = 5)] = "beige"),
(t[(t.bisque = 6)] = "bisque"),
(t[(t.black = 7)] = "black"),
(t[(t.blanchedalmond = 8)] = "blanchedalmond"),
(t[(t.blue = 9)] = "blue"),
(t[(t.blueviolet = 10)] = "blueviolet"),
(t[(t.brown = 11)] = "brown"),
(t[(t.burlywood = 12)] = "burlywood"),
(t[(t.cadetblue = 13)] = "cadetblue"),
(t[(t.chartreuse = 14)] = "chartreuse"),
(t[(t.chocolate = 15)] = "chocolate"),
(t[(t.coral = 16)] = "coral"),
(t[(t.cornflowerblue = 17)] = "cornflowerblue"),
(t[(t.cornsilk = 18)] = "cornsilk"),
(t[(t.crimson = 19)] = "crimson"),
(t[(t.cyan = 20)] = "cyan"),
(t[(t.darkblue = 21)] = "darkblue"),
(t[(t.darkcyan = 22)] = "darkcyan"),
(t[(t.darkgoldenrod = 23)] = "darkgoldenrod"),
(t[(t.darkgray = 24)] = "darkgray"),
(t[(t.darkgreen = 25)] = "darkgreen"),
(t[(t.darkgrey = 26)] = "darkgrey"),
(t[(t.darkkhaki = 27)] = "darkkhaki"),
(t[(t.darkmagenta = 28)] = "darkmagenta"),
(t[(t.darkolivegreen = 29)] = "darkolivegreen"),
(t[(t.darkorange = 30)] = "darkorange"),
(t[(t.darkorchid = 31)] = "darkorchid"),
(t[(t.darkred = 32)] = "darkred"),
(t[(t.darksalmon = 33)] = "darksalmon"),
(t[(t.darkseagreen = 34)] = "darkseagreen"),
(t[(t.darkslateblue = 35)] = "darkslateblue"),
(t[(t.darkslategray = 36)] = "darkslategray"),
(t[(t.darkslategrey = 37)] = "darkslategrey"),
(t[(t.darkturquoise = 38)] = "darkturquoise"),
(t[(t.darkviolet = 39)] = "darkviolet"),
(t[(t.deeppink = 40)] = "deeppink"),
(t[(t.deepskyblue = 41)] = "deepskyblue"),
(t[(t.dimgray = 42)] = "dimgray"),
(t[(t.dimgrey = 43)] = "dimgrey"),
(t[(t.dodgerblue = 44)] = "dodgerblue"),
(t[(t.firebrick = 45)] = "firebrick"),
(t[(t.floralwhite = 46)] = "floralwhite"),
(t[(t.forestgreen = 47)] = "forestgreen"),
(t[(t.fuchsia = 48)] = "fuchsia"),
(t[(t.gainsboro = 49)] = "gainsboro"),
(t[(t.ghostwhite = 50)] = "ghostwhite"),
(t[(t.gold = 51)] = "gold"),
(t[(t.goldenrod = 52)] = "goldenrod"),
(t[(t.gray = 53)] = "gray"),
(t[(t.green = 54)] = "green"),
(t[(t.greenyellow = 55)] = "greenyellow"),
(t[(t.grey = 56)] = "grey"),
(t[(t.honeydew = 57)] = "honeydew"),
(t[(t.hotpink = 58)] = "hotpink"),
(t[(t.indianred = 59)] = "indianred"),
(t[(t.indigo = 60)] = "indigo"),
(t[(t.ivory = 61)] = "ivory"),
(t[(t.khaki = 62)] = "khaki"),
(t[(t.lavender = 63)] = "lavender"),
(t[(t.lavenderblush = 64)] = "lavenderblush"),
(t[(t.lawngreen = 65)] = "lawngreen"),
(t[(t.lemonchiffon = 66)] = "lemonchiffon"),
(t[(t.lightblue = 67)] = "lightblue"),
(t[(t.lightcoral = 68)] = "lightcoral"),
(t[(t.lightcyan = 69)] = "lightcyan"),
(t[(t.lightgoldenrodyellow = 70)] = "lightgoldenrodyellow"),
(t[(t.lightgray = 71)] = "lightgray"),
(t[(t.lightgreen = 72)] = "lightgreen"),
(t[(t.lightgrey = 73)] = "lightgrey"),
(t[(t.lightpink = 74)] = "lightpink"),
(t[(t.lightsalmon = 75)] = "lightsalmon"),
(t[(t.lightseagreen = 76)] = "lightseagreen"),
(t[(t.lightskyblue = 77)] = "lightskyblue"),
(t[(t.lightslategray = 78)] = "lightslategray"),
(t[(t.lightslategrey = 79)] = "lightslategrey"),
(t[(t.lightsteelblue = 80)] = "lightsteelblue"),
(t[(t.lightyellow = 81)] = "lightyellow"),
(t[(t.lime = 82)] = "lime"),
(t[(t.limegreen = 83)] = "limegreen"),
(t[(t.linen = 84)] = "linen"),
(t[(t.magenta = 85)] = "magenta"),
(t[(t.maroon = 86)] = "maroon"),
(t[(t.mediumaquamarine = 87)] = "mediumaquamarine"),
(t[(t.mediumblue = 88)] = "mediumblue"),
(t[(t.mediumorchid = 89)] = "mediumorchid"),
(t[(t.mediumpurple = 90)] = "mediumpurple"),
(t[(t.mediumseagreen = 91)] = "mediumseagreen"),
(t[(t.mediumslateblue = 92)] = "mediumslateblue"),
(t[(t.mediumspringgreen = 93)] = "mediumspringgreen"),
(t[(t.mediumturquoise = 94)] = "mediumturquoise"),
(t[(t.mediumvioletred = 95)] = "mediumvioletred"),
(t[(t.midnightblue = 96)] = "midnightblue"),
(t[(t.mintcream = 97)] = "mintcream"),
(t[(t.mistyrose = 98)] = "mistyrose"),
(t[(t.moccasin = 99)] = "moccasin"),
(t[(t.navajowhite = 100)] = "navajowhite"),
(t[(t.navy = 101)] = "navy"),
(t[(t.oldlace = 102)] = "oldlace"),
(t[(t.olive = 103)] = "olive"),
(t[(t.olivedrab = 104)] = "olivedrab"),
(t[(t.orange = 105)] = "orange"),
(t[(t.orangered = 106)] = "orangered"),
(t[(t.orchid = 107)] = "orchid"),
(t[(t.palegoldenrod = 108)] = "palegoldenrod"),
(t[(t.palegreen = 109)] = "palegreen"),
(t[(t.paleturquoise = 110)] = "paleturquoise"),
(t[(t.palevioletred = 111)] = "palevioletred"),
(t[(t.papayawhip = 112)] = "papayawhip"),
(t[(t.peachpuff = 113)] = "peachpuff"),
(t[(t.peru = 114)] = "peru"),
(t[(t.pink = 115)] = "pink"),
(t[(t.plum = 116)] = "plum"),
(t[(t.powderblue = 117)] = "powderblue"),
(t[(t.purple = 118)] = "purple"),
(t[(t.red = 119)] = "red"),
(t[(t.rosybrown = 120)] = "rosybrown"),
(t[(t.royalblue = 121)] = "royalblue"),
(t[(t.saddlebrown = 122)] = "saddlebrown"),
(t[(t.salmon = 123)] = "salmon"),
(t[(t.sandybrown = 124)] = "sandybrown"),
(t[(t.seagreen = 125)] = "seagreen"),
(t[(t.seashell = 126)] = "seashell"),
(t[(t.sienna = 127)] = "sienna"),
(t[(t.silver = 128)] = "silver"),
(t[(t.skyblue = 129)] = "skyblue"),
(t[(t.slateblue = 130)] = "slateblue"),
(t[(t.slategray = 131)] = "slategray"),
(t[(t.slategrey = 132)] = "slategrey"),
(t[(t.snow = 133)] = "snow"),
(t[(t.springgreen = 134)] = "springgreen"),
(t[(t.steelblue = 135)] = "steelblue"),
(t[(t.tan = 136)] = "tan"),
(t[(t.teal = 137)] = "teal"),
(t[(t.thistle = 138)] = "thistle"),
(t[(t.tomato = 139)] = "tomato"),
(t[(t.turquoise = 140)] = "turquoise"),
(t[(t.violet = 141)] = "violet"),
(t[(t.wheat = 142)] = "wheat"),
(t[(t.white = 143)] = "white"),
(t[(t.whitesmoke = 144)] = "whitesmoke"),
(t[(t.yellow = 145)] = "yellow"),
(t[(t.yellowgreen = 146)] = "yellowgreen");
})(c || (c = {}));
var y = {
position: 1,
display: 1,
width: 1,
height: 1,
minWidth: 1,
minHeight: 1,
top: 1,
left: 1,
right: 1,
bottom: 1,
flex: 1,
margin: 1,
marginLeft: 1,
marginRight: 1,
marginTop: 1,
marginBottom: 1,
padding: 1,
paddingLeft: 1,
paddingRight: 1,
paddingTop: 1,
paddingBottom: 1,
borderWidth: 1,
borderLeftWidth: 1,
borderRightWidth: 1,
borderTopWidth: 1,
borderBottomWidth: 1,
flexDirection: 1,
justifyContent: 1,
alignItems: 1,
alignSelf: 1,
flexWrap: 1,
},
v = {};
function m(t, e) {
if (t) {
var n = t;
Array.isArray(n) || (n = [n]),
n.forEach(function (t) {
v[t] = "function" == typeof e ? e : l;
});
}
}
var b = function (t, e) {
var n = {},
r = e.split(/\s/g).filter(function (t) {
return "" !== t;
});
return (
1 !== r.length || isNaN(r[0]) || (n["" + t] = Number(r[0])),
2 === r.length &&
(!isNaN(Number(r[0])) &&
(n[t + "Bottom"] = n[t + "Top"] = Number(r[0])),
!isNaN(Number(r[1])) &&
(n[t + "Left"] = n[t + "Right"] = Number(r[1]))),
3 === r.length &&
(!isNaN(Number(r[0])) && (n[t + "Top"] = Number(r[0])),
!isNaN(Number(r[1])) &&
(n[t + "Left"] = n[t + "Right"] = Number(r[1])),
!isNaN(Number(r[2])) && (n[t + "Bottom"] = Number(r[2]))),
4 === r.length &&
(!isNaN(Number(r[0])) && (n[t + "Top"] = Number(r[0])),
!isNaN(Number(r[1])) && (n[t + "Right"] = Number(r[1])),
!isNaN(Number(r[2])) && (n[t + "Bottom"] = Number(r[2])),
!isNaN(Number(r[3])) && (n[t + "Left"] = Number(r[3]))),
n
);
},
x = ["solid", "dashed"];
function w(t, e) {
if (v[t]) return v[t](e);
try {
return l(e);
} catch (t) {
return console.error(t), e;
}
}
m("padding", b.bind(null, "padding")),
m("margin", b.bind(null, "margin")),
m("border-radius", function (t) {
var e = {},
n = t.split(/\s/g).filter(function (t) {
return "" !== t;
});
return (
1 !== n.length ||
isNaN(n[0]) ||
((e.borderTopLeftRadius = Number(n[0])),
(e.borderTopRightRadius = Number(n[0])),
(e.borderBottomRightRadius = Number(n[0])),
(e.borderBottomLeftRadius = Number(n[0]))),
2 === n.length &&
(!isNaN(Number(n[0])) &&
(e.borderTopLeftRadius = e.borderBottomRightRadius =
Number(n[0])),
!isNaN(Number(n[2])) &&
(e.borderBottomLeftRadius = e.borderTopRightRadius =
Number(n[1]))),
3 === n.length &&
(!isNaN(Number(n[0])) && (e.borderTopLeftRadius = Number(n[0])),
!isNaN(Number(n[1])) &&
(e.borderBottomLeftRadius = e.borderTopRightRadius =
Number(n[1])),
!isNaN(Number(n[2])) &&
(e.borderBottomRightRadius = Number(n[2]))),
4 === n.length &&
(!isNaN(Number(n[0])) && (e.borderTopLeftRadius = Number(n[0])),
!isNaN(Number(n[1])) && (e.borderTopRightRadius = Number(n[1])),
!isNaN(Number(n[2])) &&
(e.borderBottomRightRadius = Number(n[2])),
!isNaN(Number(n[3])) &&
(e.borderBottomLeftRadius = Number(n[3]))),
e
);
}),
m("border", function (t) {
for (
var e = {},
n = 0,
r = t.split(/\s/g).filter(function (t) {
return "" !== t;
});
n < r.length;
n++
) {
var i = r[n];
isNaN(Number(i))
? d(i)
? (e.borderColor = i)
: x.includes(i) && (e.borderStyle = i)
: (e.borderWidth = Number(i));
}
return e;
}),
m("background", function (t) {
for (
var e = {},
n = 0,
r = t.split(/\s/g).filter(function (t) {
return "" !== t;
});
n < r.length;
n++
)
if (d((t = r[n]))) e.backgroundColor = t;
else if (null == t ? void 0 : t.startsWith("url")) {
var i = t.match(/url\((.+?)\)/);
i && (e.backgroundImage = i[1]);
}
return e;
}),
m(["box-shadow", "text-shadow"], function (t) {
for (
var e = {},
n = t.split(/\s/g).filter(function (t) {
return "" !== t;
}),
r = [
"shadowOffsetX",
"shadowOffsetY",
"shadowBlur",
"shadowColor",
];
n.length;
) {
var i = n.shift();
if (isNaN(Number(i))) d(i) && (e.shadowColor = i);
else e[r.shift()] = Number(i);
}
return e;
});
var O = function () {
(this.type = ""),
(this.tagName = ""),
(this.attrs = {}),
(this.children = []),
(this.text = "");
},
M = (function () {
function t(t) {
(this.input = ""), (this.index = 0), (this.input = t);
}
return (
(t.prototype.stepNext = function () {
this.index++;
}),
(t.prototype.cur = function () {
return this.input[this.index];
}),
(t.prototype.twoChar = function () {
return this.input[this.index] + this.input[this.index + 1];
}),
(t.prototype.stepWhile = function (t) {
for (
var e = "";
this.index < this.input.length &&
t &&
t(this.input[this.index]);
)
e += this.input[this.index++];
return e;
}),
(t.prototype.skipWhiteSpace = function () {
this.stepWhile(function (t) {
return /\s/.test(t);
});
}),
(t.prototype.getText = function () {
return this.stepWhile(function (t) {
return /[a-zA-Z0-9_]/.test(t);
});
}),
(t.prototype.eof = function () {
return this.index >= this.input.length;
}),
t
);
})(),
S = (function () {
function t(t) {
this.helper = new M(t);
}
return (
(t.prototype.parse = function () {
return this.parseNodes();
}),
(t.prototype.parseNodes = function () {
for (
var t = [];
t.push(this.parseNode()),
this.helper.skipWhiteSpace(),
!this.helper.eof() && "" === this.helper.twoChar())
)
return this.helper.stepNext(), this.helper.stepNext(), e;
if (">" !== this.helper.cur())
throw new Error("解析标签开始失败");
if (
(this.helper.stepNext(),
this.helper.skipWhiteSpace(),
"" !== this.helper.cur())
throw new Error("解析标签结束失败");
return this.helper.stepNext(), e;
}),
(t.prototype.parseTextNode = function () {
var t = new O(),
e = this.helper.stepWhile(function (t) {
return /[^<]/.test(t);
});
return (t.type = "text"), (t.tagName = "text"), (t.text = e), t;
}),
(t.prototype.parseAttributes = function () {
var t = {};
for (
this.helper.skipWhiteSpace();
!this.helper.eof() &&
">" !== this.helper.cur() &&
"/>" !== this.helper.twoChar();
) {
var e = this.helper.stepWhile(function (t) {
return /[^\s=]/.test(t);
});
this.helper.skipWhiteSpace(),
this.helper.stepNext(),
this.helper.skipWhiteSpace();
var n = "";
'"' === this.helper.cur()
? (this.helper.stepNext(),
(n = this.helper.stepWhile(function (t) {
return /[^"]/.test(t);
})),
this.helper.stepNext())
: "'" === this.helper.cur()
? (this.helper.stepNext(),
(n = this.helper.stepWhile(function (t) {
return /[^']/.test(t);
})),
this.helper.stepNext())
: (n = this.helper.stepWhile(function (t) {
return /[^\s/]/.test(t);
})),
(t[e] = w(e, n)),
this.helper.skipWhiteSpace();
}
return t;
}),
(t.prototype.removeQuote = function (t) {
var e = t;
return (
/^["']/.test(e[0]) && (e = e.slice(1)),
/["']$/.test(e[e.length - 1]) && (e = e.slice(0, -1)),
e
);
}),
t
);
})();
function C(t) {
return (C =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var j = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
function k(t) {
return t ? t.replace(/^\s+|\s+$/g, "") : "";
}
var E = function (t, e) {
e = e || {};
var n = 1,
r = 1;
function i(t) {
var e = t.match(/\n/g);
e && (n += e.length);
var i = t.lastIndexOf("\n");
r = ~i ? t.length - i : r + t.length;
}
function o() {
var t = { line: n, column: r };
return function (e) {
return (e.position = new a(t)), f(), e;
};
}
function a(t) {
(this.start = t),
(this.end = { line: n, column: r }),
(this.source = e.source);
}
a.prototype.content = t;
var s = [];
function u(i) {
var o = new Error(e.source + ":" + n + ":" + r + ": " + i);
if (
((o.reason = i),
(o.filename = e.source),
(o.line = n),
(o.column = r),
(o.source = t),
!e.silent)
)
throw o;
s.push(o);
}
function c() {
return d(/^{\s*/);
}
function h() {
return d(/^}/);
}
function l() {
var e,
n = [];
for (
f(), p(n);
t.length && "}" != t.charAt(0) && (e = E() || N());
)
!1 !== e && (n.push(e), p(n));
return n;
}
function d(e) {
var n = e.exec(t);
if (n) {
var r = n[0];
return i(r), (t = t.slice(r.length)), n;
}
}
function f() {
d(/^\s*/);
}
function p(t) {
var e;
for (t = t || []; (e = g()); ) !1 !== e && t.push(e);
return t;
}
function g() {
var e = o();
if ("/" == t.charAt(0) && "*" == t.charAt(1)) {
for (
var n = 2;
"" != t.charAt(n) &&
("*" != t.charAt(n) || "/" != t.charAt(n + 1));
)
++n;
if (((n += 2), "" === t.charAt(n - 1)))
return u("End of comment missing");
var a = t.slice(2, n - 2);
return (
(r += 2),
i(a),
(t = t.slice(n)),
(r += 2),
e({ type: "comment", comment: a })
);
}
}
function y() {
var t = d(/^([^{]+)/);
if (t)
return k(t[0])
.replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, "")
.replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function (t) {
return t.replace(/,/g, "");
})
.split(/\s*(?![^(]*\)),\s*/)
.map(function (t) {
return t.replace(/\u200C/g, ",");
});
}
function v() {
var t = o(),
e = d(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
if (e) {
if (((e = k(e[0])), !d(/^:\s*/)))
return u("property missing ':'");
var n = d(
/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/,
),
r = t({
type: "declaration",
property: e.replace(j, ""),
value: n ? k(n[0]).replace(j, "") : "",
});
return d(/^[;\s]*/), r;
}
}
function m() {
var t,
e = [];
if (!c()) return u("missing '{'");
for (p(e); (t = v()); ) !1 !== t && (e.push(t), p(e));
return h() ? e : u("missing '}'");
}
function b() {
for (
var t, e = [], n = o();
(t = d(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/));
)
e.push(t[1]), d(/^,\s*/);
if (e.length)
return n({ type: "keyframe", values: e, declarations: m() });
}
var x,
w = S("import"),
O = S("charset"),
M = S("namespace");
function S(t) {
var e = new RegExp("^@" + t + "\\s*([^;]+);");
return function () {
var n = o(),
r = d(e);
if (r) {
var i = { type: t };
return (i[t] = r[1].trim()), n(i);
}
};
}
function E() {
if ("@" == t[0])
return (
(function () {
var t = o();
if ((e = d(/^@([-\w]+)?keyframes\s*/))) {
var e,
n = e[1];
if (!(e = d(/^([-\w]+)\s*/)))
return u("@keyframes missing name");
var r,
i = e[1];
if (!c()) return u("@keyframes missing '{'");
for (var a = p(); (r = b()); )
a.push(r), (a = a.concat(p()));
return h()
? t({
type: "keyframes",
name: i,
vendor: n,
keyframes: a,
})
: u("@keyframes missing '}'");
}
})() ||
(function () {
var t = o(),
e = d(/^@media *([^{]+)/);
if (e) {
var n = k(e[1]);
if (!c()) return u("@media missing '{'");
var r = p().concat(l());
return h()
? t({ type: "media", media: n, rules: r })
: u("@media missing '}'");
}
})() ||
(function () {
var t = o(),
e = d(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/);
if (e)
return t({
type: "custom-media",
name: k(e[1]),
media: k(e[2]),
});
})() ||
(function () {
var t = o(),
e = d(/^@supports *([^{]+)/);
if (e) {
var n = k(e[1]);
if (!c()) return u("@supports missing '{'");
var r = p().concat(l());
return h()
? t({ type: "supports", supports: n, rules: r })
: u("@supports missing '}'");
}
})() ||
w() ||
O() ||
M() ||
(function () {
var t = o(),
e = d(/^@([-\w]+)?document *([^{]+)/);
if (e) {
var n = k(e[1]),
r = k(e[2]);
if (!c()) return u("@document missing '{'");
var i = p().concat(l());
return h()
? t({
type: "document",
document: r,
vendor: n,
rules: i,
})
: u("@document missing '}'");
}
})() ||
(function () {
var t = o();
if (d(/^@page */)) {
var e = y() || [];
if (!c()) return u("@page missing '{'");
for (var n, r = p(); (n = v()); )
r.push(n), (r = r.concat(p()));
return h()
? t({ type: "page", selectors: e, declarations: r })
: u("@page missing '}'");
}
})() ||
(function () {
var t = o();
if (d(/^@host\s*/)) {
if (!c()) return u("@host missing '{'");
var e = p().concat(l());
return h()
? t({ type: "host", rules: e })
: u("@host missing '}'");
}
})() ||
(function () {
var t = o();
if (d(/^@font-face\s*/)) {
if (!c()) return u("@font-face missing '{'");
for (var e, n = p(); (e = v()); )
n.push(e), (n = n.concat(p()));
return h()
? t({ type: "font-face", declarations: n })
: u("@font-face missing '}'");
}
})()
);
}
function N() {
var t = o(),
e = y();
return e
? (p(), t({ type: "rule", selectors: e, declarations: m() }))
: u("selector missing");
}
return (function t(e, n) {
var r = e && "string" == typeof e.type,
i = r ? e : n;
for (var o in e) {
var a = e[o];
Array.isArray(a)
? a.forEach(function (e) {
t(e, i);
})
: a && "object" === C(a) && t(a, i);
}
r &&
Object.defineProperty(e, "parent", {
configurable: !0,
writable: !0,
enumerable: !1,
value: n || null,
});
return e;
})(
((x = l()),
{
type: "stylesheet",
stylesheet: { source: e.source, rules: x, parsingErrors: s },
}),
);
},
N = n(23),
T = n.n(N);
function P(t) {
return (P =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var I = function () {
(this.dom = null),
(this.style = null),
(this.children = []),
(this.originChildren = []);
},
B = { "font-family": "serif" },
A = [
"font",
"fontFamily",
"fontWeight",
"fontSize",
"fontVariant",
"fontStretch",
"textIndent",
"textAlign",
"textShadow",
"lineHeight",
"color",
"direction",
"wordSpacing",
"letterSpacing",
"textTransform",
"captionSide",
"borderCollapse",
"emptyCells",
"listStyleType",
"listStyleImage",
"listStylePosition",
"listStyle",
"visibility",
"cursor",
],
L = (function () {
function t(t, e) {
(this.domTree = null),
(this.cssTree = null),
(this.rulesHash = { ids: {}, classes: {}, tagNames: {} }),
(this.domTree = t),
(this.cssTree = e);
}
return (
(t.prototype.parse = function () {
return (
this.parseRulesHash(this.cssTree),
this.genStyleTree(this.domTree)
);
}),
(t.prototype.parseRulesHash = function (t) {
for (
var e = this.rulesHash, n = 0, r = t.stylesheet.rules;
n < r.length;
n++
) {
var i = r[n];
if ("rule" === i.type)
for (var o = 0, a = i.selectors; o < a.length; o++) {
var s = a[o],
u = this.genKeySelector(s);
switch (u[0]) {
case "#":
var c = u.slice(1);
e.ids[c] = Object(h.f)(
Object(h.f)([], e.ids[c] || []),
[
{
selector: s,
specificity: this.genSpecificity(s),
style: this.genStyleFromRule(i),
},
],
);
break;
case ".":
var l = u.slice(1);
e.classes[l] = Object(h.f)(
Object(h.f)([], e.classes[l] || []),
[
{
selector: s,
specificity: this.genSpecificity(s),
style: this.genStyleFromRule(i),
},
],
);
break;
default:
e.tagNames[u] = Object(h.f)(
Object(h.f)([], e.tagNames[u] || []),
[
{
selector: s,
specificity: this.genSpecificity(s),
style: this.genStyleFromRule(i),
},
],
);
}
}
}
}),
(t.prototype.genStyleTree = function (t) {
for (var e = new I(), n = [[t, [], e]]; n.length; ) {
var r = n.pop(),
i = r[0],
o = r[1],
a = r[2],
s = r[3];
(a.dom = i),
(a.style = this.computeCSS(
i,
o,
null == s ? void 0 : s.style,
));
for (var u = 0, c = i.children; u < c.length; u++) {
var l = c[u],
d = new I();
a.originChildren.push(d),
n.push([l, Object(h.f)(Object(h.f)([], o), [i]), d, a]);
}
}
return e;
}),
(t.prototype.genSpecificity = function (t) {
var e,
n,
r =
(null === (e = t.match(/#\w+/g)) || void 0 === e
? void 0
: e.length) || 0,
i =
(null === (n = t.match(/\.\w+/g)) || void 0 === n
? void 0
: n.length) || 0;
return (
100 * r +
10 * i +
(t.split(/\s+|#|\./).filter(function (t) {
return "" !== t;
}).length -
r -
i)
);
}),
(t.prototype.genKeySelector = function (t) {
var e = p(t, /\s/).pop(),
n = e.match(/(#[^\.#]+)/);
return (null == n ? void 0 : n.length) > 0 ||
(null == (n = e.match(/\.[^\.#]+/)) ? void 0 : n.length) > 0
? n[0]
: e;
}),
(t.prototype.genStyleFromRule = function (t) {
return this.genStyleFromDeclaration(t.declarations);
}),
(t.prototype.genStyleFromDeclaration = function (t) {
var e = {};
return (
t.forEach(function (t) {
var n = t.value;
e[t.property] = n;
}),
e
);
}),
(t.prototype.computeCSS = function (t, e, n) {
var r = this,
i = [];
f(t, function (t, e) {
switch (t) {
case "id":
i.push.apply(i, r.rulesHash.ids[e] || []);
break;
case "class":
i.push.apply(i, r.rulesHash.classes[e] || []);
break;
case "tagName":
i.push.apply(i, r.rulesHash.tagNames[e] || []);
}
});
var o = i.filter(function (t) {
for (
var n = p(t.selector, /\s+/g),
r = n.length - 2,
i = e.length - 1,
o = !0;
r > -1;
r--
) {
for (var a = !1; i > -1; i--) {
if (g(e[i], n[r])) {
a = !0;
break;
}
}
if (!a) {
o = !1;
break;
}
}
return o;
});
o.sort(function (t, e) {
return t.specificity - e.specificity;
});
for (
var a = o.reduce(
function (t, e) {
return Object.assign(t, e.style);
},
Object(h.a)({}, B),
),
s = {},
u = 0,
c = Object.entries(a);
u < c.length;
u++
) {
var l = c[u],
d = l[0],
y = l[1],
v = d
.split("-")
.map(function (t, e) {
return e > 0 ? "" + t[0].toUpperCase() + t.slice(1) : t;
})
.join(""),
m = w(d, y);
"object" === P(m)
? (s = Object(h.a)(Object(h.a)({}, s), m))
: (s[v] = m);
}
if (n) {
for (var b = 0, x = Object.entries(s); b < x.length; b++) {
var O = x[b];
d = O[0];
"inherit" === (y = O[1]) &&
A.includes(d) &&
(delete s[d], void 0 !== n[d] && (s[d] = n[d]));
}
for (var M = 0, S = Object.entries(n); M < S.length; M++) {
var C = S[M];
(d = C[0]), (y = C[1]);
A.includes(d) && !s[d] && (s[d] = y);
}
}
return s;
}),
t
);
})(),
D = {};
function _(t, e) {
D[t] = e;
}
function R(t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
var r = D[t];
if (!r) throw new Error("找不到标签" + t + "的构造函数");
var i = new (r.bind.apply(r, Object(h.f)([void 0], e)))();
return i;
}
var Y = (function () {
function t(t) {
var e = this;
(this.styleNode = null),
(this.gNode = null),
(this.parent = null),
(this.children = []),
(this.isMounted = !1),
(this.isDisplay = !0),
(this._parentGNode = null),
(this._prevAttrs = null),
(this._prevStyle = null),
(this._prevLayout = null),
(this.events = {}),
(this.trigger = function (t) {
for (var n, r, i = t.target; i && !i.get("uiNode"); )
i = i.get("parent");
(t.targetGNode = i || null),
(t.uiNode =
null !== (n = null == i ? void 0 : i.get("uiNode")) &&
void 0 !== n
? n
: null),
null === (r = e.events[t.type]) ||
void 0 === r ||
r.forEach(function (n) {
return n(t, e);
});
}),
(this.styleNode = t);
}
return (
Object.defineProperty(t.prototype, "top", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.layout) || void 0 === e
? void 0
: e.top;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "left", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.layout) || void 0 === e
? void 0
: e.left;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "width", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.layout) || void 0 === e
? void 0
: e.width;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "height", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.layout) || void 0 === e
? void 0
: e.height;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "tagName", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.dom) || void 0 === e
? void 0
: e.tagName;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "style", {
get: function () {
var t;
return null === (t = this.styleNode) || void 0 === t
? void 0
: t.style;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "attributes", {
get: function () {
var t, e;
return null ===
(e =
null === (t = this.styleNode) || void 0 === t
? void 0
: t.dom) || void 0 === e
? void 0
: e.attrs;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "_layout", {
get: function () {
var t;
return null === (t = this.styleNode) || void 0 === t
? void 0
: t._layout;
},
enumerable: !1,
configurable: !0,
}),
Object.defineProperty(t.prototype, "parentGNode", {
get: function () {
var t;
return (
(null === (t = this.parent) || void 0 === t
? void 0
: t.gNode) || this._parentGNode
);
},
set: function (t) {
this._parentGNode = t;
},
enumerable: !1,
configurable: !0,
}),
(t.prototype.setParent = function (t) {
this.parent = t;
}),
(t.prototype.appendChild = function () {
for (var t = this, e = [], n = 0; n < arguments.length; n++)
e[n] = arguments[n];
e.forEach(function (e) {
e.setParent(t),
t.children.push(e),
e.styleNode &&
t.styleNode &&
!t.styleNode.originChildren.includes(e.styleNode) &&
t.styleNode.originChildren.push(e.styleNode);
}),
this.reflow();
}),
(t.prototype.removeChild = function (t) {
t && t.remove();
}),
(t.prototype.remove = function () {
var t,
e,
n = this.parent;
null === (t = this.gNode) || void 0 === t || t.remove(),
n &&
(n.children.splice(1, n.children.indexOf(this)),
null === (e = n.styleNode) ||
void 0 === e ||
e.children.splice(1, n.children.indexOf(this.styleNode)),
this.isMounted && n.reflow()),
this.isMounted && this.unmount();
}),
(t.prototype.query = function (t) {
if ("string" == typeof t)
for (
var e = [
[
this,
t.split(/\s+/g).filter(function (t) {
return "" !== t;
}),
],
];
e.length;
)
for (
var n = e.shift(),
r = n[0],
i = n[1],
o = 0,
a = r.children;
o < a.length;
o++
) {
var s = a[o],
u = [];
if (s.styleNode && g(s.styleNode.dom, i[0])) {
if (0 === i.slice(1).length) return s;
u = i.slice(1);
} else u = i;
e.push([s, u]);
}
}),
(t.prototype.queryAll = function (t) {
if ("string" == typeof t) {
for (
var e = [],
n = [
[
this,
t.split(/\s+/g).filter(function (t) {
return "" !== t;
}),
e,
],
];
n.length;
)
for (
var r = n.shift(),
i = r[0],
o = r[1],
a = r[2],
s = 0,
u = i.children;
s < u.length;
s++
) {
var c = u[s],
h = [];
c.styleNode && g(c.styleNode.dom, o[0])
? 0 === o.slice(1).length
? (a.push(c), (h = [o[0]]))
: (h = o.slice(1))
: (h = o),
n.push([c, h, a]);
}
return e;
}
}),
(t.prototype.manualMount = function (t) {
(this.parentGNode = t), this.layout(), this.mount();
}),
(t.prototype.reflow = function () {
var t;
this.parentGNode &&
("absolute" !==
(null === (t = this.style) || void 0 === t
? void 0
: t.position) && this.parent
? this.parent.reflow()
: (this.layout(), this.render()));
}),
(t.prototype.layout = function () {
(this._prevLayout = Object(h.a)({}, this._layout || {})),
this.clearLayout(),
(function (t) {
for (var e = [t]; e.length; ) {
var n = e.pop();
n.children = n.originChildren.filter(function (t) {
return "none" !== t.style.display && (e.push(t), !0);
});
}
T()(t);
})(this.styleNode);
}),
(t.prototype.mount = function () {
var t;
this.isMounted ||
("none" !==
(null === (t = this.style) || void 0 === t ? void 0 : t.display)
? ((this._prevAttrs = this.attributes),
(this._prevStyle = this.style),
this.draw(this.parentGNode),
(this.isMounted = !0),
this.gNode.set("uiNode", this),
this.gNode.on("*", this.trigger),
this.children.forEach(function (t) {
return t.mount();
}),
this.didMount())
: (this.isDisplay = !1));
}),
(t.prototype.didMount = function () {}),
(t.prototype.unmount = function () {
this.isMounted &&
((this.isMounted = !1),
this.children.forEach(function (t) {
return t.unmount();
}),
this.didUnmount());
}),
(t.prototype.didUnmount = function () {}),
(t.prototype.render = function () {
var t, e, n;
if (this.isMounted) {
if (
"none" ===
(null === (t = this.style) || void 0 === t
? void 0
: t.display)
)
return (
(this.isDisplay = !1),
null === (e = this.gNode) || void 0 === e || e.remove(!1),
!1
);
!1 === this.isDisplay &&
((this.isDisplay = !0),
null === (n = this.parentGNode) ||
void 0 === n ||
n.add(this.gNode));
var r = this.shouldUpdate(
this._prevAttrs,
this._prevStyle,
this._prevLayout,
);
r && this.draw(),
this.children.forEach(function (t) {
return t.render();
}),
r && this.didUpdate();
} else this.mount();
}),
(t.prototype.didUpdate = function () {}),
(t.prototype.shouldUpdate = function (t, e, n) {
return !0;
}),
(t.prototype.draw = function (t) {}),
(t.prototype.animate = function () {}),
(t.prototype.clearLayout = function () {
(this.styleNode.isDirty = !0),
this.children.forEach(function (t) {
t.clearLayout();
});
}),
(t.prototype.setAttribute = function (t, e) {
var n;
if (this.styleNode && this.styleNode.dom) {
if (
((this._prevAttrs = Object(h.a)(
{},
this.styleNode.dom.attrs,
)),
(this.styleNode.dom.attrs[t] = e),
!(null === (n = this.parent) || void 0 === n
? void 0
: n.isMounted))
)
return;
this.render();
}
}),
(t.prototype.setStyle = function (t, e) {
if (this.styleNode && this.styleNode.style) {
if (
((this._prevStyle = Object(h.a)(
{},
this.styleNode.dom.style,
)),
(this.styleNode.style[t] = e),
this.parent && !this.parent.isMounted)
)
return;
y[t] ? this.reflow() : this.render();
}
}),
(t.prototype.getAttribute = function (t) {
var e, n;
return null ===
(n =
null === (e = this.styleNode) || void 0 === e
? void 0
: e.dom) || void 0 === n
? void 0
: n.attrs[t];
}),
(t.prototype.getStyle = function (t) {
var e, n, r;
return null !==
(n =
null === (e = this.styleNode) || void 0 === e
? void 0
: e.layout[t]) && void 0 !== n
? n
: null === (r = this.styleNode) || void 0 === r
? void 0
: r.style[t];
}),
(t.prototype.setText = function (t) {
var e = this.query("text");
e &&
e.styleNode &&
e.styleNode.dom &&
((e.styleNode.dom.text = t), e.render());
}),
(t.prototype.on = function (t, e) {
this.events[t] = Object(h.f)(
Object(h.f)([], this.events[t] || []),
[e],
);
}),
(t.prototype.off = function (t, e) {
if (e) {
var n = this.events[t],
r = null == n ? void 0 : n.indexOf(e);
r && -1 !== r && (null == n || n.splice(r, 1));
} else delete this.events[t];
}),
t
);
})(),
F = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.backgroudNode = null), e;
}
return (
Object(h.c)(e, t),
(e.prototype.draw = function (t) {
var e, n;
this.gNode ||
(this.gNode = t.addGroup({
id:
null === (e = this.attributes) || void 0 === e
? void 0
: e.id,
className: this.styleNode.dom.attrs.class,
}));
var r = this.gNode,
i = this.styleNode;
r.resetMatrix(),
null === (n = this.backgroudNode) || void 0 === n || n.remove();
var o = (this.backgroudNode = r.addGroup());
r.translate(this.left, this.top);
var a = i.style;
"number" == typeof a.zIndex && r.setZIndex(a.zIndex),
o.addShape("rect", {
attrs: {
x: 0,
y: 0,
fill: a.backgroundColor || "#fff",
fillOpacity: a.backgroundOpacity,
opacity: a.opacity,
width: this.width,
height: this.height,
radius: [
a.borderTopLeftRadius || 0,
a.borderTopRightRadius || 0,
a.borderBottomLeftRadius || 0,
a.borderBottomLeftRadius || 0,
],
shadowBlur: a.shadowBlur || 0,
shadowColor: a.shadowColor || null,
shadowOffsetX: a.shadowOffsetX || 0,
shadowOffsetY: a.shadowOffsetY || 0,
},
capture: "none" !== a.pointerEvents,
}),
a.backgroundImage &&
o.addShape("image", {
attrs: {
x: 0,
y: 0,
img: a.url,
width: this.width,
height: this.height,
},
capture: !1,
});
var s = {
attrs: {
x: (a.borderWidth || 0) / 2,
y: (a.borderWidth || 0) / 2,
lineWidth: a.borderWidth,
stroke: a.borderColor,
width: this.width - (a.borderWidth || 0),
height: this.height - (a.borderWidth || 0),
radius: [
(a.borderTopLeftRadius || 0) *
((this.width - (a.borderWidth || 0)) / this.width),
(a.borderTopRightRadius || 0) *
((this.width - (a.borderWidth || 0)) / this.width),
(a.borderBottomLeftRadius || 0) *
((this.width - (a.borderWidth || 0)) / this.width),
(a.borderBottomLeftRadius || 0) *
((this.width - (a.borderWidth || 0)) / this.width),
],
},
capture: !1,
};
"dashed" === a.borderStyle &&
(s.attrs.lineDash = a.lineDash || [2, 2]),
o.addShape("rect", s),
"hidden" === a.overflow &&
r.setClip({
type: "rect",
attrs: {
width: this.width,
height: this.height,
radius: [
a.borderTopLeftRadius || 0,
a.borderTopRightRadius || 0,
a.borderBottomLeftRadius || 0,
a.borderBottomLeftRadius || 0,
],
},
}),
o.toBack();
}),
e
);
})(Y),
z = n(13),
X = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getAttrs = function () {
var t = this.styleNode.style;
return {
x: this.styleNode.layout.left,
y: this.styleNode.layout.top,
textAlign: t.textAlign,
fill: t.color,
fontSize: t.fontSize || 12,
fontStyle: t.fontStyle,
fontFamily: t.fontFamily,
lineHeight: t.lineHeight || 0,
fontVariant: t.fontVariant,
fontWeight: t.fontWeight,
textBaseline: "top",
opacity: t.opacity,
fillOpacity: t.backgroundOpacity,
};
}),
(e.prototype.draw = function (t) {
var e = this.getAttrs();
this.gNode ||
(this.gNode = t.addShape("text", {
type: "text",
attrs: e,
capture: !1,
})),
this.update();
}),
(e.prototype.getMultiLineText = function (t, e, n) {
var r,
i =
null === (r = this.parent.gNode.get("canvas")) || void 0 === r
? void 0
: r.get("context");
if (!i) return t;
i.save();
var o = Object(z.assembleFont)(e);
if (((i.font = o), i.measureText(t).width < n)) return t;
for (var a = "", s = 0, u = 0, c = t; u < c.length; u++) {
var h = c[u],
l = i.measureText(h).width;
(s += l) >= n ? ((s = l), (a += "\n" + h)) : (a += h);
}
return i.restore(), a;
}),
(e.prototype.update = function () {
var t = this.styleNode.style,
e = this.getAttrs(),
n = this.gNode;
switch ((n.attr(e), n.resetMatrix(), t.textAlign)) {
case "center":
n.translate(this.styleNode.layout.width / 2);
break;
case "right":
n.translate(this.styleNode.layout.width);
}
"nowrap" === t.whiteSpace
? n.attr("text", String(this.styleNode.dom.text))
: n.attr(
"text",
this.getMultiLineText(
String(this.styleNode.dom.text),
e,
this.styleNode.layout.width,
),
);
}),
e
);
})(Y),
W = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getAttrs = function () {
var t = this.styleNode,
e = t.style,
n = t.layout,
r = t.dom;
return Object(h.a)(
{
fill: e.backgroundColor,
lineWidth: e.borderWidth,
fillOpacity: e.backgroundOpacity,
stroke: e.borderColor,
width: n.width - (e.borderWidth || 0),
height: n.height - (e.borderWidth || 0),
},
r.attrs,
);
}),
(e.prototype.draw = function (t) {
var e = this.styleNode,
n = this.getAttrs(),
r = e.dom;
this.gNode ||
(this.gNode = t.addShape(r.attrs.type, { attrs: n })),
this.update();
}),
(e.prototype.update = function () {
var t,
e = this.getAttrs(),
n = this.gNode,
r = "none" !== this.styleNode.style.pointerEvents;
n.attr(e),
n.set("capture", r),
n.resetMatrix(),
n.translate(this.left, this.top),
"number" ==
typeof (null === (t = this.style) || void 0 === t
? void 0
: t.zIndex) && n.setZIndex(this.style.zIndex);
}),
e
);
})(Y),
G = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.draw = function (t) {
var e = {
x: this.styleNode.layout.left,
y: this.styleNode.layout.top,
img: this.styleNode.dom.attrs.src,
width: this.styleNode.layout.width || 0,
height: this.styleNode.layout.height || 0,
},
n = "none" !== this.styleNode.style.pointerEvents;
this.gNode ||
(this.gNode = t.addShape("image", {
type: "image",
attrs: e,
capture: n,
}));
var r = this.gNode;
switch (
(r.resetMatrix(),
r.set("capture", n),
r.attr(e),
"number" == typeof this.styleNode.style.zIndex &&
r.setZIndex(this.styleNode.style.zIndex),
this.styleNode.style.textAlign)
) {
case "center":
r.translate(this.styleNode.layout.width / 2);
break;
case "right":
r.translate(this.styleNode.layout.width);
}
}),
e
);
})(Y),
q = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return Object(h.c)(e, t), e;
})(F);
function H(t, e, n) {
var r = U(t, e, !0);
return r.manualMount(n), r;
}
function V(t, e, n) {
var r = U(t, e, !1);
return n && r.manualMount(n), r;
}
function U(t, e, n) {
void 0 === n && (n = !1);
for (
var r = (function (t, e) {
return new L(t, e).parse();
})(
(function (t, e) {
var n;
void 0 === e && (e = !0);
var r = new S(t).parse(),
i = r[0];
return (
"root" !==
(null === (n = r[0]) || void 0 === n
? void 0
: n.tagName) &&
e &&
(((i = new O()).tagName = "root"), (i.children = r)),
i
);
})(t, n),
E(e),
),
i = R(r.dom.tagName, r),
o = [[r, i]];
o.length;
)
for (
var a = o.pop(), s = a[0], u = a[1], c = 0, h = s.originChildren;
c < h.length;
c++
) {
var l = h[c],
d = R(l.dom.tagName, l);
u.children.push(d), d.setParent(u), o.push([l, d]);
}
return i;
}
_("div", F), _("text", X), _("shape", W), _("image", G), _("root", q);
var Z = {};
function K(t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
var r = Z[t];
null == r ||
r.forEach(function (t) {
t.apply(null, e);
});
}
function Q(t, e) {
Z[t] = Object(h.g)(Z[t] || [], [e]);
}
var $ = { fill: "#416180", opacity: 0.05 },
J = { fill: "#416180", opacity: 0.15, radius: 5 },
tt = { fill: "#5B8FF9", opacity: 0.3, cursor: "grab" },
et = {
width: 2,
height: 26,
fill: "#1890ff",
stroke: "#1890ff",
opacity: 1,
cursor: "ew-resize",
highLightFill: "#0050b3",
},
nt = {
fill: "#fff",
stroke: "#1890ff",
radius: 15,
opacity: 1,
lineWidth: 2,
cursor: "ew-resize",
},
rt = {
textBaseline: "middle",
fill: "#000",
opacity: 0.45,
fontSize: 12,
},
it = { fill: "#607889", opacity: 0.35, fontSize: 12, width: 50 },
ot = { width: 1, height: 4, fill: "#ccc" },
at = 2,
st = 18,
ut = { height: 4, width: 1, fill: "#BFBFBF" },
ct = { fill: "#8c8c8c", fontSize: 10, width: 50 },
ht = { fill: "#5B8FF9" },
lt = { fill: "#e6e8e9" },
dt = {
speed: 1,
contentWidth: 200,
height: 60,
fill: "#fff",
stroke: "#fff",
hideTimeTypeController: !1,
preBtnStyle: { fill: "#aaa" },
nextBtnStyle: { fill: "#aaa" },
playBtnStyle: { fill: "#aaa" },
};
var ft = function (t, e) {
var n = e.height,
r = (void 0 === n ? 16 : n) / 2,
i = "";
return (
"next" === t &&
(i =
"\n \n '),
"prev" === t &&
(i =
"\n \n '),
V(
i,
"\n shape {\n margin-left: " +
r +
";\n width: " +
r +
";\n background: " +
e.fill +
";\n }\n ",
)
);
};
var pt = function (t) {
var e = t || {},
n = e.radius,
r = void 0 === n ? 15 : n,
i = e.fill,
o = (r * Math.sqrt(3)) / 2,
a = V(
'\n
\n \n
\n \n \n
\n
",
"\n #play_Btn {\n width: " +
2 * r +
";\n height: " +
2 * r +
";\n background: #fff;\n border: 1 solid " +
i +
";\n border-radius: " +
r +
";\n }\n .start{\n position: absolute;\n top: " +
r / 2 +
";\n left: " +
(r - o / 2 + 1) +
" ;\n background: " +
i +
";\n width: " +
r +
";\n height: " +
r +
";\n }\n .pause {\n display: none;\n }\n .pause shape {\n position: absolute;\n background: " +
i +
";\n width: " +
r / 4 +
";\n height: " +
r +
";\n }\n .pause_1 {\n left: " +
(4 * r) / 8 +
";\n }\n .pause {\n position: absolute;\n top: " +
r / 2 +
";\n left: " +
(5 * r) / 8 +
";\n }\n ",
),
s = a.query(".start"),
u = a.query(".pause"),
c = !0;
function h() {
s.setStyle("display", c ? "flex" : "none"),
u.setStyle("display", c ? "none" : "flex");
}
return (
h(),
a.on("tap", function () {
K(c ? "SLIDER_PLAY" : "SLIDER_PAUSE"), (c = !c), h();
}),
a
);
},
gt = n(0);
var yt = function (t) {
var e = Object(gt.d)({}, dt, t),
n = e.wrapperWidth,
r = e.contentWidth,
i = e.height,
o = e.fill,
a = e.stroke,
s = e.nextBtnStyle,
u = e.preBtnStyle,
c = e.playBtnStyle,
h = e.speed,
l = V(
"\n
\n
\n\n
\n
\n ",
"\n .wrapper {\n display: flex;\n width: " +
n +
";\n height: " +
i +
";\n flex-wrap: nowrap;\n flex-direction: row;\n justify-content: center;\n align-items: center;\n background: " +
o +
";\n " +
(a ? "border: 1 solid " + a + ";" : "") +
"\n }\n .content{\n display: flex;\n width: " +
r +
";\n flex-wrap: nowrap;\n flex-direction: row;\n justify-content: space-between;\n align-items: center;\n background-opacity: 0;\n }\n",
),
d = ft("next", s),
f = ft("prev", u),
p = pt(c);
return (
K("SPEED_CHANGE", h),
d.on("tap", function () {
K("CONTROL_NEXT");
}),
f.on("tap", function () {
K("CONTROL_PREV");
}),
l.query(".content").appendChild(f, p, d),
l
);
};
function vt(t, e) {
void 0 === e && (e = 20);
var n = !0,
r = null,
i = function () {
n
? clearTimeout(r)
: (null == t || t(),
(r = setTimeout(function () {
i();
}, e)));
};
return {
play: function () {
(n = !1), i();
},
stop: function () {
n = !0;
},
setSpeed: function (t) {
t > 10 && (t = 10), t < 1 && (t = 1), (e = 800 - (500 * t) / 9);
},
};
}
var mt = n(7),
bt = {};
function xt(t, e) {
bt[t] = e;
}
var wt = (function () {
function t(t) {
(this.type = "base"),
(this.isCategory = !1),
(this.isLinear = !1),
(this.isContinuous = !1),
(this.isIdentity = !1),
(this.values = []),
(this.range = [0, 1]),
(this.ticks = []),
(this.__cfg__ = t),
this.initCfg(),
this.init();
}
return (
(t.prototype.translate = function (t) {
return t;
}),
(t.prototype.change = function (t) {
Object(gt.a)(this.__cfg__, t), this.init();
}),
(t.prototype.clone = function () {
return this.constructor(this.__cfg__);
}),
(t.prototype.getTicks = function () {
var t = this;
return Object(gt.z)(this.ticks, function (e, n) {
return Object(gt.v)(e)
? e
: { text: t.getText(e, n), tickValue: e, value: t.scale(e) };
});
}),
(t.prototype.getText = function (t, e) {
var n = this.formatter,
r = n ? n(t, e) : t;
return Object(gt.s)(r) || !Object(gt.r)(r.toString)
? ""
: r.toString();
}),
(t.prototype.getConfig = function (t) {
return this.__cfg__[t];
}),
(t.prototype.init = function () {
Object(gt.a)(this, this.__cfg__),
this.setDomain(),
Object(gt.p)(this.getConfig("ticks")) &&
(this.ticks = this.calculateTicks());
}),
(t.prototype.initCfg = function () {}),
(t.prototype.setDomain = function () {}),
(t.prototype.calculateTicks = function () {
var t = this.tickMethod,
e = [];
if (Object(gt.x)(t)) {
var n = bt[t];
if (!n)
throw new Error("There is no method to to calculate ticks!");
e = n(this);
} else Object(gt.r)(t) && (e = t(this));
return e;
}),
(t.prototype.rangeMin = function () {
return this.range[0];
}),
(t.prototype.rangeMax = function () {
return this.range[1];
}),
(t.prototype.calcPercent = function (t, e, n) {
return Object(gt.t)(t) ? (t - e) / (n - e) : NaN;
}),
(t.prototype.calcValue = function (t, e, n) {
return e + t * (n - e);
}),
t
);
})(),
Ot = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "cat"), (e.isCategory = !0), e;
}
return (
Object(h.c)(e, t),
(e.prototype.buildIndexMap = function () {
if (!this.translateIndexMap) {
this.translateIndexMap = new Map();
for (var t = 0; t < this.values.length; t++)
this.translateIndexMap.set(this.values[t], t);
}
}),
(e.prototype.translate = function (t) {
this.buildIndexMap();
var e = this.translateIndexMap.get(t);
return void 0 === e && (e = Object(gt.t)(t) ? t : NaN), e;
}),
(e.prototype.scale = function (t) {
var e = this.translate(t),
n = this.calcPercent(e, this.min, this.max);
return this.calcValue(n, this.rangeMin(), this.rangeMax());
}),
(e.prototype.invert = function (t) {
var e = this.max - this.min,
n = this.calcPercent(t, this.rangeMin(), this.rangeMax()),
r = Math.round(e * n) + this.min;
return r < this.min || r > this.max ? NaN : this.values[r];
}),
(e.prototype.getText = function (e) {
for (var n = [], r = 1; r < arguments.length; r++)
n[r - 1] = arguments[r];
var i = e;
return (
Object(gt.t)(e) &&
!this.values.includes(e) &&
(i = this.values[i]),
t.prototype.getText.apply(this, Object(h.g)([i], n))
);
}),
(e.prototype.initCfg = function () {
this.tickMethod = "cat";
}),
(e.prototype.setDomain = function () {
if (
(Object(gt.s)(this.getConfig("min")) && (this.min = 0),
Object(gt.s)(this.getConfig("max")))
) {
var t = this.values.length;
this.max = t > 1 ? t - 1 : t;
}
this.translateIndexMap && (this.translateIndexMap = void 0);
}),
e
);
})(wt),
Mt =
/d{1,4}|M{1,4}|YY(?:YY)?|S{1,3}|Do|ZZ|Z|([HhMsDm])\1?|[aA]|"[^"]*"|'[^']*'/g,
St = "[^\\s]+",
Ct = /\[([^]*?)\]/gm;
function jt(t, e) {
for (var n = [], r = 0, i = t.length; r < i; r++)
n.push(t[r].substr(0, e));
return n;
}
var kt = function (t) {
return function (e, n) {
var r = n[t]
.map(function (t) {
return t.toLowerCase();
})
.indexOf(e.toLowerCase());
return r > -1 ? r : null;
};
};
function Et(t) {
for (var e = [], n = 1; n < arguments.length; n++)
e[n - 1] = arguments[n];
for (var r = 0, i = e; r < i.length; r++) {
var o = i[r];
for (var a in o) t[a] = o[a];
}
return t;
}
var Nt = [
"Sunday",
"Monday",
"Tuesday",
"Wednesday",
"Thursday",
"Friday",
"Saturday",
],
Tt = [
"January",
"February",
"March",
"April",
"May",
"June",
"July",
"August",
"September",
"October",
"November",
"December",
],
Pt = jt(Tt, 3),
It = {
dayNamesShort: jt(Nt, 3),
dayNames: Nt,
monthNamesShort: Pt,
monthNames: Tt,
amPm: ["am", "pm"],
DoFn: function (t) {
return (
t +
["th", "st", "nd", "rd"][
t % 10 > 3 ? 0 : ((t - (t % 10) != 10 ? 1 : 0) * t) % 10
]
);
},
},
Bt = Et({}, It),
At = function (t) {
return (Bt = Et(Bt, t));
},
Lt = function (t) {
return t.replace(/[|\\{()[^$+*?.-]/g, "\\$&");
},
Dt = function (t, e) {
for (void 0 === e && (e = 2), t = String(t); t.length < e; )
t = "0" + t;
return t;
},
_t = {
D: function (t) {
return String(t.getDate());
},
DD: function (t) {
return Dt(t.getDate());
},
Do: function (t, e) {
return e.DoFn(t.getDate());
},
d: function (t) {
return String(t.getDay());
},
dd: function (t) {
return Dt(t.getDay());
},
ddd: function (t, e) {
return e.dayNamesShort[t.getDay()];
},
dddd: function (t, e) {
return e.dayNames[t.getDay()];
},
M: function (t) {
return String(t.getMonth() + 1);
},
MM: function (t) {
return Dt(t.getMonth() + 1);
},
MMM: function (t, e) {
return e.monthNamesShort[t.getMonth()];
},
MMMM: function (t, e) {
return e.monthNames[t.getMonth()];
},
YY: function (t) {
return Dt(String(t.getFullYear()), 4).substr(2);
},
YYYY: function (t) {
return Dt(t.getFullYear(), 4);
},
h: function (t) {
return String(t.getHours() % 12 || 12);
},
hh: function (t) {
return Dt(t.getHours() % 12 || 12);
},
H: function (t) {
return String(t.getHours());
},
HH: function (t) {
return Dt(t.getHours());
},
m: function (t) {
return String(t.getMinutes());
},
mm: function (t) {
return Dt(t.getMinutes());
},
s: function (t) {
return String(t.getSeconds());
},
ss: function (t) {
return Dt(t.getSeconds());
},
S: function (t) {
return String(Math.round(t.getMilliseconds() / 100));
},
SS: function (t) {
return Dt(Math.round(t.getMilliseconds() / 10), 2);
},
SSS: function (t) {
return Dt(t.getMilliseconds(), 3);
},
a: function (t, e) {
return t.getHours() < 12 ? e.amPm[0] : e.amPm[1];
},
A: function (t, e) {
return t.getHours() < 12
? e.amPm[0].toUpperCase()
: e.amPm[1].toUpperCase();
},
ZZ: function (t) {
var e = t.getTimezoneOffset();
return (
(e > 0 ? "-" : "+") +
Dt(100 * Math.floor(Math.abs(e) / 60) + (Math.abs(e) % 60), 4)
);
},
Z: function (t) {
var e = t.getTimezoneOffset();
return (
(e > 0 ? "-" : "+") +
Dt(Math.floor(Math.abs(e) / 60), 2) +
":" +
Dt(Math.abs(e) % 60, 2)
);
},
},
Rt = function (t) {
return +t - 1;
},
Yt = [null, "[1-9]\\d?"],
Ft = [null, St],
zt = [
"isPm",
St,
function (t, e) {
var n = t.toLowerCase();
return n === e.amPm[0] ? 0 : n === e.amPm[1] ? 1 : null;
},
],
Xt = [
"timezoneOffset",
"[^\\s]*?[\\+\\-]\\d\\d:?\\d\\d|[^\\s]*?Z?",
function (t) {
var e = (t + "").match(/([+-]|\d\d)/gi);
if (e) {
var n = 60 * +e[1] + parseInt(e[2], 10);
return "+" === e[0] ? n : -n;
}
return 0;
},
],
Wt = {
D: ["day", "[1-9]\\d?"],
DD: ["day", "\\d\\d"],
Do: [
"day",
"[1-9]\\d?" + St,
function (t) {
return parseInt(t, 10);
},
],
M: ["month", "[1-9]\\d?", Rt],
MM: ["month", "\\d\\d", Rt],
YY: [
"year",
"\\d\\d",
function (t) {
var e = +("" + new Date().getFullYear()).substr(0, 2);
return +("" + (+t > 68 ? e - 1 : e) + t);
},
],
h: ["hour", "[1-9]\\d?", void 0, "isPm"],
hh: ["hour", "\\d\\d", void 0, "isPm"],
H: ["hour", "[1-9]\\d?"],
HH: ["hour", "\\d\\d"],
m: ["minute", "[1-9]\\d?"],
mm: ["minute", "\\d\\d"],
s: ["second", "[1-9]\\d?"],
ss: ["second", "\\d\\d"],
YYYY: ["year", "\\d{4}"],
S: [
"millisecond",
"\\d",
function (t) {
return 100 * +t;
},
],
SS: [
"millisecond",
"\\d\\d",
function (t) {
return 10 * +t;
},
],
SSS: ["millisecond", "\\d{3}"],
d: Yt,
dd: Yt,
ddd: Ft,
dddd: Ft,
MMM: ["month", St, kt("monthNamesShort")],
MMMM: ["month", St, kt("monthNames")],
a: zt,
A: zt,
ZZ: Xt,
Z: Xt,
},
Gt = {
default: "ddd MMM DD YYYY HH:mm:ss",
shortDate: "M/D/YY",
mediumDate: "MMM D, YYYY",
longDate: "MMMM D, YYYY",
fullDate: "dddd, MMMM D, YYYY",
isoDate: "YYYY-MM-DD",
isoDateTime: "YYYY-MM-DDTHH:mm:ssZ",
shortTime: "HH:mm",
mediumTime: "HH:mm:ss",
longTime: "HH:mm:ss.SSS",
},
qt = function (t) {
return Et(Gt, t);
},
Ht = function (t, e, n) {
if (
(void 0 === e && (e = Gt.default),
void 0 === n && (n = {}),
"number" == typeof t && (t = new Date(t)),
"[object Date]" !== Object.prototype.toString.call(t) ||
isNaN(t.getTime()))
)
throw new Error("Invalid Date pass to format");
var r = [];
e = (e = Gt[e] || e).replace(Ct, function (t, e) {
return r.push(e), "@@@";
});
var i = Et(Et({}, Bt), n);
return (e = e.replace(Mt, function (e) {
return _t[e](t, i);
})).replace(/@@@/g, function () {
return r.shift();
});
};
function Vt(t, e, n) {
if ((void 0 === n && (n = {}), "string" != typeof e))
throw new Error("Invalid format in fecha parse");
if (((e = Gt[e] || e), t.length > 1e3)) return null;
var r = {
year: new Date().getFullYear(),
month: 0,
day: 1,
hour: 0,
minute: 0,
second: 0,
millisecond: 0,
isPm: null,
timezoneOffset: null,
},
i = [],
o = [],
a = e.replace(Ct, function (t, e) {
return o.push(Lt(e)), "@@@";
}),
s = {},
u = {};
(a = Lt(a).replace(Mt, function (t) {
var e = Wt[t],
n = e[0],
r = e[1],
o = e[3];
if (s[n])
throw new Error(
"Invalid format. " + n + " specified twice in format",
);
return (s[n] = !0), o && (u[o] = !0), i.push(e), "(" + r + ")";
})),
Object.keys(u).forEach(function (t) {
if (!s[t])
throw new Error(
"Invalid format. " + t + " is required in specified format",
);
}),
(a = a.replace(/@@@/g, function () {
return o.shift();
}));
var c = t.match(new RegExp(a, "i"));
if (!c) return null;
for (var h = Et(Et({}, Bt), n), l = 1; l < c.length; l++) {
var d = i[l - 1],
f = d[0],
p = d[2],
g = p ? p(c[l], h) : +c[l];
if (null == g) return null;
r[f] = g;
}
1 === r.isPm && null != r.hour && 12 != +r.hour
? (r.hour = +r.hour + 12)
: 0 === r.isPm && 12 == +r.hour && (r.hour = 0);
for (
var y = new Date(
r.year,
r.month,
r.day,
r.hour,
r.minute,
r.second,
r.millisecond,
),
v = [
["month", "getMonth"],
["day", "getDate"],
["hour", "getHours"],
["minute", "getMinutes"],
["second", "getSeconds"],
],
m = ((l = 0), v.length);
l < m;
l++
)
if (s[v[l][0]] && r[v[l][0]] !== y[v[l][1]]()) return null;
return null == r.timezoneOffset
? y
: new Date(
Date.UTC(
r.year,
r.month,
r.day,
r.hour,
r.minute - r.timezoneOffset,
r.second,
r.millisecond,
),
);
}
var Ut = {
format: Ht,
parse: Vt,
defaultI18n: It,
setGlobalDateI18n: At,
setGlobalDateMasks: qt,
};
function Zt(t, e) {
return (r.format || Ut.format)(t, e);
}
function Kt(t) {
return (
Object(gt.x)(t) &&
(t =
t.indexOf("T") > 0
? new Date(t).getTime()
: new Date(t.replace(/-/gi, "/")).getTime()),
Object(gt.o)(t) && (t = t.getTime()),
t
);
}
var Qt = 36e5,
$t = 24 * Qt,
Jt = 31 * $t,
te = [
["HH:mm:ss", 1e3],
["HH:mm:ss", 1e4],
["HH:mm:ss", 3e4],
["HH:mm", 6e4],
["HH:mm", 6e5],
["HH:mm", 18e5],
["HH", Qt],
["HH", 6 * Qt],
["HH", 12 * Qt],
["YYYY-MM-DD", $t],
["YYYY-MM-DD", 4 * $t],
["YYYY-WW", 7 * $t],
["YYYY-MM", Jt],
["YYYY-MM", 4 * Jt],
["YYYY-MM", 6 * Jt],
["YYYY", 380 * $t],
];
function ee(t, e, n) {
var r,
i =
((r = function (t) {
return t[1];
}),
function (t, e, n, i) {
for (
var o = Object(gt.s)(n) ? 0 : n,
a = Object(gt.s)(i) ? t.length : i;
o < a;
) {
var s = (o + a) >>> 1;
r(t[s]) > e ? (a = s) : (o = s + 1);
}
return o;
})(te, (e - t) / n) - 1,
o = te[i];
return (
i < 0 ? (o = te[0]) : i >= te.length && (o = Object(gt.y)(te)), o
);
}
var ne = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "timeCat"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.translate = function (t) {
t = Kt(t);
var e = this.values.indexOf(t);
return (
-1 === e &&
(e = Object(gt.t)(t) && t < this.values.length ? t : NaN),
e
);
}),
(e.prototype.getText = function (t, e) {
var n = this.translate(t);
if (n > -1) {
var r = this.values[n],
i = this.formatter;
return (r = i ? i(r, e) : Zt(r, this.mask));
}
return t;
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "time-cat"),
(this.mask = "YYYY-MM-DD"),
(this.tickCount = 7);
}),
(e.prototype.setDomain = function () {
var e = this.values;
Object(gt.e)(e, function (t, n) {
e[n] = Kt(t);
}),
e.sort(function (t, e) {
return t - e;
}),
t.prototype.setDomain.call(this);
}),
e
);
})(Ot),
re = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.isContinuous = !0), e;
}
return (
Object(h.c)(e, t),
(e.prototype.scale = function (t) {
if (Object(gt.s)(t)) return NaN;
var e = this.rangeMin(),
n = this.rangeMax();
return this.max === this.min
? e
: e + this.getScalePercent(t) * (n - e);
}),
(e.prototype.init = function () {
t.prototype.init.call(this);
var e = this.ticks,
n = Object(gt.k)(e),
r = Object(gt.y)(e);
n < this.min && (this.min = n),
r > this.max && (this.max = r),
Object(gt.s)(this.minLimit) || (this.min = n),
Object(gt.s)(this.maxLimit) || (this.max = r);
}),
(e.prototype.setDomain = function () {
var t = Object(gt.i)(this.values),
e = t.min,
n = t.max;
Object(gt.s)(this.min) && (this.min = e),
Object(gt.s)(this.max) && (this.max = n),
this.min > this.max && ((this.min = e), (this.max = n));
}),
(e.prototype.calculateTicks = function () {
var e = this,
n = t.prototype.calculateTicks.call(this);
return (
this.nice ||
(n = Object(gt.f)(n, function (t) {
return t >= e.min && t <= e.max;
})),
n
);
}),
(e.prototype.getScalePercent = function (t) {
var e = this.max,
n = this.min;
return (t - n) / (e - n);
}),
(e.prototype.getInvertPercent = function (t) {
return (
(t - this.rangeMin()) / (this.rangeMax() - this.rangeMin())
);
}),
e
);
})(wt),
ie = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "linear"), (e.isLinear = !0), e;
}
return (
Object(h.c)(e, t),
(e.prototype.invert = function (t) {
var e = this.getInvertPercent(t);
return this.min + e * (this.max - this.min);
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "wilkinson-extended"), (this.nice = !1);
}),
e
);
})(re);
function oe(t, e) {
var n = Math.E;
return e >= 0
? Math.pow(n, Math.log(e) / t)
: -1 * Math.pow(n, Math.log(-e) / t);
}
function ae(t, e) {
return 1 === t ? 1 : Math.log(e) / Math.log(t);
}
function se(t, e, n) {
Object(gt.s)(n) && (n = Math.max.apply(null, t));
var r = n;
return (
Object(gt.e)(t, function (t) {
t > 0 && t < r && (r = t);
}),
r === n && (r = n / e),
r > 1 && (r = 1),
r
);
}
var ue = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "log"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.invert = function (t) {
var e,
n = this.base,
r = ae(n, this.max),
i = this.rangeMin(),
o = this.rangeMax() - i,
a = this.positiveMin;
if (a) {
if (0 === t) return 0;
var s = (1 / (r - (e = ae(n, a / n)))) * o;
if (t < s) return (t / s) * a;
} else e = ae(n, this.min);
var u = ((t - i) / o) * (r - e) + e;
return Math.pow(n, u);
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "log"),
(this.base = 10),
(this.tickCount = 6),
(this.nice = !0);
}),
(e.prototype.setDomain = function () {
t.prototype.setDomain.call(this);
var e = this.min;
if (e < 0)
throw new Error(
"When you use log scale, the minimum value must be greater than zero!",
);
0 === e &&
(this.positiveMin = se(this.values, this.base, this.max));
}),
(e.prototype.getScalePercent = function (t) {
var e = this.max,
n = this.min;
if (e === n) return 0;
if (t <= 0) return 0;
var r = this.base,
i = this.positiveMin;
return (
i && (n = (1 * i) / r),
t < i
? t / i / (ae(r, e) - ae(r, n))
: (ae(r, t) - ae(r, n)) / (ae(r, e) - ae(r, n))
);
}),
e
);
})(re),
ce = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "pow"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.invert = function (t) {
var e = this.getInvertPercent(t),
n = this.exponent,
r = oe(n, this.max),
i = oe(n, this.min),
o = e * (r - i) + i,
a = o >= 0 ? 1 : -1;
return Math.pow(o, n) * a;
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "pow"),
(this.exponent = 2),
(this.tickCount = 5),
(this.nice = !0);
}),
(e.prototype.getScalePercent = function (t) {
var e = this.max,
n = this.min;
if (e === n) return 0;
var r = this.exponent;
return (oe(r, t) - oe(r, n)) / (oe(r, e) - oe(r, n));
}),
e
);
})(re),
he = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "time"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.getText = function (t, e) {
var n = this.translate(t),
r = this.formatter;
return r ? r(n, e) : Zt(n, this.mask);
}),
(e.prototype.scale = function (e) {
var n = e;
return (
(Object(gt.x)(n) || Object(gt.o)(n)) && (n = this.translate(n)),
t.prototype.scale.call(this, n)
);
}),
(e.prototype.translate = function (t) {
return Kt(t);
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "time-pretty"),
(this.mask = "YYYY-MM-DD"),
(this.tickCount = 7),
(this.nice = !1);
}),
(e.prototype.setDomain = function () {
var t = this.values,
e = this.getConfig("min"),
n = this.getConfig("max");
if (
((Object(gt.s)(e) && Object(gt.t)(e)) ||
(this.min = this.translate(this.min)),
(Object(gt.s)(n) && Object(gt.t)(n)) ||
(this.max = this.translate(this.max)),
t && t.length)
) {
var r = [],
i = 1 / 0,
o = i,
a = 0;
Object(gt.e)(t, function (t) {
var e = Kt(t);
if (isNaN(e))
throw new TypeError(
"Invalid Time: " + t + " in time scale!",
);
i > e ? ((o = i), (i = e)) : o > e && (o = e),
a < e && (a = e),
r.push(e);
}),
t.length > 1 && (this.minTickInterval = o - i),
Object(gt.s)(e) && (this.min = i),
Object(gt.s)(n) && (this.max = a);
}
}),
e
);
})(ie),
le = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "quantize"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.invert = function (t) {
var e = this.ticks,
n = e.length,
r = this.getInvertPercent(t),
i = Math.floor(r * (n - 1));
if (i >= n - 1) return Object(gt.y)(e);
if (i < 0) return Object(gt.k)(e);
var o = e[i],
a = i / (n - 1);
return o + ((r - a) / ((i + 1) / (n - 1) - a)) * (e[i + 1] - o);
}),
(e.prototype.initCfg = function () {
(this.tickMethod = "r-pretty"),
(this.tickCount = 5),
(this.nice = !0);
}),
(e.prototype.calculateTicks = function () {
var e = t.prototype.calculateTicks.call(this);
return (
this.nice ||
(Object(gt.y)(e) !== this.max && e.push(this.max),
Object(gt.k)(e) !== this.min && e.unshift(this.min)),
e
);
}),
(e.prototype.getScalePercent = function (t) {
var e = this.ticks;
if (t < Object(gt.k)(e)) return 0;
if (t > Object(gt.y)(e)) return 1;
var n = 0;
return (
Object(gt.e)(e, function (e, r) {
if (!(t >= e)) return !1;
n = r;
}),
n / (e.length - 1)
);
}),
e
);
})(re),
de = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "quantile"), e;
}
return (
Object(h.c)(e, t),
(e.prototype.initCfg = function () {
(this.tickMethod = "quantile"),
(this.tickCount = 5),
(this.nice = !0);
}),
e
);
})(le),
fe = {};
function pe(t, e) {
if (
(function (t) {
return fe[t];
})(t)
)
throw new Error("type '" + t + "' existed.");
fe[t] = e;
}
var ge = (function (t) {
function e() {
var e = (null !== t && t.apply(this, arguments)) || this;
return (e.type = "identity"), (e.isIdentity = !0), e;
}
return (
Object(h.c)(e, t),
(e.prototype.calculateTicks = function () {
return this.values;
}),
(e.prototype.scale = function (t) {
return this.values[0] !== t && Object(gt.t)(t)
? t
: this.range[0];
}),
(e.prototype.invert = function (t) {
var e = this.range;
return t < e[0] || t > e[1] ? NaN : this.values[0];
}),
e
);
})(wt),
ye = [1, 5, 2, 2.5, 4, 3],
ve = 100 * Number.EPSILON;
function me(t, e, n, r, i, o) {
var a = Object(gt.F)(e),
s = Object(gt.l)(e, t),
u = 0,
c = (function (t, e) {
return ((t % e) + e) % e;
})(r, o);
return (
(c < ve || o - c < ve) && r <= 0 && i >= 0 && (u = 1),
1 - s / (a - 1) - n + u
);
}
function be(t, e, n) {
var r = Object(gt.F)(e);
return 1 - Object(gt.l)(e, t) / (r - 1) - n + 1;
}
function xe(t, e, n, r, i, o) {
var a = (t - 1) / (o - i),
s = (e - 1) / (Math.max(o, r) - Math.min(n, i));
return 2 - Math.max(a / s, s / a);
}
function we(t, e) {
return t >= e ? 2 - (t - 1) / (e - 1) : 1;
}
function Oe(t, e, n, r) {
var i = e - t;
return (
1 -
(0.5 * (Math.pow(e - r, 2) + Math.pow(t - n, 2))) /
Math.pow(0.1 * i, 2)
);
}
function Me(t, e, n) {
var r = e - t;
if (n > r) {
var i = (n - r) / 2;
return 1 - Math.pow(i, 2) / Math.pow(0.1 * r, 2);
}
return 1;
}
function Se(t, e, n, r, i, o) {
if (
(void 0 === n && (n = 5),
void 0 === r && (r = !0),
void 0 === i && (i = ye),
void 0 === o && (o = [0.25, 0.2, 0.5, 0.05]),
Number.isNaN(t) ||
Number.isNaN(e) ||
"number" != typeof t ||
"number" != typeof e ||
!n)
)
return { min: 0, max: 0, ticks: [] };
if (e - t < 1e-15 || 1 === n) return { min: t, max: e, ticks: [t] };
for (
var a = { score: -2, lmin: 0, lmax: 0, lstep: 0 }, s = 1;
s < 1 / 0;
) {
for (var u = 0; u < i.length; u += 1) {
var c = i[u],
h = be(c, i, s);
if (o[0] * h + o[1] + o[2] + o[3] < a.score) {
s = 1 / 0;
break;
}
for (var l = 2; l < 1 / 0; ) {
var d = we(l, n);
if (o[0] * h + o[1] + o[2] * d + o[3] < a.score) break;
for (
var f = (e - t) / (l + 1) / s / c, p = Math.ceil(Math.log10(f));
p < 1 / 0;
) {
var g = s * c * Math.pow(10, p),
y = Me(t, e, g * (l - 1));
if (o[0] * h + o[1] * y + o[2] * d + o[3] < a.score) break;
var v = Math.floor(e / g) * s - (l - 1) * s,
m = Math.ceil(t / g) * s;
if (v <= m)
for (var b = m - v, x = 0; x <= b; x += 1) {
var w = (v + x) * (g / s),
O = w + g * (l - 1),
M = g,
S = me(c, i, s, w, O, M),
C = Oe(t, e, w, O),
j = xe(l, n, t, e, w, O),
k = o[0] * S + o[1] * C + o[2] * j + 1 * o[3];
k > a.score &&
(!r || (w <= t && O >= e)) &&
((a.lmin = w),
(a.lmax = O),
(a.lstep = M),
(a.score = k));
}
p += 1;
}
l += 1;
}
}
s += 1;
}
var E,
N = a.lmax,
T = a.lmin,
P = a.lstep,
I = Math.floor((N - T) / P) + 1,
B = new Array(I);
for (u = 0; u < I; u++)
B[u] = (E = T + u * P) < 1e-15 ? E : parseFloat(E.toFixed(15));
return {
min: Math.min(t, Object(gt.k)(B)),
max: Math.max(e, Object(gt.y)(B)),
ticks: B,
};
}
function Ce(t) {
var e = t.values,
n = t.tickInterval,
r = t.tickCount,
i = e;
if (Object(gt.t)(n))
return Object(gt.f)(i, function (t, e) {
return e % n == 0;
});
var o = t.min,
a = t.max;
if (
(Object(gt.s)(o) && (o = 0),
Object(gt.s)(a) && (a = e.length - 1),
Object(gt.t)(r) && r < a - o)
) {
var s = Se(o, a, r, !1, [1, 2, 5, 3, 4, 7, 6, 8, 9]).ticks;
return Object(gt.f)(s, function (t) {
return t >= o && t <= a;
}).map(function (t) {
return e[t];
});
}
return e.slice(o, a + 1);
}
var je = Math.sqrt(50),
ke = Math.sqrt(10),
Ee = Math.sqrt(2),
Ne = (function () {
function t() {
this._domain = [0, 1];
}
return (
(t.prototype.domain = function (t) {
return t
? ((this._domain = Array.from(t, Number)), this)
: this._domain.slice();
}),
(t.prototype.nice = function (t) {
var e, n;
void 0 === t && (t = 5);
var r,
i = this._domain.slice(),
o = 0,
a = this._domain.length - 1,
s = this._domain[o],
u = this._domain[a];
return (
u < s &&
((s = (e = [u, s])[0]),
(u = e[1]),
(o = (n = [a, o])[0]),
(a = n[1])),
(r = Te(s, u, t)) > 0
? (r = Te(
(s = Math.floor(s / r) * r),
(u = Math.ceil(u / r) * r),
t,
))
: r < 0 &&
(r = Te(
(s = Math.ceil(s * r) / r),
(u = Math.floor(u * r) / r),
t,
)),
r > 0
? ((i[o] = Math.floor(s / r) * r),
(i[a] = Math.ceil(u / r) * r),
this.domain(i))
: r < 0 &&
((i[o] = Math.ceil(s * r) / r),
(i[a] = Math.floor(u * r) / r),
this.domain(i)),
this
);
}),
(t.prototype.ticks = function (t) {
return (
void 0 === t && (t = 5),
(function (t, e, n) {
var r,
i,
o,
a,
s = -1;
if (((n = +n), (t = +t) === (e = +e) && n > 0)) return [t];
(r = e < t) && ((i = t), (t = e), (e = i));
if (0 === (a = Te(t, e, n)) || !isFinite(a)) return [];
if (a > 0)
for (
t = Math.ceil(t / a),
e = Math.floor(e / a),
o = new Array((i = Math.ceil(e - t + 1)));
++s < i;
)
o[s] = (t + s) * a;
else
for (
t = Math.floor(t * a),
e = Math.ceil(e * a),
o = new Array((i = Math.ceil(t - e + 1)));
++s < i;
)
o[s] = (t - s) / a;
r && o.reverse();
return o;
})(
this._domain[0],
this._domain[this._domain.length - 1],
t || 5,
)
);
}),
t
);
})();
function Te(t, e, n) {
var r = (e - t) / Math.max(0, n),
i = Math.floor(Math.log(r) / Math.LN10),
o = r / Math.pow(10, i);
return i >= 0
? (o >= je ? 10 : o >= ke ? 5 : o >= Ee ? 2 : 1) * Math.pow(10, i)
: -Math.pow(10, -i) / (o >= je ? 10 : o >= ke ? 5 : o >= Ee ? 2 : 1);
}
function Pe(t, e, n) {
return (
("ceil" === n
? Math.ceil(t / e)
: "floor" === n
? Math.floor(t / e)
: Math.round(t / e)) * e
);
}
function Ie(t, e, n) {
var r = Pe(t, n, "floor"),
i = Pe(e, n, "ceil");
(r = Object(gt.g)(r, n)), (i = Object(gt.g)(i, n));
for (var o = [], a = r; a <= i; a += n) {
var s = Object(gt.g)(a, n);
o.push(s);
}
return { min: r, max: i, ticks: o };
}
function Be(t, e, n) {
var r,
i = t.minLimit,
o = t.maxLimit,
a = t.min,
s = t.max,
u = t.tickCount,
c = void 0 === u ? 5 : u,
h = Object(gt.s)(i) ? (Object(gt.s)(e) ? a : e) : i,
l = Object(gt.s)(o) ? (Object(gt.s)(n) ? s : n) : o;
if ((h > l && ((l = (r = [h, l])[0]), (h = r[1])), c <= 2))
return [h, l];
for (var d = (l - h) / (c - 1), f = [], p = 0; p < c; p++)
f.push(h + d * p);
return f;
}
function Ae(t) {
return t < 1e-15 ? t : parseFloat(t.toFixed(15));
}
function Le(t, e, n) {
if ((void 0 === n && (n = 5), t === e))
return { max: e, min: t, ticks: [t] };
var r = (e - t) / n,
i = Math.pow(10, Math.floor(Math.log10(r))),
o = i;
2 * i - r < 1.5 * (r - o) &&
5 * i - r < 2.75 * (r - (o = 2 * i)) &&
10 * i - r < 1.5 * (r - (o = 5 * i)) &&
(o = 10 * i);
for (
var a = Math.ceil(e / o),
s = Math.floor(t / o),
u = Math.max(a * o, e),
c = Math.min(s * o, t),
h = Math.floor((u - c) / o) + 1,
l = new Array(h),
d = 0;
d < h;
d++
)
l[d] = Ae(c + d * o);
return { min: c, max: u, ticks: l };
}
function De(t, e) {
var n = t.length * e;
return 1 === e
? t[t.length - 1]
: 0 === e
? t[0]
: n % 1 != 0
? t[Math.ceil(n) - 1]
: t.length % 2 == 0
? (t[n - 1] + t[n]) / 2
: t[n];
}
function _e(t) {
return new Date(t).getFullYear();
}
function Re(t) {
return new Date(t, 0, 1).getTime();
}
function Ye(t) {
return new Date(t).getMonth();
}
function Fe(t, e) {
return new Date(t, e, 1).getTime();
}
function ze(t) {
return (function (t) {
return Object(gt.z)(t, function (t, e) {
return [0 === e ? "M" : "L", t[0], t[1]];
});
})(t);
}
function Xe(t, e, n, r) {
void 0 === r && (r = !0);
var i = new ie({ values: t }),
o = new Ot({
values: Object(gt.z)(t, function (t, e) {
return e;
}),
}),
a = Object(gt.z)(t, function (t, r) {
return [o.scale(r) * e, n - i.scale(t) * n];
});
return r
? (function (t) {
if (t.length <= 2) return ze(t);
var e = [];
Object(gt.e)(t, function (t) {
Object(gt.q)(t, e.slice(e.length - 2)) || e.push(t[0], t[1]);
});
var n = mt.a(e, !1),
r = Object(gt.k)(t),
i = r[0],
o = r[1];
return n.unshift(["M", i, o]), n;
})(a)
: ze(a);
}
xt("cat", Ce),
xt("time-cat", function (t) {
var e = Ce(t),
n = Object(gt.y)(t.values);
return n !== Object(gt.y)(e) && e.push(n), e;
}),
xt("wilkinson-extended", function (t) {
var e = t.min,
n = t.max,
r = t.tickCount,
i = t.nice,
o = t.tickInterval,
a = t.minLimit,
s = t.maxLimit,
u = Se(e, n, r, i).ticks;
return Object(gt.s)(a) && Object(gt.s)(s)
? o
? Ie(e, n, o).ticks
: u
: Be(t, Object(gt.k)(u), Object(gt.y)(u));
}),
xt("r-pretty", function (t) {
var e = t.min,
n = t.max,
r = t.tickCount,
i = t.tickInterval,
o = t.minLimit,
a = t.maxLimit,
s = Le(e, n, r).ticks;
return Object(gt.s)(o) && Object(gt.s)(a)
? i
? Ie(e, n, i).ticks
: s
: Be(t, Object(gt.k)(s), Object(gt.y)(s));
}),
xt("time", function (t) {
var e = t.min,
n = t.max,
r = t.minTickInterval,
i = t.tickInterval,
o = t.tickCount;
if (i) o = Math.ceil((n - e) / i);
else {
var a = (n - e) / (i = ee(e, n, o)[1]) / o;
a > 1 && (i *= Math.ceil(a)), r && i < r && (i = r);
}
for (var s = [], u = e; u < n + i; u += i) s.push(u);
return s;
}),
xt("time-pretty", function (t) {
var e = t.min,
n = t.max,
r = t.minTickInterval,
i = t.tickCount,
o = t.tickInterval,
a = [];
o || ((o = (n - e) / i), r && o < r && (o = r));
var s = _e(e);
if (o > 31536e6)
for (
var u = _e(n), c = Math.ceil(o / 31536e6), h = s;
h <= u + c;
h += c
)
a.push(Re(h));
else if (o > Jt) {
var l = Math.ceil(o / Jt),
d = Ye(e),
f = (function (t, e) {
var n = _e(t),
r = _e(e),
i = Ye(t);
return 12 * (r - n) + ((Ye(e) - i) % 12);
})(e, n);
for (h = 0; h <= f + l; h += l) a.push(Fe(s, h + d));
} else if (o > $t) {
var p = (b = new Date(e)).getFullYear(),
g = b.getMonth(),
y = b.getDate(),
v = Math.ceil(o / $t),
m = (function (t, e) {
return Math.ceil((e - t) / $t);
})(e, n);
for (h = 0; h < m + v; h += v)
a.push(new Date(p, g, y + h).getTime());
} else if (o > Qt) {
(p = (b = new Date(e)).getFullYear()),
(g = b.getMonth()),
(v = b.getDate());
var b,
x = b.getHours(),
w = Math.ceil(o / Qt),
O = (function (t, e) {
return Math.ceil((e - t) / Qt);
})(e, n);
for (h = 0; h <= O + w; h += w)
a.push(new Date(p, g, v, x + h).getTime());
} else if (o > 6e4) {
var M = (function (t, e) {
return Math.ceil((e - t) / 6e4);
})(e, n),
S = Math.ceil(o / 6e4);
for (h = 0; h <= M + S; h += S) a.push(e + 6e4 * h);
} else {
var C = o;
C < 1e3 && (C = 1e3);
var j = 1e3 * Math.floor(e / 1e3),
k = Math.ceil((n - e) / 1e3),
E = Math.ceil(C / 1e3);
for (h = 0; h < k + E; h += E) a.push(j + 1e3 * h);
}
return (
a.length >= 512 &&
console.warn(
"Notice: current ticks length(" +
a.length +
') >= 512, may cause performance issues, even out of memory. Because of the configure "tickInterval"(in milliseconds, current is ' +
o +
") is too small, increase the value to solve the problem!",
),
a
);
}),
xt("log", function (t) {
var e,
n = t.base,
r = t.tickCount,
i = t.min,
o = t.max,
a = t.values,
s = ae(n, o);
if (i > 0) e = Math.floor(ae(n, i));
else {
var u = se(a, n, o);
e = Math.floor(ae(n, u));
}
for (
var c = s - e, h = Math.ceil(c / r), l = [], d = e;
d < s + h;
d += h
)
l.push(Math.pow(n, d));
return i <= 0 && l.unshift(0), l;
}),
xt("pow", function (t) {
var e = t.exponent,
n = t.tickCount,
r = Math.ceil(oe(e, t.max));
return Le(Math.floor(oe(e, t.min)), r, n).ticks.map(function (t) {
var n = t >= 0 ? 1 : -1;
return Math.pow(t, e) * n;
});
}),
xt("quantile", function (t) {
var e = t.tickCount,
n = t.values;
if (!n || !n.length) return [];
for (
var r = n.slice().sort(function (t, e) {
return t - e;
}),
i = [],
o = 0;
o < e;
o++
) {
var a = o / (e - 1);
i.push(De(r, a));
}
return i;
}),
xt("d3-linear", function (t) {
var e = t.min,
n = t.max,
r = t.tickInterval,
i = t.minLimit,
o = t.maxLimit,
a = (function (t) {
var e = t.min,
n = t.max,
r = t.nice,
i = t.tickCount,
o = new Ne();
return o.domain([e, n]), r && o.nice(i), o.ticks(i);
})(t);
return Object(gt.s)(i) && Object(gt.s)(o)
? r
? Ie(e, n, r).ticks
: a
: Be(t, Object(gt.k)(a), Object(gt.y)(a));
}),
pe("cat", Ot),
pe("category", Ot),
pe("identity", ge),
pe("linear", ie),
pe("log", ue),
pe("pow", ce),
pe("time", he),
pe("timeCat", ne),
pe("quantize", le),
pe("quantile", de);
var We = { stroke: "#C5C5C5", strokeOpacity: 0.85 };
function Ge(t) {
var e = t.data,
n = void 0 === e ? [] : e,
r = t.width,
i = t.slider,
o = t.sliderTick,
a = (function (t) {
var e = t.width,
n = t.height,
r = void 0 === n ? 4 : n,
i = Object.assign({}, nt, t.handlerStyle),
o = Object.assign({}, J, t.backgroundStyle),
a = Object.assign({}, tt, t.foregroundStyle),
s = Object.assign({}, rt, t.textStyle),
u = V(
"\n
\n \n
\n
0
\n
\n
\n
0
\n
\n
\n ",
"\n .slider-bg {\n width: " +
e +
";\n height: " +
r +
";\n background: " +
o.fill +
";\n opacity: " +
o.opacity +
";\n border-radius: " +
o.radius +
";\n z-index: 10;\n margin-top: 30;\n }\n \n .slider-inner{\n position: absolute;\n width: " +
e +
";\n height: " +
r +
";\n border-radius: " +
r / 2 +
";\n background: " +
a.fill +
";\n background-opacity: " +
a.opacity +
"\n z-index: 1;\n }\n\n .control {\n position: absolute;\n top: " +
(-i.radius / 2 + r / 2) +
";\n width: " +
i.radius +
";\n height: " +
i.radius +
";\n border-radius: " +
i.radius / 2 +
";\n background: " +
i.fill +
";\n border: " +
i.lineWidth +
" solid " +
i.stroke +
";\n z-index: 2;\n }\n\n .text{\n position: absolute;\n left: " +
i.radius / 2 +
";\n top: -" +
(i.radius / 2 + s.fontSize / 2) +
";\n width: 0;\n color: " +
s.fill +
";\n font-size: " +
s.fontSize +
";\n text-align: center;\n }\n\n text{\n opacity: " +
s.opacity +
";\n white-space: nowrap;\n }\n \n .left-control {\n left: 0;\n }\n\n .right-control{\n left: " +
(e - i.radius) +
";\n }\n ",
);
return {
slideContainer: u,
leftControl: u.query(".left-control"),
rightControl: u.query(".right-control"),
slideInner: u.query(".slider-inner"),
};
})(i);
return He(
{ data: n, width: r, start: i.start, end: i.end, sliderTick: o },
a,
);
}
function qe(t) {
var e = t.data,
n = t.width,
r = t.slider,
i = t.sliderTick,
o = (function (t) {
var e = t.slider,
n = void 0 === e ? {} : e,
r = t.trend,
i = void 0 === r ? {} : r,
o = n.width,
a = n.height,
s = void 0 === a ? 24 : a,
u = i.data,
c = void 0 === u ? [] : u,
h = i.lineStyle,
l = i.smooth,
d = void 0 === l || l,
f = Object.assign({}, et, n.handlerStyle),
p = Object.assign({}, $, n.backgroundStyle),
g = Object.assign({}, tt, n.foregroundStyle),
y = Object.assign({}, rt, n.textStyle),
v = Object.assign({}, We, h),
m = f.width,
b = 2 * m,
x = 2 * b + 10,
w = V(
"\n
\n \n \n
\n
\n
1
\n \n \n \n
\n
\n
\n
\n
1
\n \n \n \n
\n
\n
\n ",
"\n .slider-bg {\n width: " +
o +
";\n height: " +
s +
";\n background: " +
p.fill +
";\n opacity: " +
p.opacity +
";\n z-index: 10;\n }\n\n .trend-bg{\n position: absolute;\n width: " +
o +
";\n height: " +
s +
";\n border: 1 solid " +
v.stroke +
";\n opacity: " +
v.strokeOpacity +
";\n }\n \n .slider-inner{\n position: absolute;\n width: " +
o +
";\n height: " +
s +
";\n background: " +
g.fill +
";\n opacity: " +
g.opacity +
";\n }\n\n .control {\n position: absolute;\n width: " +
x +
";\n height: " +
s +
";\n font-size: 10;\n background-opacity: 0;\n }\n\n .handler{\n position: absolute;\n height: " +
f.height +
";\n width: " +
m +
";\n }\n \n .rect {\n position: absolute;\n width: " +
m +
";\n height: " +
f.height +
";\n background: " +
f.fill +
";\n }\n\n .circle {\n background: " +
f.fill +
";\n position: absolute;\n left: " +
m / 2 +
"\n }\n\n .top-circle{\n top: 0\n }\n\n .bottom-circle{\n bottom: 0\n }\n\n .right-control .handler{\n right: 0\n }\n\n .control .text{\n position: absolute;\n top: " +
(s / 2 - 5) +
";\n }\n \n .text{\n color: " +
y.fill +
";\n width: 40;\n text-align: center;\n }\n\n .text text{\n opacity:" +
y.opacity +
"\n }\n\n .left-control .text{\n margin-left: 0;\n }\n\n .right-control .text{\n \n }\n \n .left-control {\n left: 0;\n }\n\n .right-control{\n left: " +
(o - x) +
";\n }\n ",
),
O = Xe(c, o, s, d);
w.query(".trend-bg").setAttribute("path", O);
var M = w.query(".left-control"),
S = w.query(".right-control"),
C = M.query(".text"),
j = S.query(".text");
return (
(M.onLeftChange = function (t) {
t < C.width
? C.setStyle("marginLeft", 0)
: C.setStyle("marginLeft", -C.width);
}),
(S.onLeftChange = function (t) {
t > w.width - S.width - j.width
? j.setStyle("marginLeft", -j.width)
: j.setStyle("marginLeft", 0);
}),
{
slideContainer: w,
leftControl: w.query(".left-control"),
rightControl: w.query(".right-control"),
slideInner: w.query(".slider-inner"),
}
);
})({ slider: r, trend: t.trend });
return He(
{ data: e, width: n, start: r.start, end: r.end, sliderTick: i },
o,
);
}
function He(t, e) {
var n = t.data,
r = void 0 === n ? [] : n,
i = t.width,
o = t.start,
a = void 0 === o ? 0.1 : o,
s = t.end,
u = void 0 === s ? 0.9 : s,
c = t.sliderTick,
h = c.width,
l = (void 0 === h ? 0 : h) / r.length,
d = (function (t) {
return V(
"\n \n ",
"\n #slider {\n width: " +
t +
";\n display: flex;\n justify-content: center;\n align-items: center;\n }\n ",
);
})(i),
f = e.slideContainer,
p = e.leftControl,
g = e.rightControl,
y = e.slideInner,
v = (function (t, e, n) {
var r = n.width,
i = void 0 === r ? 0 : r,
o = Object.assign({}, it, n.textStyle),
a = Object.assign({}, ot, n.lineStyle),
s = Math.floor(o.width / e);
return V(
"\n
\n " +
t.reduce(function (t, e, n) {
return (
t +
"\n
\n " +
(n % s == 0
? "\n \n
" +
e.date +
"
"
: "") +
"\n
\n "
);
}, "") +
"\n
",
"\n .tiker {\n width: " +
i +
";\n background-opacity: 0;\n display: flex;\n flex-direction: row;\n z-index: 1;\n color: black;\n }\n .single-tick {\n width: " +
e +
";\n display: flex;\n flex-direction: column;\n justify-content: space-between;\n align-items: flex-start;\n }\n .single-tick shape{\n width: " +
a.width +
";\n height: " +
a.height +
";\n background: " +
a.fill +
";\n }\n .single-tick .text {\n height: " +
o.fontSize +
";\n text-align: center;\n font-size: " +
o.fontSize +
";\n width: 0; \n color: " +
o.fill +
";\n }\n text {\n opacity: " +
o.opacity +
";;\n white-space: nowrap;\n }\n ",
);
})(r, l, c);
d.appendChild(f, v);
var m = (function (t) {
var e = t.delegateNode,
n = t.leftControl,
r = t.rightControl,
i = t.slideInner,
o = t.data,
a = t.tickWidth,
s = t.slideContainer,
u = t.speed,
c = 0,
h = 1,
l = 0;
function d() {
var t = r.width,
e = s.width;
l > e - t || v((l += a));
}
var f = vt(d, void 0 === u ? 100 : u);
function p() {
return r.left - n.left + n.width;
}
function g(t) {
var e = (t / s.width) * o.length;
return o[Math.floor(e)];
}
function y(t, e) {
var r;
void 0 === e && (e = !0);
var o = n.width,
a = s.width;
t < 0 && (t = 0),
t > a - o && (t = a - o),
null === (r = n.onLeftChange) || void 0 === r || r.call(n, t),
n.setStyle("left", t),
e && i.setStyle("width", p()),
i.setStyle("left", t < 0 ? 0 : t);
var u = g(t);
u &&
(n.setText(u.date),
K("RANGE_CHANGE", { value: [(c = t / a), h] }));
}
function v(t, e) {
var n;
void 0 === e && (e = !0);
var o = r.width,
a = s.width;
t < 0 && (t = 0),
t >= a - o && (t = a - o),
null === (n = r.onLeftChange) || void 0 === n || n.call(r, t),
r.setStyle("left", t),
e && i.setStyle("width", p());
var u = g(t + o);
u &&
((l = t),
r.setText(u.date),
K("RANGE_CHANGE", { value: [c, (h = (t + o) / a)] }));
}
var m = new Map();
m.set(n, {
getStart: function () {
return n.left;
},
handler: y,
}),
m.set(r, {
getStart: function () {
return r.left;
},
handler: v,
}),
m.set(i, {
getStart: function () {
return i.left;
},
handler: function (t) {
var e = r.width,
n = i.width,
o = s.width;
t < 0 && (t = 0),
t > o - n && (t = o - n),
y(t, !1),
v(t + n - e, !1);
},
});
var b,
x = 0,
w = 0;
return (
e.on("panstart", function (t) {
if (t.uiNode) {
b = void 0;
var e = m.get(t.uiNode);
e && ((b = t.uiNode), (x = t.clientX), (w = e.getStart()));
}
}),
e.on("panmove", function (t) {
if (b) {
var e = m.get(b),
n = t.clientX - x;
e.handler(w + n);
}
}),
{
goLeftPercent: function (t) {
t < 0 || t > 1 || y(t * s.width);
},
goRightPercent: function (t) {
t < 0 || t > 1 || v(t * s.width);
},
goNext: d,
goPrev: function () {
l < 0 || v((l -= a));
},
player: f,
}
);
})({
data: r,
slideContainer: f,
leftControl: p,
rightControl: g,
slideInner: y,
tickWidth: l,
delegateNode: d,
});
return (
(f.didMount = function () {
m.goLeftPercent(a), m.goRightPercent(u);
}),
Q("SLIDER_PLAY", m.player.play),
Q("SLIDER_PAUSE", m.player.stop),
Q("SPEED_CHANGE", m.player.setSpeed),
Q("CONTROL_NEXT", m.goNext),
Q("CONTROL_PREV", m.goPrev),
d
);
}
function Ve(t, e, n) {
var r = Math.max(t, e),
i = Math.min(t, e);
(n.start = i),
(n.end = r),
Ue(n),
n.tickBoxs.forEach(function (t) {
n.selects.includes(t) ||
(t.getAttribute("disFromStart") >= i &&
t.getAttribute("disFromStart") <= r &&
(t.setStyle("backgroundColor", n.selectedFill),
n.selects.push(t)));
}),
n.selects.length > 0 &&
K("RANGE_CHANGE", {
value: [
n.selects[0].getAttribute("disFromStart") / n.width,
n.selects[n.selects.length - 1].getAttribute("disFromStart") /
n.width,
],
});
}
function Ue(t) {
t.selects.forEach(function (e) {
e.setStyle("backgroundColor", t.unSelectFill);
}),
(t.selects = []);
}
var Ze = function (t) {
var e,
n,
r,
i,
o,
a = t.data,
s = t.tick,
u = s.start,
c = void 0 === u ? 0.1 : u,
h = s.end,
l = void 0 === h ? 0.9 : h,
d = s.width,
f = s.padding;
console.log(t);
var p = Object.assign(
{},
ht,
null === (e = null == t ? void 0 : t.tick) || void 0 === e
? void 0
: e.selectedTickStyle,
),
g = Object.assign(
{},
lt,
null === (n = null == t ? void 0 : t.tick) || void 0 === n
? void 0
: n.unSelectedTickStyle,
),
y = {};
(y.data = a),
(y.width = d),
(y.padding = f || "10 0"),
(y.selectedFill = p.fill),
(y.unSelectFill = g.fill),
(y.gap = at),
(y.tickBoxHeight =
(null === (r = null == t ? void 0 : t.tick) || void 0 === r
? void 0
: r.tickBoxHeight) || st),
(y.lineStyle = Object.assign(
{},
ut,
null === (i = null == t ? void 0 : t.tick) || void 0 === i
? void 0
: i.tickLineStyle,
)),
(y.textStyle = Object.assign(
{},
ct,
null === (o = null == t ? void 0 : t.tick) || void 0 === o
? void 0
: o.tickLabelStyle,
)),
(y.tickWidth = d / a.length),
(y.count = Math.floor(y.textStyle.width / y.tickWidth)),
(y.start = c),
(y.end = l),
(y.selects = []);
var v = (function (t) {
var e = t.data,
n = t.tickWidth,
r = t.count,
i = t.width,
o = t.gap,
a = t.tickBoxHeight,
s = t.textStyle,
u = t.lineStyle,
c = t.start,
h = t.end,
l = t.unSelectFill,
d =
"\n
\n " +
e.reduce(function (t, e, i) {
return (
t +
"\n
\n \n " +
(i % r == 0
? "\n
\n \n
" +
e.date +
"
\n
"
: "") +
"\n
"
);
}, "") +
"\n
\n",
f =
"\n #slider {\n width: " +
i +
";\n display: flex;\n flex-direction: row;\n justify-content: space-between;\n align-items: flex-start;\n padding: " +
t.padding +
";\n }\n\n .ticker {\n width: " +
(n - o) +
";\n display: flex;\n background-opacity: 0;\n align-items: center;\n }\n\n .tick-box {\n width: " +
(n - o) +
";\n height: " +
a +
";\n background: " +
l +
";\n }\n\n .tick-desc {\n display: flex;\n align-items: center;\n }\n\n .text{\n width: 0;\n height: " +
s.fontSize +
";\n text-align:center;\n color: " +
s.fill +
";\n font-size: " +
s.fontSize +
";\n }\n\n .text text{\n white-space: nowrap;\n }\n\n .line {\n width: " +
u.width +
";\n height: " +
u.height +
";\n background: " +
u.fill +
";\n margin: 2 0;\n }\n",
p = V(d, f);
return (
(p.didMount = function () {
(t.start = c * i), (t.end = h * i), Ve(t.start, t.end, t);
}),
p
);
})(y);
return (
(y.tickBoxs = v.queryAll(".tick-box")),
(function (t) {
var e = function () {
(t.end += t.tickWidth), Ve(t.start, t.end, t);
},
n = vt(e, 1e3);
Q("CONTROL_NEXT", e),
Q("CONTROL_PREV", function () {
(t.end -= t.tickWidth), Ve(t.start, t.end, t);
}),
Q("SLIDER_PLAY", n.play),
Q("SLIDER_PAUSE", n.stop),
Q("SPEED_CHANGE", n.setSpeed);
})(y),
(function (t, e) {
var n = 0,
r = !1,
i = 0,
o = Object(gt.G)(Ve, 30, { trailing: !0, leading: !0 });
t.on("panstart", function (t) {
(r = !1),
t.uiNode &&
"tick-box" === t.uiNode.getAttribute("class") &&
((r = !0),
(n = t.clientX),
(i = t.uiNode.getAttribute("disFromStart")),
Ue(e));
}),
t.on("panmove", function (t) {
if (r) {
var a = t.clientX - n;
o(i, i + a, e);
}
}),
t.on("tap", function (t) {
t.uiNode &&
"tick-box" === t.uiNode.getAttribute("class") &&
(function (t, e) {
Ue(e),
e.selects.push(t),
(e.start = e.end = t.getAttribute("disFromStart")),
K("RANGE_CHANGE", {
value: [
t.getAttribute("disFromStart") / e.width,
t.getAttribute("disFromStart") / e.width,
],
}),
t.setStyle("backgroundColor", e.selectedFill);
})(t.uiNode, e);
});
})(v, y),
v
);
};
function Ke(t, e) {
var n = t.width,
r = t.group,
i = t.control,
o = H(
"",
"\n root {\n /** 盒模型 **/\n width: " +
n +
";\n /** flex **/\n display: flex;\n flex-direction: column;\n flex-wrap: nowrap;\n justify-content: center;\n align-items: center;\n }\n",
r,
),
a = yt(i);
return o.appendChild(e, a), o;
}
var Qe = (function () {
function t(t) {
(this._cfgs = Object(gt.d)(this.getDefaultCfgs(), t)),
(this._events = {}),
(this.destroyed = !1);
}
return (
(t.prototype.getDefaultCfgs = function () {
return {};
}),
(t.prototype.initPlugin = function (t) {
var e = this;
e.set("graph", t);
var n = e.getEvents(),
r = {};
Object(gt.e)(n, function (n, i) {
var o = Object(gt.K)(e, n);
(r[i] = o), t.on(i, o);
}),
(this._events = r),
this.init();
}),
(t.prototype.init = function () {}),
(t.prototype.getEvents = function () {
return {};
}),
(t.prototype.get = function (t) {
return this._cfgs[t];
}),
(t.prototype.set = function (t, e) {
this._cfgs[t] = e;
}),
(t.prototype.destroy = function () {}),
(t.prototype.destroyPlugin = function () {
this.destroy();
var t = this.get("graph"),
e = this._events;
Object(gt.e)(e, function (e, n) {
t.off(n, e);
}),
(this._events = null),
(this._cfgs = null),
(this.destroyed = !0);
}),
t
);
})(),
$e = (function (t) {
function e(e) {
return t.call(this, e) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getDefaultCfgs = function () {
return {
className: "f6-component-timebar",
padding: 10,
type: "trend",
data: [],
trend: { smooth: !0 },
controllerCfg: { speed: 1 },
slider: { start: 0.1, end: 0.9 },
tick: { start: 0.1, end: 0.9 },
filterEdge: !1,
};
}),
(e.prototype.init = function () {
var t = this;
setTimeout(function () {
t.render(), t.initEvent();
});
}),
(e.prototype.filterData = function (t) {
var e,
n = t.value,
r = this.get("data");
if (r && 0 !== r.length) {
var i = this.get("rangeChange"),
o = this.get("graph"),
a = Math.round(r.length * n[0]),
s = Math.round(r.length * n[1]);
(s = s >= r.length ? r.length - 1 : s),
(a = a >= r.length ? r.length - 1 : a);
var u =
null === (e = this._cfgs.tick) || void 0 === e
? void 0
: e.tickLabelFormatter,
c = u ? u(r[a]) : r[a].date,
h = u ? u(r[s]) : r[s].date;
if (i) i(o, c, h);
else {
(!this.cacheGraphData ||
(this.cacheGraphData.nodes &&
0 === this.cacheGraphData.nodes.length)) &&
(this.cacheGraphData = o.get("data"));
var l = this.cacheGraphData.nodes.filter(function (t) {
return t.date >= r[a].date && t.date <= r[s].date;
}),
d = l.map(function (t) {
return t.id;
}),
f = [];
this.cacheGraphData.edges &&
((f = this.cacheGraphData.edges.filter(function (t) {
return d.includes(t.source) && d.includes(t.target);
})),
this.get("filterEdge") &&
(f = f.filter(function (t) {
return t.date >= r[a].date && t.date <= r[s].date;
}))),
o.changeData({ nodes: l, edges: f });
}
} else console.warn("请配置 TimeBar 组件的数据");
}),
(e.prototype.render = function () {
var t = this._cfgs,
e = t.data,
n = t.width,
r = t.padding,
i = t.type,
o = t.trend,
a = t.slider,
s = t.controllerCfg,
u = t.tick,
c = t.sliderTick,
l = this.get("graph"),
d = l.get("uiGroup"),
f = null;
switch (i) {
case "trend":
f = (function (t) {
var e = t.width,
n = void 0 === e ? 0 : e,
r = t.padding,
i = void 0 === r ? 0 : r,
o = t.group,
a = t.data,
s = void 0 === a ? [] : a,
u = t.slider,
c = void 0 === u ? {} : u,
l = t.controllerCfg,
d = void 0 === l ? {} : l,
f = t.trend,
p = void 0 === f ? {} : f,
g = t.sliderTick,
y = void 0 === g ? {} : g,
v = qe({
data: s,
width: n,
slider: Object(h.a)(
{ width: c.width || n - 2 * i, paddingTop: 0 },
c || {},
),
sliderTick: Object(h.a)({ width: n - 2 * i }, y || {}),
trend: Object(h.a)(
{
data:
null == s
? void 0
: s.map(function (t) {
return t.value;
}),
},
p || {},
),
});
return Ke(
{
width: n,
group: o,
control: Object(h.a)({ wrapperWidth: n }, d),
},
v,
);
})({
group: d,
width: n,
padding: r,
data: e,
trend: o,
slider: a,
controllerCfg: s,
sliderTick: c,
});
break;
case "tick":
f = (function (t) {
var e = t.group,
n = t.data,
r = void 0 === n ? [] : n,
i = t.width,
o = t.padding,
a = t.controllerCfg,
s = void 0 === a ? {} : a,
u = t.tick,
c = void 0 === u ? {} : u,
l = Ze({
data: r,
tick: Object(h.a)({ width: i - o }, c),
});
return Ke(
{
width: i,
group: e,
control: Object(h.a)({ wrapperWidth: i }, s),
},
l,
);
})({
group: d,
width: n,
padding: r,
tick: u,
data: e,
controllerCfg: s,
});
break;
case "simple":
f = (function (t) {
var e = t.width,
n = void 0 === e ? 0 : e,
r = t.padding,
i = void 0 === r ? 0 : r,
o = t.group,
a = t.data,
s = void 0 === a ? [] : a,
u = t.slider,
c = void 0 === u ? {} : u,
l = t.controllerCfg,
d = void 0 === l ? {} : l,
f = t.sliderTick,
p = void 0 === f ? {} : f,
g = Ge({
data: s,
width: n,
slider: Object(h.a)(
{ width: c.width || n - 2 * i, paddingTop: 0 },
c,
),
sliderTick: Object(h.a)({ width: n - 2 * i }, p),
});
return Ke(
{
width: n,
group: o,
control: Object(h.a)({ wrapperWidth: n }, d),
},
g,
);
})({
group: d,
width: n,
padding: r,
slider: a,
data: e,
controllerCfg: s,
sliderTick: c,
});
}
var p = l.get("height");
d.translate(0, p - f.height);
}),
(e.prototype.initEvent = function () {
Q(
"RANGE_CHANGE",
Object(gt.G)(this.filterData.bind(this), 200, {
trailing: !0,
leading: !0,
}),
);
}),
(e.prototype.destroy = function () {
Z = {};
}),
e
);
})(Qe),
Je = {
getDefaultCfg: function () {
return {};
},
getEvents: function () {
return {};
},
updateCfg: function (t) {
return Object.assign(this, t), !0;
},
shouldBegin: function () {
return !0;
},
shouldUpdate: function () {
return !0;
},
shouldEnd: function () {
return !0;
},
bind: function (t) {
var e = this.events;
(this.graph = t),
("drag-canvas" !== this.type &&
"brush-select" !== this.type &&
"lasso-select" !== this.type) ||
t.get("canvas").set("draggable", !0),
Object(gt.e)(e, function (e, n) {
t.on(n, e);
});
},
unbind: function (t) {
var e = this.events;
("drag-canvas" !== this.type &&
"brush-select" !== this.type &&
"lasso-select" !== this.type) ||
t.get("canvas").set("draggable", !1),
Object(gt.e)(e, function (e, n) {
t.off(n, e);
});
},
get: function (t) {
return this[t];
},
set: function (t, e) {
return (this[t] = e), this;
},
},
tn = (function () {
function t() {}
return (
(t.registerBehavior = function (e, n) {
if (!n)
throw new Error(
"please specify handler for this behavior: " + e,
);
var r = Object(gt.b)(Je);
Object.assign(r, n);
var i = function (t) {
var e = this;
Object.assign(this, this.getDefaultCfg(), t);
var n = this.getEvents();
this.events = null;
var r = {};
n &&
(Object(gt.e)(n, function (t, n) {
r[n] = Object(gt.K)(e, t);
}),
(this.events = r));
};
(i.prototype = r), (t.types[e] = i);
}),
(t.hasBehavior = function (e) {
return !!t.types[e];
}),
(t.getBehavior = function (e) {
return t.types[e];
}),
(t.types = {}),
t
);
})(),
en = tn,
nn = n(14);
function rn(t) {
return (rn =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var on = {};
function an(t) {
return on.requestAnimationFrame
? on.requestAnimationFrame(t)
: ("object" ===
("undefined" == typeof window ? "undefined" : rn(window)) &&
window.requestAnimationFrame
? window.requestAnimationFrame
: function (t) {
return setTimeout(t, 16);
})(t);
}
var sn = n(2),
un = function (t, e) {
var n = t.nodes,
r = t.edges,
i = [],
o = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
o[t.id] = e;
i.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
a = o[n],
s = o[r];
(!a && 0 !== a) ||
(!s && 0 !== s) ||
((i[a][s] = 1), e || (i[s][a] = 1));
}),
i
);
},
cn = function (t, e) {
return t === e;
},
hn = (function () {
function t(t, e) {
void 0 === e && (e = null), (this.value = t), (this.next = e);
}
return (
(t.prototype.toString = function (t) {
return t ? t(this.value) : "" + this.value;
}),
t
);
})(),
ln = (function () {
function t(t) {
void 0 === t && (t = cn),
(this.head = null),
(this.tail = null),
(this.compare = t);
}
return (
(t.prototype.prepend = function (t) {
var e = new hn(t, this.head);
return (this.head = e), this.tail || (this.tail = e), this;
}),
(t.prototype.append = function (t) {
var e = new hn(t);
return this.head
? ((this.tail.next = e), (this.tail = e), this)
: ((this.head = e), (this.tail = e), this);
}),
(t.prototype.delete = function (t) {
if (!this.head) return null;
for (
var e = null;
this.head && this.compare(this.head.value, t);
)
(e = this.head), (this.head = this.head.next);
var n = this.head;
if (null !== n)
for (; n.next; )
this.compare(n.next.value, t)
? ((e = n.next), (n.next = n.next.next))
: (n = n.next);
return this.compare(this.tail.value, t) && (this.tail = n), e;
}),
(t.prototype.find = function (t) {
var e = t.value,
n = void 0 === e ? void 0 : e,
r = t.callback,
i = void 0 === r ? void 0 : r;
if (!this.head) return null;
for (var o = this.head; o; ) {
if (i && i(o.value)) return o;
if (void 0 !== n && this.compare(o.value, n)) return o;
o = o.next;
}
return null;
}),
(t.prototype.deleteTail = function () {
var t = this.tail;
if (this.head === this.tail)
return (this.head = null), (this.tail = null), t;
for (var e = this.head; e.next; )
e.next.next ? (e = e.next) : (e.next = null);
return (this.tail = e), t;
}),
(t.prototype.deleteHead = function () {
if (!this.head) return null;
var t = this.head;
return (
this.head.next
? (this.head = this.head.next)
: ((this.head = null), (this.tail = null)),
t
);
}),
(t.prototype.fromArray = function (t) {
var e = this;
return (
t.forEach(function (t) {
return e.append(t);
}),
this
);
}),
(t.prototype.toArray = function () {
for (var t = [], e = this.head; e; ) t.push(e), (e = e.next);
return t;
}),
(t.prototype.reverse = function () {
for (var t = this.head, e = null, n = null; t; )
(n = t.next), (t.next = e), (e = t), (t = n);
(this.tail = this.head), (this.head = e);
}),
(t.prototype.toString = function (t) {
return (
void 0 === t && (t = void 0),
this.toArray()
.map(function (e) {
return e.toString(t);
})
.toString()
);
}),
t
);
})();
!(function () {
function t() {
this.linkedList = new ln();
}
(t.prototype.isEmpty = function () {
return !this.linkedList.head;
}),
(t.prototype.peek = function () {
return this.linkedList.head ? this.linkedList.head.value : null;
}),
(t.prototype.enqueue = function (t) {
this.linkedList.append(t);
}),
(t.prototype.dequeue = function () {
var t = this.linkedList.deleteHead();
return t ? t.value : null;
}),
(t.prototype.toString = function (t) {
return this.linkedList.toString(t);
});
})();
var dn = function (t) {
var e = {},
n = t.nodes,
r = void 0 === n ? [] : n,
i = t.edges,
o = void 0 === i ? [] : i;
return (
r.forEach(function (t) {
e[t.id] = { degree: 0, inDegree: 0, outDegree: 0 };
}),
o.forEach(function (t) {
e[t.source].degree++,
e[t.source].outDegree++,
e[t.target].degree++,
e[t.target].inDegree++;
}),
e
);
},
fn = dn;
var pn = function (t, e) {
for (var n = un(t, e), r = [], i = n.length, o = 0; o < i; o += 1) {
r[o] = [];
for (var a = 0; a < i; a += 1)
o === a
? (r[o][a] = 0)
: 0 !== n[o][a] && n[o][a]
? (r[o][a] = n[o][a])
: (r[o][a] = 1 / 0);
}
for (var s = 0; s < i; s += 1)
for (o = 0; o < i; o += 1)
for (a = 0; a < i; a += 1)
r[o][a] > r[o][s] + r[s][a] && (r[o][a] = r[o][s] + r[s][a]);
return r;
},
gn =
((function () {
function t(t) {
(this.count = t.length), (this.parent = {});
for (var e = 0, n = t; e < n.length; e++) {
var r = n[e];
this.parent[r] = r;
}
}
(t.prototype.find = function (t) {
for (; this.parent[t] !== t; ) t = this.parent[t];
return t;
}),
(t.prototype.union = function (t, e) {
var n = this.find(t),
r = this.find(e);
n !== r &&
(n < r
? (this.parent[e] !== e && this.union(this.parent[e], t),
(this.parent[e] = this.parent[t]))
: (this.parent[t] !== t && this.union(this.parent[t], e),
(this.parent[t] = this.parent[e])));
}),
(t.prototype.connected = function (t, e) {
return this.find(t) === this.find(e);
});
})(),
function (t, e) {
return t - e;
}),
yn =
((function () {
function t(t) {
void 0 === t && (t = gn), (this.compareFn = t), (this.list = []);
}
(t.prototype.getLeft = function (t) {
return 2 * t + 1;
}),
(t.prototype.getRight = function (t) {
return 2 * t + 2;
}),
(t.prototype.getParent = function (t) {
return 0 === t ? null : Math.floor((t - 1) / 2);
}),
(t.prototype.isEmpty = function () {
return this.list.length <= 0;
}),
(t.prototype.top = function () {
return this.isEmpty() ? void 0 : this.list[0];
}),
(t.prototype.delMin = function () {
var t = this.top(),
e = this.list.pop();
return (
this.list.length > 0 &&
((this.list[0] = e), this.moveDown(0)),
t
);
}),
(t.prototype.insert = function (t) {
if (null !== t) {
this.list.push(t);
var e = this.list.length - 1;
return this.moveUp(e), !0;
}
return !1;
}),
(t.prototype.moveUp = function (t) {
for (
var e = this.getParent(t);
t && t > 0 && this.compareFn(this.list[e], this.list[t]) > 0;
) {
var n = this.list[e];
(this.list[e] = this.list[t]),
(this.list[t] = n),
(t = e),
(e = this.getParent(t));
}
}),
(t.prototype.moveDown = function (t) {
var e,
n = t,
r = this.getLeft(t),
i = this.getRight(t),
o = this.list.length;
null !== r &&
r < o &&
this.compareFn(this.list[n], this.list[r]) > 0
? (n = r)
: null !== i &&
i < o &&
this.compareFn(this.list[n], this.list[i]) > 0 &&
(n = i),
t !== n &&
((e = [this.list[n], this.list[t]]),
(this.list[t] = e[0]),
(this.list[n] = e[1]),
this.moveDown(n));
});
})(),
function (t, e, n, r) {
void 0 === t && (t = -1),
void 0 === e && (e = -1),
void 0 === n && (n = -1),
void 0 === r && (r = "-1"),
(this.id = t),
(this.from = e),
(this.to = n),
(this.label = r);
}),
vn = (function () {
function t(t, e) {
void 0 === t && (t = -1),
void 0 === e && (e = "-1"),
(this.id = t),
(this.label = e),
(this.edges = []),
(this.edgeMap = {});
}
return (
(t.prototype.addEdge = function (t) {
this.edges.push(t), (this.edgeMap[t.id] = t);
}),
t
);
})(),
mn = (function () {
function t(t, e, n) {
void 0 === t && (t = -1),
void 0 === e && (e = !0),
void 0 === n && (n = !1),
(this.id = t),
(this.edgeIdAutoIncrease = e),
(this.edges = []),
(this.nodes = []),
(this.nodeMap = {}),
(this.edgeMap = {}),
(this.nodeLabelMap = {}),
(this.edgeLabelMap = {}),
(this.counter = 0),
(this.directed = n);
}
return (
(t.prototype.getNodeNum = function () {
return this.nodes.length;
}),
(t.prototype.addNode = function (t, e) {
if (!this.nodeMap[t]) {
var n = new vn(t, e);
this.nodes.push(n),
(this.nodeMap[t] = n),
this.nodeLabelMap[e] || (this.nodeLabelMap[e] = []),
this.nodeLabelMap[e].push(t);
}
}),
(t.prototype.addEdge = function (t, e, n, r) {
if (
((this.edgeIdAutoIncrease || void 0 === t) &&
(t = this.counter++),
!(
this.nodeMap[e] &&
this.nodeMap[n] &&
this.nodeMap[n].edgeMap[t]
))
) {
var i = new yn(t, e, n, r);
if (
(this.edges.push(i),
(this.edgeMap[t] = i),
this.nodeMap[e].addEdge(i),
this.edgeLabelMap[r] || (this.edgeLabelMap[r] = []),
this.edgeLabelMap[r].push(i),
!this.directed)
) {
var o = new yn(t, n, e, r);
this.nodeMap[n].addEdge(o), this.edgeLabelMap[r].push(o);
}
}
}),
t
);
})(),
bn = (function () {
function t(t, e, n, r, i) {
(this.fromNode = t),
(this.toNode = e),
(this.nodeEdgeNodeLabel = {
nodeLabel1: n || "-1",
edgeLabel: r || "-1",
nodeLabel2: i || "-1",
});
}
return (
(t.prototype.equalTo = function (t) {
return (
this.fromNode === t.formNode &&
this.toNode === t.toNode &&
this.nodeEdgeNodeLabel === t.nodeEdgeNodeLabel
);
}),
(t.prototype.notEqualTo = function (t) {
return !this.equalTo(t);
}),
t
);
})(),
xn = (function () {
function t() {
(this.rmpath = []), (this.dfsEdgeList = []);
}
return (
(t.prototype.equalTo = function (t) {
var e = this.dfsEdgeList.length;
if (e !== t.length) return !1;
for (var n = 0; n < e; n++)
if (this.dfsEdgeList[n] !== t[n]) return !1;
return !0;
}),
(t.prototype.notEqualTo = function (t) {
return !this.equalTo(t);
}),
(t.prototype.pushBack = function (t, e, n, r, i) {
return (
this.dfsEdgeList.push(new bn(t, e, n, r, i)), this.dfsEdgeList
);
}),
(t.prototype.toGraph = function (t, e) {
void 0 === t && (t = -1), void 0 === e && (e = !1);
var n = new mn(t, !0, e);
return (
this.dfsEdgeList.forEach(function (t) {
var e = t.fromNode,
r = t.toNode,
i = t.nodeEdgeNodeLabel,
o = i.nodeLabel1,
a = i.edgeLabel,
s = i.nodeLabel2;
"-1" !== o && n.addNode(e, o),
"-1" !== s && n.addNode(r, s),
n.addEdge(void 0, e, r, a);
}),
n
);
}),
(t.prototype.buildRmpath = function () {
this.rmpath = [];
for (
var t = void 0, e = this.dfsEdgeList.length - 1;
e >= 0;
e--
) {
var n = this.dfsEdgeList[e],
r = n.fromNode,
i = n.toNode;
r < i &&
(void 0 === t || i === t) &&
(this.rmpath.push(e), (t = r));
}
return this.rmpath;
}),
(t.prototype.getNodeNum = function () {
var t = {};
return (
this.dfsEdgeList.forEach(function (e) {
t[e.fromNode] || (t[e.fromNode] = !0),
t[e.toNode] || (t[e.toNode] = !0);
}),
Object.keys(t).length
);
}),
t
);
})(),
wn = (function () {
function t(t) {
if (
((this.his = {}),
(this.nodesUsed = {}),
(this.edgesUsed = {}),
(this.edges = []),
t)
) {
for (; t; ) {
var e = t.edge;
this.edges.push(e),
(this.nodesUsed[e.from] = 1),
(this.nodesUsed[e.to] = 1),
(this.edgesUsed[e.id] = 1),
(t = t.preNode);
}
this.edges = this.edges.reverse();
}
}
return (
(t.prototype.hasNode = function (t) {
return 1 === this.nodesUsed[t.id];
}),
(t.prototype.hasEdge = function (t) {
return 1 === this.edgesUsed[t.id];
}),
t
);
})();
!(function () {
function t(t) {
var e = t.graphs,
n = t.minSupport,
r = void 0 === n ? 2 : n,
i = t.minNodeNum,
o = void 0 === i ? 1 : i,
a = t.maxNodeNum,
s = void 0 === a ? 4 : a,
u = t.top,
c = void 0 === u ? 10 : u,
h = t.directed,
l = void 0 !== h && h,
d = t.verbose,
f = void 0 !== d && d;
(this.graphs = e),
(this.dfsCode = new xn()),
(this.support = 0),
(this.frequentSize1Subgraphs = []),
(this.frequentSubgraphs = []),
(this.minSupport = r),
(this.top = c),
(this.directed = l),
(this.counter = 0),
(this.maxNodeNum = s),
(this.minNodeNum = o),
(this.verbose = f),
this.maxNodeNum < this.minNodeNum &&
(this.maxNodeNum = this.minNodeNum),
(this.reportDF = []);
}
(t.prototype.findForwardRootEdges = function (t, e) {
var n = this,
r = [],
i = t.nodeMap;
return (
e.edges.forEach(function (t) {
(n.directed || e.label <= i[t.to].label) && r.push(t);
}),
r
);
}),
(t.prototype.findBackwardEdge = function (t, e, n, r) {
if (!this.directed && e === n) return null;
for (
var i = t.nodeMap, o = i[n.to].edges, a = o.length, s = 0;
s < a;
s++
) {
var u = o[s];
if (!r.hasEdge(u) && u.to === e.from)
if (this.directed) {
if (
i[e.from].label < i[n.to].label ||
(i[e.from].label === i[n.to].label && e.label <= u.label)
)
return u;
} else if (
e.label < u.label ||
(e.label === u.label && i[e.to].label <= i[n.to].label)
)
return u;
}
return null;
}),
(t.prototype.findForwardPureEdges = function (t, e, n, r) {
for (
var i = [], o = e.to, a = t.nodeMap[o].edges, s = a.length, u = 0;
u < s;
u++
) {
var c = a[u],
h = t.nodeMap[c.to];
n <= h.label && !r.hasNode(h) && i.push(c);
}
return i;
}),
(t.prototype.findForwardRmpathEdges = function (t, e, n, r) {
for (
var i = [],
o = t.nodeMap,
a = o[e.to].label,
s = o[e.from].edges,
u = s.length,
c = 0;
c < u;
c++
) {
var h = s[c],
l = o[h.to].label;
e.to === h.to ||
n > l ||
r.hasNode(o[h.to]) ||
((e.label < h.label || (e.label === h.label && a <= l)) &&
i.push(h));
}
return i;
}),
(t.prototype.getSupport = function (t) {
var e = {};
return (
t.forEach(function (t) {
e[t.graphId] || (e[t.graphId] = !0);
}),
Object.keys(e).length
);
}),
(t.prototype.findMinLabel = function (t) {
var e = void 0;
return (
Object.keys(t).forEach(function (n) {
var r = t[n],
i = r.nodeLabel1,
o = r.edgeLabel,
a = r.nodeLabel2;
e
? (i < e.nodeLabel1 ||
(i === e.nodeLabel1 && o < e.edgeLabel) ||
(i === e.nodeLabel1 &&
o === e.edgeLabel &&
a < e.nodeLabel2)) &&
(e = { nodeLabel1: i, edgeLabel: o, nodeLabel2: a })
: (e = { nodeLabel1: i, edgeLabel: o, nodeLabel2: a });
}),
e
);
}),
(t.prototype.isMin = function () {
var t = this,
e = this.dfsCode;
if (
(this.verbose && console.log("isMin checking", e),
1 === e.dfsEdgeList.length)
)
return !0;
var n = this.directed,
r = e.toGraph(-1, n),
i = r.nodeMap,
o = new xn(),
a = {};
r.nodes.forEach(function (e) {
t.findForwardRootEdges(r, e).forEach(function (t) {
var n = i[t.to],
o = e.label + "-" + t.label + "-" + n.label;
a[o] ||
(a[o] = {
projected: [],
nodeLabel1: e.label,
edgeLabel: t.label,
nodeLabel2: n.label,
});
var s = { graphId: r.id, edge: t, preNode: null };
a[o].projected.push(s);
});
});
var s = this.findMinLabel(a);
o.dfsEdgeList.push(
new bn(0, 1, s.nodeLabel1, s.edgeLabel, s.nodeLabel2),
);
var u = s.nodeLabel1 + "-" + s.edgeLabel + "-" + s.nodeLabel2;
return (function a(s) {
for (
var u = o.buildRmpath(),
c = o.dfsEdgeList[0].nodeEdgeNodeLabel.nodeLabel1,
h = o.dfsEdgeList[u[0]].toNode,
l = {},
d = !1,
f = 0,
p = n ? -1 : 0,
g = function (e) {
if (d) return "break";
s.forEach(function (n) {
var i = new wn(n),
a = t.findBackwardEdge(
r,
i.edges[u[e]],
i.edges[u[0]],
i,
);
a &&
(l[a.label] ||
(l[a.label] = { projected: [], edgeLabel: a.label }),
l[a.label].projected.push({
graphId: r.id,
edge: l,
preNode: n,
}),
(f = o.dfsEdgeList[u[e]].fromNode),
(d = !0));
});
},
y = u.length - 1;
y > p;
y--
) {
if ("break" === g(y)) break;
}
if (d) {
var v = t.findMinLabel(l);
o.dfsEdgeList.push(new bn(h, f, "-1", v.edgeLabel, "-1"));
var m = o.dfsEdgeList.length - 1;
return (
t.dfsCode.dfsEdgeList[m] === o.dfsEdgeList[m] &&
a(l[v.edgeLabel].projected)
);
}
var b = {};
d = !1;
var x = 0;
s.forEach(function (e) {
var n = new wn(e),
o = t.findForwardPureEdges(r, n.edges[u[0]], c, n);
o.length > 0 &&
((d = !0),
(x = h),
o.forEach(function (t) {
var n = t.label + "-" + i[t.to].label;
b[n] ||
(b[n] = {
projected: [],
edgeLabel: t.label,
nodeLabel2: i[t.to].label,
}),
b[n].projected.push({
graphId: r.id,
edge: t,
preNode: e,
});
}));
});
var w = u.length,
O = function (e) {
if (d) return "break";
var n = u[e];
s.forEach(function (e) {
var a = new wn(e),
s = t.findForwardRmpathEdges(r, a.edges[n], c, a);
s.length > 0 &&
((d = !0),
(x = o.dfsEdgeList[n].fromNode),
s.forEach(function (t) {
var n = t.label + "-" + i[t.to].label;
b[n] ||
(b[n] = {
projected: [],
edgeLabel: t.label,
nodeLabel2: i[t.to].label,
}),
b[n].projected.push({
graphId: r.id,
edge: t,
preNode: e,
});
}));
});
};
for (y = 0; y < w; y++) {
if ("break" === O(y)) break;
}
if (!d) return !0;
var M = t.findMinLabel(b);
o.dfsEdgeList.push(
new bn(x, h + 1, "-1", M.edgeLabel, M.nodeLabel2),
);
var S = o.dfsEdgeList.length - 1;
return (
e.dfsEdgeList[S] === o.dfsEdgeList[S] &&
a(b[M.edgeLabel + "-" + M.nodeLabel2].projected)
);
})(a[u].projected);
}),
(t.prototype.report = function () {
if (!(this.dfsCode.getNodeNum() < this.minNodeNum)) {
this.counter++;
var t = this.dfsCode.toGraph(this.counter, this.directed);
this.frequentSubgraphs.push(Object(gt.b)(t));
}
}),
(t.prototype.subGraphMining = function (t) {
var e = this;
if (!(this.getSupport(t) < this.minSupport) && this.isMin()) {
this.report();
var n = this.dfsCode.getNodeNum(),
r = this.dfsCode.buildRmpath(),
i = this.dfsCode.dfsEdgeList[r[0]].toNode,
o = this.dfsCode.dfsEdgeList[0].nodeEdgeNodeLabel.nodeLabel1,
a = {},
s = {};
t.forEach(function (t) {
for (
var u = e.graphs[t.graphId],
c = u.nodeMap,
h = new wn(t),
l = r.length - 1;
l >= 0;
l--
) {
var d = e.findBackwardEdge(
u,
h.edges[r[l]],
h.edges[r[0]],
h,
);
if (d) {
var f =
e.dfsCode.dfsEdgeList[r[l]].fromNode + "-" + d.label;
s[f] ||
(s[f] = {
projected: [],
toNodeId: e.dfsCode.dfsEdgeList[r[l]].fromNode,
edgeLabel: d.label,
}),
s[f].projected.push({
graphId: t.graphId,
edge: d,
preNode: t,
});
}
}
if (!(n >= e.maxNodeNum)) {
e.findForwardPureEdges(u, h.edges[r[0]], o, h).forEach(
function (e) {
var n = i + "-" + e.label + "-" + c[e.to].label;
a[n] ||
(a[n] = {
projected: [],
fromNodeId: i,
edgeLabel: e.label,
nodeLabel2: c[e.to].label,
}),
a[n].projected.push({
graphId: t.graphId,
edge: e,
preNode: t,
});
},
);
var p = function (n) {
e.findForwardRmpathEdges(u, h.edges[r[n]], o, h).forEach(
function (i) {
var o =
e.dfsCode.dfsEdgeList[r[n]].fromNode +
"-" +
i.label +
"-" +
c[i.to].label;
a[o] ||
(a[o] = {
projected: [],
fromNodeId: e.dfsCode.dfsEdgeList[r[n]].fromNode,
edgeLabel: i.label,
nodeLabel2: c[i.to].label,
}),
a[o].projected.push({
graphId: t.graphId,
edge: i,
preNode: t,
});
},
);
};
for (l = 0; l < r.length; l++) p(l);
}
}),
Object.keys(s).forEach(function (t) {
var n = s[t],
r = n.toNodeId,
o = n.edgeLabel;
e.dfsCode.dfsEdgeList.push(new bn(i, r, "-1", o, "-1")),
e.subGraphMining(s[t].projected),
e.dfsCode.dfsEdgeList.pop();
}),
Object.keys(a).forEach(function (t) {
var n = a[t],
r = n.fromNodeId,
o = n.edgeLabel,
s = n.nodeLabel2;
e.dfsCode.dfsEdgeList.push(new bn(r, i + 1, "-1", o, s)),
e.subGraphMining(a[t].projected),
e.dfsCode.dfsEdgeList.pop();
});
}
}),
(t.prototype.generate1EdgeFrequentSubGraphs = function () {
var t = this.graphs,
e = this.directed,
n = this.minSupport,
r = this.frequentSize1Subgraphs,
i = {},
o = {},
a = {},
s = {};
return (
Object.keys(t).forEach(function (n) {
var r = t[n],
u = r.nodeMap;
r.nodes.forEach(function (t, r) {
var c = t.label,
h = n + "-" + c;
if (!a[h]) {
var l = i[c] || 0;
l++, (i[c] = l);
}
(a[h] = { graphKey: n, label: c }),
t.edges.forEach(function (t) {
var r = c,
i = u[t.to].label;
if (!e && r > i) {
var a = i;
(i = r), (r = a);
}
var h = t.label,
l = n + "-" + r + "-" + h + "-" + i,
d = r + "-" + h + "-" + i;
if (!o[d]) {
var f = o[d] || 0;
f++, (o[d] = f);
}
s[l] = {
graphId: n,
nodeLabel1: r,
edgeLabel: h,
nodeLabel2: i,
};
});
});
}),
Object.keys(i).forEach(function (t) {
if (!(i[t] < n)) {
var e = { nodes: [], edges: [] };
e.nodes.push({ id: "0", label: t }), r.push(e);
}
}),
r
);
}),
(t.prototype.run = function () {
var t = this;
if (
((this.frequentSize1Subgraphs =
this.generate1EdgeFrequentSubGraphs()),
!(this.maxNodeNum < 2))
) {
var e = this.graphs,
n = (this.directed, {});
Object.keys(e).forEach(function (r) {
var i = e[r],
o = i.nodeMap;
i.nodes.forEach(function (e) {
t.findForwardRootEdges(i, e).forEach(function (t) {
var i = o[t.to],
a = e.label + "-" + t.label + "-" + i.label;
n[a] ||
(n[a] = {
projected: [],
nodeLabel1: e.label,
edgeLabel: t.label,
nodeLabel2: i.label,
});
var s = { graphId: r, edge: t, preNode: null };
n[a].projected.push(s);
});
});
}),
Object.keys(n).forEach(function (e) {
var r = n[e],
i = r.projected,
o = r.nodeLabel1,
a = r.edgeLabel,
s = r.nodeLabel2;
t.dfsCode.dfsEdgeList.push(new bn(0, 1, o, a, s)),
t.subGraphMining(i),
t.dfsCode.dfsEdgeList.pop();
});
}
});
})();
var On = (function () {
function t(t) {
void 0 === t && (t = 10),
(this.linkedList = new ln()),
(this.maxStep = t);
}
return (
Object.defineProperty(t.prototype, "length", {
get: function () {
return this.linkedList.toArray().length;
},
enumerable: !1,
configurable: !0,
}),
(t.prototype.isEmpty = function () {
return !this.linkedList.head;
}),
(t.prototype.isMaxStack = function () {
return this.toArray().length >= this.maxStep;
}),
(t.prototype.peek = function () {
return this.isEmpty() ? null : this.linkedList.head.value;
}),
(t.prototype.push = function (t) {
this.linkedList.prepend(t),
this.length > this.maxStep && this.linkedList.deleteTail();
}),
(t.prototype.pop = function () {
var t = this.linkedList.deleteHead();
return t ? t.value : null;
}),
(t.prototype.toArray = function () {
return this.linkedList.toArray().map(function (t) {
return t.value;
});
}),
(t.prototype.clear = function () {
for (; !this.isEmpty(); ) this.pop();
}),
t
);
})(),
Mn = sn.a.transform,
Sn = function (t) {
return function (e, n) {
return e[t] - n[t];
};
},
Cn = function (t, e, n) {
return t >= e && t <= n;
},
jn = function (t, e, n, r) {
var i = n.x - t.x,
o = n.y - t.y,
a = e.x - t.x,
s = e.y - t.y,
u = r.x - n.x,
c = r.y - n.y,
h = a * c - s * u,
l = 1 / h;
if (h * h > 1e-4 * (a * a + s * s) * (u * u + c * c)) {
var d = (i * c - o * u) * l,
f = (i * s - o * a) * l;
return Cn(d, 0, 1) && Cn(f, 0, 1)
? { x: t.x + d * a, y: t.y + d * s }
: null;
}
return null;
},
kn = function (t, e) {
var n = t.x,
r = t.y,
i = t.width,
o = t.height,
a = [],
s = { x: n + i / 2, y: r + o / 2 };
a.push({ x: n, y: r }),
a.push({ x: n + i, y: r }),
a.push({ x: n + i, y: r + o }),
a.push({ x: n, y: r + o }),
a.push({ x: n, y: r });
for (
var u = null, c = 1;
c < a.length && !(u = jn(a[c - 1], a[c], s, e));
c++
);
return u;
},
En = function (t, e) {
var n = t.x,
r = t.y,
i = t.r,
o = e.x - n,
a = e.y - r;
if (Math.sqrt(o * o + a * a) < i) return null;
var s = Math.sign(o),
u = Math.sign(a),
c = Math.atan(a / o);
return {
x: n + Math.abs(i * Math.cos(c)) * s,
y: r + Math.abs(i * Math.sin(c)) * u,
};
},
Nn = function (t, e) {
var n = t.rx,
r = t.ry,
i = t.x,
o = t.y,
a = e.x - i,
s = e.y - o,
u = Math.atan2(s / r, a / n);
return (
u < 0 && (u += 2 * Math.PI),
{ x: i + n * Math.cos(u), y: o + r * Math.sin(u) }
);
},
Tn = function (t, e, n) {
void 0 === n && (n = 1);
var r = [t.x, t.y, n];
return (
(e && !isNaN(e[0])) || (e = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
sn.d.transformMat3(r, r, e),
{ x: r[0], y: r[1] }
);
},
Pn = function (t, e, n) {
void 0 === n && (n = 1),
(e && !isNaN(e[0])) || (e = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = sn.b.invert([1, 0, 0, 0, 1, 0, 0, 0, 1], e);
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var i = [t.x, t.y, n];
return sn.d.transformMat3(i, i, r), { x: i[0], y: i[1] };
},
In = function (t, e, n) {
var r = t.x - e.x,
i = t.y - e.y,
o = t.x - n.x,
a = t.y - n.y,
s = (t.x * t.x - e.x * e.x - e.y * e.y + t.y * t.y) / 2,
u = (t.x * t.x - n.x * n.x - n.y * n.y + t.y * t.y) / 2,
c = i * o - r * a;
return { x: -(a * s - i * u) / c, y: -(r * u - o * s) / c };
},
Bn = function (t, e) {
var n = t.x - e.x,
r = t.y - e.y;
return Math.sqrt(n * n + r * r);
},
An = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = [];
t.forEach(function (t) {
r.push(t * e);
}),
n.push(r);
}),
n
);
},
Ln = function (t) {
for (var e = [], n = t.length, r = 0; r < n; r += 1) {
e[r] = [];
for (var i = 0; i < n; i += 1)
r === i
? (e[r][i] = 0)
: 0 !== t[r][i] && t[r][i]
? (e[r][i] = t[r][i])
: (e[r][i] = 1 / 0);
}
for (var o = 0; o < n; o += 1)
for (r = 0; r < n; r += 1)
for (i = 0; i < n; i += 1)
e[r][i] > e[r][o] + e[o][i] && (e[r][i] = e[r][o] + e[o][i]);
return e;
},
Dn = function (t, e) {
var n = t.nodes,
r = t.edges,
i = [],
o = {};
if (!n) throw new Error("invalid nodes data!");
return (
n &&
n.forEach(function (t, e) {
o[t.id] = e;
i.push([]);
}),
r &&
r.forEach(function (t) {
var n = t.source,
r = t.target,
a = o[n],
s = o[r];
(i[a][s] = 1), e || (i[s][a] = 1);
}),
i
);
},
_n = function (t, e) {
t.translate(e.x, e.y);
},
Rn = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = t.getCanvasBBox(),
i = e.x - r.minX,
o = e.y - r.minY,
a = Mn(n, [["t", i, o]]);
t.setMatrix(a);
},
Yn = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = e;
Object(gt.m)(e) || (r = [e, e]),
Object(gt.m)(e) && 1 === e.length && (r = [e[0], e[0]]),
(n = Mn(n, [["s", r[0], r[1]]])),
t.setMatrix(n);
},
Fn = function (t, e) {
var n = t.getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(n = Mn(n, [["r", e]])),
t.setMatrix(n);
},
zn = function (t, e, n) {
for (var r = [], i = 0; i < t; i++) r[i] = 0;
return (
n.forEach(function (t) {
t.source && (r[e[t.source]] += 1),
t.target && (r[e[t.target]] += 1);
}),
r
);
};
function Xn(t, e, n) {
return (
(n[0] - t[0]) * (e[1] - t[1]) == (e[0] - t[0]) * (n[1] - t[1]) &&
Math.min(t[0], e[0]) <= n[0] &&
n[0] <= Math.max(t[0], e[0]) &&
Math.min(t[1], e[1]) <= n[1] &&
n[1] <= Math.max(t[1], e[1])
);
}
var Wn = function (t, e, n) {
var r = !1,
i = t.length;
function o(t) {
return Math.abs(t) < 1e-6 ? 0 : t < 0 ? -1 : 1;
}
if (i <= 2) return !1;
for (var a = 0; a < i; a++) {
var s = t[a],
u = t[(a + 1) % i];
if (Xn(s, u, [e, n])) return !0;
o(s[1] - n) > 0 != o(u[1] - n) > 0 &&
o(e - ((n - s[1]) * (s[0] - u[0])) / (s[1] - u[1]) - s[0]) < 0 &&
(r = !r);
}
return r;
},
Gn = function (t, e) {
return !(
e.minX > t.maxX ||
e.maxX < t.minX ||
e.minY > t.maxY ||
e.maxY < t.minY
);
},
qn = function (t, e) {
var n = function (t) {
var e = t.map(function (t) {
return t[0];
}),
n = t.map(function (t) {
return t[1];
});
return {
minX: Math.min.apply(null, e),
maxX: Math.max.apply(null, e),
minY: Math.min.apply(null, n),
maxY: Math.max.apply(null, n),
};
},
r = function (t) {
for (var e = [], n = t.length, r = 0; r < n - 1; r++) {
var i = t[r],
o = t[r + 1];
e.push({
from: { x: i[0], y: i[1] },
to: { x: o[0], y: o[1] },
});
}
if (e.length > 1) {
var a = t[0],
s = t[n - 1];
e.push({
from: { x: s[0], y: s[1] },
to: { x: a[0], y: a[1] },
});
}
return e;
};
if (t.length < 2 || e.length < 2) return !1;
var i = n(t),
o = n(e);
if (!Gn(i, o)) return !1;
var a = !1;
if (
(Object(gt.e)(e, function (e) {
if (Wn(t, e[0], e[1])) return (a = !0), !1;
}),
a)
)
return !0;
if (
(Object(gt.e)(t, function (t) {
if (Wn(e, t[0], t[1])) return (a = !0), !1;
}),
a)
)
return !0;
var s = r(t),
u = r(e),
c = !1;
return (
Object(gt.e)(u, function (t) {
if (
(function (t, e) {
var n = !1;
return (
Object(gt.e)(t, function (t) {
if (jn(t.from, t.to, e.from, e.to)) return (n = !0), !1;
}),
n
);
})(s, t)
)
return (c = !0), !1;
}),
c
);
},
Hn = (function () {
function t(t, e, n, r) {
(this.x1 = t), (this.y1 = e), (this.x2 = n), (this.y2 = r);
}
return (
(t.prototype.getBBox = function () {
var t = Math.min(this.x1, this.x2),
e = Math.min(this.y1, this.y2),
n = Math.max(this.x1, this.x2),
r = Math.max(this.y1, this.y2);
return {
x: t,
y: e,
minX: t,
minY: e,
maxX: n,
maxY: r,
width: n - t,
height: r - e,
};
}),
t
);
})(),
Vn = function (t, e) {
return {
top: [t.minX, t.minY, t.maxX, t.minY],
left: [t.minX, t.minY, t.minX, t.maxY],
bottom: [t.minX, t.maxY, t.maxX, t.maxY],
right: [t.maxX, t.minY, t.maxX, t.maxY],
}[e];
},
Un = function (t, e) {
var n = (e.x2 - e.x1) * (t.y1 - e.y1) - (e.y2 - e.y1) * (t.x1 - e.x1),
r = (t.x2 - t.x1) * (t.y1 - e.y1) - (t.y2 - t.y1) * (t.x1 - e.x1),
i = (e.y2 - e.y1) * (t.x2 - t.x1) - (e.x2 - e.x1) * (t.y2 - t.y1);
if (i) {
var o = n / i,
a = r / i;
if (o >= 0 && o <= 1 && a >= 0 && a <= 1) return o;
}
return Number.POSITIVE_INFINITY;
},
Zn = function (t, e) {
for (
var n = ["top", "left", "bottom", "right"],
r = t.getBBox(),
i = 0,
o = [],
a = 0;
a < 4;
a++
) {
var s = Vn(r, n[a]),
u = s[0],
c = s[1],
h = s[2],
l = s[3];
(o[a] = jn(
{ x: e.x1, y: e.y1 },
{ x: e.x2, y: e.y2 },
{ x: u, y: c },
{ x: h, y: l },
)),
o[a] && (i += 1);
}
return [o, i];
},
Kn = function (t, e) {
for (
var n = ["top", "left", "bottom", "right"],
r = t.getBBox(),
i = Number.POSITIVE_INFINITY,
o = 0,
a = 0;
a < 4;
a++
) {
var s = Vn(r, n[a]),
u = s[0],
c = s[1],
h = s[2],
l = s[3],
d = Un(e, new Hn(u, c, h, l));
(d = Math.abs(d - 0.5)) >= 0 &&
d <= 1 &&
((o += 1), (i = d < i ? d : i));
}
return 0 === o ? -1 : i;
},
Qn = function (t) {
var e = 0,
n = 0;
if (t.length > 0) {
for (var r = 0, i = t; r < i.length; r++) {
var o = i[r];
(e += o.x), (n += o.y);
}
(e /= t.length), (n /= t.length);
}
return { x: e, y: n };
},
$n = function (t, e) {
return Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2);
},
Jn = function (t, e) {
var n,
r = e.x1,
i = e.y1,
o = e.x2 - r,
a = e.y2 - i,
s = t.x - r,
u = t.y - i,
c = s * o + u * a;
n =
c <= 0 || (c = (s = o - s) * o + (u = a - u) * a) <= 0
? 0
: (c * c) / (o * o + a * a);
var h = s * s + u * u - n;
return h < 0 && (h = 0), h;
},
tr = function (t, e, n) {
return (
void 0 === n && (n = 0.001),
Math.pow(t.x - e.x, 2) + Math.pow(t.y - e.y, 2) < Math.pow(n, 2)
);
},
er = function (t, e) {
var n = t.x < e.x,
r = t.x > e.x + e.width,
i = t.y > e.y + e.height,
o = t.y < e.y;
if (!(n || r || i || o)) return 0;
if (i && !n && !r) return Math.pow(e.y + e.height - t.y, 2);
if (o && !n && !r) return Math.pow(t.y - e.y, 2);
if (n && !i && !o) return Math.pow(e.x - t.x, 2);
if (r && !i && !o) return Math.pow(e.x + e.width - t.x, 2);
var a = Math.min(Math.abs(e.x - t.x), Math.abs(e.x + e.width - t.x)),
s = Math.min(Math.abs(e.y - t.y), Math.abs(e.y + e.height - t.y));
return a * a + s * s;
},
nr = function (t, e) {
var n = t[0],
r = t[1],
i = t[2],
o = t[3],
a = e.x,
s = e.y,
u = [i - n, o - r];
if (sn.c.exactEquals(u, [0, 0])) return NaN;
var c = [-u[1], u[0]];
sn.c.normalize(c, c);
var h = [a - n, s - r];
return Math.abs(sn.c.dot(h, c));
},
rr = "rgb(95, 149, 255)",
ir = "rgb(253, 253, 253)",
or = "rgb(247, 250, 255)",
ar = "rgb(224, 224, 224)",
sr = "rgb(224, 224, 224)",
ur = {
version: "0.3.0",
rootContainerClassName: "root-container",
nodeContainerClassName: "node-container",
edgeContainerClassName: "edge-container",
comboContainerClassName: "combo-container",
delegateContainerClassName: "delegate-container",
defaultLoopPosition: "top",
nodeLabel: {
style: {
fill: "#000",
fontSize: 12,
textAlign: "center",
textBaseline: "middle",
},
offset: 4,
},
defaultNode: {
type: "circle",
style: { lineWidth: 1, stroke: rr, fill: "rgb(239, 244, 255)" },
size: 20,
color: rr,
linkPoints: { size: 8, lineWidth: 1, fill: or, stroke: rr },
},
nodeStateStyles: {
active: {
fill: or,
stroke: rr,
lineWidth: 2,
shadowColor: rr,
shadowBlur: 10,
},
selected: {
fill: "rgb(255, 255, 255)",
stroke: rr,
lineWidth: 4,
shadowColor: rr,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
fill: "rgb(223, 234, 255)",
stroke: "#4572d9",
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: {
fill: "rgb(247, 250, 255)",
stroke: "rgb(191, 213, 255)",
lineWidth: 1,
},
disable: {
fill: "rgb(250, 250, 250)",
stroke: "rgb(224, 224, 224)",
lineWidth: 1,
},
},
edgeLabel: {
style: {
fill: "rgb(0, 0, 0)",
textAlign: "center",
textBaseline: "middle",
fontSize: 12,
},
},
defaultEdge: {
type: "line",
size: 1,
style: { stroke: ar, lineAppendWidth: 2 },
color: ar,
},
edgeStateStyles: {
active: { stroke: rr, lineWidth: 1 },
selected: {
stroke: rr,
lineWidth: 2,
shadowColor: rr,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: rr,
lineWidth: 2,
"text-shape": { fontWeight: 500 },
},
inactive: { stroke: "rgb(234, 234, 234)", lineWidth: 1 },
disable: { stroke: "rgb(245, 245, 245)", lineWidth: 1 },
},
comboLabel: {
style: {
fill: "rgb(0, 0, 0)",
textBaseline: "middle",
fontSize: 12,
},
refY: 10,
refX: 10,
},
defaultCombo: {
type: "circle",
style: {
fill: ir,
lineWidth: 1,
stroke: sr,
r: 5,
width: 20,
height: 10,
},
size: [20, 5],
color: sr,
padding: [25, 20, 15, 20],
},
comboStateStyles: {
active: { stroke: rr, lineWidth: 1, fill: "rgb(247, 250, 255)" },
selected: {
stroke: rr,
lineWidth: 2,
fill: ir,
shadowColor: rr,
shadowBlur: 10,
"text-shape": { fontWeight: 500 },
},
highlight: {
stroke: "#4572d9",
lineWidth: 2,
fill: ir,
"text-shape": { fontWeight: 500 },
},
inactive: { stroke: "rgb(224, 224, 224)", fill: ir, lineWidth: 1 },
disable: {
stroke: "rgb(234, 234, 234)",
fill: "rgb(250, 250, 250)",
lineWidth: 1,
},
},
delegateStyle: {
fill: "#F3F9FF",
fillOpacity: 0.5,
stroke: "#1890FF",
strokeOpacity: 0.9,
lineDash: [5, 5],
},
},
cr = {
" ": 0.3329986572265625,
a: 0.5589996337890625,
A: 0.6569992065429687,
b: 0.58599853515625,
B: 0.6769989013671875,
c: 0.5469985961914062,
C: 0.7279998779296875,
d: 0.58599853515625,
D: 0.705999755859375,
e: 0.554998779296875,
E: 0.63699951171875,
f: 0.37299957275390627,
F: 0.5769989013671875,
g: 0.5909988403320312,
G: 0.7479995727539063,
h: 0.555999755859375,
H: 0.7199996948242188,
i: 0.255999755859375,
I: 0.23699951171875,
j: 0.26699981689453123,
J: 0.5169998168945312,
k: 0.5289993286132812,
K: 0.6899993896484375,
l: 0.23499908447265624,
L: 0.5879989624023437,
m: 0.854998779296875,
M: 0.8819992065429687,
n: 0.5589996337890625,
N: 0.7189987182617188,
o: 0.58599853515625,
O: 0.7669998168945312,
p: 0.58599853515625,
P: 0.6419998168945312,
q: 0.58599853515625,
Q: 0.7669998168945312,
r: 0.3649993896484375,
R: 0.6759994506835938,
s: 0.504998779296875,
S: 0.6319992065429687,
t: 0.354998779296875,
T: 0.6189987182617187,
u: 0.5599990844726562,
U: 0.7139999389648437,
v: 0.48199920654296874,
V: 0.6389999389648438,
w: 0.754998779296875,
W: 0.929998779296875,
x: 0.5089996337890625,
X: 0.63699951171875,
y: 0.4959991455078125,
Y: 0.66199951171875,
z: 0.48699951171875,
Z: 0.6239990234375,
0: 0.6,
1: 0.40099945068359377,
2: 0.6,
3: 0.6,
4: 0.6,
5: 0.6,
6: 0.6,
7: 0.5469985961914062,
8: 0.6,
9: 0.6,
"[": 0.3329986572265625,
"]": 0.3329986572265625,
",": 0.26399993896484375,
".": 0.26399993896484375,
";": 0.26399993896484375,
":": 0.26399993896484375,
"{": 0.3329986572265625,
"}": 0.3329986572265625,
"\\": 0.5,
"|": 0.19499969482421875,
"=": 0.604998779296875,
"+": 0.604998779296875,
"-": 0.604998779296875,
_: 0.5,
"`": 0.3329986572265625,
" ~": 0.8329986572265625,
"!": 0.3329986572265625,
"@": 0.8579986572265625,
"#": 0.6,
$: 0.6,
"%": 0.9699996948242188,
"^": 0.517999267578125,
"&": 0.7259994506835937,
"*": 0.505999755859375,
"(": 0.3329986572265625,
")": 0.3329986572265625,
"<": 0.604998779296875,
">": 0.604998779296875,
"/": 0.5,
"?": 0.53699951171875,
},
hr = Math.PI,
lr = Math.sin,
dr = Math.cos,
fr = lr(hr / 8),
pr = dr(hr / 8),
gr = function (t, e) {
var n = t.getBBox(),
r = { x: n.minX, y: n.minY },
i = { x: n.maxX, y: n.maxY };
if (e) {
var o = e.getMatrix();
o || (o = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = Tn(r, o)),
(i = Tn(i, o));
}
var a = r.x,
s = r.y,
u = i.x,
c = i.y;
return {
x: a,
y: s,
minX: a,
minY: s,
maxX: u,
maxY: c,
width: u - a,
height: c - s,
};
},
yr = function (t) {
var e = t.sourceNode || t.targetNode,
n = e.get("group").getMatrix();
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]);
var r = e.getKeyShape().getBBox(),
i = t.loopCfg || {},
o = i.dist || 2 * Math.max(r.width, r.height),
a = i.position || ur.defaultLoopPosition,
s = [n[6], n[7]],
u = [t.startPoint.x, t.startPoint.y],
c = [t.endPoint.x, t.endPoint.y],
h = r.height / 2,
l = r.height / 2,
d = h * fr,
f = h * pr,
p = l * fr,
g = l * pr;
if (u[0] === c[0] && u[1] === c[1]) {
switch (a) {
case "top":
(u = [s[0] - d, s[1] - f]), (c = [s[0] + p, s[1] - g]);
break;
case "top-right":
(h = r.height / 2),
(l = r.width / 2),
(u = [s[0] + (d = h * fr), s[1] - (f = h * pr)]),
(c = [s[0] + (g = l * pr), s[1] - (p = l * fr)]);
break;
case "right":
(h = r.width / 2),
(l = r.width / 2),
(u = [s[0] + (f = h * pr), s[1] - (d = h * fr)]),
(c = [s[0] + (g = l * pr), s[1] + (p = l * fr)]);
break;
case "bottom-right":
(h = r.width / 2),
(l = r.height / 2),
(u = [s[0] + (f = h * pr), s[1] + (d = h * fr)]),
(c = [s[0] + (p = l * fr), s[1] + (g = l * pr)]);
break;
case "bottom":
(h = r.height / 2),
(l = r.height / 2),
(u = [s[0] + (d = h * fr), s[1] + (f = h * pr)]),
(c = [s[0] - (p = l * fr), s[1] + (g = l * pr)]);
break;
case "bottom-left":
(h = r.height / 2),
(l = r.width / 2),
(u = [s[0] - (d = h * fr), s[1] + (f = h * pr)]),
(c = [s[0] - (g = l * pr), s[1] + (p = l * fr)]);
break;
case "left":
(h = r.width / 2),
(l = r.width / 2),
(u = [s[0] - (f = h * pr), s[1] + (d = h * fr)]),
(c = [s[0] - (g = l * pr), s[1] - (p = l * fr)]);
break;
case "top-left":
(h = r.width / 2),
(l = r.height / 2),
(u = [s[0] - (f = h * pr), s[1] - (d = h * fr)]),
(c = [s[0] - (p = l * fr), s[1] - (g = l * pr)]);
break;
default:
(h = r.width / 2),
(l = r.width / 2),
(u = [s[0] - (d = h * fr), s[1] - (f = h * pr)]),
(c = [s[0] + (p = l * fr), s[1] - (g = l * pr)]);
}
if (!1 === i.clockwise) {
var y = [u[0], u[1]];
(u = [c[0], c[1]]), (c = [y[0], y[1]]);
}
}
var v = [u[0] - s[0], u[1] - s[1]],
m = (h + o) / h,
b = (l + o) / l;
!1 === i.clockwise && ((m = (l + o) / l), (b = (h + o) / h));
var x = sn.c.scale([0, 0], v, m),
w = [s[0] + x[0], s[1] + x[1]],
O = [c[0] - s[0], c[1] - s[1]],
M = sn.c.scale([0, 0], O, b),
S = [s[0] + M[0], s[1] + M[1]];
return (
(t.startPoint = { x: u[0], y: u[1] }),
(t.endPoint = { x: c[0], y: c[1] }),
(t.controlPoints = [
{ x: w[0], y: w[1] },
{ x: S[0], y: S[1] },
]),
t
);
},
vr = function (t, e, n, r, i) {
var o = [],
a = t.getPoint(e);
if (null === a) return { x: 0, y: 0, angle: 0 };
if (e < 1e-4) o = t.getStartTangent().reverse();
else if (e > 0.9999) o = t.getEndTangent();
else {
var s = t.getPoint(e + 1e-4);
o.push([a.x, a.y]), o.push([s.x, s.y]);
}
var u = Math.atan2(o[1][1] - o[0][1], o[1][0] - o[0][0]);
if (
(u < 0 && (u += 2 * hr),
n && ((a.x += dr(u) * n), (a.y += lr(u) * n)),
r)
) {
var c = u - hr / 2;
u > 0.5 * hr && u < 1.5 * hr && (c -= hr),
(a.x += dr(c) * r),
(a.y += lr(c) * r);
}
var l = { x: a.x, y: a.y, angle: u };
return i
? (u > 0.5 * hr && u < 1.5 * hr && (u -= hr),
Object(h.a)({ rotate: u }, l))
: l;
},
mr = function t(e, n) {
if (!1 === n(e)) return !1;
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return !1;
return !0;
},
br = function (t, e) {
"function" == typeof e && mr(t, e);
},
xr = function (t, e) {
"function" == typeof e &&
(function t(e, n) {
if (e && e.children)
for (var r = e.children.length - 1; r >= 0; r--)
if (!t(e.children[r], n)) return;
return !1 !== n(e);
})(t, e);
},
wr = function (t, e) {
return e * (cr[t] || 1);
},
Or = function (t, e) {
var n = 0,
r = new RegExp("[一-龥]+");
return (
t.split("").forEach(function (t) {
r.test(t) ? (n += e) : (n += wr(t, e));
}),
[n, e]
);
},
Mr = function (t, e) {
var n = [],
r = {},
i = {};
t.forEach(function (t) {
i[t.id] = t;
}),
t.forEach(function (t, e) {
var o = Object(gt.b)(t);
(o.itemType = "combo"),
(o.children = void 0),
o.parentId === o.id
? (console.warn(
"The parentId for combo " +
o.id +
" can not be the same as the combo's id",
),
delete o.parentId)
: o.parentId &&
!i[o.parentId] &&
(console.warn(
"The parent combo for combo " + o.id + " does not exist!",
),
delete o.parentId);
var a = r[o.id];
if (a) {
if (
((o.children = a.children), (r[o.id] = o), !(a = o).parentId)
)
return void n.push(a);
var s = r[a.parentId];
if (s) s.children ? s.children.push(o) : (s.children = [o]);
else {
var u = { id: a.parentId, children: [a] };
(r[a.parentId] = u), (r[o.id] = o);
}
} else if (Object(gt.x)(t.parentId)) {
var c = r[t.parentId];
if (c)
c.children ? c.children.push(o) : (c.children = [o]),
(r[o.id] = o);
else {
var h = { id: t.parentId, children: [o] };
(r[h.id] = h), (r[o.id] = o);
}
} else n.push(o), (r[o.id] = o);
});
var o = {};
(e || []).forEach(function (t) {
o[t.id] = t;
var e = r[t.comboId];
if (e) {
var n = { id: t.id, comboId: t.comboId };
e.children ? e.children.push(n) : (e.children = [n]),
(n.itemType = "node"),
(r[t.id] = n);
}
});
var a = 0;
return (
n.forEach(function (t) {
(t.depth = a + 10),
mr(t, function (t) {
var e,
n = r[t.id].itemType;
(e = "node" === n ? r[t.comboId] : r[t.parentId]),
(t.depth = e && "node" === n ? a + 1 : a + 10),
a < t.depth && (a = t.depth);
var i = o[t.id];
return i && (i.depth = t.depth), !0;
});
}),
n
);
},
Sr = function (t, e, n) {
var r,
i = t,
o = { root: { children: t } },
a = !1,
s = "root";
(t || []).forEach(function (t) {
if (!a)
return t.id === e
? ((r = t),
"combo" === t.itemType ? (r.parentId = n) : (r.comboId = n),
void (a = !0))
: void br(t, function (t) {
return (
(o[t.id] = { children: t.children }),
(i = o[t.parentId || t.comboId || "root"].children),
!t ||
(!t.removed && e !== t.id) ||
!i ||
((s = t.parentId || t.comboId || "root"),
(r = t),
"combo" === t.itemType
? (r.parentId = n)
: (r.comboId = n),
(a = !0),
!1)
);
});
});
var u = (i = o[s].children) ? i.indexOf(r) : -1;
if (
(u > -1 && i.splice(u, 1),
a ||
((r = { id: e, itemType: "node", comboId: n }),
(o[e] = { children: void 0 })),
e)
) {
var c = !1;
if (n) {
var h = 0;
(t || []).forEach(function (t) {
c ||
br(t, function (t) {
return (
n !== t.id ||
((c = !0),
t.children ? t.children.push(r) : (t.children = [r]),
(h = t.depth),
"node" === r.itemType
? (r.depth = h + 2)
: (r.depth = h + 1),
!1)
);
});
});
} else (n && c) || "node" === r.itemType || t.push(r);
var l = r.depth;
br(r, function (t) {
return (
"node" === t.itemType ? (l += 2) : (l += 1), (t.depth = l), !0
);
});
}
return t;
},
Cr = function (t, e) {
var n = {
minX: 1 / 0,
minY: 1 / 0,
maxX: -1 / 0,
maxY: -1 / 0,
x: void 0,
y: void 0,
width: void 0,
height: void 0,
centerX: void 0,
centerY: void 0,
};
return t && 0 !== t.length
? (t.forEach(function (t) {
var r = e.findById(t.id);
if (r && r.isVisible()) {
r.set("bboxCanvasCache", void 0);
var i = r.getCanvasBBox();
i.x && n.minX > i.minX && (n.minX = i.minX),
i.y && n.minY > i.minY && (n.minY = i.minY),
i.x && n.maxX < i.maxX && (n.maxX = i.maxX),
i.y && n.maxY < i.maxY && (n.maxY = i.maxY);
}
}),
(n.x = (n.minX + n.maxX) / 2),
(n.y = (n.minY + n.maxY) / 2),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
Object.keys(n).forEach(function (t) {
(n[t] !== 1 / 0 && n[t] !== -1 / 0) || (n[t] = void 0);
}),
n)
: n;
},
jr = function (t) {
var e =
Object(gt.t)(t.x) ||
Object(gt.t)(t.y) ||
t.type ||
t.anchorPoints ||
t.size;
return (
t.style &&
(e =
e ||
Object(gt.t)(t.style.r) ||
Object(gt.t)(t.style.width) ||
Object(gt.t)(t.style.height) ||
Object(gt.t)(t.style.rx) ||
Object(gt.t)(t.style.ry)),
e
);
},
kr = function (t) {
var e = {};
return (
Object.keys(t).forEach(function (n) {
var r = t[n];
if (Object(gt.v)(r)) {
var i = {};
Object.keys(r).forEach(function (t) {
var e = r[t];
("img" !== t || Object(gt.x)(e)) && (i[t] = Object(gt.b)(e));
}),
(e[n] = i);
} else e[n] = Object(gt.b)(r);
}),
e
);
},
Er = function (t) {
if (!t)
return console.error("G6 Error Tips: the data must be defined"), !1;
var e = t.nodes,
n = t.edges,
r = t.combos,
i = void 0 === r ? [] : r;
if (!e && !n) {
var o = !0;
return (
br(t, function (t) {
return !!Object(gt.x)(t.id) || ((o = !1), !1);
}),
o
);
}
var a = (e || []).find(function (t) {
return !Object(gt.x)(t.id);
});
if (a)
return (
console.warn(
"G6 Warning Tips: missing 'id' property, or %c" +
a.id +
"%c is not a string.",
"font-size: 20px; color: red;",
"",
),
!1
);
var s = (e || []).map(function (t) {
return t.id;
}),
u = i.map(function (t) {
return t.id;
}),
c = Object(h.f)(Object(h.f)([], s), u),
l = (n || []).find(function (t) {
return !c.includes(t.source) || !c.includes(t.target);
});
return (
!l ||
(console.warn(
"G6 Warning Tips: The source %c" +
l.source +
"%c or the target %c" +
l.target +
"%c of the edge do not exist in the nodes or combos.",
"font-size: 20px; color: red;",
"",
"font-size: 20px; color: red;",
"",
),
!1)
);
},
Nr = (function () {
function t(t) {
(this.graph = t),
(this.destroyed = !1),
(this.modes = t.get("modes") || { default: [] }),
this.formatModes(),
(this.mode = t.get("defaultMode") || "default"),
(this.currentBehaves = []),
this.setMode(this.mode);
}
return (
(t.prototype.formatModes = function () {
var t = this.modes;
Object(gt.e)(t, function (t) {
Object(gt.e)(t, function (e, n) {
Object(gt.x)(e) && (t[n] = { type: e });
});
});
}),
(t.prototype.setBehaviors = function (t) {
var e,
n = this.graph,
r = this.modes[t],
i = [];
Object(gt.e)(r || [], function (t) {
var r = tn.getBehavior(t.type || t);
r && (e = new r(t)) && (e.bind(n), i.push(e));
}),
(this.currentBehaves = i);
}),
(t.mergeBehaviors = function (t, e) {
return (
Object(gt.e)(e, function (e) {
t.indexOf(e) < 0 &&
(Object(gt.x)(e) && (e = { type: e }), t.push(e));
}),
t
);
}),
(t.filterBehaviors = function (t, e) {
var n = [];
return (
t.forEach(function (t) {
var r = "";
(r = Object(gt.x)(t) ? t : t.type),
e.indexOf(r) < 0 && n.push(t);
}),
n
);
}),
(t.prototype.setMode = function (t) {
var e = this.modes,
n = this.graph,
r = t;
e[r] &&
(n.emit("beforemodechange", { mode: t }),
Object(gt.e)(this.currentBehaves, function (t) {
t.delegate && t.delegate.remove(), t.unbind(n);
}),
this.setBehaviors(r),
n.emit("aftermodechange", { mode: t }),
(this.mode = t));
}),
(t.prototype.getMode = function () {
return this.mode;
}),
(t.prototype.manipulateBehaviors = function (e, n, r) {
var i,
o = this;
if (((i = Object(gt.m)(e) ? e : [e]), Object(gt.m)(n)))
return (
Object(gt.e)(n, function (e) {
o.modes[e]
? (o.modes[e] = r
? t.mergeBehaviors(o.modes[e] || [], i)
: t.filterBehaviors(o.modes[e] || [], i))
: r && (o.modes[e] = i);
}),
this
);
var a = n;
return (
n || (a = this.mode),
this.modes[a] || (r && (this.modes[a] = i)),
(this.modes[a] = r
? t.mergeBehaviors(this.modes[a] || [], i)
: t.filterBehaviors(this.modes[a] || [], i)),
this.setMode(this.mode),
this
);
}),
(t.prototype.updateBehavior = function (t, e, n) {
Object(gt.x)(t) && (t = { type: t });
var r = [];
if (n && n !== this.mode && "default" !== n) {
if (!(r = this.modes[n]) || !r.length)
return (
console.warn(
"Update behavior failed! There is no behaviors in this mode on the graph.",
),
this
);
var i = r.length;
for (a = 0; a < i; a++) {
if ((s = r[a]).type === t.type || s === t.type)
return (
s === t.type && (s = { type: s }),
Object.assign(s, e),
(r[a] = s),
this
);
a === i - 1 &&
console.warn(
"Update behavior failed! There is no such behavior in the mode",
);
}
} else {
if (!(r = this.currentBehaves) || !r.length)
return (
console.warn(
"Update behavior failed! There is no behaviors in this mode on the graph.",
),
this
);
for (var o = r.length, a = 0; a < o; a++) {
var s;
if ((s = r[a]).type === t.type) return s.updateCfg(e), this;
a === o - 1 &&
console.warn(
"Update behavior failed! There is no such behavior in the mode",
);
}
}
return this;
}),
(t.prototype.destroy = function () {
(this.graph = null),
(this.modes = null),
(this.currentBehaves = null),
(this.destroyed = !0);
}),
t
);
})();
function Tr(t, e) {
if (t) for (var n in e) e.hasOwnProperty(n) && (t.style[n] = e[n]);
return t;
}
var Pr = (function (t) {
function e(e, n) {
var r = t.call(this, e, n) || this;
return (
(r.item = n.item),
(r.canvasX = n.canvasX),
(r.canvasY = n.canvasY),
(r.detail = n.detail),
r
);
}
return Object(h.c)(e, t), e;
})(z.Event),
Ir = function (t) {
return t + "-" + Math.random() + Date.now();
},
Br = function (t) {
var e = 0,
n = 0,
r = 0,
i = 0;
if (Object(gt.t)(t)) e = n = r = i = t;
else if (Object(gt.x)(t)) {
e = n = r = i = parseInt(t, 10);
} else
Object(gt.m)(t) &&
((e = t[0]),
(r = Object(gt.s)(t[1]) ? t[0] : t[1]),
(i = Object(gt.s)(t[2]) ? t[0] : t[2]),
(n = Object(gt.s)(t[3]) ? r : t[3]));
return [e, r, i, n];
},
Ar = function (t) {
var e = new Pr(t.type, t);
return (
(e.clientX = t.clientX),
(e.clientY = t.clientY),
(e.x = t.x),
(e.y = t.y),
(e.target = t.target),
(e.currentTarget = t.currentTarget),
(e.bubbles = !0),
(e.item = t.item),
e
);
},
Lr = function (t) {
if (!t) return !1;
for (var e = [1, 0, 0, 0, 1, 0, 0, 0, 1], n = 0; n < 9; n++)
if (t[n] !== e[n]) return !0;
return !1;
},
Dr = function (t) {
return Number.isNaN(Number(t));
},
_r = function (t) {
for (
var e = 1 / 0, n = -1 / 0, r = 1 / 0, i = -1 / 0, o = 0;
o < t.length;
o++
) {
var a = t[o].getBBox(),
s = a.minX,
u = a.minY,
c = a.maxX,
h = a.maxY;
s < e && (e = s),
u < r && (r = u),
c > n && (n = c),
h > i && (i = h);
}
return {
x: Math.floor(e),
y: Math.floor(r),
width: Math.ceil(n) - Math.floor(e),
height: Math.ceil(i) - Math.floor(r),
minX: e,
minY: r,
maxX: n,
maxY: i,
};
},
Rr = function (t, e, n, r, i) {
void 0 === e && (e = 15),
void 0 === n && (n = "quadratic"),
void 0 === r && (r = void 0),
void 0 === i && (i = void 0);
for (
var o = t.length,
a = 2 * e,
s = [
"top",
"top-right",
"right",
"bottom-right",
"bottom",
"bottom-left",
"left",
"top-left",
],
u = {},
c = [],
h = {},
l = 0;
l < o;
l++
) {
var d = t[l],
f = d.source,
p = d.target,
g = f + "-" + p;
if (!c[l]) {
u[g] || (u[g] = []), (c[l] = !0), u[g].push(d);
for (var y = 0; y < o; y++)
if (l !== y) {
var v = t[y],
m = v.source,
b = v.target;
c[y] ||
(f === b && p === m
? (u[g].push(v),
(c[y] = !0),
(h[m + "|" + b + "|" + (u[g].length - 1)] = !0))
: f === m && p === b && (u[g].push(v), (c[y] = !0)));
}
}
}
for (var x in u)
for (var w = u[x], O = w.length, M = 0; M < O; M++) {
var S = w[M];
if (S.source !== S.target)
if (1 === O && r && S.source !== S.target) S.type = r;
else {
S.type = n;
var C =
(M % 2 == 0 ? 1 : -1) *
(h[S.source + "|" + S.target + "|" + M] ? -1 : 1);
S.curveOffset =
O % 2 == 1
? C * Math.ceil(M / 2) * a
: C * (Math.floor(M / 2) * a + e);
}
else
i && (S.type = i),
(S.loopCfg = {
position: s[M % 8],
dist: 20 * Math.floor(M / 8) + 50,
});
}
return t;
},
Yr = (function () {
function t(t) {
(this.destroyed = !1), (this.graph = t), (this.destroyed = !1);
}
return (
(t.prototype.getViewCenter = function () {
var t = this.getFormatPadding(),
e = this.graph,
n = this.graph.get("width"),
r = e.get("height");
return {
x: (n - t[1] - t[3]) / 2 + t[3],
y: (r - t[0] - t[2]) / 2 + t[0],
};
}),
(t.prototype.fitCenter = function () {
var t = this.graph,
e = t.get("group");
e.resetMatrix();
var n = e.getCanvasBBox();
if (0 !== n.width && 0 !== n.height) {
var r = this.getViewCenter(),
i = n.x + n.width / 2,
o = n.y + n.height / 2;
t.translate(r.x - i, r.y - o);
}
}),
(t.prototype.fitView = function () {
var t = this.graph,
e = this.getFormatPadding(),
n = t.get("width"),
r = t.get("height"),
i = t.get("group");
i.resetMatrix();
var o = i.getCanvasBBox();
if (0 !== o.width && 0 !== o.height) {
var a = this.getViewCenter(),
s = o.x + o.width / 2,
u = o.y + o.height / 2;
t.translate(a.x - s, a.y - u);
var c = (n - e[1] - e[3]) / o.width,
h = (r - e[0] - e[2]) / o.height,
l = c;
c > h && (l = h), t.zoom(l, a);
}
}),
(t.prototype.getFormatPadding = function () {
var t = this.graph.get("fitViewPadding");
return Br(t);
}),
(t.prototype.focusPoint = function (t, e, n) {
var r = this,
i = this.getViewCenter(),
o = this.getPointByCanvas(i.x, i.y),
a = this.graph.get("group").getMatrix();
if ((a || (a = [1, 0, 0, 0, 1, 0, 0, 0, 1]), e)) {
var s = (o.x - t.x) * a[0],
u = (o.y - t.y) * a[4],
c = 0,
l = 0,
d = 0,
f = 0;
this.graph.get("canvas").animate(
function (t) {
(d = s * t),
(f = u * t),
r.graph.translate(d - c, f - l),
(c = d),
(l = f);
},
Object(h.a)({}, n),
);
} else
this.graph.translate((o.x - t.x) * a[0], (o.y - t.y) * a[4]);
}),
(t.prototype.getPointByCanvas = function (t, e) {
var n = this.graph.get("group").getMatrix();
return (
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]), Pn({ x: t, y: e }, n)
);
}),
(t.prototype.getPointByClient = function (t, e) {
var n = this.graph.get("canvas").getPointByClient(t, e);
return this.getPointByCanvas(n.x, n.y);
}),
(t.prototype.getClientByPoint = function (t, e) {
var n = this.graph.get("canvas"),
r = this.getCanvasByPoint(t, e),
i = n.getClientByPoint(r.x, r.y);
return { x: i.x, y: i.y };
}),
(t.prototype.getCanvasByPoint = function (t, e) {
var n = this.graph.get("group").getMatrix();
return (
n || (n = [1, 0, 0, 0, 1, 0, 0, 0, 1]), Tn({ x: t, y: e }, n)
);
}),
(t.prototype.focus = function (t, e, n) {
if ((Object(gt.x)(t) && (t = this.graph.findById(t)), t)) {
var r = 0,
i = 0;
if (t.getType && "edge" === t.getType()) {
var o = t.getSource().get("group").getMatrix(),
a = t.getTarget().get("group").getMatrix();
o && a
? ((r = (o[6] + a[6]) / 2), (i = (o[7] + a[7]) / 2))
: (o || a) &&
((r = o ? o[6] : a[6]), (i = o ? o[7] : a[7]));
} else {
var s = t.get("group").getMatrix();
s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = s[6]),
(i = s[7]);
}
this.focusPoint({ x: r, y: i }, e, n);
}
}),
(t.prototype.changeSize = function (t, e) {
var n = this.graph;
if (!Object(gt.t)(t) || !Object(gt.t)(e))
throw Error(
"invalid canvas width & height, please make sure width & height type is number",
);
n.set({ width: t, height: e }),
n.get("canvas").changeSize(t, e),
n.get("plugins").forEach(function (r) {
if (r.get("gridContainer")) {
var i = n.get("minZoom");
Tr(r.get("container"), {
width: t + "px",
height: e + "px",
}),
Tr(r.get("gridContainer"), {
width: t / i + "px",
height: e / i + "px",
left: 0,
top: 0,
});
}
});
}),
(t.prototype.destroy = function () {
(this.graph = null), (this.destroyed = !1);
}),
t
);
})();
function Fr(t) {
return (Fr =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
function zr(t) {
if ("string" != typeof t) return t;
var e = function (t) {
if ("string" != typeof t) return t;
try {
return JSON.parse(t.trim());
} catch (e) {
return t.trim();
}
},
n = e(t);
if ("string" != typeof n) return n;
for (
var r = function (t) {
return t[t.length - 1];
},
i = t.trim(),
o = [],
a = [],
s = function () {
for (var t = [], e = 0; e < arguments.length; e++)
t[e] = arguments[e];
return t.some(function (t) {
return r(a) === t;
});
},
u = null,
c = 0,
h = "";
c < i.length;
) {
var l = i[c],
d = s('"', "'");
if (d || l.trim()) {
var f = "\\" === i[c - 1],
p = s("}"),
g = s("]"),
y = s(","),
v = r(o);
if (d)
if (r(a) !== l || f) h += l;
else {
a.pop();
var m = e(h);
v.push(m), (u = m), (h = "");
}
else if (g && "," === l) h && (v.push(e(h)), (h = ""));
else if (p && ":" === l) a.push(","), h && (v.push(h), (h = ""));
else if (y && "," === l) h && (v.push(e(h)), (h = "")), a.pop();
else if ("}" === l && (p || y)) {
h && (v.push(e(h)), (h = "")), y && a.pop();
for (var b = {}, x = 1; x < v.length; x += 2) b[v[x - 1]] = v[x];
o.pop(), o.length && r(o).push(b), a.pop(), (u = b);
} else
"]" === l && g
? (h && (v.push(e(h)), (h = "")),
o.pop(),
o.length && r(o).push(v),
a.pop(),
(u = v))
: "{" === l
? (o.push([]), a.push("}"))
: "[" === l
? (o.push([]), a.push("]"))
: '"' === l
? a.push('"')
: "'" === l
? a.push("'")
: (h += l);
c += 1;
} else c += 1;
}
return u || h;
}
function Xr(t, e) {
var n;
void 0 === e && (e = { x: 0, y: 0 });
var r = Object(h.a)({ x: 0, y: 0, width: 0, height: 0 }, e);
if (null === (n = t.children) || void 0 === n ? void 0 : n.length) {
var i = t.attrs,
o = void 0 === i ? {} : i,
a = o.marginTop,
s = Object(h.a)({}, e);
a && (s.y += a);
for (var u = 0; u < t.children.length; u++) {
t.children[u].attrs.key = (o.key || "root") + " -" + u + " ";
var c = Xr(t.children[u], s);
if (c.bbox) {
var l = c.bbox;
"inline" === c.attrs.next
? (s.x += c.bbox.width)
: (s.y += c.bbox.height),
l.width + l.x > r.width && (r.width = l.width + l.x),
l.height + l.y > r.height && (r.height = l.height + l.y);
}
}
}
return (
(t.bbox = (function (t, e, n) {
var r,
i,
o = t.attrs,
a = void 0 === o ? {} : o,
s = {
x: e.x || 0,
y: e.y || 0,
width: n.width || 0,
height: n.height || 0,
};
switch (t.type) {
case "maker":
case "circle":
a.r && ((i = 2 * a.r), (r = 2 * a.r));
break;
case "text":
a.text &&
((i = Or(a.text, a.fontSize || 12)[0]),
(r = 16),
(s.y += r),
(s.height = r),
(s.width = i),
(t.attrs = Object(h.a)({ fontSize: 12, fill: "#000" }, a)));
break;
default:
a.width && (i = a.width), a.height && (r = a.height);
}
return (
r >= 0 && (s.height = r),
i >= 0 && (s.width = i),
a.marginTop && (s.y += a.marginTop),
a.marginLeft && (s.x += a.marginLeft),
s
);
})(t, e, r)),
(t.attrs = Object(h.a)(Object(h.a)({}, t.attrs), t.bbox)),
t
);
}
function Wr(t) {
var e = {},
n = function (e) {
var n = (function (t) {
return function (e) {
for (var n = t.length, r = [], i = 0, o = ""; i < n; )
if ("{" === t[i] && "{" === t[i + 1])
r.push(o), (o = ""), (i += 2);
else if ("}" === t[i] && "}" === t[i + 1]) {
if (r.length) {
var a = r.pop();
(o = Object(gt.h)(
e,
o,
a.endsWith("=") ? '"{' + o + '}"' : o,
)),
r.push(a + o);
}
(i += 2), (o = "");
} else (o += t[i]), (i += 1);
return (
r.push(o),
r
.map(function (t, e) {
return r[e - 1] && r[e - 1].endsWith("=")
? '"{' + t + '}"'
: t;
})
.join("")
);
};
})("function" == typeof t ? t(e) : t)(e),
r = document.createElement("div");
r.innerHTML = n;
var i = Xr(
(function t(e, n) {
var r = {},
i = (e.getAttributeNames && e.getAttributeNames()) || [],
o =
e.children &&
Array.from(e.children).map(function (e) {
return t(e, n);
}),
a = {},
s = e.tagName ? e.tagName.toLowerCase() : "group";
return (
"text" === s && (r.text = e.innerText),
(a.type = s),
"img" === s && (a.type = "image"),
Array.from(i).forEach(function (t) {
var n = t.split("-").reduce(function (t, e) {
return t + e.charAt(0).toUpperCase() + e.slice(1);
}),
i = e.getAttribute(t);
try {
if ("style" === n || "attrs" === n) {
var o = zr(i);
r = Object(h.a)(Object(h.a)({}, r), o);
} else a[n] = zr(i);
} catch (t) {
if ("style" === n) throw t;
a[n] = i;
}
}),
(a.attrs = r),
n &&
n.style &&
a.name &&
"object" === Fr(n.style[a.name]) &&
(a.attrs = Object(h.a)(
Object(h.a)({}, a.attrs),
n.style[a.name],
)),
n &&
n.style &&
a.keyshape &&
(a.attrs = Object(h.a)(Object(h.a)({}, a.attrs), n.style)),
o.length && (a.children = o),
a
);
})(r.children[0], e),
);
return r.remove(), i;
};
return {
draw: function (t, r) {
var i = n(t),
o = r;
return (
(function t(e) {
var n = e.attrs,
i = void 0 === n ? {} : n,
a = e.bbox,
s = e.type,
u = e.children,
c = Object(h.e)(e, ["attrs", "bbox", "type", "children"]);
if ("group" !== e.type) {
var l = r.addShape(
e.type,
Object(h.a)(
{ attrs: i, origin: { bbox: a, type: s, children: u } },
c,
),
);
e.keyshape && (o = l);
}
e.children &&
e.children.forEach(function (e) {
return t(e);
});
})(i),
(e[t.id] = [i]),
o
);
},
update: function (t, r) {
e[t.id] || (e[t.id] = []);
var i = r.getContainer(),
o = i.get("children"),
a = n(t),
s = (function t(e, n) {
var r,
i,
o,
a,
s = (e || {}).type,
u = ((null == n ? void 0 : n.attrs) || {}).key;
if ((u && e && (e.attrs.key = u), !e && n))
return { action: "delete", val: n, type: s, key: u };
if (e && !n) return { action: "add", val: e, type: s };
if (!e && !n) return { action: "same", type: s };
var c = [];
if (
(null === (r = e.children) || void 0 === r
? void 0
: r.length) > 0 ||
(null === (i = n.children) || void 0 === i
? void 0
: i.length) > 0
)
for (
var h = Math.max(
null === (o = e.children) || void 0 === o
? void 0
: o.length,
null === (a = n.children) || void 0 === a
? void 0
: a.length,
),
l = n.children || [],
d = e.children || [],
f = 0;
f < h;
f += 1
)
c.push(t(d[f], l[f]));
var p = Object.keys(n.attrs),
g = Object.keys(e.attrs);
return n.type !== e.type
? {
action: "restructure",
nowTarget: e,
formerTarget: n,
key: u,
children: c,
}
: p
.filter(function (t) {
return "children" !== t;
})
.some(function (t) {
return e.attrs[t] !== n.attrs[t] || !g.includes(t);
})
? { action: "change", val: e, children: c, type: s, key: u }
: { action: "same", children: c, type: s, key: u };
})(a, e[t.id].pop()),
u = function t(e) {
var n;
"group" !== e.type && i.addShape(e.type, { attrs: e.attrs }),
(null === (n = e.children) || void 0 === n
? void 0
: n.length) &&
e.children.map(function (e) {
return t(e);
});
},
c = function t(e) {
var n,
r = o.find(function (t) {
return t.attrs.key === e.attrs.key;
});
r && i.removeChild(r),
(null === (n = e.children) || void 0 === n
? void 0
: n.length) &&
e.children.map(function (e) {
return t(e);
});
};
!(function t(e) {
var n = e.key;
if ("group" !== e.type) {
var i = o.find(function (t) {
return t.attrs.key === n;
});
switch (e.action) {
case "change":
if (i) {
var a = e.val.keyshape ? r.getOriginStyle() : {};
i.attr(Object(h.a)(Object(h.a)({}, a), e.val.attrs));
}
break;
case "add":
u(e.val);
break;
case "delete":
c(e.val);
break;
case "restructure":
c(e.formerTarget), u(e.nowTarget);
}
}
e.children &&
e.children.forEach(function (e) {
return t(e);
});
})(s),
e[t.id].push(a);
},
getAnchorPoints: function () {
return [
[0, 0.5],
[1, 0.5],
[0.5, 1],
[0.5, 0],
];
},
};
}
var Gr = {};
function qr(t) {
return Gr[t] || (Gr[t] = Object(gt.J)(t)), Gr[t];
}
var Hr = {
defaultShapeType: "defaultType",
className: null,
getShape: function (t) {
return (
this[t] || this[this.defaultShapeType] || this["simple-circle"]
);
},
draw: function (t, e, n) {
var r = this.getShape(t),
i = r.draw(e, n);
return r.afterDraw && r.afterDraw(e, n, i), i;
},
baseUpdate: function (t, e, n) {
var r = this.getShape(t);
r.update && r.update(e, n), r.afterUpdate && r.afterUpdate(e, n);
},
setState: function (t, e, n, r) {
this.getShape(t).setState(e, n, r);
},
shouldUpdate: function (t) {
return !!this.getShape(t).update;
},
getControlPoints: function (t, e) {
return this.getShape(t).getControlPoints(e);
},
getAnchorPoints: function (t, e) {
return this.getShape(t).getAnchorPoints(e);
},
},
Vr = {
options: {},
draw: function (t, e) {
return this.drawShape(t, e);
},
drawShape: function () {},
afterDraw: function () {},
afterUpdate: function () {},
setState: function () {},
getControlPoints: function (t) {
return t.controlPoints;
},
getAnchorPoints: function (t) {
var e = this.options.anchorPoints;
return t.anchorPoints || e;
},
},
Ur = (function () {
function t() {}
return (
(t.registerFactory = function (e, n) {
var r = qr(e),
i = Hr,
o = Object(h.a)(Object(h.a)({}, i), n);
return (t[r] = o), (o.className = r), o;
}),
(t.getFactory = function (e) {
return t[qr(e)];
}),
(t.registerNode = function (e, n, r) {
var i,
o = t.Node;
if ("string" == typeof n || "function" == typeof n) {
var a = Wr(n);
i = Object(h.a)(Object(h.a)({}, o.getShape("single-node")), a);
} else if (n.jsx) {
a = Wr(n.jsx);
i = Object(h.a)(
Object(h.a)(Object(h.a)({}, o.getShape("single-node")), a),
n,
);
} else {
o.getShape(r);
var s = r ? o.getShape(r) : Vr;
i = Object(h.a)(Object(h.a)({}, s), n);
}
return (i.type = e), (i.itemType = "node"), (o[e] = i), i;
}),
(t.registerEdge = function (e, n, r) {
var i = t.Edge,
o = r ? i.getShape(r) : Vr,
a = Object(h.a)(Object(h.a)({}, o), n);
return (a.type = e), (a.itemType = "edge"), (i[e] = a), a;
}),
(t.registerCombo = function (e, n, r) {
var i = t.Combo,
o = r ? i.getShape(r) : Vr,
a = Object(h.a)(Object(h.a)({}, o), n);
return (a.type = e), (a.itemType = "combo"), (i[e] = a), a;
}),
t
);
})(),
Zr = Ur;
Ur.registerFactory("node", { defaultShapeType: "circle" }),
Ur.registerFactory("edge", { defaultShapeType: "line" }),
Ur.registerFactory("combo", { defaultShapeType: "circle" });
var Kr = (function () {
function t(t) {
(this._cfg = {}), (this.destroyed = !1);
var e = {
id: void 0,
type: "item",
model: {},
group: void 0,
animate: !1,
visible: !0,
locked: !1,
event: !0,
keyShape: void 0,
states: [],
};
this._cfg = Object.assign(e, this.getDefaultCfg(), t);
var n = this.get("model"),
r = n.id,
i = this.get("type");
r || ((r = Ir(i)), (this.get("model").id = r)), this.set("id", r);
var o = t.group;
o && (o.set("item", this), o.set("id", r)),
this.init(),
this.draw();
var a = n.shape || n.type || ("edge" === i ? "line" : "circle"),
s = this.get("shapeFactory");
if (s && s[a]) {
var u = s[a].options;
if (u && u.stateStyles) {
var c = this.get("styles") || n.stateStyles;
(c = Object(gt.d)({}, u.stateStyles, c)), this.set("styles", c);
}
}
}
return (
(t.prototype.calculateBBox = function () {
var t = this.get("keyShape"),
e = this.get("group"),
n = gr(t, e);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
n
);
}),
(t.prototype.calculateCanvasBBox = function () {
var t = this.get("keyShape"),
e = this.get("group"),
n = gr(t, e);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2),
n
);
}),
(t.prototype.drawInner = function () {
var t = this.get("shapeFactory"),
e = this.get("group"),
n = this.get("model");
e.clear();
var r = n.visible;
if ((void 0 === r || r || this.changeVisibility(r), t)) {
this.updatePosition(n);
var i = this.getShapeCfg(n),
o = i.type,
a = t.draw(o, i, e);
a &&
(this.set("keyShape", a),
a.set("isKeyShape", !0),
a.set("draggable", !0)),
this.setOriginStyle(),
this.set("currentShape", o),
this.restoreStates(t, o);
}
}),
(t.prototype.setOriginStyle = function () {
var t = this.get("group").get("children"),
e = this.getKeyShape(),
n = this,
r = e.get("name");
if (this.get("originStyle")) {
var i = this.getOriginStyle();
r && !i[r] && (i[r] = {});
var o = this.getCurrentStatesStyle();
Object(gt.e)(t, function (t) {
var e = t.get("name"),
a = t.attr();
if (e && e !== r) {
var s = o[e];
i[e] || (i[e] = {}),
s
? Object.keys(a).forEach(function (t) {
var n = a[t];
n !== s[t] && (i[e][t] = n);
})
: (i[e] =
"image" !== t.get("type")
? Object(gt.b)(a)
: n.getShapeStyleByName(e));
} else {
var u = t.attr(),
c = Object(h.a)(Object(h.a)({}, o), o[r]);
Object.keys(u).forEach(function (t) {
var e = u[t];
c[t] !== e && (r ? (i[r][t] = e) : (i[t] = e));
});
}
}),
i.path && delete i.path,
i.matrix && delete i.matrix,
i.x && delete i.x,
i.y && delete i.y,
i[r] && i[r].x && delete i[r].x,
i[r] && i[r].y && delete i[r].y,
n.set("originStyle", i);
} else {
var a = {};
Object(gt.e)(t, function (t) {
var e = t.get("type"),
i = t.get("name");
if (i && i !== r)
a[i] =
"image" !== e
? Object(gt.b)(t.attr())
: n.getShapeStyleByName(i);
else {
var o = n.getShapeStyleByName();
if (
(o.path && delete o.path, o.matrix && delete o.matrix, r)
)
if (i) a[r] = o;
else {
var s = Ir("shape");
t.set("name", s),
(a[s] =
"image" !== e
? Object(gt.b)(t.attr())
: n.getShapeStyleByName(i));
}
else Object.assign(a, o);
}
}),
n.set("originStyle", a);
}
}),
(t.prototype.restoreStates = function (t, e) {
var n = this,
r = n.get("states");
Object(gt.e)(r, function (r) {
t.setState(e, r, !0, n);
});
}),
(t.prototype.init = function () {
var t = Zr.getFactory(this.get("type"));
this.set("shapeFactory", t);
}),
(t.prototype.get = function (t) {
return this._cfg[t];
}),
(t.prototype.set = function (t, e) {
Object(gt.w)(t)
? (this._cfg = Object(h.a)(Object(h.a)({}, this._cfg), t))
: (this._cfg[t] = e);
}),
(t.prototype.getDefaultCfg = function () {
return {};
}),
(t.prototype.clearCache = function () {
this.set("bboxCache", null), this.set("bboxCanvasCache", null);
}),
(t.prototype.beforeDraw = function () {}),
(t.prototype.afterDraw = function () {}),
(t.prototype.afterUpdate = function () {}),
(t.prototype.draw = function () {
this.beforeDraw(), this.drawInner(), this.afterDraw();
}),
(t.prototype.getShapeStyleByName = function (t) {
var e,
n = this.get("group");
if (
(e = t
? n.find(function (e) {
return e.get("name") === t;
})
: this.getKeyShape())
) {
var r = {};
return (
Object(gt.e)(e.attr(), function (t, e) {
"img" !== e && (r[e] = t);
}),
r
);
}
return {};
}),
(t.prototype.getShapeCfg = function (t) {
var e = this.get("styles");
if (e) {
var n = t;
return (n.style = Object(h.a)(Object(h.a)({}, e), t.style)), n;
}
return t;
}),
(t.prototype.getStateStyle = function (t) {
var e = this.get("styles");
return e && e[t];
}),
(t.prototype.getOriginStyle = function () {
return this.get("originStyle");
}),
(t.prototype.getCurrentStatesStyle = function () {
var t = this,
e = {},
n = t.getStates();
return n && n.length
? (Object(gt.e)(t.getStates(), function (n) {
e = Object.assign(e, t.getStateStyle(n));
}),
e)
: this.getOriginStyle();
}),
(t.prototype.setState = function (t, e) {
var n = this.get("states"),
r = this.get("shapeFactory"),
i = t,
o = t;
Object(gt.x)(e) && ((i = t + ":" + e), (o = t + ":"));
var a = n;
if (Object(gt.n)(e)) {
var s = n.indexOf(o);
if (e) {
if (s > -1) return;
n.push(i);
} else s > -1 && n.splice(s, 1);
} else if (Object(gt.x)(e)) {
var u = n.filter(function (t) {
return t.includes(o);
});
u.length > 0 && this.clearStates(u),
(a = a.filter(function (t) {
return !t.includes(o);
})).push(i),
this.set("states", a);
}
if (r) {
var c = this.get("model").type;
r.setState(c, t, e, this);
}
}),
(t.prototype.clearStates = function (t) {
var e = this,
n = e.getStates(),
r = e.get("shapeFactory"),
i = e.get("model").type;
t || (t = n), Object(gt.x)(t) && (t = [t]);
var o = n.filter(function (e) {
return -1 === t.indexOf(e);
});
e.set("states", o),
t.forEach(function (t) {
r.setState(i, t, !1, e);
});
}),
(t.prototype.getContainer = function () {
return this.get("group");
}),
(t.prototype.getKeyShape = function () {
return this.get("keyShape");
}),
(t.prototype.getModel = function () {
return this.get("model");
}),
(t.prototype.getType = function () {
return this.get("type");
}),
(t.prototype.getID = function () {
return this.get("id");
}),
(t.prototype.isItem = function () {
return !0;
}),
(t.prototype.getStates = function () {
return this.get("states");
}),
(t.prototype.hasState = function (t) {
return this.getStates().indexOf(t) >= 0;
}),
(t.prototype.refresh = function () {
var t = this.get("model");
this.updatePosition(t),
this.updateShape(),
this.afterUpdate(),
this.clearCache();
}),
(t.prototype.isOnlyMove = function (t) {
return !1;
}),
(t.prototype.update = function (t, e) {
void 0 === e && (e = !1);
var n = this.get("model"),
r = n.visible,
i = t.visible;
r !== i && void 0 !== i && this.changeVisibility(i);
var o = n.x,
a = n.y;
(t.x = isNaN(t.x) ? n.x : t.x), (t.y = isNaN(t.y) ? n.y : t.y);
var s = this.get("styles");
if (t.stateStyles) {
var u = t.stateStyles;
Object(gt.C)(s, u), delete t.stateStyles;
}
Object.assign(n, t),
e
? this.updatePosition(t)
: ((o === t.x && a === t.y) || this.updatePosition(t),
this.updateShape()),
this.afterUpdate(),
this.clearCache();
}),
(t.prototype.updateShape = function () {
var t = this.get("shapeFactory"),
e = this.get("model"),
n = e.type;
if (t.shouldUpdate(n) && n === this.get("currentShape")) {
var r = this.getShapeCfg(e);
t.baseUpdate(n, r, this), this.setOriginStyle();
} else this.draw();
this.restoreStates(t, n);
}),
(t.prototype.updatePosition = function (t) {
var e = this.get("model"),
n = Object(gt.s)(t.x) ? e.x : t.x,
r = Object(gt.s)(t.y) ? e.y : t.y,
i = this.get("group");
if (Object(gt.s)(n) || Object(gt.s)(r)) return !1;
(e.x = n), (e.y = r);
var o = i.getMatrix();
return (
(!o || o[6] !== n || o[7] !== r) &&
(i.resetMatrix(), _n(i, { x: n, y: r }), this.clearCache(), !0)
);
}),
(t.prototype.getBBox = function () {
var t = this.get("bboxCache");
return (
t || ((t = this.calculateBBox()), this.set("bboxCache", t)), t
);
}),
(t.prototype.getCanvasBBox = function () {
var t = this.get("bboxCanvasCache");
return (
t ||
((t = this.calculateCanvasBBox()),
this.set("bboxCanvasCache", t)),
t
);
}),
(t.prototype.toFront = function () {
this.get("group").toFront();
}),
(t.prototype.toBack = function () {
this.get("group").toBack();
}),
(t.prototype.show = function () {
this.changeVisibility(!0);
}),
(t.prototype.hide = function () {
this.changeVisibility(!1);
}),
(t.prototype.changeVisibility = function (t) {
var e = this.get("group");
t ? e.show() : e.hide(), this.set("visible", t);
}),
(t.prototype.isVisible = function () {
return this.get("visible");
}),
(t.prototype.enableCapture = function (t) {
var e = this.get("group");
e && e.set("capture", t);
}),
(t.prototype.destroy = function () {
if (!this.destroyed) {
var t = this.get("animate"),
e = this.get("group");
t && e.stopAnimate(),
this.clearCache(),
e.remove(),
(this._cfg = null),
(this.destroyed = !0);
}
}),
t
);
})(),
Qr = { source: "start", target: "end" },
$r = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return {
type: "edge",
sourceNode: null,
targetNode: null,
startPoint: null,
endPoint: null,
linkCenter: !1,
};
}),
(e.prototype.setEnd = function (t, e) {
var n = Qr[t] + "Point",
r = t + "Node",
i = this.get(r);
i && !i.destroyed && i.removeEdge(this),
Object(gt.w)(e)
? (this.set(n, e), this.set(r, null))
: (e.addEdge(this), this.set(r, e), this.set(n, null));
}),
(e.prototype.getLinkPoint = function (t, e, n) {
var r = Qr[t] + "Point",
i = t + "Node",
o = this.get(r);
if (!o) {
var a = this.get(i),
s = t + "Anchor",
u = this.getPrePoint(t, n),
c = e[s];
Object(gt.s)(c) || (o = a.getLinkPointByAnchor(c)),
(o = o || a.getLinkPoint(u)),
Object(gt.s)(o.index) || this.set(t + "AnchorIndex", o.index);
}
return o;
}),
(e.prototype.getPrePoint = function (t, e) {
if (e && e.length) return e["source" === t ? 0 : e.length - 1];
var n = "source" === t ? "target" : "source";
return this.getEndPoint(n);
}),
(e.prototype.getEndPoint = function (t) {
var e = t + "Node",
n = Qr[t] + "Point",
r = this.get(e);
return r ? r.get("model") : this.get(n);
}),
(e.prototype.getControlPointsByCenter = function (t) {
var e = this.getEndPoint("source"),
n = this.getEndPoint("target"),
r = this.get("shapeFactory"),
i = t.type;
return r.getControlPoints(i, { startPoint: e, endPoint: n });
}),
(e.prototype.getEndCenter = function (t) {
var e = t + "Node",
n = Qr[t] + "Point",
r = this.get(e);
if (r) {
var i = r.getBBox();
return { x: i.centerX, y: i.centerY };
}
return this.get(n);
}),
(e.prototype.init = function () {
t.prototype.init.call(this),
this.setSource(this.get("source")),
this.setTarget(this.get("target"));
}),
(e.prototype.getShapeCfg = function (e) {
var n = this.get("linkCenter"),
r = t.prototype.getShapeCfg.call(this, e);
if (n)
(r.startPoint = this.getEndCenter("source")),
(r.endPoint = this.getEndCenter("target"));
else {
var i = r.controlPoints || this.getControlPointsByCenter(r);
(r.startPoint = this.getLinkPoint("source", e, i)),
(r.endPoint = this.getLinkPoint("target", e, i));
}
return (
(r.sourceNode = this.get("sourceNode")),
(r.targetNode = this.get("targetNode")),
r
);
}),
(e.prototype.getModel = function () {
var t = this.get("model"),
e = this.get("sourceNode"),
n = this.get("targetNode");
return (
e ? delete t.sourceNode : (t.source = this.get("startPoint")),
n ? delete t.targetNode : (t.target = this.get("endPoint")),
Object(gt.x)(t.source) ||
Object(gt.w)(t.source) ||
(t.source = t.source.getID()),
Object(gt.x)(t.target) ||
Object(gt.w)(t.target) ||
(t.target = t.target.getID()),
t
);
}),
(e.prototype.setSource = function (t) {
this.setEnd("source", t), this.set("source", t);
}),
(e.prototype.setTarget = function (t) {
this.setEnd("target", t), this.set("target", t);
}),
(e.prototype.getSource = function () {
return this.get("source");
}),
(e.prototype.getTarget = function () {
return this.get("target");
}),
(e.prototype.updatePosition = function () {
return !1;
}),
(e.prototype.update = function (t, e) {
void 0 === e && (e = !1);
var n = this.get("model"),
r = n.visible,
i = t.visible;
r !== i && void 0 !== i && this.changeVisibility(i);
var o = this.get("styles");
if (t.stateStyles) {
var a = t.stateStyles;
Object(gt.C)(o, a), delete t.stateStyles;
}
Object.assign(n, t),
this.updateShape(),
this.afterUpdate(),
this.clearCache();
}),
(e.prototype.destroy = function () {
var e = this.get("sourceNode"),
n = this.get("targetNode");
e && !e.destroyed && e.removeEdge(this),
n && !n.destroyed && n.removeEdge(this),
t.prototype.destroy.call(this);
}),
e
);
})(Kr),
Jr = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getNearestPoint = function (t, e) {
for (
var n = 0, r = t[0], i = Bn(t[0], e), o = 0;
o < t.length;
o++
) {
var a = t[o],
s = Bn(a, e);
s < i && ((r = a), (i = s), (n = o));
}
return (r.anchorIndex = n), r;
}),
(e.prototype.getDefaultCfg = function () {
return { type: "node", edges: [] };
}),
(e.prototype.getEdges = function () {
return this.get("edges");
}),
(e.prototype.getInEdges = function () {
var t = this;
return this.get("edges").filter(function (e) {
return e.get("target") === t;
});
}),
(e.prototype.getOutEdges = function () {
var t = this;
return this.get("edges").filter(function (e) {
return e.get("source") === t;
});
}),
(e.prototype.getNeighbors = function (t) {
var e = this,
n = this.get("edges");
if ("target" === t) {
return n
.filter(function (t) {
return t.getSource() === e;
})
.map(function (t) {
return t.getTarget();
});
}
if ("source" === t) {
return n
.filter(function (t) {
return t.getTarget() === e;
})
.map(function (t) {
return t.getSource();
});
}
return n.map(function (t) {
return t.getSource() === e ? t.getTarget() : t.getSource();
});
}),
(e.prototype.getLinkPointByAnchor = function (t) {
return this.getAnchorPoints()[t];
}),
(e.prototype.getLinkPoint = function (t) {
var e,
n,
r = this.get("keyShape").get("type"),
i = this.get("type"),
o = this.getBBox();
"combo" === i
? ((e = o.centerX || (o.maxX + o.minX) / 2),
(n = o.centerY || (o.maxY + o.minY) / 2))
: ((e = o.centerX), (n = o.centerY));
var a,
s = this.getAnchorPoints();
switch (r) {
case "circle":
a = En({ x: e, y: n, r: o.width / 2 }, t);
break;
case "ellipse":
a = Nn({ x: e, y: n, rx: o.width / 2, ry: o.height / 2 }, t);
break;
default:
a = kn(o, t);
}
var u = a;
return (
s.length && (u || (u = t), (u = this.getNearestPoint(s, u))),
u || (u = { x: e, y: n }),
u
);
}),
(e.prototype.getAnchorPoints = function () {
var t = this.get("anchorPointsCache");
if (!t) {
t = [];
var e = this.get("shapeFactory"),
n = this.getBBox(),
r = this.get("model"),
i = this.getShapeCfg(r),
o = r.type,
a = e.getAnchorPoints(o, i) || [];
Object(gt.e)(a, function (e, r) {
var i = {
x: n.minX + e[0] * n.width,
y: n.minY + e[1] * n.height,
anchorIndex: r,
};
t.push(i);
}),
this.set("anchorPointsCache", t);
}
return t;
}),
(e.prototype.addEdge = function (t) {
this.get("edges").push(t);
}),
(e.prototype.lock = function () {
this.set("locked", !0);
}),
(e.prototype.unlock = function () {
this.set("locked", !1);
}),
(e.prototype.hasLocked = function () {
return this.get("locked");
}),
(e.prototype.removeEdge = function (t) {
var e = this.getEdges(),
n = e.indexOf(t);
n > -1 && e.splice(n, 1);
}),
(e.prototype.clearCache = function () {
this.set("bboxCache", null), this.set("anchorPointsCache", null);
}),
(e.prototype.isOnlyMove = function (t) {
if (!t) return !1;
var e = !Object(gt.s)(t.x),
n = !Object(gt.s)(t.y),
r = Object.keys(t);
return (1 === r.length && (e || n)) || (2 === r.length && e && n);
}),
e
);
})(Kr),
ti = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getDefaultCfg = function () {
return { type: "combo", nodes: [], edges: [], combos: [] };
}),
(e.prototype.getShapeCfg = function (t) {
var e = this.get("styles"),
n = this.get("bbox");
if (e && n) {
var r = t,
i = {
r:
Math.hypot(n.height, n.width) / 2 ||
ur.defaultCombo.size[0] / 2,
width: n.width || ur.defaultCombo.size[0],
height: n.height || ur.defaultCombo.size[1],
};
r.style = Object(h.a)(
Object(h.a)(Object(h.a)({}, e), t.style),
i,
);
var o = t.padding || ur.defaultCombo.padding;
return (
Object(gt.t)(o)
? ((i.r += o), (i.width += 2 * o), (i.height += 2 * o))
: ((i.r += o[0]),
(i.width += o[1] + o[3] || 2 * o[1]),
(i.height += o[0] + o[2] || 2 * o[0])),
this.set("sizeCache", i),
r
);
}
return t;
}),
(e.prototype.calculateCanvasBBox = function () {
if (!this.destroyed) {
var t = this.get("keyShape"),
e = this.get("group"),
n = gr(t, e);
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2);
var r = this.get("sizeCache"),
i = this.get("bboxCache") || {},
o = i.x,
a = i.x;
if (r)
(r.width = Math.max(r.width, n.width)),
(r.height = Math.max(r.height, n.height)),
"circle" === t.get("type")
? ((n.width = 2 * r.r), (n.height = 2 * r.r))
: ((n.width = r.width), (n.height = r.height)),
(n.minX = n.centerX - n.width / 2),
(n.minY = n.centerY - n.height / 2),
(n.maxX = n.centerX + n.width / 2),
(n.maxY = n.centerY + n.height / 2);
else
(n.width = n.maxX - n.minX),
(n.height = n.maxY - n.minY),
(n.centerX = (n.minX + n.maxX) / 2),
(n.centerY = (n.minY + n.maxY) / 2);
return (
(n.x = n.minX),
(n.y = n.minY),
(n.x === o && n.y === a) ||
this.set("anchorPointsCache", null),
n
);
}
}),
(e.prototype.getChildren = function () {
return { nodes: this.getNodes(), combos: this.getCombos() };
}),
(e.prototype.getNodes = function () {
return this.get("nodes");
}),
(e.prototype.getCombos = function () {
return this.get("combos");
}),
(e.prototype.addChild = function (t) {
switch (t.getType()) {
case "node":
this.addNode(t);
break;
case "combo":
this.addCombo(t);
break;
default:
return (
console.warn(
"Only node or combo items are allowed to be added into a combo",
),
!1
);
}
return !0;
}),
(e.prototype.addCombo = function (t) {
return this.get("combos").push(t), !0;
}),
(e.prototype.addNode = function (t) {
return this.get("nodes").push(t), !0;
}),
(e.prototype.removeChild = function (t) {
switch (t.getType()) {
case "node":
this.removeNode(t);
break;
case "combo":
this.removeCombo(t);
break;
default:
return (
console.warn(
"Only node or combo items are allowed to be added into a combo",
),
!1
);
}
return !0;
}),
(e.prototype.removeCombo = function (t) {
if (t) {
var e = this.getCombos(),
n = e.indexOf(t);
return n > -1 && (e.splice(n, 1), !0);
}
}),
(e.prototype.removeNode = function (t) {
if (t) {
var e = this.getNodes(),
n = e.indexOf(t);
return n > -1 && (e.splice(n, 1), !0);
}
}),
(e.prototype.isOnlyMove = function (t) {
return !1;
}),
(e.prototype.getBBox = function () {
return (
this.set("bboxCanvasCache", null), this.calculateCanvasBBox()
);
}),
(e.prototype.clearCache = function () {
this.set("bboxCache", null),
this.set("bboxCanvasCache", null),
this.set("anchorPointsCache", null);
}),
(e.prototype.destroy = function () {
if (!this.destroyed) {
var t = this.get("animate"),
e = this.get("group");
t && e.stopAnimate(),
this.clearCache(),
this.set("sizeCache", null),
this.set("bbox", null),
e.remove(),
(this._cfg = null),
(this.destroyed = !0);
}
}),
e
);
})(Jr),
ei = (function () {
function t(t) {
(this.graph = t), (this.destroyed = !1);
}
return (
(t.prototype.addItem = function (t, e) {
var n = this.graph,
r = "vedge" === t ? "edge" : t,
i = n.get(r + "Group") || n.get("group"),
o = Object(gt.J)(r),
a = null,
s = n.get(r + Object(gt.J)("stateStyles")) || {},
u = n.get("default" + o);
e.stateStyles && (s = e.stateStyles),
u &&
Object(gt.e)(u, function (t, n) {
Object(gt.v)(t) && !Object(gt.m)(t)
? (e[n] = Object(gt.d)({}, t, e[n]))
: Object(gt.m)(t)
? (e[n] = e[n] || Object(gt.b)(u[n]))
: (e[n] = e[n] || u[n]);
});
var c = n.get(r + "Mapper");
if (c) {
var h = c(e);
h.stateStyles && ((s = h.stateStyles), delete h.stateStyles),
Object(gt.e)(h, function (t, n) {
Object(gt.v)(t) && !Object(gt.m)(t)
? (e[n] = Object(gt.d)({}, e[n], t))
: (e[n] = h[n] || e[n]);
});
}
if (
(n.emit("beforeadditem", { type: t, model: e }),
"edge" === t || "vedge" === t)
) {
var l = void 0,
d = void 0;
if (
((l = e.source),
(d = e.target),
l && Object(gt.x)(l) && (l = n.findById(l)),
d && Object(gt.x)(d) && (d = n.findById(d)),
!l || !d)
)
return void console.warn(
"The source or target node of edge " +
e.id +
" does not exist!",
);
l.getType && "combo" === l.getType() && (e.isComboEdge = !0),
d.getType && "combo" === d.getType() && (e.isComboEdge = !0),
(a = new $r({
model: e,
source: l,
target: d,
styles: s,
linkCenter: n.get("linkCenter"),
group: i.addGroup(),
}));
} else if ("node" === t)
a = new Jr({ model: e, styles: s, group: i.addGroup() });
else if ("combo" === t) {
var f = e.children,
p = Cr(f, n);
isNaN(p.x)
? isNaN(e.x) && (e.x = 100 * Math.random())
: (e.x = p.x),
isNaN(p.y)
? isNaN(e.y) && (e.y = 100 * Math.random())
: (e.y = p.y);
var g = i.addGroup();
g.setZIndex(e.depth);
var y = (a = new ti({
model: e,
styles: s,
bbox: e.collapsed ? Cr([], n) : p,
group: g,
})).getModel();
(f || []).forEach(function (t) {
var e = n.findById(t.id);
a.addChild(e), (t.depth = y.depth + 2);
}),
e.collapsed &&
setTimeout(function () {
n.collapseCombo(a);
}, 16);
}
if (a)
return (
n.get(t + "s").push(a),
(n.get("itemMap")[a.get("id")] = a),
n.emit("afteradditem", { item: a, model: e }),
a
);
}),
(t.prototype.updateItem = function (t, e) {
var n,
r,
i = this.graph;
if ((Object(gt.x)(t) && (t = i.findById(t)), t && !t.destroyed)) {
var o = "";
t.getType && (o = t.getType());
var a = i.get(o + "Mapper"),
s = t.getModel(),
u = t.isOnlyMove(e);
if (a) {
var c = a(Object(gt.d)({}, s, e)),
l = Object(gt.d)({}, s, c, e);
c.stateStyles &&
(t.set("styles", l.stateStyles), delete l.stateStyles),
Object(gt.e)(l, function (t, n) {
e[n] = t;
});
} else
Object(gt.e)(e, function (t, n) {
s[n] &&
Object(gt.v)(t) &&
!Object(gt.m)(t) &&
(e[n] = Object(h.a)(Object(h.a)({}, s[n]), e[n]));
});
if (
(i.emit("beforeupdateitem", { item: t, cfg: e }),
"edge" === o)
) {
if (e.source) {
var d = e.source;
Object(gt.x)(d) && (d = i.findById(d)), t.setSource(d);
}
if (e.target) {
var f = e.target;
Object(gt.x)(f) && (f = i.findById(f)), t.setTarget(f);
}
t.update(e);
}
if ("node" === o || "combo" === o) {
t.update(e, u);
var p = t.getEdges(),
g = jr(e);
if (g && "node" === o)
Object(gt.e)(p, function (t) {
t.refresh();
});
else if (g && "combo" === o) {
var y = t.get("shapeFactory"),
v = s.type || "circle";
(
void 0 === s.animate || void 0 === e.animate
? null ===
(r =
null === (n = y[v]) || void 0 === n
? void 0
: n.options) || void 0 === r
? void 0
: r.animate
: s.animate || e.animate
)
? setTimeout(function () {
if (t && !t.destroyed) {
var e = t.getKeyShape();
e &&
!e.destroyed &&
Object(gt.e)(p, function (t) {
t && !t.destroyed && t.refresh();
});
}
}, 201)
: Object(gt.e)(p, function (t) {
t.refresh();
});
}
}
i.emit("afterupdateitem", { item: t, cfg: e });
}
}),
(t.prototype.updateCombo = function (t, e) {
var n,
r,
i = this,
o = this.graph;
if ((Object(gt.x)(t) && (t = o.findById(t)), t && !t.destroyed)) {
var a = t.getModel(),
s = Cr(a.collapsed ? [] : e, o);
t.set("bbox", s), t.update({ x: s.x, y: s.y });
var u = t.get("shapeFactory"),
c = a.type || "circle";
(
void 0 === a.animate
? null ===
(r =
null === (n = u[c]) || void 0 === n
? void 0
: n.options) || void 0 === r
? void 0
: r.animate
: a.animate
)
? setTimeout(function () {
if (t && !t.destroyed) {
var e = t.getKeyShape();
e &&
!e.destroyed &&
(t.getShapeCfg(a), i.updateComboEdges(t));
}
}, 201)
: this.updateComboEdges(t);
}
}),
(t.prototype.updateComboEdges = function (t) {
for (var e = t.getEdges() || [], n = 0; n < e.length; n++) {
var r = e[n];
if (r && !r.destroyed) {
var i = r.get("shapeFactory"),
o = r.getShapeCfg(r.getModel()),
a = r.getContainer();
a.clear();
var s = i.draw(o.type, o, a);
r.set("keyShape", s),
s.set("isKeyShape", !0),
s.set("draggable", !0),
r.setOriginStyle();
}
}
}),
(t.prototype.collapseCombo = function (t) {
var e = this.graph;
Object(gt.x)(t) && (t = e.findById(t));
var n = t.getChildren();
n.nodes.forEach(function (t) {
e.hideItem(t);
}),
n.combos.forEach(function (t) {
e.hideItem(t);
});
}),
(t.prototype.expandCombo = function (t) {
var e = this.graph;
Object(gt.x)(t) && (t = e.findById(t));
var n = t.getChildren();
n.nodes.forEach(function (t) {
e.showItem(t);
}),
n.combos.forEach(function (t) {
t.getModel().collapsed ? t.show() : e.showItem(t);
});
}),
(t.prototype.removeItem = function (t) {
var e = this,
n = this.graph;
if ((Object(gt.x)(t) && (t = n.findById(t)), t && !t.destroyed)) {
var r = Object(gt.b)(t.getModel());
n.emit("beforeremoveitem", { item: r });
var i = "";
t.getType && (i = t.getType());
var o = n.get(i + "s"),
a = o.indexOf(t);
if ((a > -1 && o.splice(a, 1), "edge" === i)) {
var s = n.get("v" + i + "s"),
u = s.indexOf(t);
u > -1 && s.splice(u, 1);
}
var c = t.get("id");
delete n.get("itemMap")[c];
var h = n.get("comboTrees"),
l = t.get("id");
if ("node" === i) {
var d = t.getModel().comboId;
if (h && d) {
var f = h,
p = !1;
h.forEach(function (t) {
p ||
br(t, function (t) {
if (t.id === l && f) {
var e = f.indexOf(t);
return f.splice(e, 1), (p = !0), !1;
}
return (f = t.children), !0;
});
});
}
for (var g = (b = t.getEdges()).length - 1; g >= 0; g--)
n.removeItem(b[g], !1);
d && n.updateCombo(d);
} else if ("combo" === i) {
var y,
v = t.getModel().parentId,
m = !1;
(h || []).forEach(function (t) {
m ||
br(t, function (t) {
return t.id !== l || ((y = t), (m = !0), !1);
});
}),
(y.removed = !0),
y &&
y.children &&
y.children.forEach(function (t) {
e.removeItem(t.id);
});
var b;
for (g = (b = t.getEdges()).length; g >= 0; g--)
n.removeItem(b[g], !1);
v && n.updateCombo(v);
}
t.destroy(), n.emit("afterremoveitem", { item: r });
}
}),
(t.prototype.setItemState = function (t, e, n) {
var r = this.graph,
i = e;
Object(gt.x)(n) && (i = e + ":" + n),
(t.hasState(i) === n && n) ||
(Object(gt.x)(n) && t.hasState(i)) ||
(r.emit("beforeitemstatechange", {
item: t,
state: i,
enabled: n,
}),
t.setState(e, n),
r.autoPaint(),
r.emit("afteritemstatechange", {
item: t,
state: i,
enabled: n,
}));
}),
(t.prototype.priorityState = function (t, e) {
var n = this.graph,
r = t;
Object(gt.x)(t) && (r = n.findById(t)),
this.setItemState(r, e, !1),
this.setItemState(r, e, !0);
}),
(t.prototype.clearItemStates = function (t, e) {
var n = this.graph;
Object(gt.x)(t) && (t = n.findById(t)),
n.emit("beforeitemstatesclear", { item: t, states: e }),
t.clearStates(e),
n.emit("afteritemstatesclear", { item: t, states: e });
}),
(t.prototype.refreshItem = function (t) {
var e = this.graph;
Object(gt.x)(t) && (t = e.findById(t)),
e.emit("beforeitemrefresh", { item: t }),
t.refresh(),
e.emit("afteritemrefresh", { item: t });
}),
(t.prototype.addCombos = function (t, e) {
var n = this,
r = this.graph;
(t || []).forEach(function (t) {
xr(t, function (t) {
var r;
return (
e.forEach(function (e) {
e.id === t.id &&
((e.children = t.children),
(e.depth = t.depth),
(r = e));
}),
r && n.addItem("combo", r),
!0
);
});
});
var i = r.get("comboGroup");
i && i.sort();
}),
(t.prototype.changeItemVisibility = function (t, e) {
var n = this,
r = this.graph;
if ((Object(gt.x)(t) && (t = r.findById(t)), t)) {
if (
(r.emit("beforeitemvisibilitychange", {
item: t,
visible: e,
}),
t.changeVisibility(e),
t.getType && "node" === t.getType())
) {
var i = t.getEdges();
Object(gt.e)(i, function (t) {
(!e ||
(t.get("source").isVisible() &&
t.get("target").isVisible())) &&
n.changeItemVisibility(t, e);
});
} else if (t.getType && "combo" === t.getType()) {
var o = r.get("comboTrees"),
a = t.get("id"),
s = [],
u = !1;
(o || []).forEach(function (t) {
u ||
(t.children &&
0 !== t.children.length &&
br(t, function (t) {
return t.id !== a || ((s = t.children), (u = !0), !1);
}));
}),
s &&
(!e || (e && !t.getModel().collapsed)) &&
s.forEach(function (t) {
var i = r.findById(t.id);
n.changeItemVisibility(i, e);
});
i = t.getEdges();
Object(gt.e)(i, function (t) {
(!e ||
(t.get("source").isVisible() &&
t.get("target").isVisible())) &&
n.changeItemVisibility(t, e);
});
}
return (
r.emit("afteritemvisibilitychange", { item: t, visible: e }),
t
);
}
console.warn("The item to be shown or hidden does not exist!");
}),
(t.prototype.destroy = function () {
(this.graph = null), (this.destroyed = !0);
}),
t
);
})(),
ni = null,
ri = (function () {
function t(t) {
(this.graph = t),
(this.cachedStates = { enabled: {}, disabled: {} }),
(this.destroyed = !1);
}
return (
(t.checkCache = function (t, e, n) {
if (n[e]) {
var r = n[e].indexOf(t);
r >= 0 && n[e].splice(r, 1);
}
}),
(t.cacheState = function (t, e, n) {
n[e] || (n[e] = []), n[e].push(t);
}),
(t.prototype.updateState = function (e, n, r) {
var i = this,
o = t.checkCache,
a = t.cacheState;
if (!e.destroyed) {
var s = this.cachedStates,
u = s.enabled,
c = s.disabled;
r ? (o(e, n, c), a(e, n, u)) : (o(e, n, u), a(e, n, c)),
ni && clearTimeout(ni),
(ni = setTimeout(function () {
(ni = null), i.updateGraphStates();
}, 16));
}
}),
(t.prototype.updateStates = function (t, e, n) {
var r = this;
Object(gt.x)(e)
? this.updateState(t, e, n)
: e.forEach(function (e) {
r.updateState(t, e, n);
});
}),
(t.prototype.updateGraphStates = function () {
var t = this.graph.get("states"),
e = this.cachedStates;
Object(gt.e)(e.disabled, function (e, n) {
t[n] &&
(t[n] = t[n].filter(function (t) {
return e.indexOf(t) < 0 && !e.destroyed;
}));
}),
Object(gt.e)(e.enabled, function (e, n) {
if (t[n]) {
var r = {};
t[n].forEach(function (t) {
t.destroyed || (r[t.get("id")] = !0);
}),
e.forEach(function (e) {
if (!e.destroyed) {
var i = e.get("id");
r[i] || ((r[i] = !0), t[n].push(e));
}
});
} else t[n] = e;
}),
this.graph.emit("graphstatechange", { states: t }),
(this.cachedStates = { enabled: {}, disabled: {} });
}),
(t.prototype.destroy = function () {
(this.graph = null),
(this.cachedStates = null),
ni && clearTimeout(ni),
(ni = null),
(this.destroyed = !0);
}),
t
);
})(),
ii = function (t, e) {
return t && e
? t.replace(/\\?\{([^{}]+)\}/g, function (t, n) {
if ("\\" === t.charAt(0)) return t.slice(1);
var r = e[n];
return 0 === r && (r = "0"), r || "";
})
: t;
},
oi = function (t) {
var e = [];
if (t.length < 2)
throw new Error(
"point length must largn than 2, now it's " + t.length,
);
for (var n = 0, r = t; n < r.length; n++) {
var i = r[n],
o = i.x,
a = i.y;
e.push(o), e.push(a);
}
var s = Object(mt.a)(e);
return s.unshift(["M", t[0].x, t[0].y]), s;
},
ai = function (t, e, n, r) {
void 0 === n && (n = 0), void 0 === r && (r = 0);
var i = { x: (1 - n) * t.x + n * e.x, y: (1 - n) * t.y + n * e.y },
o = [0, 0];
sn.c.normalize(o, [e.x - t.x, e.y - t.y]),
(o && (o[0] || o[1])) || (o = [0, 0]);
var a = [-o[1] * r, o[0] * r];
return (i.x += a[0]), (i.y += a[1]), i;
},
si = function (t, e) {
var n = t.length;
if (!n) return "";
for (var r = "", i = 0; i < n; i++) {
var o = t[i];
r += ii(0 === i ? "M{x} {y}" : "L{x} {y}", o);
}
return e && (r += "Z"), r;
},
ui = function (t) {
var e = [];
return (
t.forEach(function (t) {
if ("A" !== t[0])
for (var n = 1; n < t.length; n += 2) e.push([t[n], t[n + 1]]);
else {
var r = t.length;
e.push([t[r - 2], t[r - 1]]);
}
}),
e
);
},
ci = function (t) {
if (t.length < 2)
throw new Error(
"point length must largn than 2, now it's " + t.length,
);
var e = t[0],
n = t[1],
r = t[t.length - 1],
i = t[t.length - 2];
t.unshift(r), t.unshift(i), t.push(e), t.push(n);
for (var o = [], a = 1; a < t.length - 2; a += 1) {
var s = t[a - 1].x,
u = t[a - 1].y,
c = t[a].x,
h = t[a].y,
l = t[a + 1].x,
d = t[a + 1].y,
f = c + (l - s) / 6,
p = h + (d - u) / 6,
g = l - ((a !== t.length - 2 ? t[a + 2].x : l) - c) / 6,
y = d - ((a !== t.length - 2 ? t[a + 2].y : d) - h) / 6;
o.push(["C", f, p, g, y, l, d]);
}
return o.unshift(["M", r.x, r.y]), o;
},
hi = function (t, e) {
return sn.c.scale([0, 0], sn.c.normalize([0, 0], t), e);
},
li = function (t, e) {
var n = [t[1] - e[1], e[0] - t[0]],
r = Math.sqrt(n[0] * n[0] + n[1] * n[1]);
if (0 === r) throw new Error("p0 should not be equal to p1");
return [n[0] / r, n[1] / r];
},
di = function (t, e) {
return [e[0] - t[0], e[1] - t[1]];
};
function fi(t, e) {
if (!t || t.length < 1) return "";
if (1 === t.length)
return (function (t) {
var n = [t[0][0], t[0][1] - e],
r = [t[0][0], t[0][1] + e];
return (
"M " +
n +
" A " +
e +
"," +
e +
",0,0,0," +
r +
" A " +
e +
"," +
e +
",0,0,0," +
n
);
})(t);
if (2 === t.length)
return (function (t) {
var n = sn.c.scale([0, 0], li(t[0], t[1]), e),
r = sn.c.scale([0, 0], n, -1),
i = sn.c.add([0, 0], t[0], n),
o = sn.c.add([0, 0], t[1], n),
a = sn.c.add([0, 0], t[1], r),
s = sn.c.add([0, 0], t[0], r);
return (
"M " +
i +
" L " +
o +
" A " +
[e, e, "0,0,0", a].join(",") +
" L " +
s +
" A " +
[e, e, "0,0,0", i].join(",")
);
})(t);
for (var n = new Array(t.length), r = 0; r < n.length; ++r) {
var i = 0 === r ? t[t.length - 1] : t[r - 1],
o = t[r],
a = sn.c.scale([0, 0], li(i, o), e);
n[r] = [sn.c.add([0, 0], i, a), sn.c.add([0, 0], o, a)];
}
var s = "A " + [e, e, "0,0,0,"].join(",");
return (n = n.map(function (t, e) {
var r = "";
return (
0 === e && (r = "M " + n[n.length - 1][1] + " "),
(r += s + t[0] + " L " + t[1])
);
})).join(" ");
}
function pi(t, e) {
var n,
r,
i,
o = t.length;
if (!t || o < 1) return "";
if (1 === o)
return (
(r = [(n = t)[0][0], n[0][1] - e]),
(i = [n[0][0], n[0][1] + e]),
"M " +
r +
" A " +
[e, e, "0,0,0", i].join(",") +
" A " +
[e, e, "0,0,0", r].join(",")
);
if (2 === o)
return (function (t) {
var n = di(t[0], t[1]),
r = hi(n, e),
i = sn.c.add([0, 0], t[0], sn.c.scale([0, 0], r, -1)),
o = sn.c.add([0, 0], t[1], r),
a = 1.2 * e,
s = hi(sn.c.normalize([0, 0], n), a),
u = sn.c.scale([0, 0], s, -1),
c = sn.c.add([0, 0], i, u),
h = sn.c.add([0, 0], o, u),
l = sn.c.add([0, 0], i, s);
return (
"M " +
i +
" C " +
[c, h, o].join(",") +
" S " +
[l, i].join(",") +
" Z"
);
})(t);
for (
var a = t.map(function (e, n) {
var r = t[(n + 1) % o];
return { p: e, v: sn.c.normalize([0, 0], di(e, r)) };
}),
s = 0;
s < a.length;
++s
) {
var u = s > 0 ? s - 1 : o - 1,
c = sn.c.normalize(
[0, 0],
sn.c.add([0, 0], a[u].v, sn.c.scale([0, 0], a[s].v, -1)),
);
a[s].p = sn.c.add([0, 0], a[s].p, sn.c.scale([0, 0], c, e));
}
return a.map(function (t) {
var e = t.p;
return { x: e[0], y: e[1] };
});
}
var gi = function (t, e, n) {
return (t.y - n.y) * (e.x - n.x) - (t.x - n.x) * (e.y - n.y);
},
yi = function (t) {
var e = t.map(function (t) {
return { x: t.getModel().x, y: t.getModel().y };
});
if (
(e.sort(function (t, e) {
return t.x === e.x ? t.y - e.y : t.x - e.x;
}),
1 === e.length)
)
return e;
for (var n = [], r = 0; r < e.length; r++) {
for (
;
n.length >= 2 && gi(n[n.length - 2], n[n.length - 1], e[r]) <= 0;
)
n.pop();
n.push(e[r]);
}
var i = [];
for (r = e.length - 1; r >= 0; r--) {
for (
;
i.length >= 2 && gi(i[i.length - 2], i[i.length - 1], e[r]) <= 0;
)
i.pop();
i.push(e[r]);
}
return i.pop(), n.pop(), n.concat(i);
},
vi = {
maxRoutingIterations: 100,
maxMarchingIterations: 100,
pixelGroupSize: 2,
edgeR0: 10,
edgeR1: 10,
nodeR0: 5,
nodeR1: 10,
morphBuffer: 5,
threshold: 0.001,
skip: 16,
nodeInfluenceFactor: 1,
edgeInfluenceFactor: 1,
negativeNodeInfluenceFactor: -0.5,
};
function mi(t, e, n) {
var r = !1,
i = function (t, n) {
return e.cells[t + n * e.width];
},
o = function (t, e) {
var r = 0;
return (
i(t - 1, e - 1) >= n && (r += 1),
i(t, e - 1) > n && (r += 2),
i(t - 1, e) > n && (r += 4),
i(t, e) > n && (r += 8),
r
);
},
a = function (n, r) {
for (var i, a, s = n, u = r, c = 0; c < e.width * e.height; c++) {
if (
((i = s),
(a = u),
t.findIndex(function (t) {
return t.x === s && t.y === u;
}) > -1)
) {
if (t[0].x === s && t[0].y === u) return !0;
} else t.push({ x: s, y: u });
var h = o(s, u);
switch (h) {
case -1:
return console.warn("Marched out of bounds"), !0;
case 0:
case 3:
case 2:
case 7:
s++;
break;
case 12:
case 14:
case 4:
s--;
break;
case 6:
0 === i && (-1 === a ? (s -= 1) : (s += 1));
break;
case 1:
case 13:
case 5:
u--;
break;
case 9:
1 === i && (0 === a ? (u -= 1) : (u += 1));
break;
case 10:
case 8:
case 11:
u++;
break;
default:
return (
console.warn("Marching squares invalid state: " + h), !0
);
}
}
};
this.march = function () {
for (var t = 0; t < e.width && !r; t += 1)
for (var s = 0; s < e.height && !r; s += 1)
i(t, s) > n && 15 !== o(t, s) && (r = a(t, s));
return r;
};
}
var bi = function (t, e) {
var n = Number.POSITIVE_INFINITY,
r = null;
return (
t.forEach(function (t) {
var i = Kn(t, e);
i >= 0 && i < n && ((r = t), (n = i));
}),
r
);
};
function xi(t, e, n, r, i) {
var o = (function (t, e, n) {
var r = null,
i = Number.POSITIVE_INFINITY;
return (
e.forEach(function (e) {
var o = { x: t.getModel().x, y: t.getModel().y },
a = { x: e.getModel().x, y: e.getModel().y },
s = $n(o, a),
u = new Hn(o.x, o.y, a.x, a.y),
c = n.reduce(function (t, e) {
return Kn(e, u) > 0 ? t + 1 : t;
}, 0);
s * Math.pow(c + 1, 2) < i &&
((r = e), (i = s * Math.pow(c + 1, 2)));
}),
r
);
})(t, n, e);
if (null === o) return [];
return (function (t) {
for (var n = []; t.length > 0; ) {
var r = t.pop();
if (0 === t.length) {
n.push(r);
break;
}
var i = t.pop(),
o = new Hn(r.x1, r.y1, i.x2, i.y2);
bi(e, o) ? (n.push(r), t.push(i)) : t.push(o);
}
return n;
})(
(function (t, e, n, r) {
var i = [],
o = [];
o.push(t);
for (
var a = !0,
s = 0,
u = function (t, e) {
var n = !1;
return (
e.forEach(function (e) {
n ||
((tr(t, { x: e.x1, y: e.y1 }) ||
tr(t, { x: e.x2, y: e.y2 })) &&
(n = !0));
}),
n
);
},
c = function (t, e) {
for (var n = 0, r = e; n < r.length; n++) {
var i = r[n].getBBox(),
o = [
[i.x, i.y],
[i.x + i.width, i.y],
[i.x, i.y + i.height],
[i.x + i.width, i.y + i.height],
];
if (Wn(o, t.x, t.y)) return !0;
}
return !1;
};
a && s < n;
) {
a = !1;
for (
var h = function () {
var t = o.pop(),
n = bi(e, t);
if (n) {
var h = Zn(n, t),
l = h[0];
if (2 === h[1]) {
var d = function (s) {
for (
var h = r,
d = Mi(n, h, l, s),
f = u(d, o) || u(d, i),
p = c(d, e);
!f && p && h >= 1;
)
(d = Mi(n, (h /= 1.5), l, s)),
(f = u(d, o) || u(d, i)),
(p = c(d, e));
!d ||
f ||
(s && p) ||
(o.push(new Hn(t.x1, t.y1, d.x, d.y)),
o.push(new Hn(d.x, d.y, t.x2, t.y2)),
(a = !0));
};
d(!0), a || d(!1);
}
}
a || i.push(t), (s += 1);
};
!a && o.length;
)
h();
}
for (; o.length; ) i.push(o.pop());
return i;
})(
new Hn(
t.getModel().x,
t.getModel().y,
o.getModel().x,
o.getModel().y,
),
e,
r,
i,
),
);
}
var wi = function (t, e, n) {
var r = Object.assign(vi, n),
i = Qn(
t.map(function (t) {
return { x: t.getModel().x, y: t.getModel().y };
}),
);
t = t.sort(function (t, e) {
return (
$n({ x: t.getModel().x, y: t.getModel().y }, i) -
$n({ x: e.getModel().x, y: e.getModel().y }, i)
);
});
var o = [],
a = [];
t.forEach(function (t) {
xi(t, e, o, r.maxRoutingIterations, r.morphBuffer).forEach(
function (t) {
a.push(t);
},
),
o.push(t);
});
for (
var s,
u,
c,
h,
l,
d = (function (t, e, n) {
var r = {
minX: Number.POSITIVE_INFINITY,
minY: Number.POSITIVE_INFINITY,
maxX: Number.NEGATIVE_INFINITY,
maxY: Number.NEGATIVE_INFINITY,
width: 0,
height: 0,
x: 0,
y: 0,
},
i = [];
t.forEach(function (t) {
i.push(t.getBBox());
}),
e.forEach(function (t) {
i.push(t.getBBox());
});
for (var o = 0, a = i; o < a.length; o++) {
var s = a[o];
(r.minX = (s.minX < r.minX ? s.minX : r.minX) - n),
(r.minY = (s.minY < r.minY ? s.minY : r.minY) - n),
(r.maxX = (s.maxX > r.maxX ? s.maxX : r.maxX) + n),
(r.maxY = (s.maxY > r.maxY ? s.maxY : r.maxY) + n);
}
return (
(r.width = r.maxX - r.minX),
(r.height = r.maxY - r.minY),
(r.x = r.minX),
(r.y = r.minY),
r
);
})(t, a, r.nodeR0),
f =
((s = d.width),
(u = d.height),
(c = r.pixelGroupSize),
(h = Math.ceil(s / c)),
(l = Math.ceil(u / c)),
{
cells: new Float32Array(Math.max(0, h * l)).fill(0),
width: h,
height: l,
}),
p = [],
g = [],
y = 0;
y < r.maxMarchingIterations;
y++
)
if (
(Oi(t, e, a, d, f, r),
(g = []),
new mi((p = []), f, r.threshold).march())
) {
var v = p.map(function (t) {
return {
x: Math.round(t.x * r.pixelGroupSize + d.minX),
y: Math.round(t.y * r.pixelGroupSize + d.minY),
};
});
if (v) {
var m = v.length;
if (r.skip > 1)
for (m = Math.floor(v.length / r.skip); m < 3 && r.skip > 1; )
(r.skip -= 1), (m = Math.floor(v.length / r.skip));
for (var b = 0, x = 0; x < m; x += 1, b += r.skip)
g.push({ x: v[b].x, y: v[b].y });
}
if (
g &&
(function () {
for (var e = 0, n = t; e < n.length; e++) {
var r = n[e],
i = g.map(function (t) {
return [t.x, t.y];
});
if (!Wn(i, r.getBBox().centerX, r.getBBox().centerY))
return !1;
}
return !0;
})()
)
return g;
if (((r.threshold *= 0.9), y <= 0.5 * r.maxMarchingIterations))
(r.memberInfluenceFactor *= 1.2), (r.edgeInfluenceFactor *= 1.2);
else {
if (!(0 !== r.nonMemberInfluenceFactor && e.length > 0)) break;
r.nonMemberInfluenceFactor *= 0.8;
}
}
return g;
};
function Oi(t, e, n, r, i, o) {
function a(t, e) {
var n = Math.floor((t - e) / o.pixelGroupSize);
return n < 0 ? 0 : n;
}
function s(t, e) {
return t * o.pixelGroupSize + e;
}
var u = (o.nodeR0 - o.nodeR1) * (o.nodeR0 - o.nodeR1),
c = (o.edgeR0 - o.edgeR1) * (o.edgeR0 - o.edgeR1),
h = function (t, e) {
return [
Math.min(a(t.minX, e + r.minX), i.width),
Math.min(a(t.minY, e + r.minY), i.height),
Math.min(a(t.maxX, -e + r.minX), i.width),
Math.min(a(t.maxY, -e + r.minY), i.height),
];
},
l = function (t, e) {
for (
var n = t.getBBox(),
a = h(n, o.nodeR1),
u = a[0],
c = a[1],
l = a[2],
d = a[3],
f = c;
f < d;
f += 1
)
for (var p = u; p < l; p += 1)
if (!(e < 0 && i[p + f * i.width] <= 0)) {
var g = s(p, r.minX),
y = s(f, r.minY),
v = er(
{ x: g, y: y },
{
x: n.minX,
y: n.minY,
width: n.width,
height: n.height,
},
);
if (v < Math.pow(o.nodeR1, 2)) {
var m = Math.sqrt(v) - o.nodeR1;
i.cells[p + f * i.width] += e * m * m;
}
}
};
o.nodeInfluenceFactor &&
t.forEach(function (t) {
l(t, o.nodeInfluenceFactor / u);
}),
o.edgeInfluenceFactor &&
n.forEach(function (t) {
!(function (t, e) {
for (
var n = t.getBBox(),
a = h(n, o.edgeR1),
u = a[0],
c = a[1],
l = a[2],
d = a[3],
f = c;
f < d;
f += 1
)
for (var p = u; p < l; p += 1)
if (!(e < 0 && i.cells[p + f * i.width] <= 0)) {
var g = s(p, r.minX),
y = s(f, r.minY),
v = Jn({ x: g, y: y }, t);
if (v < Math.pow(o.edgeR1, 2)) {
var m = Math.sqrt(v) - o.edgeR1;
i.cells[p + f * i.width] += e * m * m;
}
}
})(t, o.edgeInfluenceFactor / c);
}),
o.negativeNodeInfluenceFactor &&
e.forEach(function (t) {
l(t, o.negativeNodeInfluenceFactor / u);
});
}
function Mi(t, e, n, r) {
var i = t.getBBox(),
o = n[0],
a = n[1],
s = n[2],
u = n[3],
c = {
topLeft: { x: i.minX - e, y: i.minY - e },
topRight: { x: i.maxX + e, y: i.minY - e },
bottomLeft: { x: i.minX - e, y: i.maxY + e },
bottomRight: { x: i.maxX + e, y: i.maxY + e },
},
h = i.height * i.width;
function l(t, e) {
return i.width * (0.5 * (t.y - i.minY + (e.y - i.minY)));
}
if (a)
return o
? r
? c.topLeft
: c.bottomRight
: s
? r
? c.bottomLeft
: c.topRight
: l(a, u) < 0.5 * h
? a.y > u.y
? r
? c.topLeft
: c.bottomRight
: r
? c.topRight
: c.bottomLeft
: a.y < u.y
? r
? c.bottomLeft
: c.topRight
: r
? c.bottomRight
: c.topLeft;
if (u) {
if (o) return r ? c.topRight : c.bottomLeft;
if (s) return r ? c.bottomRight : c.topLeft;
}
return l(o, s) < 0.5 * h
? o.x > s.x
? r
? c.topLeft
: c.bottomRight
: r
? c.bottomLeft
: c.topRight
: o.x < s.x
? r
? c.topRight
: c.bottomLeft
: r
? c.bottomRight
: c.topLeft;
}
var Si = (function () {
function t(t, e) {
(this.cfg = Object(gt.d)(this.getDefaultCfg(), e)),
(this.graph = t),
(this.id = this.cfg.id),
(this.group = this.cfg.group),
(this.members = this.cfg.members.map(function (e) {
return Object(gt.x)(e) ? t.findById(e) : e;
})),
(this.nonMembers = this.cfg.nonMembers.map(function (e) {
return Object(gt.x)(e) ? t.findById(e) : e;
})),
this.setPadding(),
this.setType(),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}
return (
(t.prototype.getDefaultCfg = function () {
return {
id: "g6-hull",
type: "round-convex",
members: [],
nonMembers: [],
style: { fill: "lightblue", stroke: "blue", opacity: 0.2 },
padding: 10,
};
}),
(t.prototype.setPadding = function () {
var t =
this.members.length &&
this.members[0].getKeyShape().getCanvasBBox().width / 2;
(this.padding =
this.cfg.padding > 0 ? this.cfg.padding + t : 10 + t),
(this.cfg.bubbleCfg = {
nodeR0: this.padding - t,
nodeR1: this.padding - t,
morphBuffer: this.padding - t,
});
}),
(t.prototype.setType = function () {
(this.type = this.cfg.type),
this.members.length < 3 && (this.type = "round-convex"),
"round-convex" !== this.type &&
"smooth-convex" !== this.type &&
"bubble" !== this.type &&
(console.warn(
"The hull type should be either round-convex, smooth-convex or bubble, round-convex is used by default.",
),
(this.type = "round-convex"));
}),
(t.prototype.calcPath = function (t, e) {
var n, r, i;
switch (this.type) {
case "round-convex":
(i = fi(
(n = yi(t)).map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = Object(mt.b)(i));
break;
case "smooth-convex":
2 === (n = yi(t)).length
? ((i = fi(
n.map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = Object(mt.b)(i)))
: n.length > 2 &&
((i = pi(
n.map(function (t) {
return [t.x, t.y];
}),
this.padding,
)),
(r = ci(i)));
break;
case "bubble":
r = (n = wi(t, e, this.cfg.bubbleCfg)).length >= 2 && ci(n);
}
return r;
}),
(t.prototype.render = function () {
this.group.addShape("path", {
attrs: Object(h.a)({ path: this.path }, this.cfg.style),
id: this.id,
name: this.cfg.id,
}),
this.group.toBack();
}),
(t.prototype.addMember = function (t) {
if (t) {
Object(gt.x)(t) && (t = this.graph.findById(t)),
this.members.push(t);
var e = this.nonMembers.indexOf(t);
return (
e > -1 && this.nonMembers.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0
);
}
}),
(t.prototype.addNonMember = function (t) {
if (t) {
Object(gt.x)(t) && (t = this.graph.findById(t)),
this.nonMembers.push(t);
var e = this.members.indexOf(t);
return (
e > -1 && this.members.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0
);
}
}),
(t.prototype.removeMember = function (t) {
if (t) {
Object(gt.x)(t) && (t = this.graph.findById(t));
var e = this.members.indexOf(t);
return (
e > -1 &&
(this.members.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0)
);
}
}),
(t.prototype.removeNonMember = function (t) {
if (t) {
Object(gt.x)(t) && (t = this.graph.findById(t));
var e = this.nonMembers.indexOf(t);
return (
e > -1 &&
(this.nonMembers.splice(e, 1),
this.updateData(this.members, this.nonMembers),
!0)
);
}
}),
(t.prototype.updateData = function (t, e) {
var n = this;
this.group.findById(this.id).remove(),
t &&
(this.members = t.map(function (t) {
return Object(gt.x)(t) ? n.graph.findById(t) : t;
})),
e &&
(this.nonMembers = e.map(function (t) {
return Object(gt.x)(t) ? n.graph.findById(t) : t;
})),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}),
(t.prototype.updateStyle = function (t) {
this.group.findById(this.id).attr(Object(h.a)({}, t));
}),
(t.prototype.updateCfg = function (t) {
var e = this;
(this.cfg = Object(gt.d)(this.cfg, t)),
(this.id = this.cfg.id),
(this.group = this.cfg.group),
t.members &&
(this.members = this.cfg.members.map(function (t) {
return Object(gt.x)(t) ? e.graph.findById(t) : t;
})),
t.nonMembers &&
(this.nonMembers = this.cfg.nonMembers.map(function (t) {
return Object(gt.x)(t) ? e.graph.findById(t) : t;
})),
this.setPadding(),
this.setType(),
(this.path = this.calcPath(this.members, this.nonMembers)),
this.render();
}),
(t.prototype.contain = function (t) {
var e,
n,
r = this,
i = (e = Object(gt.x)(t)
? this.graph.findById(t)
: t).getKeyShape();
if ("path" === e.get("type")) n = ui(i.attr("path"));
else {
var o = i.getCanvasBBox();
n = [
[o.minX, o.minY],
[o.maxX, o.minY],
[o.maxX, o.maxY],
[o.minX, o.maxY],
];
}
return (
(n = n.map(function (t) {
var e = r.graph.getPointByCanvas(t[0], t[1]);
return [e.x, e.y];
})),
qn(n, ui(this.path))
);
}),
(t.prototype.destroy = function () {
this.group.remove(), (this.cfg = null);
}),
t
);
})(),
Ci = sn.a.transform;
!(function (t) {
function e(e) {
var n = t.call(this) || this;
return (
(n.cfg = Object(gt.d)(n.getDefaultCfg(), e)),
n.init(),
(n.animating = !1),
(n.destroyed = !1),
n.cfg.enabledStack &&
((n.undoStack = new On(n.cfg.maxStep)),
(n.redoStack = new On(n.cfg.maxStep))),
n
);
}
Object(h.c)(e, t),
(e.prototype.init = function () {
this.initCanvas();
var t = new Yr(this),
e = new Nr(this),
n = new ei(this),
r = new ri(this);
this.set({
viewController: t,
modeController: e,
itemController: n,
stateController: r,
}),
this.initLayoutController(),
this.initEventController(),
this.initGroups(),
this.initPlugins(),
an(this.onTick.bind(this));
}),
(e.prototype.initGroups = function () {
var t = this.get("canvas"),
e = this.get("canvas").get("el").id,
n = t.addGroup({
id: e + "-root",
className: ur.rootContainerClassName,
});
if (this.get("groupByTypes")) {
var r = n.addGroup({
id: e + "-edge",
className: ur.edgeContainerClassName,
}),
i = n.addGroup({
id: e + "-node",
className: ur.nodeContainerClassName,
}),
o = n.addGroup({
id: e + "-combo",
className: ur.comboContainerClassName,
});
o.toBack(),
this.set({ nodeGroup: i, edgeGroup: r, comboGroup: o });
}
var a = n.addGroup({
id: e + "-delegate",
className: ur.delegateContainerClassName,
});
this.set({ delegateGroup: a }), this.set("group", n);
}),
(e.prototype.getDefaultCfg = function () {
return {
container: void 0,
width: void 0,
height: void 0,
renderer: "canvas",
modes: {},
plugins: [],
data: {},
fitViewPadding: 10,
minZoom: 0.2,
maxZoom: 10,
event: !0,
groupByTypes: !0,
directed: !1,
autoPaint: !0,
nodes: [],
edges: [],
combos: [],
vedges: [],
itemMap: {},
linkCenter: !1,
defaultNode: {},
defaultEdge: {},
nodeStateStyles: {},
edgeStateStyles: {},
states: {},
animate: !1,
animateCfg: {
onFrame: void 0,
duration: 500,
easing: "easeLinear",
},
callback: void 0,
enabledStack: !1,
maxStep: 10,
tooltips: [],
};
}),
(e.prototype.set = function (t, e) {
return (
Object(gt.w)(t)
? (this.cfg = Object(h.a)(Object(h.a)({}, this.cfg), t))
: (this.cfg[t] = e),
this
);
}),
(e.prototype.get = function (t) {
return this.cfg[t];
}),
(e.prototype.getGroup = function () {
return this.get("group");
}),
(e.prototype.getContainer = function () {
return this.get("container");
}),
(e.prototype.getMinZoom = function () {
return this.get("minZoom");
}),
(e.prototype.setMinZoom = function (t) {
return this.set("minZoom", t);
}),
(e.prototype.getMaxZoom = function () {
return this.get("maxZoom");
}),
(e.prototype.setMaxZoom = function (t) {
return this.set("maxZoom", t);
}),
(e.prototype.getWidth = function () {
return this.get("width");
}),
(e.prototype.getHeight = function () {
return this.get("height");
}),
(e.prototype.clearItemStates = function (t, e) {
Object(gt.x)(t) && (t = this.findById(t));
var n = this.get("itemController");
e || (e = t.get("states")),
n.clearItemStates(t, e),
this.get("stateController").updateStates(t, e, !1);
}),
(e.prototype.node = function (t) {
"function" == typeof t && this.set("nodeMapper", t);
}),
(e.prototype.edge = function (t) {
"function" == typeof t && this.set("edgeMapper", t);
}),
(e.prototype.combo = function (t) {
"function" == typeof t && this.set("comboMapper", t);
}),
(e.prototype.findById = function (t) {
return this.get("itemMap")[t];
}),
(e.prototype.find = function (t, e) {
var n,
r = this.get(t + "s");
return (
Object(gt.e)(r, function (t, r) {
if (e(t, r)) return (n = t);
}),
n
);
}),
(e.prototype.findAll = function (t, e) {
var n = [];
return (
Object(gt.e)(this.get(t + "s"), function (t, r) {
e(t, r) && n.push(t);
}),
n
);
}),
(e.prototype.findAllByState = function (t, e) {
return this.findAll(t, function (t) {
return t.hasState(e);
});
}),
(e.prototype.translate = function (t, e) {
var n = this.get("group"),
r = Object(gt.b)(n.getMatrix());
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = Ci(r, [["t", t, e]])),
n.setMatrix(r),
this.emit("viewportchange", {
action: "translate",
matrix: n.getMatrix(),
}),
this.autoPaint();
}),
(e.prototype.moveTo = function (t, e) {
var n = this.get("group");
Rn(n, { x: t, y: e }),
this.emit("viewportchange", {
action: "move",
matrix: n.getMatrix(),
});
}),
(e.prototype.fitView = function (t) {
t && this.set("fitViewPadding", t),
this.get("viewController").fitView(),
this.autoPaint();
}),
(e.prototype.fitCenter = function () {
this.get("viewController").fitCenter(), this.autoPaint();
}),
(e.prototype.addBehaviors = function (t, e) {
return (
this.get("modeController").manipulateBehaviors(t, e, !0), this
);
}),
(e.prototype.removeBehaviors = function (t, e) {
return (
this.get("modeController").manipulateBehaviors(t, e, !1), this
);
}),
(e.prototype.updateBehavior = function (t, e, n) {
return this.get("modeController").updateBehavior(t, e, n), this;
}),
(e.prototype.zoom = function (t, e) {
var n = this.get("group"),
r = Object(gt.b)(n.getMatrix()),
i = this.get("minZoom"),
o = this.get("maxZoom");
r || (r = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(r = Ci(
r,
e
? [
["t", -e.x, -e.y],
["s", t, t],
["t", e.x, e.y],
]
: [["s", t, t]],
)),
(i && r[0] < i) ||
(o && r[0] > o) ||
(n.setMatrix(r),
this.emit("viewportchange", { action: "zoom", matrix: r }),
this.autoPaint());
}),
(e.prototype.zoomTo = function (t, e) {
var n = t / this.getZoom();
this.zoom(n, e);
}),
(e.prototype.focusItem = function (t, e, n) {
var r = this.get("viewController"),
i = !1;
e ? (i = !0) : void 0 === e && (i = this.get("animate"));
var o = {};
n ? (o = n) : void 0 === n && (o = this.get("animateCfg")),
r.focus(t, i, o),
this.autoPaint();
}),
(e.prototype.autoPaint = function () {
this.get("autoPaint") && this.paint();
}),
(e.prototype.paint = function () {
this.emit("beforepaint"),
this.get("canvas").draw(),
this.emit("afterpaint");
}),
(e.prototype.getPointByClient = function (t, e) {
return this.get("viewController").getPointByClient(t, e);
}),
(e.prototype.getClientByPoint = function (t, e) {
return this.get("viewController").getClientByPoint(t, e);
}),
(e.prototype.getPointByCanvas = function (t, e) {
return this.get("viewController").getPointByCanvas(t, e);
}),
(e.prototype.getCanvasByPoint = function (t, e) {
return this.get("viewController").getCanvasByPoint(t, e);
}),
(e.prototype.getGraphCenterPoint = function () {
var t = this.get("group").getCanvasBBox();
return { x: (t.minX + t.maxX) / 2, y: (t.minY + t.maxY) / 2 };
}),
(e.prototype.getViewPortCenterPoint = function () {
return this.getPointByCanvas(
this.get("width") / 2,
this.get("height") / 2,
);
}),
(e.prototype.showItem = function (t, e) {
void 0 === e && (e = !0);
var n = this.get("itemController").changeItemVisibility(t, !0);
if (e && this.get("enabledStack")) {
var r = n.getID(),
i = {},
o = {};
switch (n.getType()) {
case "node":
(i.nodes = [{ id: r, visible: !1 }]),
(o.nodes = [{ id: r, visible: !0 }]);
break;
case "edge":
(i.nodes = [{ id: r, visible: !1 }]),
(o.edges = [{ id: r, visible: !0 }]);
break;
case "combo":
(i.nodes = [{ id: r, visible: !1 }]),
(o.combos = [{ id: r, visible: !0 }]);
}
this.pushStack("visible", { before: i, after: o });
}
}),
(e.prototype.hideItem = function (t, e) {
void 0 === e && (e = !0);
var n = this.get("itemController").changeItemVisibility(t, !1);
if (e && this.get("enabledStack")) {
var r = n.getID(),
i = {},
o = {};
switch (n.getType()) {
case "node":
(i.nodes = [{ id: r, visible: !0 }]),
(o.nodes = [{ id: r, visible: !1 }]);
break;
case "edge":
(i.nodes = [{ id: r, visible: !0 }]),
(o.edges = [{ id: r, visible: !1 }]);
break;
case "combo":
(i.nodes = [{ id: r, visible: !0 }]),
(o.combos = [{ id: r, visible: !1 }]);
}
this.pushStack("visible", { before: i, after: o });
}
}),
(e.prototype.refreshItem = function (t) {
this.get("itemController").refreshItem(t);
}),
(e.prototype.setAutoPaint = function (t) {
this.set("autoPaint", t), this.get("canvas").set("autoDraw", t);
}),
(e.prototype.remove = function (t, e) {
void 0 === e && (e = !0), this.removeItem(t, e);
}),
(e.prototype.removeItem = function (t, e) {
void 0 === e && (e = !0);
var n = t;
if (
(Object(gt.x)(t) && (n = this.findById(t)), !n && Object(gt.x)(t))
)
console.warn("The item to be removed does not exist!");
else if (n) {
var r = "";
if (
(n.getType && (r = n.getType()), e && this.get("enabledStack"))
) {
var i = Object(h.a)(Object(h.a)({}, n.getModel()), {
itemType: r,
}),
o = {};
switch (r) {
case "node":
(o.nodes = [i]), (o.edges = []);
for (var a = n.getEdges(), s = a.length - 1; s >= 0; s--)
o.edges.push(
Object(h.a)(Object(h.a)({}, a[s].getModel()), {
itemType: "edge",
}),
);
break;
case "edge":
o.edges = [i];
break;
case "combo":
o.combos = [i];
}
this.pushStack("delete", { before: o, after: {} });
}
if ("node" === r) n.getModel().comboId && this.updateComboTree(n);
if ((this.get("itemController").removeItem(n), "combo" === r)) {
var u = Sr(this.get("comboTrees"));
this.set("comboTrees", u);
}
}
}),
(e.prototype.addItem = function (t, e, n, r) {
void 0 === n && (n = !0), void 0 === r && (r = !0);
var i = this.get("comboSorted");
this.set("comboSorted", i && !r);
var o = this.get("itemController");
if (
!(function (t, e) {
if ("node" === t || "combo" === t) {
if (e.id && !Object(gt.x)(e.id))
return (
console.warn(
"G6 Warning Tips: missing 'id' property, or the 'id' %c" +
e.id +
"%c is not a string.",
"font-size: 20px; color: red;",
"",
),
!1
);
} else if (!("edge" !== t || (e.source && e.target)))
return (
console.warn(
"G6 Warning Tips: missing 'source' or 'target' for the edge.",
),
!1
);
return !0;
})(t, e)
)
return !1;
if (!e.id || !this.findById(e.id)) {
var a,
s = this.get("comboTrees");
if ((s || (s = []), "combo" === t)) {
var u = this.get("itemMap"),
c = !1;
if (
(s.forEach(function (n) {
c ||
xr(n, function (n) {
if (e.parentId === n.id) {
c = !0;
var r = Object(h.a)(
{ id: e.id, depth: n.depth + 2 },
e,
);
n.children ? n.children.push(r) : (n.children = [r]),
(e.depth = r.depth),
(a = o.addItem(t, e));
}
var i = u[n.id];
return (
c &&
i &&
i.getType &&
"combo" === i.getType() &&
o.updateCombo(i, n.children),
!0
);
});
}),
!c)
) {
var l = Object(h.a)({ id: e.id, depth: 0 }, e);
(e.depth = l.depth), s.push(l), (a = o.addItem(t, e));
}
this.set("comboTrees", s);
} else if ("node" === t && Object(gt.x)(e.comboId) && s) {
var d;
(d = this.findById(e.comboId)) &&
d.getType &&
"combo" !== d.getType() &&
console.warn(
"'" +
e.comboId +
"' is not a id of a combo in the graph, the node will be added without combo.",
),
(a = o.addItem(t, e));
var f = this.get("itemMap"),
p = !1,
g = !1;
(s || []).forEach(function (t) {
g ||
p ||
xr(t, function (t) {
if (t.id === e.id) return (g = !0), !1;
if (e.comboId === t.id && !g) {
p = !0;
var n = Object(gt.b)(e);
(n.itemType = "node"),
t.children ? t.children.push(n) : (t.children = [n]),
(n.depth = t.depth + 1);
}
return (
p &&
f[t.id].getType &&
"combo" === f[t.id].getType() &&
o.updateCombo(f[t.id], t.children),
!0
);
});
});
} else a = o.addItem(t, e);
if (("node" === t && e.comboId) || ("combo" === t && e.parentId))
(d = this.findById(e.comboId || e.parentId)) &&
d.getType &&
"combo" === d.getType() &&
d.addChild(a);
var y = this.get("combos");
if (
(y && y.length > 0 && this.sortCombos(),
this.autoPaint(),
n && this.get("enabledStack"))
) {
var v = Object(h.a)(Object(h.a)({}, a.getModel()), {
itemType: t,
}),
m = {};
switch (t) {
case "node":
m.nodes = [v];
break;
case "edge":
m.edges = [v];
break;
case "combo":
m.combos = [v];
}
this.pushStack("add", { before: {}, after: m });
}
return a;
}
console.warn(
"This item exists already. Be sure the id %c" +
e.id +
"%c is unique.",
"font-size: 20px; color: red;",
"",
);
}),
(e.prototype.add = function (t, e, n, r) {
return (
void 0 === n && (n = !0),
void 0 === r && (r = !0),
this.addItem(t, e, n, r)
);
}),
(e.prototype.updateItem = function (t, e, n) {
var r = this;
void 0 === n && (n = !0);
var i,
o = this.get("itemController");
i = Object(gt.x)(t) ? this.findById(t) : t;
var a = Object(gt.b)(i.getModel()),
s = "";
i.getType && (s = i.getType());
var u = Object(h.f)([], i.getStates());
if (
("combo" === s &&
Object(gt.e)(u, function (t) {
return r.setItemState(i, t, !1);
}),
o.updateItem(i, e),
"combo" === s &&
Object(gt.e)(u, function (t) {
return r.setItemState(i, t, !0);
}),
n && this.get("enabledStack"))
) {
var c = { nodes: [], edges: [], combos: [] },
l = { nodes: [], edges: [], combos: [] },
d = Object(h.a)({ id: a.id }, e);
switch (s) {
case "node":
c.nodes.push(a), l.nodes.push(d);
break;
case "edge":
c.edges.push(a), l.edges.push(d);
break;
case "combo":
c.combos.push(a), l.combos.push(d);
}
"node" === s && c.nodes.push(a),
this.pushStack("update", { before: c, after: l });
}
}),
(e.prototype.update = function (t, e, n) {
void 0 === n && (n = !0), this.updateItem(t, e, n);
}),
(e.prototype.setItemState = function (t, e, n) {
Object(gt.x)(t) && (t = this.findById(t)),
this.get("itemController").setItemState(t, e, n);
var r = this.get("stateController");
Object(gt.x)(n)
? r.updateState(t, e + ":" + n, !0)
: r.updateState(t, e, n);
}),
(e.prototype.priorityState = function (t, e) {
this.get("itemController").priorityState(t, e);
}),
(e.prototype.data = function (t) {
Er(t), this.set("data", t);
}),
(e.prototype.render = function () {
var t = this;
this.set("comboSorted", !1);
var e = this.get("data");
if ((this.get("enabledStack") && this.clearStack(), !e))
throw new Error("data must be defined first");
var n = e.nodes,
r = void 0 === n ? [] : n,
i = e.edges,
o = void 0 === i ? [] : i,
a = e.combos,
s = void 0 === a ? [] : a;
if (
(this.clear(!0),
this.emit("beforerender"),
Object(gt.e)(r, function (e) {
t.add("node", e, !1, !1);
}),
s && 0 !== s.length)
) {
var u = Mr(s, r);
this.set("comboTrees", u), t.addCombos(s);
}
Object(gt.e)(o, function (e) {
t.add("edge", e, !1, !1);
});
var c = t.get("animate");
(t.get("fitView") || t.get("fitCenter")) && t.set("animate", !1);
var h = t.get("layoutController");
if (h) {
if (
(h.layout(function () {
t.get("fitView")
? t.fitView()
: t.get("fitCenter") && t.fitCenter();
t.autoPaint(),
t.emit("afterrender"),
(t.get("fitView") || t.get("fitCenter")) &&
t.set("animate", c);
}),
this.refreshPositions(),
this.destroyed)
)
return;
} else
t.get("fitView") && t.fitView(),
t.get("fitCenter") && t.fitCenter(),
t.emit("afterrender"),
t.set("animate", c);
this.get("groupByTypes") ||
(s && 0 !== s.length
? this.sortCombos()
: e.nodes && e.edges && e.nodes.length < e.edges.length
? this.getNodes().forEach(function (t) {
t.toFront();
})
: this.getEdges().forEach(function (t) {
t.toBack();
}));
this.get("enabledStack") && this.pushStack("render");
}),
(e.prototype.read = function (t) {
this.data(t), this.render();
}),
(e.prototype.diffItems = function (t, e, n) {
var r,
i = this,
o = this.get("itemMap");
Object(gt.e)(n, function (n) {
if ((r = o[n.id])) {
if (i.get("animate") && "node" === t) {
var a = r.getContainer().getMatrix();
a || (a = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
r.set("originAttrs", { x: a[6], y: a[7] });
}
i.updateItem(r, n, !1);
} else r = i.addItem(t, n, !1);
r && e[t + "s"].push(r);
});
}),
(e.prototype.changeData = function (t, e) {
void 0 === e && (e = !0);
var n = this;
if (!Er(t)) return this;
e &&
this.get("enabledStack") &&
this.pushStack("changedata", { before: n.save(), after: t }),
this.set("comboSorted", !1),
this.removeHulls(),
this.getNodes().map(function (t) {
return n.clearItemStates(t);
}),
this.getEdges().map(function (t) {
return n.clearItemStates(t);
});
var r = this.get("canvas"),
i = r.get("localRefresh");
r.set("localRefresh", !1), n.get("data") || (n.data(t), n.render());
var o = this.get("itemMap"),
a = { nodes: [], edges: [] },
s = t.combos;
if (s) {
var u = Mr(s, t.nodes);
this.set("comboTrees", u);
}
this.diffItems("node", a, t.nodes),
Object(gt.e)(o, function (t, e) {
(o[e].getModel().depth = 0),
(t.getType && "edge" === t.getType()) ||
(t.getType && "combo" === t.getType()
? (delete o[e], t.destroy())
: a.nodes.indexOf(t) < 0 &&
(delete o[e], n.remove(t, !1)));
});
for (var c = this.getCombos(), h = c.length - 1; h >= 0; h--)
c[h].destroyed && c.splice(h, 1);
s &&
(n.addCombos(s), this.get("groupByTypes") || this.sortCombos()),
this.diffItems("edge", a, t.edges),
Object(gt.e)(o, function (t, e) {
(!t.getType ||
("node" !== t.getType() && "combo" !== t.getType())) &&
a.edges.indexOf(t) < 0 &&
(delete o[e], n.remove(t, !1));
}),
this.set({ nodes: a.nodes, edges: a.edges });
var l = this.get("layoutController");
return (
l &&
(l.changeData(),
n.get("animate") && !l.getLayoutType()
? n.positionsAnimate()
: n.autoPaint()),
setTimeout(function () {
r.set("localRefresh", i);
}, 16),
this
);
}),
(e.prototype.addCombos = function (t) {
var e = this.get("comboTrees");
this.get("itemController").addCombos(e, t);
}),
(e.prototype.createCombo = function (t, e) {
var n = this;
this.set("comboSorted", !1);
var r,
i = "";
if (t) {
if (Object(gt.x)(t)) (i = t), (r = { id: t });
else {
if (!(i = t.id))
return void console.warn(
"Create combo failed. Please assign a unique string id for the adding combo.",
);
r = t;
}
var o = e.map(function (t) {
var e = n.findById(t),
r = e.getModel(),
o = "";
e.getType && (o = e.getType());
var a = { id: e.getID(), itemType: o };
return (
"combo" === o
? ((a.parentId = i), (r.parentId = i))
: "node" === o && ((a.comboId = i), (r.comboId = i)),
a
);
});
(r.children = o),
this.addItem("combo", r, !1),
this.set("comboSorted", !1);
var a = this.get("comboTrees");
(a || []).forEach(function (t) {
xr(t, function (t) {
return (
t.id !== i || ((t.itemType = "combo"), (t.children = o), !1)
);
});
}),
a && this.sortCombos();
}
}),
(e.prototype.uncombo = function (t) {
var e = this,
n = t;
if (
(Object(gt.x)(t) && (n = this.findById(t)),
!n || (n.getType && "combo" !== n.getType()))
)
console.warn("The item is not a combo!");
else {
var r = n.getModel().parentId,
i = this.get("comboTrees");
i || (i = []);
var o,
a = this.get("itemMap"),
s = n.get("id"),
u = [],
c = this.get("combos"),
h = this.findById(r);
if (
(i.forEach(function (i) {
o ||
xr(i, function (i) {
if (i.id === s) {
(o = i),
n.getEdges().forEach(function (t) {
e.removeItem(t, !1);
});
var l = c.indexOf(t);
c.splice(l, 1), delete a[s], n.destroy();
}
return (
!r ||
!o ||
i.id !== r ||
(h.removeCombo(n),
-1 !== (l = (u = i.children).indexOf(o)) &&
u.splice(l, 1),
o.children.forEach(function (t) {
var n = e.findById(t.id),
i = n.getModel();
n.getType && "combo" === n.getType()
? ((t.parentId = r),
delete t.comboId,
(i.parentId = r),
delete i.comboId)
: n.getType &&
"node" === n.getType() &&
((t.comboId = r), (i.comboId = r)),
h.addChild(n),
u.push(t);
}),
!1)
);
});
}),
!r && o)
) {
var l = i.indexOf(o);
i.splice(l, 1),
o.children.forEach(function (t) {
t.parentId = void 0;
var n = e.findById(t.id).getModel();
delete n.parentId,
delete n.comboId,
"node" !== t.itemType && i.push(t);
});
}
}
}),
(e.prototype.updateCombos = function () {
var t = this,
e = this.get("comboTrees"),
n = this.get("itemController"),
r = this.get("itemMap");
(e || []).forEach(function (e) {
xr(e, function (e) {
if (!e) return !0;
var i = r[e.id];
if (i && i.getType && "combo" === i.getType()) {
var o = Object(h.f)([], i.getStates());
Object(gt.e)(o, function (e) {
return t.setItemState(i, e, !1);
}),
n.updateCombo(i, e.children),
Object(gt.e)(o, function (e) {
return t.setItemState(i, e, !0);
});
}
return !0;
});
}),
this.sortCombos();
}),
(e.prototype.updateCombo = function (t) {
var e,
n = this,
r = t;
if (
(Object(gt.x)(t) && (r = this.findById(t)),
!r || (r.getType && "combo" !== r.getType()))
)
console.warn("The item to be updated is not a combo!");
else {
e = r.get("id");
var i = this.get("comboTrees"),
o = this.get("itemController"),
a = this.get("itemMap");
(i || []).forEach(function (t) {
xr(t, function (t) {
if (!t) return !0;
var r = a[t.id];
if (e === t.id && r && r.getType && "combo" === r.getType()) {
var i = Object(h.f)([], r.getStates());
Object(gt.e)(i, function (t) {
r.getStateStyle(t) && n.setItemState(r, t, !1);
}),
o.updateCombo(r, t.children),
Object(gt.e)(i, function (t) {
r.getStateStyle(t) && n.setItemState(r, t, !0);
}),
e && (e = t.parentId);
}
return !0;
});
});
}
}),
(e.prototype.updateComboTree = function (t, e, n) {
void 0 === n && (n = !0);
var r;
this.set("comboSorted", !1);
var i,
o = (r = Object(gt.x)(t) ? this.findById(t) : t).getModel(),
a = o.comboId || o.parentId,
s = "";
if ((r.getType && (s = r.getType()), e && "combo" === s)) {
var u,
c = this.get("comboTrees"),
h = !0;
if (
((c || []).forEach(function (t) {
u ||
br(t, function (t) {
if (!u) return t.id === r.getID() && (u = t), !0;
});
}),
br(u, function (t) {
return t.id !== e || ((h = !1), !1);
}),
!h)
)
return void console.warn(
"Failed to update the combo tree! The parentId points to a descendant of the combo!",
);
}
if (n && this.get("enabledStack")) {
var l = {},
d = {};
"combo" === s
? ((l.combos = [{ id: o.id, parentId: o.parentId }]),
(d.combos = [{ id: o.id, parentId: e }]))
: "node" === s &&
((l.nodes = [{ id: o.id, parentId: o.comboId }]),
(d.nodes = [{ id: o.id, parentId: e }])),
this.pushStack("updateComboTree", { before: l, after: d });
}
if (o.parentId || o.comboId) {
var f = this.findById(o.parentId || o.comboId);
f && f.removeChild(r);
}
("combo" === s ? (o.parentId = e) : "node" === s && (o.comboId = e),
e) &&
(i = this.findById(e)) &&
i.addChild(r);
a && (i = this.findById(a)) && i.removeChild(r);
var p = Sr(this.get("comboTrees"), o.id, e);
this.set("comboTrees", p), this.updateCombos();
}),
(e.prototype.save = function () {
var t = [],
e = [],
n = [];
return (
Object(gt.e)(this.get("nodes"), function (e) {
t.push(e.getModel());
}),
Object(gt.e)(this.get("edges"), function (t) {
e.push(t.getModel());
}),
Object(gt.e)(this.get("combos"), function (t) {
n.push(t.getModel());
}),
{ nodes: t, edges: e, combos: n }
);
}),
(e.prototype.changeSize = function (t, e) {
return this.get("viewController").changeSize(t, e), this;
}),
(e.prototype.refresh = function () {
if ((this.emit("beforegraphrefresh"), this.get("animate")))
this.positionsAnimate();
else {
var t = this.get("nodes"),
e = this.get("edges"),
n = this.get("edges");
Object(gt.e)(t, function (t) {
t.refresh();
}),
Object(gt.e)(e, function (t) {
t.refresh();
}),
Object(gt.e)(n, function (t) {
t.refresh();
});
}
this.emit("aftergraphrefresh"), this.autoPaint();
}),
(e.prototype.getNodes = function () {
return this.get("nodes");
}),
(e.prototype.getEdges = function () {
return this.get("edges");
}),
(e.prototype.getCombos = function () {
return this.get("combos");
}),
(e.prototype.getComboChildren = function (t) {
if (
(Object(gt.x)(t) && (t = this.findById(t)),
t && (!t.getType || "combo" === t.getType()))
)
return t.getChildren();
console.warn("The combo does not exist!");
}),
(e.prototype.positionsAnimate = function () {
var t = this;
t.emit("beforeanimate");
var e = t.get("animateCfg"),
n = e.onFrame,
r = t.getNodes(),
i = r.map(function (t) {
var e = t.getModel();
return { id: e.id, x: e.x, y: e.y };
});
t.isAnimating() && t.stopAnimate(),
t.get("canvas").animate(
function (e) {
Object(gt.e)(i, function (r) {
var i = t.findById(r.id);
if (i && !i.destroyed) {
var o = i.get("originAttrs"),
a = i.get("model");
if (!o) {
var s = i.getContainer().getMatrix();
s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]),
(o = { x: s[6], y: s[7] }),
i.set("originAttrs", o);
}
if (n) {
var u = n(i, e, r, o);
i.set("model", Object.assign(a, u));
} else
(a.x = o.x + (r.x - o.x) * e),
(a.y = o.y + (r.y - o.y) * e);
}
}),
t.refreshPositions();
},
{
duration: e.duration,
easing: e.easing,
callback: function () {
Object(gt.e)(r, function (t) {
t.set("originAttrs", null);
}),
e.callback && e.callback(),
t.emit("afteranimate"),
(t.animating = !1);
},
},
);
}),
(e.prototype.refreshPositions = function () {
this.emit("beforegraphrefreshposition");
var t,
e = this.get("nodes"),
n = this.get("edges"),
r = this.get("vedges"),
i = this.get("combos"),
o = {};
Object(gt.e)(e, function (e) {
t = e.getModel();
var n = e.get("originAttrs");
if (!n || t.x !== n.x || t.y !== n.y) {
var r = e.updatePosition({ x: t.x, y: t.y });
(o[t.id] = r), t.comboId && (o[t.comboId] = o[t.comboId] || r);
}
}),
i && 0 !== i.length && this.updateCombos(),
Object(gt.e)(n, function (t) {
var e = t.getSource().getModel(),
n = t.getTarget();
if (!Object(gt.w)(n)) {
var r = n.getModel();
(o[e.id] || o[r.id] || t.getModel().isComboEdge) &&
t.refresh();
}
}),
Object(gt.e)(r, function (t) {
t.refresh();
}),
this.emit("aftergraphrefreshposition"),
this.autoPaint();
}),
(e.prototype.stopAnimate = function () {
this.get("canvas").stopAnimate();
}),
(e.prototype.isAnimating = function () {
return this.animating;
}),
(e.prototype.getZoom = function () {
var t = this.get("group").getMatrix();
return t ? t[0] : 1;
}),
(e.prototype.getCurrentMode = function () {
return this.get("modeController").getMode();
}),
(e.prototype.setMode = function (t) {
return this.get("modeController").setMode(t), this;
}),
(e.prototype.clear = function (t) {
return (
void 0 === t && (t = !1),
this.get("canvas").clear(),
this.initGroups(),
this.set({
itemMap: {},
nodes: [],
edges: [],
groups: [],
combos: [],
comboTrees: [],
}),
t || this.emit("afterrender"),
this
);
}),
(e.prototype.updateLayout = function (t) {
var e = this.get("layoutController");
Object(gt.x)(t) && (t = { type: t });
var n = this.get("layout"),
r = {};
Object.assign(r, n, t),
this.set("layout", r),
e.isLayoutTypeSame(r) && r.gpuEnabled === n.gpuEnabled
? e.updateLayoutCfg(r)
: e.changeLayout(r);
}),
(e.prototype.destroyLayout = function () {
this.get("layoutController").destroyLayout();
}),
(e.prototype.layout = function () {
var t = this.get("layoutController"),
e = this.get("layout");
e &&
t &&
(e.workerEnabled
? t.layout()
: t.layoutMethod
? t.relayout(!0)
: t.layout());
}),
(e.prototype.collapseCombo = function (t) {
var e = this;
if ((Object(gt.x)(t) && (t = this.findById(t)), t)) {
this.emit("beforecollapseexpandcombo", {
action: "expand",
item: t,
});
var n = t.getModel();
this.get("itemController").collapseCombo(t), (n.collapsed = !0);
var r = this.getEdges().concat(this.get("vedges")),
i = [],
o = [],
a = this.get("comboTrees"),
s = !1;
(a || []).forEach(function (t) {
s ||
br(t, function (t) {
if (s && t.depth <= n.depth) return !1;
if ((n.id === t.id && (s = !0), s)) {
var r = e.findById(t.id);
r &&
r.getType &&
"combo" === r.getType() &&
((i = i.concat(r.getNodes())),
(o = o.concat(r.getCombos())));
}
return !0;
});
});
var u = {},
c = [];
r.forEach(function (t) {
if (!t.isVisible() || t.getModel().isVEdge) {
var r = t.getSource(),
a = t.getTarget();
if (
((i.includes(r) || o.includes(r)) &&
!i.includes(a) &&
!o.includes(a)) ||
r.getModel().id === n.id
) {
if ((d = t.getModel()).isVEdge)
return void e.removeItem(t, !1);
for (var s = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(s.parentId || s.comboId)) ||
(!s.parentId && !s.comboId)
)
return;
s = a.getModel();
}
var h = s.id;
if (u[n.id + "-" + h])
return void (u[n.id + "-" + h] += d.size || 1);
var l = e.addItem(
"vedge",
{ source: n.id, target: h, isVEdge: !0 },
!1,
);
(u[n.id + "-" + h] = d.size || 1), c.push(l);
} else if (
(!i.includes(r) &&
!o.includes(r) &&
(i.includes(a) || o.includes(a))) ||
a.getModel().id === n.id
) {
var d;
if ((d = t.getModel()).isVEdge)
return void e.removeItem(t, !1);
for (var f = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(f.parentId || f.comboId)) ||
(!f.parentId && !f.comboId)
)
return;
f = r.getModel();
}
var p = f.id;
if (u[p + "-" + n.id])
return void (u[p + "-" + n.id] += d.size || 1);
l = e.addItem(
"vedge",
{ target: n.id, source: p, isVEdge: !0 },
!1,
);
(u[p + "-" + n.id] = d.size || 1), c.push(l);
}
}
}),
c.forEach(function (t) {
var n = t.getModel();
e.updateItem(t, { size: u[n.source + "-" + n.target] }, !1);
}),
this.emit("aftercollapseexpandcombo", {
action: "collapse",
item: t,
});
} else console.warn("The combo to be collapsed does not exist!");
}),
(e.prototype.expandCombo = function (t) {
var e = this;
if (
(Object(gt.x)(t) && (t = this.findById(t)),
!t || (t.getType && "combo" !== t.getType()))
)
console.warn("The combo to be collapsed does not exist!");
else {
this.emit("beforecollapseexpandcombo", {
action: "expand",
item: t,
});
var n = t.getModel();
this.get("itemController").expandCombo(t), (n.collapsed = !1);
var r = this.getEdges().concat(this.get("vedges")),
i = [],
o = [],
a = this.get("comboTrees"),
s = !1;
(a || []).forEach(function (t) {
s ||
br(t, function (t) {
if (s && t.depth <= n.depth) return !1;
if ((n.id === t.id && (s = !0), s)) {
var r = e.findById(t.id);
r &&
r.getType &&
"combo" === r.getType() &&
((i = i.concat(r.getNodes())),
(o = o.concat(r.getCombos())));
}
return !0;
});
});
var u = {},
c = {};
r.forEach(function (t) {
if (!t.isVisible() || t.getModel().isVEdge) {
var r = t.getSource(),
a = t.getTarget(),
s = r.get("id"),
h = a.get("id");
if (
((i.includes(r) || o.includes(r)) &&
!i.includes(a) &&
!o.includes(a)) ||
s === n.id
) {
if (t.getModel().isVEdge) return void e.removeItem(t, !1);
for (var l = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(l.comboId || l.parentId)) ||
(!l.parentId && !l.comboId)
)
return;
l = a.getModel();
}
h = l.id;
for (var d = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(d.comboId || d.parentId)) ||
(!d.parentId && !d.comboId)
)
return;
if (d.comboId === n.id || d.parentId === n.id) break;
d = r.getModel();
}
if (((s = d.id), h)) {
if (u[(p = s + "-" + h)])
return (
(u[p] += t.getModel().size || 1),
void e.updateItem(c[p], { size: u[p] }, !1)
);
var f = e.addItem(
"vedge",
{ source: s, target: h, isVEdge: !0 },
!1,
);
(u[p] = t.getModel().size || 1), (c[p] = f);
}
} else if (
(!i.includes(r) &&
!o.includes(r) &&
(i.includes(a) || o.includes(a))) ||
h === n.id
) {
if (t.getModel().isVEdge) return void e.removeItem(t, !1);
for (d = r.getModel(); !r.isVisible(); ) {
if (
!(r = e.findById(d.comboId || d.parentId)) ||
(!d.parentId && !d.comboId)
)
return;
d = r.getModel();
}
s = d.id;
for (l = a.getModel(); !a.isVisible(); ) {
if (
!(a = e.findById(l.comboId || l.parentId)) ||
(!l.parentId && !l.comboId)
)
return;
if (l.comboId === n.id || l.parentId === n.id) break;
l = a.getModel();
}
if (((h = l.id), s)) {
var p;
if (u[(p = s + "-" + h)])
return (
(u[p] += t.getModel().size || 1),
void e.updateItem(c[p], { size: u[p] }, !1)
);
f = e.addItem(
"vedge",
{ target: h, source: s, isVEdge: !0 },
!1,
);
(u[p] = t.getModel().size || 1), (c[p] = f);
}
} else
(i.includes(r) || o.includes(r)) &&
(i.includes(a) || o.includes(a)) &&
r.isVisible() &&
a.isVisible() &&
t.show();
}
}),
this.emit("aftercollapseexpandcombo", {
action: "expand",
item: t,
});
}
}),
(e.prototype.collapseExpandCombo = function (t) {
if (
(Object(gt.x)(t) && (t = this.findById(t)),
t && (!t.getType || "combo" === t.getType()))
) {
for (var e = t.getModel(), n = this.findById(e.parentId); n; ) {
var r = n.getModel();
if (r.collapsed)
return (
console.warn(
"Fail to expand the combo since it's ancestor combo is collapsed.",
),
void (n = void 0)
);
n = this.findById(r.parentId);
}
e.collapsed ? this.expandCombo(t) : this.collapseCombo(t),
this.updateCombo(t);
}
}),
(e.prototype.sortCombos = function () {
var t = this;
if (!this.get("comboSorted")) {
this.set("comboSorted", !0);
var e = [],
n = {};
(this.get("comboTrees") || []).forEach(function (t) {
br(t, function (t) {
return (
e[t.depth] ? e[t.depth].push(t.id) : (e[t.depth] = [t.id]),
(n[t.id] = t.depth),
!0
);
});
}),
(this.getEdges().concat(this.get("vedges")) || []).forEach(
function (t) {
var r = t.getModel(),
i = n[r.source] || 0,
o = n[r.target] || 0,
a = Math.max(i, o);
e[a] ? e[a].push(r.id) : (e[a] = [r.id]);
},
),
e.forEach(function (e) {
if (e && e.length)
for (var n = e.length - 1; n >= 0; n--) {
var r = t.findById(e[n]);
r && r.toFront();
}
});
}
}),
(e.prototype.getNeighbors = function (t, e) {
var n = t;
return Object(gt.x)(t) && (n = this.findById(t)), n.getNeighbors(e);
}),
(e.prototype.getNodeDegree = function (t, e, n) {
void 0 === e && (e = void 0), void 0 === n && (n = !1);
var r = t;
Object(gt.x)(t) && (r = this.findById(t));
var i = this.get("degrees");
(i && !n) || ((i = fn(this.save())), this.set("degrees", i));
var o = i[r.getID()],
a = 0;
if (!o) return 0;
switch (e) {
case "in":
a = o.inDegree;
break;
case "out":
a = o.outDegree;
break;
case "all":
a = o;
break;
default:
a = o.degree;
}
return a;
}),
(e.prototype.getUndoStack = function () {
return this.undoStack;
}),
(e.prototype.getRedoStack = function () {
return this.redoStack;
}),
(e.prototype.getStackData = function () {
return this.get("enabledStack")
? {
undoStack: this.undoStack.toArray(),
redoStack: this.redoStack.toArray(),
}
: null;
}),
(e.prototype.clearStack = function () {
this.get("enabledStack") &&
(this.undoStack.clear(), this.redoStack.clear());
}),
(e.prototype.pushStack = function (t, e, n) {
if (
(void 0 === t && (t = "update"),
void 0 === n && (n = "undo"),
this.get("enabledStack"))
) {
var r = e
? Object(gt.b)(e)
: { before: {}, after: Object(gt.b)(this.save()) };
"redo" === n
? this.redoStack.push({ action: t, data: r })
: this.undoStack.push({ action: t, data: r }),
this.emit("stackchange", {
undoStack: this.undoStack,
redoStack: this.redoStack,
});
} else
console.warn(
"请先启用 undo & redo 功能，在实例化 Graph 时候配置 enabledStack: true !",
);
}),
(e.prototype.getAdjMatrix = function (t, e) {
void 0 === t && (t = !0),
void 0 === e && (e = this.get("directed"));
var n = this.get("adjMatrix");
return (
(n && t) || ((n = un(this.save(), e)), this.set("adjMatrix", n)),
n
);
}),
(e.prototype.getShortestPathMatrix = function (t, e) {
void 0 === t && (t = !0),
void 0 === e && (e = this.get("directed"));
var n = this.get("adjMatrix"),
r = this.get("shortestPathMatrix");
return (
(n && t) || ((n = un(this.save(), e)), this.set("adjMatrix", n)),
(r && t) ||
((r = pn(this.save(), e)), this.set("shortestPathMatrix", r)),
r
);
}),
(e.prototype.on = function (e, n, r) {
return t.prototype.on.call(this, e, n, r);
}),
(e.prototype.destroy = function () {
this.clear(),
this.clearStack(),
this.get("itemController").destroy(),
this.get("modeController").destroy(),
this.get("viewController").destroy(),
this.get("stateController").destroy(),
this.get("canvas").destroy(),
(this.cfg = null),
(this.destroyed = !0),
(this.redoStack = null),
(this.undoStack = null);
}),
(e.prototype.createHull = function (t) {
if (t.members && !(t.members.length < 1)) {
var e = this.get("hullGroup"),
n = this.get("hullMap");
if (
(n || ((n = {}), this.set("hullMap", n)),
(e && !e.get("destroyed")) ||
((e = this.get("group").addGroup({
id: "hullGroup",
})).toBack(),
this.set("hullGroup", e)),
n[t.id])
)
return console.warn("Existed hull id."), n[t.id];
var r = e.addGroup({ id: t.id + "-container" }),
i = new Si(this, Object(h.a)(Object(h.a)({}, t), { group: r }));
return (n[i.id] = i), i;
}
console.warn("Create hull failed! The members is empty.");
}),
(e.prototype.getHulls = function () {
return this.get("hullMap");
}),
(e.prototype.getHullById = function (t) {
return this.get("hullMap")[t];
}),
(e.prototype.removeHull = function (t) {
var e;
(e = Object(gt.x)(t) ? this.getHullById(t) : t),
delete this.get("hullMap")[e.id],
e.destroy();
}),
(e.prototype.removeHulls = function () {
var t = this.getHulls();
t &&
Object.keys(t).length &&
(Object.keys(t).forEach(function (e) {
t[e].destroy();
}),
this.set("hullMap", {}));
}),
(e.prototype.onTick = function (t) {
this.get("layoutController").onTick(t), an(this.onTick.bind(this));
});
})(nn.a);
function ji(t) {
return (ji =
"function" == typeof Symbol && "symbol" == typeof Symbol.iterator
? function (t) {
return typeof t;
}
: function (t) {
return t &&
"function" == typeof Symbol &&
t.constructor === Symbol &&
t !== Symbol.prototype
? "symbol"
: typeof t;
})(t);
}
var ki = sn.a.transform,
Ei = ["startArrow", "endArrow"],
Ni = {
lineWidth: 1,
stroke: void 0,
fill: void 0,
lineAppendWidth: 1,
opacity: void 0,
strokeOpacity: void 0,
fillOpacity: void 0,
x: 0,
y: 0,
r: 10,
width: 20,
height: 20,
shadowColor: void 0,
shadowBlur: 0,
shadowOffsetX: 0,
shadowOffsetY: 0,
},
Ti = {
edge: {
lineWidth: 1,
stroke: "#000",
lineDash: void 0,
startArrow: !1,
endArrow: !1,
opacity: void 0,
strokeOpacity: void 0,
fillOpacity: void 0,
shadowColor: void 0,
shadowBlur: 0,
shadowOffsetX: 0,
shadowOffsetY: 0,
},
node: Ni,
combo: Ni,
},
Pi = {
options: {},
itemType: "",
type: "",
getCustomConfig: function (t) {
return {};
},
getOptions: function (t) {
return Object(gt.d)(
{
labelCfg: {
style: {
fontFamily:
("undefined" != typeof window &&
window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif",
},
},
descriptionCfg: {
style: {
fontFamily:
("undefined" != typeof window &&
window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif",
},
},
},
this.options,
this.getCustomConfig(t) || {},
t,
);
},
draw: function (t, e) {
var n = this.drawShape(t, e);
(n.set("className", this.itemType + "-shape"), t.label) &&
this.drawLabel(t, e).set("className", this.itemType + "-label");
return n;
},
afterDraw: function (t, e, n) {},
drawShape: function (t, e) {
return null;
},
drawLabel: function (t, e) {
var n = this.getOptions(t).labelCfg || {},
r = this.getLabelStyle(t, n, e),
i = r.rotate;
delete r.rotate;
var o = e.addShape("text", {
attrs: r,
draggable: !0,
className: "text-shape",
name: "text-shape",
});
if (i) {
var a = o.getBBox(),
s = o.getMatrix();
if ((s || (s = [1, 0, 0, 0, 1, 0, 0, 0, 1]), r.rotateCenter))
switch (r.rotateCenter) {
case "center":
s = ki(s, [
["t", -a.width / 2, -a.height / 2],
["r", i],
["t", a.width / 2, a.height / 2],
]);
break;
case "lefttop":
s = ki(s, [
["t", -r.x, -r.y],
["r", i],
["t", r.x, r.y],
]);
break;
case "leftcenter":
s = ki(s, [
["t", -r.x, -r.y - a.height / 2],
["r", i],
["t", r.x, r.y + a.height / 2],
]);
break;
default:
s = ki(s, [
["t", -a.width / 2, -a.height / 2],
["r", i],
["t", a.width / 2, a.height / 2],
]);
}
else
s = ki(s, [
["t", -r.x, -r.y - a.height / 2],
["r", i],
["t", r.x, r.y + a.height / 2],
]);
o.setMatrix(s);
}
if (r.background) {
var u = this.drawLabelBg(t, e, o),
c = this.itemType + "-label-bg";
u.set("classname", c), o.toFront();
}
return o;
},
drawLabelBg: function (t, e, n) {
var r = this.options.labelCfg,
i = Object(gt.C)({}, r, t.labelCfg),
o = this.getLabelBgStyleByPosition(n, t, i, e);
return e.addShape("rect", { name: "text-bg-shape", attrs: o });
},
getLabelStyleByPosition: function (t, e, n) {
return { text: t.label };
},
getLabelBgStyleByPosition: function (t, e, n, r) {
return {};
},
getLabelStyle: function (t, e, n) {
var r = this.getLabelStyleByPosition(t, e, n),
i = this.itemType + "Label",
o = ur[i] ? ur[i].style : null;
return Object(h.a)(Object(h.a)(Object(h.a)({}, o), r), e.style);
},
getShapeStyle: function (t) {
return t.style;
},
update: function (t, e) {
this.updateShapeStyle(t, e), this.updateLabel(t, e);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = e.getKeyShape(),
i = Object(gt.C)({}, r.attr(), t.style),
o = function (t) {
var e,
o = i[t];
if (Object(gt.w)(o)) {
var a = n.find(function (e) {
return e.get("name") === t;
});
a && a.attr(o);
} else r.attr((((e = {})[t] = o), e));
};
for (var a in i) o(a);
},
updateLabel: function (t, e) {
var n = e.getContainer(),
r = this.getOptions({}).labelCfg,
i = this.itemType + "-label",
o = n.find(function (t) {
return t.get("className") === i;
}),
a = this.itemType + "-label-bg",
s = n.find(function (t) {
return t.get("classname") === a;
});
if (t.label || "" === t.label)
if (o) {
var u = {};
e.getModel && (u = e.getModel().labelCfg);
var c = Object(gt.d)({}, r, u, t.labelCfg),
l = this.getLabelStyleByPosition(t, c, n),
d = t.labelCfg ? t.labelCfg.style : void 0,
f = c.style && c.style.background,
p = Object(h.a)(Object(h.a)(Object(h.a)({}, o.attr()), l), d),
g = p.rotate;
if ((delete p.rotate, g)) {
var y = [1, 0, 0, 0, 1, 0, 0, 0, 1];
(y = ki(y, [
["t", -p.x, -p.y],
["r", g],
["t", p.x, p.y],
])),
o.resetMatrix(),
o.attr(Object(h.a)(Object(h.a)({}, p), { matrix: y }));
} else o.resetMatrix(), o.attr(p);
if (s)
if (p.background) {
var v = this.getLabelBgStyleByPosition(o, t, c, n),
m = Object(h.a)(Object(h.a)({}, v), f);
if ((s.resetMatrix(), g)) {
var b = [1, 0, 0, 0, 1, 0, 0, 0, 1];
(b = ki(b, [
["t", -m.x, -m.y],
["r", g],
["t", m.x, m.y],
])),
(m.matrix = b);
}
s.attr(m);
} else n.removeChild(s);
else
p.background &&
((s = this.drawLabelBg(t, n, o)).set("classname", a),
o.toFront());
} else {
this.drawLabel(t, n).set("className", i);
}
},
afterUpdate: function (t, e) {},
setState: function (t, e, n) {
var r,
i,
o = n.get("keyShape");
if (o && !o.destroyed) {
var a = n.getType(),
s = Object(gt.n)(e) ? t : t + ":" + e,
u = this.getStateStyle(s, n),
c = n.getStateStyle(s);
if (c || u) {
var h = Object(gt.C)({}, c || u),
l = n.getContainer(),
d = { x: 1, y: 1, cx: 1, cy: 1 };
if (
("combo" === a && ((d.r = 1), (d.width = 1), (d.height = 1)),
e)
) {
var f = function (t) {
var e,
n = h[t];
if (Object(gt.w)(n) && !Ei.includes(t)) {
var r = l.find(function (e) {
return e.get("name") === t;
});
r && r.attr(n);
} else o.attr((((e = {})[t] = n), e));
};
for (var p in h) f(p);
} else {
var g = kr(n.getCurrentStatesStyle()),
y = n.getModel(),
v = Object(gt.C)({}, y.style, kr(n.getOriginStyle())),
m = o.get("name"),
b = o.attr(),
x = {};
Object.keys(b).forEach(function (t) {
if ("img" !== t) {
var e = b[t];
e && "object" === ji(e)
? (x[t] = Object(gt.b)(e))
: (x[t] = e);
}
});
var w = {},
O = function (t) {
var e = h[t];
if (Object(gt.w)(e) && !Ei.includes(t)) {
var n = l.find(function (e) {
return e.get("name") === t;
});
if (n) {
var r = Object(gt.b)(n.attr());
Object(gt.e)(e, function (e, i) {
if (t === m && x[i] && !d[i]) {
delete x[i];
var s = v[t][i] || Ti[a][i];
o.attr(i, s);
} else if (r[i] || 0 === r[i]) {
delete r[i];
var u = v[t][i] || Ti[a][i];
n.attr(i, u);
}
}),
(w[t] = r);
}
} else if (x[t] && !d[t]) {
delete x[t];
var i = v[t] || (v[m] ? v[m][t] : void 0) || Ti[a][t];
o.attr(t, i);
}
};
for (var M in h) O(M);
for (var p in (m ? (w[m] = x) : Object(gt.C)(w, x), g))
if (!d[p]) {
var S = g[p];
(Object(gt.w)(S) && !Ei.includes(p)) ||
(m
? (Object(gt.C)(v[m], (((i = {})[p] = S), i)),
delete v[p])
: Object(gt.C)(v, (((r = {})[p] = S), r)),
delete g[p]);
}
var C = {};
Object(gt.d)(C, v, w, g);
var j = !1,
k = function (t) {
var e,
n,
r = C[t];
if (Object(gt.w)(r) && !Ei.includes(t)) {
var i = l.find(function (e) {
return e.get("name") === t;
});
i &&
(t === m &&
("combo" === a &&
(delete r.r, delete r.width, delete r.height),
(j = !0)),
i.attr(r));
} else if (!j) {
var s = r || Ti[a][t];
"combo" === a
? m || o.attr((((e = {})[t] = s), e))
: o.attr((((n = {})[t] = s), n));
}
};
for (var E in C) k(E);
}
}
}
},
getStateStyle: function (t, e) {
var n = e.getModel(),
r = e.getType(),
i = this.getOptions(n),
o = i.stateStyles,
a = i.style,
s = void 0 === a ? {} : a,
u = n.stateStyles ? n.stateStyles[t] : o && o[t];
return "combo" === r ? Object(gt.b)(u) : Object(gt.C)({}, s, u);
},
getControlPoints: function (t) {
return t.controlPoints;
},
getAnchorPoints: function (t) {
return this.getOptions(t).anchorPoints;
},
},
Ii = {
itemType: "node",
shapeType: "single-node",
labelPosition: "center",
offset: ur.nodeLabel.offset,
getSize: function (t) {
var e = t.size || this.getOptions({}).size || ur.defaultNode.size;
return (
Object(gt.m)(e) && 1 === e.length && (e = [e[0], e[0]]),
Object(gt.m)(e) || (e = [e, e]),
e
);
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition;
if ("center" === n) return { x: 0, y: 0, text: t.label };
var r = e.offset;
Object(gt.s)(r) && (r = this.offset);
var i,
o = this.getSize(t),
a = o[0],
s = o[1];
switch (n) {
case "top":
i = { x: 0, y: 0 - s / 2 - r, textBaseline: "bottom" };
break;
case "bottom":
i = { x: 0, y: s / 2 + r, textBaseline: "top" };
break;
case "left":
i = { x: 0 - a / 2 - r, y: 0, textAlign: "right" };
break;
default:
i = { x: a / 2 + r, y: 0, textAlign: "left" };
}
return (i.text = t.label), i;
},
getLabelBgStyleByPosition: function (t, e, n, r) {
if (!t) return {};
var i = t.getBBox(),
o = n.style && n.style.background;
if (!o) return {};
var a,
s = Br(o.padding),
u = i.width + s[1] + s[3],
c = i.height + s[0] + s[2],
l = n.offset;
return (
Object(gt.s)(l) && (l = this.offset),
(a = { x: i.minX - s[3], y: i.minY - s[0] }),
(a = Object(h.a)(Object(h.a)(Object(h.a)({}, a), o), {
width: u,
height: c,
}))
);
},
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
return e.addShape(n, {
attrs: r,
draggable: !0,
name: "node-shape",
});
},
updateLinkPoints: function (t, e) {
var n,
r = this.getOptions(t).linkPoints,
i = e.find(function (t) {
return "link-point-left" === t.get("className");
}),
o = e.find(function (t) {
return "link-point-right" === t.get("className");
}),
a = e.find(function (t) {
return "link-point-top" === t.get("className");
}),
s = e.find(function (t) {
return "link-point-bottom" === t.get("className");
});
i && (n = i.attr()),
o && !n && (n = o.attr()),
a && !n && (n = a.attr()),
s && !n && (n = s.attr()),
n || (n = r);
var u = Object(gt.C)({}, n, t.linkPoints),
c = u.fill,
l = u.stroke,
d = u.lineWidth,
f = u.size / 2;
f || (f = u.r);
var p = t.linkPoints
? t.linkPoints
: { left: void 0, right: void 0, top: void 0, bottom: void 0 },
g = p.left,
y = p.right,
v = p.top,
m = p.bottom,
b = this.getSize(t),
x = b[0],
w = b[1],
O = { r: f, fill: c, stroke: l, lineWidth: d };
i
? g || void 0 === g
? i.attr(Object(h.a)(Object(h.a)({}, O), { x: -x / 2, y: 0 }))
: i.remove()
: g &&
e.addShape("circle", {
attrs: Object(h.a)(Object(h.a)({}, O), { x: -x / 2, y: 0 }),
className: "link-point-left",
name: "link-point-left",
isAnchorPoint: !0,
}),
o
? (y || void 0 === y || o.remove(),
o.attr(Object(h.a)(Object(h.a)({}, O), { x: x / 2, y: 0 })))
: y &&
e.addShape("circle", {
attrs: Object(h.a)(Object(h.a)({}, O), { x: x / 2, y: 0 }),
className: "link-point-right",
name: "link-point-right",
isAnchorPoint: !0,
}),
a
? (v || void 0 === v || a.remove(),
a.attr(Object(h.a)(Object(h.a)({}, O), { x: 0, y: -w / 2 })))
: v &&
e.addShape("circle", {
attrs: Object(h.a)(Object(h.a)({}, O), { x: 0, y: -w / 2 }),
className: "link-point-top",
name: "link-point-top",
isAnchorPoint: !0,
}),
s
? m || void 0 === m
? s.attr(Object(h.a)(Object(h.a)({}, O), { x: 0, y: w / 2 }))
: s.remove()
: m &&
e.addShape("circle", {
attrs: Object(h.a)(Object(h.a)({}, O), { x: 0, y: w / 2 }),
className: "link-point-bottom",
name: "link-point-bottom",
isAnchorPoint: !0,
});
},
updateShape: function (t, e, n, r) {
e.get("keyShape").attr(Object(h.a)({}, n)),
this.updateLabel(t, e),
r && this.updateIcon(t, e);
},
updateIcon: function (t, e) {
var n = this,
r = e.getContainer(),
i = this.getOptions(t).icon,
o = (t.icon ? t.icon : { show: void 0 }).show,
a = r.find(function (t) {
return t.get("className") === n.type + "-icon";
});
if (a)
if (o || void 0 === o) {
var s = Object(gt.C)({}, a.attr(), i),
u = s.width,
c = s.height;
a.attr(
Object(h.a)(Object(h.a)({}, s), { x: -u / 2, y: -c / 2 }),
);
} else a.remove();
else if (o) {
(u = i.width), (c = i.height);
r.addShape("image", {
attrs: Object(h.a)(Object(h.a)({}, i), {
x: -u / 2,
y: -c / 2,
}),
className: this.type + "-icon",
name: this.type + "-icon",
});
var l = r.find(function (t) {
return "node-label" === t.get("className");
});
l && l.toFront();
}
},
},
Bi = Object(h.a)(Object(h.a)({}, Pi), Ii);
Zr.registerNode("single-node", Bi);
var Ai = {
itemType: "edge",
labelPosition: "center",
refX: 0,
refY: 0,
labelAutoRotate: !1,
options: {
size: ur.defaultEdge.size,
style: {
x: 0,
y: 0,
stroke: ur.defaultEdge.style.stroke,
lineAppendWidth: ur.defaultEdge.style.lineAppendWidth,
},
labelCfg: {
style: {
fill: ur.edgeLabel.style.fill,
fontSize: ur.edgeLabel.style.fontSize,
},
},
stateStyles: Object(h.a)({}, ur.edgeStateStyles),
},
getPath: function (t) {
var e = [];
return (
Object(gt.e)(t, function (t, n) {
0 === n ? e.push(["M", t.x, t.y]) : e.push(["L", t.x, t.y]);
}),
e
);
},
getShapeStyle: function (t) {
var e = this.options.style,
n = { stroke: t.color },
r = Object(gt.C)({}, e, n, t.style),
i = t.size || ur.defaultEdge.size,
o = (t = this.getPathPoints(t)).startPoint,
a = t.endPoint,
s = this.getControlPoints(t),
u = [o];
s && (u = u.concat(s)), u.push(a);
var c = this.getPath(u);
return Object(gt.C)(
{},
ur.defaultEdge.style,
{ stroke: ur.defaultEdge.color, lineWidth: i, path: c },
r,
);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = { stroke: t.color },
i =
n.find(function (t) {
return "edge-shape" === t.get("className");
}) || e.getKeyShape(),
o = t.size,
a = (t = this.getPathPoints(t)).startPoint,
s = t.endPoint,
u = this.getControlPoints(t),
c = [a];
u && (c = c.concat(u)), c.push(s);
var h = i.attr(),
l = Object(gt.C)({}, r, h, t.style),
d = t.sourceNode,
f = t.targetNode,
p = { radius: l.radius };
u ||
(p = {
source: d,
target: f,
offset: l.offset,
radius: l.radius,
}),
h.endArrow &&
!1 === l.endArrow &&
(t.style.endArrow = { path: "" }),
h.startArrow &&
!1 === l.startArrow &&
(t.style.startArrow = { path: "" });
var g = this.getPath(c, p),
y = Object(gt.C)(r, i.attr(), { lineWidth: o, path: g }, t.style);
i && i.attr(y);
},
getLabelStyleByPosition: function (t, e, n) {
var r,
i = e.position || this.labelPosition,
o = {},
a =
n &&
n.find(function (t) {
return "edge-shape" === t.get("className");
});
r = "start" === i ? 0 : "end" === i ? 1 : 0.5;
var s,
u = e.refX || this.refX,
c = e.refY || this.refY;
if (
t.startPoint.x === t.endPoint.x &&
t.startPoint.y === t.endPoint.y
)
return (
(o.x = t.startPoint.x + u),
(o.y = t.startPoint.y + c),
(o.text = t.label),
o
);
s = Object(gt.s)(e.autoRotate)
? this.labelAutoRotate
: e.autoRotate;
var h = vr(a, r, u, c, s);
return (
(o.x = h.x),
(o.y = h.y),
(o.rotate = h.rotate),
(o.textAlign = this._getTextAlign(i, h.angle)),
(o.text = t.label),
o
);
},
getLabelBgStyleByPosition: function (t, e, n, r) {
if (!t) return {};
var i = t.getBBox(),
o = n.style && n.style.background;
if (!o) return {};
var a,
s = o.padding,
u = i.width + s[1] + s[3],
c = i.height + s[0] + s[2],
l = n.position || this.labelPosition,
d = Object(h.a)(Object(h.a)({}, o), {
width: u,
height: c,
x: i.minX - s[2],
y: i.minY - s[0],
rotate: 0,
});
a = Object(gt.s)(n.autoRotate)
? this.labelAutoRotate
: n.autoRotate;
var f,
p =
r &&
r.find(function (t) {
return "edge-shape" === t.get("className");
});
f = "start" === l ? 0 : "end" === l ? 1 : 0.5;
var g = n.refX || this.refX,
y = n.refY || this.refY;
if (
e.startPoint.x === e.endPoint.x &&
e.startPoint.y === e.endPoint.y
)
return (
(d.x = e.startPoint.x + g - u / 2),
(d.y = e.startPoint.y + y - c / 2),
d
);
var v = vr(p, f, g - u / 2, y + c / 2, a),
m = v.angle;
return (
m > 0.5 * Math.PI &&
m < 1.5 * Math.PI &&
(v = vr(p, f, g + u / 2, y + c / 2, a)),
a && ((d.x = v.x), (d.y = v.y)),
(d.rotate = v.rotate),
d
);
},
_getTextAlign: function (t, e) {
var n = "center";
return e
? ((e %= 2 * Math.PI),
"center" !== t &&
(n =
(e >= 0 && e <= Math.PI / 2) ||
(e >= 1.5 * Math.PI && e < 2 * Math.PI)
? t
: (function (t) {
var e = t;
return (
"start" === t
? (e = "end")
: "end" === t && (e = "start"),
e
);
})(t)),
n)
: t;
},
getControlPoints: function (t) {
return t.controlPoints;
},
getPathPoints: function (t) {
return t;
},
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("path", {
className: "edge-shape",
name: "edge-shape",
attrs: n,
});
},
drawLabel: function (t, e) {
var n,
r = this.options.labelCfg;
n =
("undefined" != typeof window &&
void 0 !== window.getComputedStyle &&
window
.getComputedStyle(document.body, null)
.getPropertyValue("font-family")) ||
"Arial, sans-serif";
var i = Object(gt.d)({ fontFamily: n }, r, t.labelCfg),
o = this.getLabelStyle(t, i, e),
a = o.rotate;
delete o.rotate;
var s = e.addShape("text", { attrs: o, name: "text-shape" });
if ((a && s.rotateAtStart(a), o.background)) {
var u = this.drawLabelBg(t, e, s),
c = this.itemType + "-label-bg";
u.set("classname", c), s.toFront();
}
return s;
},
drawLabelBg: function (t, e, n) {
var r = this.options.labelCfg,
i = Object(gt.d)({}, r, t.labelCfg),
o = this.getLabelStyle(t, i, e).rotate,
a = this.getLabelBgStyleByPosition(n, t, i, e);
delete a.rotate;
var s = e.addShape("rect", { name: "text-bg-shape", attrs: a });
return o && s.rotateAtStart(o), s;
},
},
Li = Object(h.a)(Object(h.a)({}, Pi), Ai);
Zr.registerEdge("single-edge", Li),
Zr.registerEdge(
"line",
{ getControlPoints: function () {} },
"single-edge",
),
Zr.registerEdge(
"spline",
{
getPath: function (t) {
return oi(t);
},
},
"single-edge",
),
Zr.registerEdge(
"arc",
{
curveOffset: 20,
clockwise: 1,
getControlPoints: function (t) {
var e,
n,
r = t.startPoint,
i = t.endPoint,
o = (r.x + i.x) / 2,
a = (r.y + i.y) / 2;
if (void 0 !== t.controlPoints) {
if (
((n = t.controlPoints[0]),
(e = In(r, n, i)),
r.x <= i.x && r.y > i.y
? (this.clockwise = e.x > n.x ? 0 : 1)
: r.x <= i.x && r.y < i.y
? (this.clockwise = e.x > n.x ? 1 : 0)
: r.x > i.x && r.y <= i.y
? (this.clockwise = e.y < n.y ? 0 : 1)
: (this.clockwise = e.y < n.y ? 1 : 0),
(n.x - r.x) / (n.y - r.y) == (i.x - r.x) / (i.y - r.y))
)
return [];
} else {
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
Object(gt.m)(t.curveOffset) &&
(t.curveOffset = t.curveOffset[0]),
t.curveOffset < 0
? (this.clockwise = 0)
: (this.clockwise = 1);
var s = { x: i.x - r.x, y: i.y - r.y },
u = Math.atan2(s.y, s.x);
(n = {
x: t.curveOffset * Math.cos(-Math.PI / 2 + u) + o,
y: t.curveOffset * Math.sin(-Math.PI / 2 + u) + a,
}),
(e = In(r, n, i));
}
var c = Bn(r, e);
return [{ x: c, y: c }];
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
2 === t.length
? e.push(["L", t[1].x, t[1].y])
: e.push([
"A",
t[1].x,
t[1].y,
0,
0,
this.clockwise,
t[2].x,
t[2].y,
]),
e
);
},
},
"single-edge",
),
Zr.registerEdge(
"quadratic",
{
curvePosition: 0.5,
curveOffset: -20,
getControlPoints: function (t) {
var e = t.controlPoints;
if (!e || !e.length) {
var n = t.startPoint,
r = t.endPoint;
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
Object(gt.m)(this.curveOffset) &&
(t.curveOffset = t.curveOffset[0]),
Object(gt.m)(this.curvePosition) &&
(t.curvePosition = t.curveOffset[0]),
(e = [ai(n, r, t.curvePosition, t.curveOffset)]);
}
return e;
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
e.push(["Q", t[1].x, t[1].y, t[2].x, t[2].y]),
e
);
},
},
"single-edge",
),
Zr.registerEdge(
"cubic",
{
curvePosition: [0.5, 0.5],
curveOffset: [-20, 20],
getControlPoints: function (t) {
var e = t.controlPoints;
if (
(void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
Object(gt.t)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(gt.t)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]),
!e || !e.length || e.length < 2)
) {
var n = t.startPoint,
r = t.endPoint;
e = [
ai(n, r, t.curvePosition[0], t.curveOffset[0]),
ai(n, r, t.curvePosition[1], t.curveOffset[1]),
];
}
return e;
},
getPath: function (t) {
var e = [];
return (
e.push(["M", t[0].x, t[0].y]),
e.push(["C", t[1].x, t[1].y, t[2].x, t[2].y, t[3].x, t[3].y]),
e
);
},
},
"single-edge",
),
Zr.registerEdge(
"cubic-vertical",
{
curvePosition: [0.5, 0.5],
minCurveOffset: [0, 0],
curveOffset: void 0,
getControlPoints: function (t) {
var e = t.startPoint,
n = t.endPoint;
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.minCurveOffset &&
(t.minCurveOffset = this.minCurveOffset),
Object(gt.t)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(gt.t)(t.minCurveOffset) &&
(t.minCurveOffset = [t.minCurveOffset, -t.minCurveOffset]),
Object(gt.t)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]);
var r = n.y - e.y,
i = [0, 0];
return (
t.curveOffset
? (i = t.curveOffset)
: Math.abs(r) < Math.abs(t.minCurveOffset[0]) &&
(i = t.minCurveOffset),
[
{ x: e.x, y: e.y + r * this.curvePosition[0] + i[0] },
{ x: n.x, y: n.y - r * this.curvePosition[1] + i[1] },
]
);
},
},
"cubic",
),
Zr.registerEdge(
"cubic-horizontal",
{
curvePosition: [0.5, 0.5],
minCurveOffset: [0, 0],
curveOffset: void 0,
getControlPoints: function (t) {
var e = t.startPoint,
n = t.endPoint;
void 0 === t.curvePosition &&
(t.curvePosition = this.curvePosition),
void 0 === t.curveOffset && (t.curveOffset = this.curveOffset),
void 0 === t.minCurveOffset &&
(t.minCurveOffset = this.minCurveOffset),
Object(gt.t)(t.curveOffset) &&
(t.curveOffset = [t.curveOffset, -t.curveOffset]),
Object(gt.t)(t.minCurveOffset) &&
(t.minCurveOffset = [t.minCurveOffset, -t.minCurveOffset]),
Object(gt.t)(t.curvePosition) &&
(t.curvePosition = [t.curvePosition, 1 - t.curvePosition]);
var r = n.x - e.x,
i = [0, 0];
return (
t.curveOffset
? (i = t.curveOffset)
: Math.abs(r) < Math.abs(t.minCurveOffset[0]) &&
(i = t.minCurveOffset),
[
{ x: e.x + r * this.curvePosition[0] + i[0], y: e.y },
{ x: n.x - r * this.curvePosition[1] + i[1], y: n.y },
]
);
},
},
"cubic",
),
Zr.registerEdge(
"loop",
{
getPathPoints: function (t) {
return yr(t);
},
getControlPoints: function (t) {
return t.controlPoints;
},
afterDraw: function (t) {
t.controlPoints = void 0;
},
afterUpdate: function (t) {
t.controlPoints = void 0;
},
},
"cubic",
);
var Di = {
itemType: "combo",
shapeType: "single-combo",
labelPosition: "top",
refX: ur.comboLabel.refX,
refY: ur.comboLabel.refY,
options: {
style: {
stroke: ur.defaultCombo.style.stroke,
fill: ur.defaultCombo.style.fill,
lineWidth: ur.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: ur.comboLabel.style.fill,
fontSize: ur.comboLabel.style.fontSize,
},
},
stateStyles: Object(h.a)({}, ur.comboStateStyles),
},
getSize: function (t) {
var e = Object(gt.b)(
t.size || this.options.size || ur.defaultCombo.size,
);
return (
Object(gt.m)(e) && 1 === e.length && (e = [e[0], e[0]]),
Object(gt.m)(e) || (e = [e, e]),
e
);
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition,
r = t.style,
i = t.padding || this.options.padding;
Object(gt.m)(i) && (i = i[0]);
var o = e.refX,
a = e.refY;
Object(gt.s)(o) && (o = this.refX),
Object(gt.s)(a) && (a = this.refY);
var s,
u = this.getSize(t),
c = (Math.max(r.r, u[0] / 2) || u[0] / 2) + i;
switch (n) {
case "top":
s = {
x: 0,
y: -c - a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "bottom":
s = {
x: 0,
y: c + a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "left":
s = { x: -c + o, y: 0, textAlign: "left" };
break;
case "center":
s = { x: 0, y: 0, text: t.label, textAlign: "center" };
break;
default:
s = { x: c + o, y: 0, textAlign: "right" };
}
return (s.text = t.label), s;
},
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
return e.addShape(n, {
attrs: r,
draggable: !0,
name: "combo-shape",
});
},
updateShape: function (t, e, n) {
var r = e.get("keyShape");
(void 0 === t.animate ? this.options.animate : t.animate) &&
r.animate
? r.animate(n, { duration: 200, easing: "easeLinear" })
: r.attr(Object(h.a)({}, n)),
this.updateLabel(t, e);
},
},
_i = Object(h.a)(Object(h.a)({}, Pi), Di);
Zr.registerCombo("single-combo", _i),
Zr.registerCombo(
"circle",
{
options: {
size: [ur.defaultCombo.size[0], ur.defaultCombo.size[0]],
padding: ur.defaultCombo.padding[0],
animate: !0,
style: {
stroke: ur.defaultCombo.style.stroke,
fill: ur.defaultCombo.style.fill,
lineWidth: ur.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: ur.comboLabel.style.fill,
fontSize: ur.comboLabel.style.fontSize,
},
refX: 0,
refY: 0,
},
stateStyles: Object(h.a)({}, ur.comboStateStyles),
},
shapeType: "circle",
labelPosition: "top",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return (
delete n.height,
delete n.width,
e.addShape("circle", {
attrs: n,
className: "circle-combo",
name: "circle-combo",
draggable: !0,
})
);
},
getShapeStyle: function (t) {
var e = this.options.style,
n = t.padding || this.options.padding;
Object(gt.m)(n) && (n = n[0]);
var r,
i = { stroke: t.color },
o = Object(gt.C)({}, e, i, t.style);
if (t.fixSize)
r = Object(gt.t)(t.fixSize) ? t.fixSize : t.fixSize[0];
else {
var a = this.getSize(t);
r =
!Object(gt.t)(o.r) || isNaN(o.r)
? a[0] / 2 || ur.defaultCombo.style.r
: Math.max(o.r, a[0] / 2) || a[0] / 2;
}
o.r = r + n;
var s = Object(h.a)({ x: 0, y: 0 }, o);
return t.style ? (t.style.r = r) : (t.style = { r: r }), s;
},
update: function (t, e) {
var n = this.getSize(t),
r = t.padding || this.options.padding;
Object(gt.m)(r) && (r = r[0]);
var i,
o = Object(gt.b)(t.style);
(i = t.fixSize
? Object(gt.t)(t.fixSize)
? t.fixSize
: t.fixSize[0]
: Math.max(o.r, n[0] / 2) || n[0] / 2),
(o.r = i + r);
var a = e.get("sizeCache");
a && (a.r = o.r);
var s = { stroke: t.color },
u = e.get("keyShape"),
c = Object(gt.C)({}, u.attr(), s, o);
t.style ? (t.style.r = i) : (t.style = { r: i }),
this.updateShape(t, e, c, !0);
},
},
"single-combo",
),
Zr.registerCombo(
"rect",
{
options: {
size: [40, 5],
padding: [25, 20, 15, 20],
animate: !0,
style: {
radius: 0,
stroke: ur.defaultCombo.style.stroke,
fill: ur.defaultCombo.style.fill,
lineWidth: ur.defaultCombo.style.lineWidth,
},
labelCfg: {
style: {
fill: ur.comboLabel.style.fill,
fontSize: ur.comboLabel.style.fontSize,
},
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
stateStyles: Object(h.a)({}, ur.comboStateStyles),
},
shapeType: "rect",
labelPosition: "top",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("rect", {
attrs: n,
className: "rect-combo",
name: "rect-combo",
draggable: !0,
});
},
getLabelStyleByPosition: function (t, e) {
var n = e.position || this.labelPosition,
r = t.style,
i = t.padding || this.options.padding;
Object(gt.t)(i) && (i = [i, i, i, i]);
var o = e.refX,
a = e.refY;
Object(gt.s)(o) && (o = this.refX),
Object(gt.s)(a) && (a = this.refY);
var s,
u = r.width / 2 + i[3],
c = r.height / 2 + i[0];
switch (n) {
case "top":
s = {
x: 0 - u + o,
y: 0 - c + a,
textBaseline: "top",
textAlign: "left",
};
break;
case "bottom":
s = {
x: 0,
y: c + a,
textBaseline: "bottom",
textAlign: "center",
};
break;
case "left":
s = { x: 0 - u + a, y: 0, textAlign: "left" };
break;
case "center":
s = { x: 0, y: 0, text: t.label, textAlign: "center" };
break;
default:
s = { x: u + o, y: 0, textAlign: "right" };
}
return (s.text = t.label), s;
},
getShapeStyle: function (t) {
var e = this.options.style,
n = t.padding || this.options.padding;
Object(gt.t)(n) && (n = [n, n, n, n]);
var r,
i,
o = { stroke: t.color },
a = Object(gt.C)({}, e, o, t.style),
s = this.getSize(t),
u =
t.collapsed && t.fixCollapseSize
? t.fixCollapseSize
: t.fixSize;
u
? Object(gt.t)(u)
? ((r = u), (i = u))
: ((r = u[0]), (i = u[1]))
: ((r =
!Object(gt.t)(a.width) || isNaN(a.width)
? s[0] || ur.defaultCombo.style.width
: Math.max(a.width, s[0]) || s[0]),
(i =
!Object(gt.t)(a.height) || isNaN(a.height)
? s[1] || ur.defaultCombo.style.height
: Math.max(a.height, s[1]) || s[1]));
var c = -r / 2 - n[3],
l = -i / 2 - n[0];
(a.width = r + n[1] + n[3]), (a.height = i + n[0] + n[2]);
var d = Object(h.a)({ x: c, y: l }, a);
return (
t.style
? ((t.style.width = r), (t.style.height = i))
: (t.style = { width: r, height: i }),
d
);
},
update: function (t, e) {
var n = this.getSize(t),
r = t.padding || this.options.padding;
Object(gt.t)(r) && (r = [r, r, r, r]);
var i,
o,
a = Object(gt.b)(t.style),
s =
t.collapsed && t.fixCollapseSize
? t.fixCollapseSize
: t.fixSize;
s
? Object(gt.t)(s)
? ((i = s), (o = s))
: ((i = s[0]), (o = s[1]))
: ((i = Math.max(a.width, n[0]) || n[0]),
(o = Math.max(a.height, n[1]) || n[1])),
(a.width = i + r[1] + r[3]),
(a.height = o + r[0] + r[2]);
var u = e.get("sizeCache");
u && ((u.width = a.width), (u.height = a.height)),
(a.x = -i / 2 - r[3]),
(a.y = -o / 2 - r[0]);
var c = { stroke: t.color },
h = e.get("keyShape"),
l = Object(gt.C)({}, h.attr(), c, a);
t.style
? ((t.style.width = i), (t.style.height = o))
: (t.style = { width: i, height: o }),
this.updateShape(t, e, l, !1);
},
updateShape: function (t, e, n) {
var r = e.get("keyShape");
(void 0 === t.animate ? this.options.animate : t.animate) &&
r.animate
? r.animate(n, { duration: 200, easing: "easeLinear" })
: r.attr(Object(h.a)({}, n)),
this.updateLabel(t, e);
},
},
"single-combo",
),
Zr.registerNode(
"simple-circle",
{
options: {
size: ur.defaultNode.size,
style: {
x: 0,
y: 0,
stroke: ur.defaultNode.style.stroke,
fill: ur.defaultNode.style.fill,
lineWidth: ur.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: ur.nodeLabel.style.fill,
fontSize: ur.nodeLabel.style.fontSize,
},
},
stateStyles: Object(h.a)({}, ur.nodeStateStyles),
},
shapeType: "simple-circle",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("circle", {
attrs: n,
className: this.type + "-keyShape",
draggable: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
r = Object(gt.d)({}, e, n),
i = this.getSize(t)[0] / 2;
return Object(h.a)({ x: 0, y: 0, r: i }, r);
},
update: function (t, e) {
var n = this.getSize(t),
r = { stroke: t.color, r: n[0] / 2 },
i = e.get("keyShape"),
o = Object(gt.d)({}, i.attr(), r, t.style);
this.updateShape(t, e, o, !0);
},
},
"single-node",
),
Zr.registerNode(
"simple-rect",
{
options: {
size: [100, 30],
style: {
radius: 0,
stroke: ur.defaultNode.style.stroke,
fill: ur.defaultNode.style.fill,
lineWidth: ur.defaultNode.style.lineWidth,
},
labelCfg: {
style: {
fill: ur.nodeLabel.style.fill,
fontSize: ur.nodeLabel.style.fontSize,
},
},
anchorPoints: [
[0, 0.5],
[1, 0.5],
],
stateStyles: Object(h.a)({}, ur.nodeStateStyles),
},
shapeType: "simple-rect",
labelPosition: "center",
drawShape: function (t, e) {
var n = this.getShapeStyle(t);
return e.addShape("rect", {
attrs: n,
className: this.type + "-keyShape",
name: this.type + "-keyShape",
draggable: !0,
});
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = { stroke: t.color },
r = Object(gt.C)({}, e, n),
i = this.getSize(t),
o = r.width || i[0],
a = r.height || i[1];
return Object(h.a)(
{ x: -o / 2, y: -a / 2, width: o, height: a },
r,
);
},
update: function (t, e) {
e.getContainer();
var n = this.getOptions({}).style,
r = this.getSize(t),
i = e.get("keyShape");
t.size ||
((r[0] = i.attr("width") || n.width),
(r[1] = i.attr("height") || n.height));
var o = {
stroke: t.color,
x: -r[0] / 2,
y: -r[1] / 2,
width: r[0],
height: r[1],
},
a = Object(gt.C)({}, n, i.attr(), o);
(a = Object(gt.C)(a, t.style)), this.updateShape(t, e, a, !1);
},
},
"single-node",
),
Zr.registerNode(
"image",
{
options: {
img: "https://gw.alipayobjects.com/mdn/rms_f8c6a0/afts/img/A*eD7nT6tmYgAAAAAAAAAAAABkARQnAQ",
size: 200,
clipCfg: {
show: !1,
type: "circle",
r: 50,
rx: 50,
ry: 35,
width: 50,
height: 35,
points: [
[30, 12],
[12, 30],
[30, 48],
[48, 30],
],
path: [
["M", 25, 25],
["L", 50, 25],
["A", 12.5, 12.5, 0, 1, 1, 50, 50],
["A", 12.5, 12.5, 0, 1, 0, 50, 50],
["L", 25, 75],
["Z"],
],
x: 0,
y: 0,
},
},
shapeType: "image",
labelPosition: "bottom",
drawShape: function (t, e) {
var n = this.shapeType,
r = this.getShapeStyle(t);
delete r.fill;
var i = e.addShape(n, {
attrs: r,
className: this.type + "-keyShape",
name: this.type + "-keyShape",
draggable: !0,
});
return this.drawClip(t, i), i;
},
drawClip: function (t, e) {
var n = this.getOptions(t).clipCfg;
if (n.show) {
var r = n.type,
i = n.x,
o = n.y,
a = n.style;
if ("circle" === r) {
var s = n.r;
e.setClip({
type: "circle",
attrs: Object(h.a)({ r: s, x: i, y: o }, a),
});
} else if ("rect" === r) {
var u = n.width,
c = n.height,
l = i - u / 2,
d = o - c / 2;
e.setClip({
type: "rect",
attrs: Object(h.a)({ x: l, y: d, width: u, height: c }, a),
});
} else if ("ellipse" === r) {
var f = n.rx,
p = n.ry;
e.setClip({
type: "ellipse",
attrs: Object(h.a)({ x: i, y: o, rx: f, ry: p }, a),
});
} else if ("polygon" === r) {
var g = n.points;
e.setClip({
type: "polygon",
attrs: Object(h.a)({ points: g }, a),
});
} else if ("path" === r) {
var y = n.path;
e.setClip({
type: "path",
attrs: Object(h.a)({ path: y }, a),
});
}
}
},
getShapeStyle: function (t) {
var e = this.getOptions(t).style,
n = this.getSize(t),
r = this.getOptions(t).img,
i = n[0],
o = n[1];
return (
e && ((i = e.width || n[0]), (o = e.height || n[1])),
Object(h.a)(
{ x: -i / 2, y: -o / 2, width: i, height: o, img: r },
e,
)
);
},
updateShapeStyle: function (t, e) {
var n = e.getContainer(),
r = this.itemType + "-shape",
i =
n.find(function (t) {
return t.get("className") === r;
}) || e.getKeyShape(),
o = this.getShapeStyle(t);
i && i.attr(o);
},
},
"single-node",
);
var Ri,
Yi = Zr,
Fi = [
"#5F95FF",
"#61DDAA",
"#65789B",
"#F6BD16",
"#7262FD",
"#78D3F8",
"#9661BC",
"#F6903D",
"#008685",
"#F08BB4",
],
zi = sn.a.transform,
Xi = Object(h.a)(
Object(h.a)(
Object(h.a)(Object(h.a)(Object(h.a)(Object(h.a)({}, a), o), s), i),
u,
),
{ transform: zi, mat3: sn.b },
);
!(function () {
function t(t) {
(this.graph = t),
(this.layoutCfg = t.get("layout") || {}),
(this.layoutType = this.getLayoutType()),
(this.layoutMethods = []),
this.initLayout();
}
(t.prototype.initLayout = function () {}),
(t.prototype.getLayoutType = function () {
return this.getLayoutCfgType(this.layoutCfg);
}),
(t.prototype.getLayoutCfgType = function (t) {
var e = t.type;
if (e) return e;
var n = t.pipes;
return Array.isArray(n)
? n.map(function (t) {
return (null == t ? void 0 : t.type) || "";
})
: null;
}),
(t.prototype.isLayoutTypeSame = function (t) {
var e = this.getLayoutCfgType(t);
return Array.isArray(this.layoutType)
? this.layoutType.every(function (t, n) {
return t === e[n];
})
: (null == t ? void 0 : t.type) === this.layoutType;
}),
(t.prototype.refreshLayout = function () {
var t = this.graph;
t &&
(t.get("animate") ? t.positionsAnimate() : t.refreshPositions());
}),
(t.prototype.changeLayout = function (t) {
(this.layoutCfg = t), this.destoryLayoutMethods(), this.layout();
}),
(t.prototype.changeData = function () {
this.destoryLayoutMethods(), this.layout();
}),
(t.prototype.destoryLayoutMethods = function () {
var t = this.layoutMethods;
null == t ||
t.forEach(function (t) {
t.destroy();
}),
(this.layoutMethods = []);
}),
(t.prototype.destroyLayout = function () {
var t = this.graph;
this.destoryLayoutMethods(),
t.set("layout", void 0),
(this.layoutCfg = void 0),
(this.layoutType = void 0),
(this.layoutMethods = void 0);
}),
(t.prototype.setDataFromGraph = function () {
for (
var t = [],
e = [],
n = [],
r = [],
i = [],
o = [],
a = this.graph.getNodes(),
s = this.graph.getEdges(),
u = this.graph.getCombos(),
c = a.length,
h = 0;
h < c;
h++
) {
var l = a[h];
if (l && !l.destroyed) {
var d = l.getModel();
l.isVisible() ? t.push(d) : e.push(d);
}
}
var f = s.length;
for (h = 0; h < f; h++) {
var p = s[h];
if (p && !p.destroyed) {
d = p.getModel();
p.isVisible()
? d.isComboEdge
? i.push(d)
: n.push(d)
: r.push(d);
}
}
var g = u.length;
for (h = 0; h < g; h++) {
var y = u[h];
if (!y.destroyed) {
d = y.getModel();
y.isVisible() ? o.push(d) : r.push(d);
}
}
return {
nodes: t,
hiddenNodes: e,
edges: n,
hiddenEdges: r,
combos: o,
hiddenCombos: [],
comboEdges: i,
};
}),
(t.prototype.reLayoutMethod = function (t, e) {
var n = this;
return new Promise(function (r, i) {
var o = n.graph,
a = null == e ? void 0 : e.type;
(e.onLayoutEnd = function () {
o.emit("aftersublayout", { type: a }), r();
}),
t.init(n.data),
"force" === a && ((t.ticking = !1), t.forceSimulation.stop()),
o.emit("beforesublayout", { type: a }),
t.execute(),
t.isCustomLayout && e.onLayoutEnd && e.onLayoutEnd();
});
}),
(t.prototype.relayout = function (t) {
var e = this,
n = this.graph,
r = this.layoutMethods,
i = this.layoutCfg;
if (t) {
this.data = this.setDataFromGraph();
var o = this.data.nodes;
if (!o) return !1;
this.initPositions(i.center, o);
}
n.emit("beforelayout");
var a = Promise.resolve();
null == r ||
r.forEach(function (t, n) {
var r = i[n];
a = a.then(function () {
return e.reLayoutMethod(t, r);
});
}),
a
.then(function () {
i.onAllLayoutEnd && i.onAllLayoutEnd();
})
.catch(function (t) {
console.warn("relayout failed", t);
});
}),
(t.prototype.filterLayoutData = function (t, e) {
var n,
r,
i = t.nodes,
o = t.edges,
a = Object(h.e)(t, ["nodes", "edges"]);
if (!i) return t;
if (
((n = Object(gt.r)(null == e ? void 0 : e.nodesFilter)
? e.nodesFilter
: function () {
return !0;
}),
Object(gt.r)(null == e ? void 0 : e.edgesFilter))
)
r = e.edgesFilter;
else {
var s = i.reduce(function (t, e) {
return (t[e.id] = !0), t;
}, {});
r = function (t) {
return s[t.source] && s[t.target];
};
}
return Object(h.a)({ nodes: i.filter(n), edges: o.filter(r) }, a);
}),
(t.prototype.getLayoutBBox = function (t) {
var e = this.graph,
n = Object(gt.j)(e.getNodes(), function (t) {
return t.getModel().layoutOrder;
}),
r = Object.values(n).map(function (t) {
var e = _r(t);
return (e.size = [e.width, e.height]), e;
});
return {
groupNodes: Object.values(Object(gt.j)(t, "layoutOrder")),
layoutNodes: r,
};
}),
(t.prototype.layoutAnimate = function () {}),
(t.prototype.moveToZero = function () {
var t = this.graph.get("data").nodes;
if (void 0 !== t[0].x && null !== t[0].x && !Dr(t[0].x)) {
for (var e = [0, 0], n = t.length, r = 0; r < n; r++) {
var i = t[r];
(e[0] += i.x), (e[1] += i.y);
}
(e[0] /= t.length), (e[1] /= t.length);
for (r = 0; r < n; r++) {
((i = t[r]).x -= e[0]), (i.y -= e[1]);
}
}
}),
(t.prototype.initPositions = function (t, e) {
var n = this.graph;
if (!e) return !1;
var r = e ? e.length : 0;
if (r) {
var i = 0.85 * n.get("width"),
o = 0.85 * n.get("height"),
a = Math.ceil(Math.sqrt(r) * (i / o)),
s = i / (a - 1),
u = o / (Math.ceil(r / a) - 1);
(isFinite(s) && s) || (s = 0), (isFinite(u) && s) || (u = 0);
for (
var c = t[0] - i / 2, h = t[1] - o / 2, l = !0, d = 0;
d < r;
d++
) {
var f = e[d];
Dr(f.x) && ((l = !1), (f.x = (d % a) * s + c)),
Dr(f.y) && ((l = !1), (f.y = Math.floor(d / a) * u + h));
}
return l;
}
}),
(t.prototype.destroy = function () {
(this.graph = null),
this.destoryLayoutMethods(),
(this.destroyed = !0);
}),
(t.prototype.onTick = function (t) {
var e;
null === (e = this.layoutMethods) ||
void 0 === e ||
e.forEach(function (e) {
null == e || e.onTick(t);
});
});
})();
!(function (t) {
(t.CLICK = "click"),
(t.DBLCLICK = "dblclick"),
(t.TAP = "tap"),
(t.DBLTAP = "dbltap"),
(t.DRAGSTART = "dragstart"),
(t.DRAGEND = "dragend"),
(t.DRAG = "drag"),
(t.DRAGENTER = "dragenter"),
(t.DRAGLEAVE = "dragleave"),
(t.DRAGOVER = "dragover"),
(t.DRAGOUT = "dragout"),
(t.DDROP = "drop"),
(t.PINCHSTART = "pinchstart"),
(t.PINCHMOVE = "pinchmove"),
(t.PANSTART = "panstart"),
(t.PANMOVE = "panmove"),
(t.PANEND = "panend"),
(t.PRESS = "press"),
(t.ACTION_END = "actionend"),
(t.TOUCHSTART = "touchstart"),
(t.TOUCHMOVE = "touchmove"),
(t.TOUCHEND = "touchend"),
(t.CANVAS_TOUCHSTART = "canvas:touchstart"),
(t.CANVAS_TOUCHMOVE = "canvas:touchmove"),
(t.CANVAS_TOUCHEND = "canvas:touchend"),
(t.NODE_TOUCHSTART = "node:touchstart"),
(t.NODE_TOUCHMOVE = "node:touchmove"),
(t.NODE_TOUCHEND = "node:touchend"),
(t.COMBO_TOUCHSTART = "combo:touchstart"),
(t.COMBO_TOUCHMOVE = "combo:touchmove"),
(t.COMBO_TOUCHEND = "combo:touchend"),
(t.EDGE_TOUCHSTART = "edge:touchstart"),
(t.EDGE_TOUCHMOVE = "edge:touchmove"),
(t.EDGE_TOUCHEND = "edge:touchend"),
(t.NODE_CLICK = "node:click"),
(t.NODE_DBLCLICK = "node:dblclick"),
(t.NODE_DROP = "node:drop"),
(t.NODE_DRAGOVER = "node:dragover"),
(t.NODE_DRAGENTER = "node:dragenter"),
(t.NODE_DRAGLEAVE = "node:dragleave"),
(t.NODE_DRAGSTART = "node:dragstart"),
(t.NODE_DRAG = "node:drag"),
(t.NODE_DRAGEND = "node:dragend"),
(t.NODE_TAP = "node:tap"),
(t.NODE_DBLTAP = "node:dbltap"),
(t.NODE_PANSTART = "node:panstart"),
(t.NODE_PANMOVE = "node:panmove"),
(t.NODE_PANEND = "node:panend"),
(t.NODE_PRESS = "node:press"),
(t.COMBO_CLICK = "combo:click"),
(t.COMBO_DBLCLICK = "combo:dblclick"),
(t.COMBO_DROP = "combo:drop"),
(t.COMBO_DRAGOVER = "combo:dragover"),
(t.COMBO_DRAGENTER = "combo:dragenter"),
(t.COMBO_DRAGLEAVE = "combo:dragleave"),
(t.COMBO_DRAGSTART = "combo:dragstart"),
(t.COMBO_DRAG = "combo:drag"),
(t.COMBO_DRAGEND = "combo:dragend"),
(t.COMBO_TAP = "combo:tap"),
(t.COMBO_DBLTAP = "combo:dbltap"),
(t.COMBO_PANSTART = "combo:panstart"),
(t.COMBO_PANMOVE = "combo:panmove"),
(t.COMBO_PANEND = "combo:panend"),
(t.COMBO_PRESS = "combo:press"),
(t.EDGE_CLICK = "edge:click"),
(t.EDGE_DBLCLICK = "edge:dblclick"),
(t.EDGE_DROP = "edge:drop"),
(t.EDGE_DRAGOVER = "edge:dragover"),
(t.EDGE_DRAGENTER = "edge:dragenter"),
(t.EDGE_DRAGLEAVE = "edge:dragleave"),
(t.EDGE_TAP = "edge:tap"),
(t.EDGE_DBLTAP = "edge:dbltap"),
(t.EDGE_PRESS = "edge:press"),
(t.CANVAS_CLICK = "canvas:click"),
(t.CANVAS_DBLCLICK = "canvas:dblclick"),
(t.CANVAS_DROP = "canvas:drop"),
(t.CANVAS_DRAGENTER = "canvas:dragenter"),
(t.CANVAS_DRAGLEAVE = "canvas:dragleave"),
(t.CANVAS_DRAGSTART = "canvas:dragstart"),
(t.CANVAS_DRAG = "canvas:drag"),
(t.CANVAS_DRAGEND = "canvas:dragend"),
(t.CANVAS_TAP = "canvas:tap"),
(t.CANVAS_DBLTAP = "canvas:dbltap"),
(t.CANVAS_PANSTART = "canvas:panstart"),
(t.CANVAS_PANMOVE = "canvas:panmove"),
(t.CANVAS_PANEND = "canvas:panend"),
(t.CANVAS_PRESS = "canvas:press"),
(t.BEFORERENDER = "beforerender"),
(t.AFTERRENDER = "afterrender"),
(t.BEFOREADDITEM = "beforeadditem"),
(t.AFTERADDITEM = "afteradditem"),
(t.BEFOREREMOVEITEM = "beforeremoveitem"),
(t.AFTERREMOVEITEM = "afterremoveitem"),
(t.BEFOREUPDATEITEM = "beforeupdateitem"),
(t.AFTERUPDATEITEM = "afterupdateitem"),
(t.BEFOREITEMVISIBILITYCHANGE = "beforeitemvisibilitychange"),
(t.AFTERITEMVISIBILITYCHANGE = "afteritemvisibilitychange"),
(t.BEFOREITEMSTATECHANGE = "beforeitemstatechange"),
(t.AFTERITEMSTATECHANGE = "afteritemstatechange"),
(t.BEFOREITEMREFRESH = "beforeitemrefresh"),
(t.AFTERITEMREFRESH = "afteritemrefresh"),
(t.BEFOREITEMSTATESCLEAR = "beforeitemstatesclear"),
(t.AFTERITEMSTATESCLEAR = "afteritemstatesclear"),
(t.BEFOREMODECHANGE = "beforemodechange"),
(t.AFTERMODECHANGE = "aftermodechange"),
(t.BEFORELAYOUT = "beforelayout"),
(t.AFTERLAYOUT = "afterlayout"),
(t.BEFORECREATEEDGE = "beforecreateedge"),
(t.AFTERCREATEEDGE = "aftercreateedge"),
(t.BEFOREGRAPHREFRESHPOSITION = "beforegraphrefreshposition"),
(t.AFTERGRAPHREFRESHPOSITION = "aftergraphrefreshposition"),
(t.BEFOREGRAPHREFRESH = "beforegraphrefresh"),
(t.AFTERGRAPHREFRESH = "aftergraphrefresh"),
(t.BEFOREANIMATE = "beforeanimate"),
(t.AFTERANIMATE = "afteranimate"),
(t.BEFOREPAINT = "beforepaint"),
(t.AFTERPAINT = "afterpaint"),
(t.BEFORECOLLAPSEEXPANDCOMBO = "beforecollapseexpandcombo"),
(t.AFTERCOLLAPSEEXPANDCOMBO = "aftercollapseexpandcombo"),
(t.GRAPHSTATECHANGE = "graphstatechange"),
(t.AFTERACTIVATERELATIONS = "afteractivaterelations"),
(t.NODESELECTCHANGE = "nodeselectchange"),
(t.TOOLTIPCHANGE = "tooltipchange"),
(t.WHEELZOOM = "wheelzoom"),
(t.VIEWPORTCHANGE = "viewportchange"),
(t.DRAGNODEEND = "dragnodeend"),
(t.STACKCHANGE = "stackchange");
})(Ri || (Ri = {}));
Yi.registerNode,
Yi.registerEdge,
Yi.registerCombo,
en.registerBehavior,
Yi.registerNode,
Yi.registerEdge,
Yi.registerCombo,
en.registerBehavior;
var Wi = Xi.pointLineDistance,
Gi = { stroke: "#FA8C16", lineWidth: 1 },
qi = (function (t) {
function e(e) {
return t.call(this, e) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getDefaultCfgs = function () {
return {
line: Gi,
itemAlignType: "center",
tolerance: 5,
horizontalLines: {},
verticalLines: {},
alignLines: [],
};
}),
(e.prototype.init = function () {}),
(e.prototype.getEvents = function () {
return {
"node:dragstart": "onDragStart",
"node:drag": "onDrag",
"node:dragend": "onDragEnd",
};
}),
(e.prototype.onDragStart = function () {
this.initBoxLine();
}),
(e.prototype.onDrag = function (t) {
var e = t.item,
n = (e.get("delegateShape") || e).getBBox(),
r = e.getModel(),
i = r.x - n.x,
o = r.y - n.y;
this.show(
{ x: n.minX + i, y: n.minY + o },
{ width: n.width, height: n.height },
);
}),
(e.prototype.onDragEnd = function () {
this.destory();
}),
(e.prototype.initBoxLine = function () {
var t = this._cfgs,
e = t.horizontalLines,
n = t.verticalLines,
r = t.itemAlignType;
this.get("graph")
.getNodes()
.forEach(function (t) {
var i = t.getBBox(),
o = t.get("id");
!0 === r || "horizontal" === r
? ((e[o + "tltr"] = [i.minX, i.minY, i.maxX, i.minY, t]),
(e[o + "lcrc"] = [
i.minX,
i.centerY,
i.maxX,
i.centerY,
t,
]),
(e[o + "blbr"] = [i.minX, i.maxY, i.maxX, i.maxY, t]))
: "center" === r &&
(e[o + "lcrc"] = [
i.minX,
i.centerY,
i.maxX,
i.centerY,
t,
]),
!0 === r || "vertical" === r
? ((n[o + "tlbl"] = [i.minX, i.minY, i.minX, i.maxY, t]),
(n[o + "tcbc"] = [
i.centerX,
i.minY,
i.centerX,
i.maxY,
t,
]),
(n[o + "trbr"] = [i.maxX, i.minY, i.maxX, i.maxY, t]))
: "center" === r &&
(n[o + "tcbc"] = [
i.centerX,
i.minY,
i.centerX,
i.maxY,
t,
]);
});
}),
(e.prototype.show = function (t, e) {
var n = Object(gt.C)({}, t);
return this.itemAlign(t, e, n), t;
}),
(e.prototype.itemAlign = function (t, e, n) {
var r = this,
i = this._cfgs,
o = i.horizontalLines,
a = i.verticalLines,
s = i.tolerance,
u = { x: n.x + e.width / 2, y: n.y },
c = { x: n.x + e.width / 2, y: n.y + e.height / 2 },
h = { x: n.x + e.width / 2, y: n.y + e.height },
l = { x: n.x, y: n.y + e.height / 2 },
d = { x: n.x + e.width, y: n.y + e.height / 2 },
f = [],
p = [],
g = null;
if (
(this.clearAlignLine(),
Object(gt.e)(o, function (t) {
t[4].isVisible &&
(f.push(r.getLineDisObject(t, u)),
f.push(r.getLineDisObject(t, c)),
f.push(r.getLineDisObject(t, h)));
}),
Object(gt.e)(a, function (t) {
t[4].isVisible &&
(p.push(r.getLineDisObject(t, l)),
p.push(r.getLineDisObject(t, c)),
p.push(r.getLineDisObject(t, d)));
}),
f.sort(function (t, e) {
return t.dis - e.dis;
}),
p.sort(function (t, e) {
return t.dis - e.dis;
}),
0 !== f.length && f[0].dis < s)
) {
(t.y = f[0].line[1] - f[0].point.y + n.y),
(g = { type: "item", horizontals: [f[0]] });
for (var y = 1; y < 3; y++)
f[0].dis === f[y].dis && g.horizontals.push(f[y]);
}
if (0 !== p.length && p[0].dis < s) {
(t.x = p[0].line[0] - p[0].point.x + n.x),
g
? (g.verticals = [p[0]])
: (g = { type: "item", verticals: [p[0]] });
for (y = 1; y < 3; y++)
p[0].dis === p[y].dis && g.verticals.push(p[y]);
}
g && ((g.bbox = e), this.addAlignLine(g));
}),
(e.prototype.addAlignLine = function (t) {
var e = t.bbox,
n = t.type,
r = t.horizontals,
i = t.verticals,
o = this._cfgs,
a = o.line,
s = o.alignLines,
u = this.get("graph").get("group");
"item" === n &&
(r &&
Object(gt.e)(r, function (t) {
var n,
r,
i = t.line,
o = t.point,
c = (i[0] + i[2]) / 2;
o.x < c
? ((n = o.x - e.width / 2), (r = Math.max(i[0], i[2])))
: ((n = o.x + e.width / 2), (r = Math.min(i[0], i[2])));
var h = Object(gt.C)(
{ x1: n, y1: i[1], x2: r, y2: i[1] },
a,
),
l = u.addShape("line", { attrs: h, capture: !1 });
s.push(l);
}),
i &&
Object(gt.e)(i, function (t) {
var n,
r,
i = t.line,
o = t.point,
c = (i[1] + i[3]) / 2;
o.y < c
? ((n = o.y - e.height / 2), (r = Math.max(i[1], i[3])))
: ((n = o.y + e.height / 2), (r = Math.min(i[1], i[3])));
var h = Object(gt.C)(
{ x1: i[0], y1: n, x2: i[0], y2: r },
a,
),
l = u.addShape("line", { attrs: h, capture: !1 });
s.push(l);
}));
}),
(e.prototype.getLineDisObject = function (t, e) {
return { line: t, point: e, dis: Wi(t, e) };
}),
(e.prototype.getContainer = function () {
return this.get("container");
}),
(e.prototype.clearAlignLine = function () {
var t = this._cfgs.alignLines;
Object(gt.e)(t, function (t) {
t.remove();
}),
(t.length = 0);
}),
(e.prototype.destory = function () {
var t = this._cfgs,
e = t.horizontalLines,
n = t.verticalLines;
this.get("graph")
.getNodes()
.forEach(function (t) {
var r = t.get("id");
delete e[r + "tltr"],
delete e[r + "lcrc"],
delete e[r + "blbr"],
delete n[r + "tlbl"],
delete n[r + "tcbc"],
delete n[r + "trbr"];
}),
this.clearAlignLine();
}),
e
);
})(Qe);
var Hi = (function (t) {
function e() {
return (null !== t && t.apply(this, arguments)) || this;
}
return (
Object(h.c)(e, t),
(e.prototype.getDefaultCfgs = function () {
return {
offsetX: 6,
offsetY: 6,
getContent: function (t) {
var e, n;
return (
"\n
\n
类型：" +
(null === (e = t.item) || void 0 === e
? void 0
: e.getType()) +
"
## 什么是 F6
F6 是一款可以快速、流畅运行于移动设备中的图可视化引擎，通过丰富的布局、组件及分析能力，帮助用户落地跨平台的图可视化应用解决方案。在 H5、小程序等移动端平台上，对包体积、性能有更高的要求，也需要定义一套合适的交互模式。针对以上问题，我们在 G6 的基础上重新设计并构建了 F6。F6 不仅具有基础的关联图绘制、事件、动画，同时内置了常用的移动端交互模式、丰富的布局和分析组件，通过简单的配置即可使用。
如果您还没有使用过 F6， 建议通过 [快速上手](https://f6.antv.vision/zh/docs/manual/getting-started) 抢先体验 F6 的魅力。
## F6 文档
- [F6 入门教程](https://f6.antv.vision/zh/docs/manual/introduction)
- [F6 核心概念](https://f6.antv.vision/zh/docs/manual/middle/overview)
- [F6 扩展阅读](https://f6.antv.vision/zh/docs/manual/advanced/coordinate-system)
- [API](https://f6.antv.vision/zh/docs/api/Graph)
- [示例](https://f6.antv.vision/zh/docs/examples/tree/compactBox)
## 安装
```bash
$ npm install @antv/f6
```
## 使用
- demo
```js
import F6 from "@antv/f6";
import graphData from "./data";
import dagreLayout from "@antv/f6/dist/extends/layout/dagreLayout";
import TreeGraph from "@antv/f6/dist/extends/graph/treeGraph";
F6.registerLayout("dagreLayout", dagreLayout);
F6.registerGraph("TreeGraph", TreeGraph);
Page({
data: {
width: 300,
height: 400,
pixelRatio: 1,
},
onLoad() {
const { windowWidth, windowHeight, pixelRatio } = my.getSystemInfoSync();
this.setData({
width: windowWidth,
height: windowHeight,
pixelRatio: pixelRatio,
});
},
onCanvasInit(ctx, rect, canvas, renderer) {
this.graph = new F6.TreeGraph({
context: ctx,
renderer,
width: this.data.width,
height: this.data.height,
linkCenter: true,
modes: {
default: ["drag-canvas", "zoom-canvas"],
},
defaultNode: {
size: 40,
},
layout: {
type: "compactBox",
direction: "RL",
getId: function getId(d) {
return d.id;
},
getHeight: () => {
return 26;
},
getWidth: () => {
return 26;
},
getVGap: () => {
return 20;
},
getHGap: () => {
return 30;
},
radial: false,
},
});
this.graph.node(function (node) {
return {
label: node.id,
};
});
this.graph.data(graphData);
this.graph.render();
this.graph.fitView();
},
onTouch(e) {
this.graph.emitEvent(e);
},
onUnload() {
this.graph?.destroy();
},
});
```
## 如何开发
```bash
$ npm install -g @microsoft/rush
# update dependencies
$ rush update
# build the packages
$ rush build
# demo
$ cd packages/f6 && rushx storybook
```
更详细的内容请参考 [快速上手](https://f6.antv.vision/zh/docs/manual/getting-started) 文档。
## 如何贡献
请让我们知道您要解决或贡献什么，所以在贡献之前请先提交 issues 描述 bug 或建议。
成为一个贡献者前请阅读 代码贡献规范。
## License
MIT license。
================================================
FILE: README.md
================================================
# F6: A Mobile Graph Visualization Framework in TypeScript.
[](https://www.npmjs.com/package/@antv/f6)
[](https://npmjs.org/package/@antv/f6)
[](http://isitmaintained.com/project/antvis/f6 "Percentage of issues still open")
English | [简体中文](./README-zh-CN.md)
## What is F6
[F6](https://github.com/antvis/f6) is a mobile graph visualization engine, which provides a set of basic mechanisms, including rendering, layout, analysis, interaction, animation, and other auxiliary tools. F6 aims to simplify the relationships, and help people to obtain the insight of relational data.
Developers are able to build graph visualization **analysis** applications or graph visualization **modeling** applications easily.
> Powerful Animation and Interactions
## Features
- Abundant Built-in Items: Nodes and edges with free configurations;
- Steerable Interactions: More than 10 basic interaction behaviors ;
- Powerful Layout: More than 10 layout algorithms;
- Convenient Components: Outstanding ability and performance;
- Friendly User Experience: Complete documents for different levels of user requirements. TypeScript supported.
F6 concentrates on the principle of 'good by default'. In addition, the custom mechanism of the item, interation behavior, and layout satisfies the customazation requirements.
> Abundant Built-in Items
## Installation
```bash
$ npm install @antv/f6
```
## Usage