@blueking/ai-blueking 2.0.0-dev.1 → 2.0.0-dev.3

package/dist/vue2/graphlib-KDKEjVHX.js

@@ -0,0 +1,344 @@
+import { C as stubArray_default, E as _arrayMap_default, S as _getSymbols_default, T as _arrayPush_default, a as _baseUniq_default, b as _getAllKeys_default, c as filter_default, i as _arrayEach_default, n as forEach_default, s as _baseFlatten_default, t as reduce_default, w as _baseGetAllKeys_default, x as keys_default } from "./reduce-BFKSG9Rs.js";
+import { C as isFunction_default, E as _Symbol_default, g as isArray_default, h as isObjectLike_default, l as _nodeUtil_default, p as isBuffer_default, u as _baseUnary_default, v as _Stack_default, w as isObject_default } from "./_baseFor-DAbrc8SN.js";
+import { n as _getTag_default, t as isEmpty_default } from "./isEmpty-z27q3o-D.js";
+import { A as _copyArray_default, D as isArrayLikeObject_default, E as _assignValue_default, M as _cloneArrayBuffer_default, N as _cloneBuffer_default, O as _initCloneObject_default, S as constant_default, T as _copyObject_default, b as _baseRest_default, j as _cloneTypedArray_default, k as _getPrototype_default, w as keysIn_default } from "./chunk-S3R3BYOJ-Bs_r55Kk.js";
+function baseAssign(l, R) {
+	return l && _copyObject_default(R, keys_default(R), l);
+}
+var _baseAssign_default = baseAssign;
+function baseAssignIn(l, R) {
+	return l && _copyObject_default(R, keysIn_default(R), l);
+}
+var _baseAssignIn_default = baseAssignIn;
+function copySymbols(l, R) {
+	return _copyObject_default(l, _getSymbols_default(l), R);
+}
+var _copySymbols_default = copySymbols, _getSymbolsIn_default = Object.getOwnPropertySymbols ? function(l) {
+	for (var R = []; l;) _arrayPush_default(R, _getSymbols_default(l)), l = _getPrototype_default(l);
+	return R;
+} : stubArray_default;
+function copySymbolsIn(l, R) {
+	return _copyObject_default(l, _getSymbolsIn_default(l), R);
+}
+var _copySymbolsIn_default = copySymbolsIn;
+function getAllKeysIn(l) {
+	return _baseGetAllKeys_default(l, keysIn_default, _getSymbolsIn_default);
+}
+var _getAllKeysIn_default = getAllKeysIn, hasOwnProperty = Object.prototype.hasOwnProperty;
+function initCloneArray(l) {
+	var R = l.length, z = new l.constructor(R);
+	return R && typeof l[0] == "string" && hasOwnProperty.call(l, "index") && (z.index = l.index, z.input = l.input), z;
+}
+var _initCloneArray_default = initCloneArray;
+function cloneDataView(l, R) {
+	var z = R ? _cloneArrayBuffer_default(l.buffer) : l.buffer;
+	return new l.constructor(z, l.byteOffset, l.byteLength);
+}
+var _cloneDataView_default = cloneDataView, reFlags = /\w*$/;
+function cloneRegExp(l) {
+	var R = new l.constructor(l.source, reFlags.exec(l));
+	return R.lastIndex = l.lastIndex, R;
+}
+var _cloneRegExp_default = cloneRegExp, symbolProto = _Symbol_default ? _Symbol_default.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(l) {
+	return symbolValueOf ? Object(symbolValueOf.call(l)) : {};
+}
+var _cloneSymbol_default = cloneSymbol, boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]", arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag(l, R, z) {
+	var B = l.constructor;
+	switch (R) {
+		case arrayBufferTag$1: return _cloneArrayBuffer_default(l);
+		case boolTag$1:
+		case dateTag$1: return new B(+l);
+		case dataViewTag$1: return _cloneDataView_default(l, z);
+		case float32Tag$1:
+		case float64Tag$1:
+		case int8Tag$1:
+		case int16Tag$1:
+		case int32Tag$1:
+		case uint8Tag$1:
+		case uint8ClampedTag$1:
+		case uint16Tag$1:
+		case uint32Tag$1: return _cloneTypedArray_default(l, z);
+		case mapTag$2: return new B();
+		case numberTag$1:
+		case stringTag$1: return new B(l);
+		case regexpTag$1: return _cloneRegExp_default(l);
+		case setTag$2: return new B();
+		case symbolTag$1: return _cloneSymbol_default(l);
+	}
+}
+var _initCloneByTag_default = initCloneByTag, mapTag$1 = "[object Map]";
+function baseIsMap(l) {
+	return isObjectLike_default(l) && _getTag_default(l) == mapTag$1;
+}
+var _baseIsMap_default = baseIsMap, nodeIsMap = _nodeUtil_default && _nodeUtil_default.isMap, isMap_default = nodeIsMap ? _baseUnary_default(nodeIsMap) : _baseIsMap_default, setTag$1 = "[object Set]";
+function baseIsSet(l) {
+	return isObjectLike_default(l) && _getTag_default(l) == setTag$1;
+}
+var _baseIsSet_default = baseIsSet, nodeIsSet = _nodeUtil_default && _nodeUtil_default.isSet, isSet_default = nodeIsSet ? _baseUnary_default(nodeIsSet) : _baseIsSet_default, CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4, argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]", arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]", cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = !0, cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = !1;
+function baseClone(l, R, z, B, V, U) {
+	var G, K = R & CLONE_DEEP_FLAG, q = R & CLONE_FLAT_FLAG, J = R & CLONE_SYMBOLS_FLAG;
+	if (z && (G = V ? z(l, B, V, U) : z(l)), G !== void 0) return G;
+	if (!isObject_default(l)) return l;
+	var Y = isArray_default(l);
+	if (Y) {
+		if (G = _initCloneArray_default(l), !K) return _copyArray_default(l, G);
+	} else {
+		var X = _getTag_default(l), Z = X == funcTag || X == genTag;
+		if (isBuffer_default(l)) return _cloneBuffer_default(l, K);
+		if (X == objectTag || X == argsTag || Z && !V) {
+			if (G = q || Z ? {} : _initCloneObject_default(l), !K) return q ? _copySymbolsIn_default(l, _baseAssignIn_default(G, l)) : _copySymbols_default(l, _baseAssign_default(G, l));
+		} else {
+			if (!cloneableTags[X]) return V ? l : {};
+			G = _initCloneByTag_default(l, X, K);
+		}
+	}
+	U ||= new _Stack_default();
+	var Q = U.get(l);
+	if (Q) return Q;
+	U.set(l, G), isSet_default(l) ? l.forEach(function(B) {
+		G.add(baseClone(B, R, z, B, l, U));
+	}) : isMap_default(l) && l.forEach(function(B, V) {
+		G.set(V, baseClone(B, R, z, V, l, U));
+	});
+	var $ = Y ? void 0 : (J ? q ? _getAllKeysIn_default : _getAllKeys_default : q ? keysIn_default : keys_default)(l);
+	return _arrayEach_default($ || l, function(B, V) {
+		$ && (V = B, B = l[V]), _assignValue_default(G, V, baseClone(B, R, z, V, l, U));
+	}), G;
+}
+var _baseClone_default = baseClone;
+function baseValues(l, z) {
+	return _arrayMap_default(z, function(R) {
+		return l[R];
+	});
+}
+var _baseValues_default = baseValues;
+function values(l) {
+	return l == null ? [] : _baseValues_default(l, keys_default(l));
+}
+var values_default = values;
+function isUndefined(l) {
+	return l === void 0;
+}
+var isUndefined_default = isUndefined, union_default = _baseRest_default(function(l) {
+	return _baseUniq_default(_baseFlatten_default(l, 1, isArrayLikeObject_default, !0));
+}), DEFAULT_EDGE_NAME = "\0", GRAPH_NODE = "\0", EDGE_KEY_DELIM = "
", Graph = class {
+	constructor(l = {}) {
+		this._isDirected = Object.prototype.hasOwnProperty.call(l, "directed") ? l.directed : !0, this._isMultigraph = Object.prototype.hasOwnProperty.call(l, "multigraph") ? l.multigraph : !1, this._isCompound = Object.prototype.hasOwnProperty.call(l, "compound") ? l.compound : !1, this._label = void 0, this._defaultNodeLabelFn = constant_default(void 0), this._defaultEdgeLabelFn = constant_default(void 0), this._nodes = {}, this._isCompound && (this._parent = {}, this._children = {}, this._children[GRAPH_NODE] = {}), this._in = {}, this._preds = {}, this._out = {}, this._sucs = {}, this._edgeObjs = {}, this._edgeLabels = {};
+	}
+	isDirected() {
+		return this._isDirected;
+	}
+	isMultigraph() {
+		return this._isMultigraph;
+	}
+	isCompound() {
+		return this._isCompound;
+	}
+	setGraph(l) {
+		return this._label = l, this;
+	}
+	graph() {
+		return this._label;
+	}
+	setDefaultNodeLabel(l) {
+		return isFunction_default(l) || (l = constant_default(l)), this._defaultNodeLabelFn = l, this;
+	}
+	nodeCount() {
+		return this._nodeCount;
+	}
+	nodes() {
+		return keys_default(this._nodes);
+	}
+	sources() {
+		var l = this;
+		return filter_default(this.nodes(), function(R) {
+			return isEmpty_default(l._in[R]);
+		});
+	}
+	sinks() {
+		var l = this;
+		return filter_default(this.nodes(), function(R) {
+			return isEmpty_default(l._out[R]);
+		});
+	}
+	setNodes(l, R) {
+		var z = arguments, B = this;
+		return forEach_default(l, function(l) {
+			z.length > 1 ? B.setNode(l, R) : B.setNode(l);
+		}), this;
+	}
+	setNode(l, R) {
+		return Object.prototype.hasOwnProperty.call(this._nodes, l) ? (arguments.length > 1 && (this._nodes[l] = R), this) : (this._nodes[l] = arguments.length > 1 ? R : this._defaultNodeLabelFn(l), this._isCompound && (this._parent[l] = GRAPH_NODE, this._children[l] = {}, this._children[GRAPH_NODE][l] = !0), this._in[l] = {}, this._preds[l] = {}, this._out[l] = {}, this._sucs[l] = {}, ++this._nodeCount, this);
+	}
+	node(l) {
+		return this._nodes[l];
+	}
+	hasNode(l) {
+		return Object.prototype.hasOwnProperty.call(this._nodes, l);
+	}
+	removeNode(l) {
+		if (Object.prototype.hasOwnProperty.call(this._nodes, l)) {
+			var R = (l) => this.removeEdge(this._edgeObjs[l]);
+			delete this._nodes[l], this._isCompound && (this._removeFromParentsChildList(l), delete this._parent[l], forEach_default(this.children(l), (l) => {
+				this.setParent(l);
+			}), delete this._children[l]), forEach_default(keys_default(this._in[l]), R), delete this._in[l], delete this._preds[l], forEach_default(keys_default(this._out[l]), R), delete this._out[l], delete this._sucs[l], --this._nodeCount;
+		}
+		return this;
+	}
+	setParent(l, R) {
+		if (!this._isCompound) throw Error("Cannot set parent in a non-compound graph");
+		if (isUndefined_default(R)) R = GRAPH_NODE;
+		else {
+			R += "";
+			for (var z = R; !isUndefined_default(z); z = this.parent(z)) if (z === l) throw Error("Setting " + R + " as parent of " + l + " would create a cycle");
+			this.setNode(R);
+		}
+		return this.setNode(l), this._removeFromParentsChildList(l), this._parent[l] = R, this._children[R][l] = !0, this;
+	}
+	_removeFromParentsChildList(l) {
+		delete this._children[this._parent[l]][l];
+	}
+	parent(l) {
+		if (this._isCompound) {
+			var R = this._parent[l];
+			if (R !== GRAPH_NODE) return R;
+		}
+	}
+	children(l) {
+		if (isUndefined_default(l) && (l = GRAPH_NODE), this._isCompound) {
+			var R = this._children[l];
+			if (R) return keys_default(R);
+		} else if (l === GRAPH_NODE) return this.nodes();
+		else if (this.hasNode(l)) return [];
+	}
+	predecessors(l) {
+		var R = this._preds[l];
+		if (R) return keys_default(R);
+	}
+	successors(l) {
+		var R = this._sucs[l];
+		if (R) return keys_default(R);
+	}
+	neighbors(l) {
+		var R = this.predecessors(l);
+		if (R) return union_default(R, this.successors(l));
+	}
+	isLeaf(l) {
+		return (this.isDirected() ? this.successors(l) : this.neighbors(l)).length === 0;
+	}
+	filterNodes(l) {
+		var R = new this.constructor({
+			directed: this._isDirected,
+			multigraph: this._isMultigraph,
+			compound: this._isCompound
+		});
+		R.setGraph(this.graph());
+		var z = this;
+		forEach_default(this._nodes, function(z, B) {
+			l(B) && R.setNode(B, z);
+		}), forEach_default(this._edgeObjs, function(l) {
+			R.hasNode(l.v) && R.hasNode(l.w) && R.setEdge(l, z.edge(l));
+		});
+		var B = {};
+		function V(l) {
+			var H = z.parent(l);
+			return H === void 0 || R.hasNode(H) ? (B[l] = H, H) : H in B ? B[H] : V(H);
+		}
+		return this._isCompound && forEach_default(R.nodes(), function(l) {
+			R.setParent(l, V(l));
+		}), R;
+	}
+	setDefaultEdgeLabel(l) {
+		return isFunction_default(l) || (l = constant_default(l)), this._defaultEdgeLabelFn = l, this;
+	}
+	edgeCount() {
+		return this._edgeCount;
+	}
+	edges() {
+		return values_default(this._edgeObjs);
+	}
+	setPath(l, R) {
+		var z = this, B = arguments;
+		return reduce_default(l, function(l, V) {
+			return B.length > 1 ? z.setEdge(l, V, R) : z.setEdge(l, V), V;
+		}), this;
+	}
+	setEdge() {
+		var l, R, z, B, V = !1, H = arguments[0];
+		typeof H == "object" && H && "v" in H ? (l = H.v, R = H.w, z = H.name, arguments.length === 2 && (B = arguments[1], V = !0)) : (l = H, R = arguments[1], z = arguments[3], arguments.length > 2 && (B = arguments[2], V = !0)), l = "" + l, R = "" + R, isUndefined_default(z) || (z = "" + z);
+		var U = edgeArgsToId(this._isDirected, l, R, z);
+		if (Object.prototype.hasOwnProperty.call(this._edgeLabels, U)) return V && (this._edgeLabels[U] = B), this;
+		if (!isUndefined_default(z) && !this._isMultigraph) throw Error("Cannot set a named edge when isMultigraph = false");
+		this.setNode(l), this.setNode(R), this._edgeLabels[U] = V ? B : this._defaultEdgeLabelFn(l, R, z);
+		var W = edgeArgsToObj(this._isDirected, l, R, z);
+		return l = W.v, R = W.w, Object.freeze(W), this._edgeObjs[U] = W, incrementOrInitEntry(this._preds[R], l), incrementOrInitEntry(this._sucs[l], R), this._in[R][U] = W, this._out[l][U] = W, this._edgeCount++, this;
+	}
+	edge(l, R, z) {
+		var B = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, l, R, z);
+		return this._edgeLabels[B];
+	}
+	hasEdge(l, R, z) {
+		var B = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, l, R, z);
+		return Object.prototype.hasOwnProperty.call(this._edgeLabels, B);
+	}
+	removeEdge(l, R, z) {
+		var B = arguments.length === 1 ? edgeObjToId(this._isDirected, arguments[0]) : edgeArgsToId(this._isDirected, l, R, z), V = this._edgeObjs[B];
+		return V && (l = V.v, R = V.w, delete this._edgeLabels[B], delete this._edgeObjs[B], decrementOrRemoveEntry(this._preds[R], l), decrementOrRemoveEntry(this._sucs[l], R), delete this._in[R][B], delete this._out[l][B], this._edgeCount--), this;
+	}
+	inEdges(l, R) {
+		var z = this._in[l];
+		if (z) {
+			var B = values_default(z);
+			return R ? filter_default(B, function(l) {
+				return l.v === R;
+			}) : B;
+		}
+	}
+	outEdges(l, R) {
+		var z = this._out[l];
+		if (z) {
+			var B = values_default(z);
+			return R ? filter_default(B, function(l) {
+				return l.w === R;
+			}) : B;
+		}
+	}
+	nodeEdges(l, R) {
+		var z = this.inEdges(l, R);
+		if (z) return z.concat(this.outEdges(l, R));
+	}
+};
+Graph.prototype._nodeCount = 0, Graph.prototype._edgeCount = 0;
+function incrementOrInitEntry(l, R) {
+	l[R] ? l[R]++ : l[R] = 1;
+}
+function decrementOrRemoveEntry(l, R) {
+	--l[R] || delete l[R];
+}
+function edgeArgsToId(l, R, z, B) {
+	var V = "" + R, H = "" + z;
+	if (!l && V > H) {
+		var U = V;
+		V = H, H = U;
+	}
+	return V + EDGE_KEY_DELIM + H + EDGE_KEY_DELIM + (isUndefined_default(B) ? DEFAULT_EDGE_NAME : B);
+}
+function edgeArgsToObj(l, R, z, B) {
+	var V = "" + R, H = "" + z;
+	if (!l && V > H) {
+		var U = V;
+		V = H, H = U;
+	}
+	var W = {
+		v: V,
+		w: H
+	};
+	return B && (W.name = B), W;
+}
+function edgeObjToId(l, R) {
+	return edgeArgsToId(l, R.v, R.w, R.name);
+}
+export { _baseClone_default as i, isUndefined_default as n, values_default as r, Graph as t };