539 lines
16 KiB
JavaScript
539 lines
16 KiB
JavaScript
// Module ID: 656
|
|
// Function ID: 657
|
|
// Name: DepGraph
|
|
// Dependencies: []
|
|
|
|
// Module 656 (DepGraph)
|
|
class DepGraph {
|
|
constructor(arg0) {
|
|
tmp = arg0;
|
|
if (arg0) {
|
|
tmp = arg0.circular;
|
|
}
|
|
{ nodes: {}, outgoingEdges: {}, incomingEdges: {} }.circular = tmp;
|
|
return;
|
|
}
|
|
}
|
|
arg5.DepGraph = DepGraph;
|
|
DepGraph.prototype = {
|
|
size() {
|
|
return Object.keys(this.nodes).length;
|
|
},
|
|
addNode(arg0, arg1) {
|
|
const self = this;
|
|
if (!this.hasNode(arg0)) {
|
|
let tmp = arg0;
|
|
if (2 === arguments.length) {
|
|
tmp = arg1;
|
|
}
|
|
self.nodes[arg0] = tmp;
|
|
self.outgoingEdges[arg0] = [];
|
|
self.incomingEdges[arg0] = [];
|
|
}
|
|
},
|
|
removeNode(arg0) {
|
|
const self = this;
|
|
let closure_0 = arg0;
|
|
if (this.hasNode(arg0)) {
|
|
const nodes = self.nodes;
|
|
delete tmp[tmp2];
|
|
const outgoingEdges = self.outgoingEdges;
|
|
delete tmp[tmp2];
|
|
const incomingEdges = self.incomingEdges;
|
|
delete tmp[tmp2];
|
|
const items = [, ];
|
|
({ incomingEdges: arr[0], outgoingEdges: arr[1] } = self);
|
|
let item = items.forEach(function(arg0) {
|
|
let closure_0 = arg0;
|
|
const keys = Object.keys(arg0);
|
|
const item = keys.forEach((arg0) => {
|
|
const index = table[arg0].indexOf(table);
|
|
if (index >= 0) {
|
|
table[arg0].splice(index, 1);
|
|
const arr2 = table[arg0];
|
|
}
|
|
}, this);
|
|
});
|
|
}
|
|
},
|
|
hasNode(key10009) {
|
|
const nodes = this.nodes;
|
|
return nodes.hasOwnProperty(key10009);
|
|
},
|
|
getNodeData(arg0) {
|
|
if (this.hasNode(arg0)) {
|
|
return this.nodes[arg0];
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("Node does not exist: " + arg0);
|
|
throw error;
|
|
}
|
|
},
|
|
setNodeData(arg0, arg1) {
|
|
if (this.hasNode(arg0)) {
|
|
this.nodes[arg0] = arg1;
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("Node does not exist: " + arg0);
|
|
throw error;
|
|
}
|
|
},
|
|
addDependency(arg0, arg1) {
|
|
const self = this;
|
|
if (this.hasNode(arg0)) {
|
|
if (self.hasNode(arg1)) {
|
|
let arr = self.outgoingEdges[arg0];
|
|
if (-1 === arr.indexOf(arg1)) {
|
|
arr = self.outgoingEdges[arg0].push(arg1);
|
|
const arr2 = self.outgoingEdges[arg0];
|
|
}
|
|
if (-1 === arr3.indexOf(arg0)) {
|
|
arr = self.incomingEdges[arg1].push(arg0);
|
|
const arr4 = self.incomingEdges[arg1];
|
|
}
|
|
return true;
|
|
} else {
|
|
const _Error2 = Error;
|
|
const error = new Error("Node does not exist: " + arg1);
|
|
throw error;
|
|
}
|
|
} else {
|
|
const _Error = Error;
|
|
const error1 = new Error("Node does not exist: " + arg0);
|
|
throw error1;
|
|
}
|
|
},
|
|
removeDependency(arg0, arg1) {
|
|
const self = this;
|
|
let hasNodeResult = this.hasNode(arg0);
|
|
if (hasNodeResult) {
|
|
const index = self.outgoingEdges[arg0].indexOf(arg1);
|
|
hasNodeResult = index >= 0;
|
|
let tmp2 = index;
|
|
const arr = self.outgoingEdges[arg0];
|
|
}
|
|
if (hasNodeResult) {
|
|
self.outgoingEdges[arg0].splice(tmp2, 1);
|
|
const arr2 = self.outgoingEdges[arg0];
|
|
}
|
|
let hasNodeResult1 = self.hasNode(arg1);
|
|
if (hasNodeResult1) {
|
|
const index1 = self.incomingEdges[arg1].indexOf(arg0);
|
|
hasNodeResult1 = index1 >= 0;
|
|
tmp2 = index1;
|
|
const arr3 = self.incomingEdges[arg1];
|
|
}
|
|
if (hasNodeResult1) {
|
|
self.incomingEdges[arg1].splice(tmp2, 1);
|
|
const arr4 = self.incomingEdges[arg1];
|
|
}
|
|
},
|
|
clone() {
|
|
const self = this;
|
|
if (typeof self !== "function") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
const obj = { nodes: {}, outgoingEdges: {}, incomingEdges: {}, circular: undefined };
|
|
const keys = Object.keys(this.nodes);
|
|
const item = keys.forEach((arg0) => {
|
|
obj.nodes[arg0] = self.nodes[arg0];
|
|
obj.outgoingEdges[arg0] = self.outgoingEdges[arg0].slice(0);
|
|
obj.incomingEdges[arg0] = self.incomingEdges[arg0].slice(0);
|
|
});
|
|
return obj;
|
|
},
|
|
dependenciesOf(arg0, arg1) {
|
|
const self = this;
|
|
if (this.hasNode(arg0)) {
|
|
const items = [];
|
|
const outgoingEdges = self.outgoingEdges;
|
|
let closure_1 = arg1;
|
|
const circular = self.circular;
|
|
let closure_4 = [];
|
|
let closure_5 = {};
|
|
let closure_6 = {};
|
|
let closure_7 = {};
|
|
class DFS {
|
|
constructor(arg0) {
|
|
circular[arg0] = true;
|
|
arr = circular.push(arg0);
|
|
circular[arg0] = true;
|
|
tmp4 = outgoingEdges;
|
|
num = 0;
|
|
if (0 < outgoingEdges[arg0].length) {
|
|
while (true) {
|
|
tmp5 = outgoingEdges;
|
|
tmp6 = outgoingEdges[arg0][num];
|
|
tmp7 = circular;
|
|
tmp8 = num;
|
|
if (circular[tmp6]) {
|
|
tmp11 = circular;
|
|
if (circular[tmp6]) {
|
|
obj = circular;
|
|
arr1 = circular.push(tmp6);
|
|
tmp13 = circular;
|
|
if (!circular) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
tmp9 = DFS;
|
|
tmp10 = DFS(tmp6);
|
|
}
|
|
num = num + 1;
|
|
tmp4 = tmp5;
|
|
}
|
|
tmp14 = closure_1;
|
|
tmp15 = new.target;
|
|
if (typeof closure_1 !== "function") {
|
|
str3 = "Trying to call a non-function";
|
|
throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
}
|
|
str = " -> ";
|
|
str2 = "Dependency Cycle Found: ";
|
|
tmp16 = globalThis;
|
|
_Error = Error;
|
|
tmp17 = new.target;
|
|
tmp18 = new.target;
|
|
error = new Error("Dependency Cycle Found: " + obj.join(" -> "));
|
|
tmp20 = error;
|
|
error.cyclePath = obj;
|
|
_Object = Object;
|
|
_Object2 = Object;
|
|
setPrototypeOfResult = Object.setPrototypeOf(error, Object.getPrototypeOf(tmp15));
|
|
_Error2 = Error;
|
|
if (Error.captureStackTrace) {
|
|
_Error3 = Error;
|
|
captureStackTraceResult = Error.captureStackTrace(error, tmp14);
|
|
}
|
|
throw error;
|
|
}
|
|
arr2 = circular.pop();
|
|
delete tmp2[tmp];
|
|
tmp24 = closure_1;
|
|
if (closure_1) {
|
|
tmp24 = 0 !== tmp4[arg0].length;
|
|
}
|
|
if (!tmp24) {
|
|
tmp25 = circular;
|
|
tmp24 = circular[arg0];
|
|
}
|
|
if (!tmp24) {
|
|
tmp26 = DFS;
|
|
arr3 = DFS.push(arg0);
|
|
tmp28 = circular;
|
|
circular[arg0] = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
DFS(arg0);
|
|
const index = items.indexOf(arg0);
|
|
if (index >= 0) {
|
|
items.splice(index, 1);
|
|
}
|
|
return items;
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("Node does not exist: " + arg0);
|
|
throw error;
|
|
}
|
|
},
|
|
dependantsOf(arg0, arg1) {
|
|
const self = this;
|
|
if (this.hasNode(arg0)) {
|
|
const items = [];
|
|
const incomingEdges = self.incomingEdges;
|
|
let closure_1 = arg1;
|
|
const circular = self.circular;
|
|
let closure_4 = [];
|
|
let closure_5 = {};
|
|
let closure_6 = {};
|
|
let closure_7 = {};
|
|
class DFS {
|
|
constructor(arg0) {
|
|
circular[arg0] = true;
|
|
arr = circular.push(arg0);
|
|
circular[arg0] = true;
|
|
tmp4 = outgoingEdges;
|
|
num = 0;
|
|
if (0 < outgoingEdges[arg0].length) {
|
|
while (true) {
|
|
tmp5 = outgoingEdges;
|
|
tmp6 = outgoingEdges[arg0][num];
|
|
tmp7 = circular;
|
|
tmp8 = num;
|
|
if (circular[tmp6]) {
|
|
tmp11 = circular;
|
|
if (circular[tmp6]) {
|
|
obj = circular;
|
|
arr1 = circular.push(tmp6);
|
|
tmp13 = circular;
|
|
if (!circular) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
tmp9 = DFS;
|
|
tmp10 = DFS(tmp6);
|
|
}
|
|
num = num + 1;
|
|
tmp4 = tmp5;
|
|
}
|
|
tmp14 = closure_1;
|
|
tmp15 = new.target;
|
|
if (typeof closure_1 !== "function") {
|
|
str3 = "Trying to call a non-function";
|
|
throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
}
|
|
str = " -> ";
|
|
str2 = "Dependency Cycle Found: ";
|
|
tmp16 = globalThis;
|
|
_Error = Error;
|
|
tmp17 = new.target;
|
|
tmp18 = new.target;
|
|
error = new Error("Dependency Cycle Found: " + obj.join(" -> "));
|
|
tmp20 = error;
|
|
error.cyclePath = obj;
|
|
_Object = Object;
|
|
_Object2 = Object;
|
|
setPrototypeOfResult = Object.setPrototypeOf(error, Object.getPrototypeOf(tmp15));
|
|
_Error2 = Error;
|
|
if (Error.captureStackTrace) {
|
|
_Error3 = Error;
|
|
captureStackTraceResult = Error.captureStackTrace(error, tmp14);
|
|
}
|
|
throw error;
|
|
}
|
|
arr2 = circular.pop();
|
|
delete tmp2[tmp];
|
|
tmp24 = closure_1;
|
|
if (closure_1) {
|
|
tmp24 = 0 !== tmp4[arg0].length;
|
|
}
|
|
if (!tmp24) {
|
|
tmp25 = circular;
|
|
tmp24 = circular[arg0];
|
|
}
|
|
if (!tmp24) {
|
|
tmp26 = DFS;
|
|
arr3 = DFS.push(arg0);
|
|
tmp28 = circular;
|
|
circular[arg0] = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
DFS(arg0);
|
|
const index = items.indexOf(arg0);
|
|
if (index >= 0) {
|
|
items.splice(index, 1);
|
|
}
|
|
return items;
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("Node does not exist: " + arg0);
|
|
throw error;
|
|
}
|
|
},
|
|
overallOrder(arg0) {
|
|
const self = this;
|
|
let outgoingEdges = this;
|
|
const items = [];
|
|
const keys = Object.keys(this.nodes);
|
|
if (0 === keys.length) {
|
|
return items;
|
|
} else {
|
|
outgoingEdges = self.outgoingEdges;
|
|
let closure_1 = false;
|
|
let DFS = [];
|
|
let circular = self.circular;
|
|
let closure_4 = [];
|
|
let closure_5 = {};
|
|
let closure_6 = {};
|
|
let closure_7 = {};
|
|
class DFS {
|
|
constructor(arg0) {
|
|
circular[arg0] = true;
|
|
arr = circular.push(arg0);
|
|
circular[arg0] = true;
|
|
tmp4 = outgoingEdges;
|
|
num = 0;
|
|
if (0 < outgoingEdges[arg0].length) {
|
|
while (true) {
|
|
tmp5 = outgoingEdges;
|
|
tmp6 = outgoingEdges[arg0][num];
|
|
tmp7 = circular;
|
|
tmp8 = num;
|
|
if (circular[tmp6]) {
|
|
tmp11 = circular;
|
|
if (circular[tmp6]) {
|
|
obj = circular;
|
|
arr1 = circular.push(tmp6);
|
|
tmp13 = circular;
|
|
if (!circular) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
tmp9 = DFS;
|
|
tmp10 = DFS(tmp6);
|
|
}
|
|
num = num + 1;
|
|
tmp4 = tmp5;
|
|
}
|
|
tmp14 = closure_1;
|
|
tmp15 = new.target;
|
|
if (typeof closure_1 !== "function") {
|
|
str3 = "Trying to call a non-function";
|
|
throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
}
|
|
str = " -> ";
|
|
str2 = "Dependency Cycle Found: ";
|
|
tmp16 = globalThis;
|
|
_Error = Error;
|
|
tmp17 = new.target;
|
|
tmp18 = new.target;
|
|
error = new Error("Dependency Cycle Found: " + obj.join(" -> "));
|
|
tmp20 = error;
|
|
error.cyclePath = obj;
|
|
_Object = Object;
|
|
_Object2 = Object;
|
|
setPrototypeOfResult = Object.setPrototypeOf(error, Object.getPrototypeOf(tmp15));
|
|
_Error2 = Error;
|
|
if (Error.captureStackTrace) {
|
|
_Error3 = Error;
|
|
captureStackTraceResult = Error.captureStackTrace(error, tmp14);
|
|
}
|
|
throw error;
|
|
}
|
|
arr2 = circular.pop();
|
|
delete tmp2[tmp];
|
|
tmp24 = closure_1;
|
|
if (closure_1) {
|
|
tmp24 = 0 !== tmp4[arg0].length;
|
|
}
|
|
if (!tmp24) {
|
|
tmp25 = circular;
|
|
tmp24 = circular[arg0];
|
|
}
|
|
if (!tmp24) {
|
|
tmp26 = DFS;
|
|
arr3 = DFS.push(arg0);
|
|
tmp28 = circular;
|
|
circular[arg0] = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
closure_1 = DFS;
|
|
const item = keys.forEach((arg0) => {
|
|
callback(arg0);
|
|
});
|
|
outgoingEdges = self.outgoingEdges;
|
|
closure_1 = arg0;
|
|
DFS = items;
|
|
circular = self.circular;
|
|
closure_4 = [];
|
|
closure_5 = {};
|
|
closure_6 = {};
|
|
closure_7 = {};
|
|
class DFS {
|
|
constructor(arg0) {
|
|
circular[arg0] = true;
|
|
arr = circular.push(arg0);
|
|
circular[arg0] = true;
|
|
tmp4 = outgoingEdges;
|
|
num = 0;
|
|
if (0 < outgoingEdges[arg0].length) {
|
|
while (true) {
|
|
tmp5 = outgoingEdges;
|
|
tmp6 = outgoingEdges[arg0][num];
|
|
tmp7 = circular;
|
|
tmp8 = num;
|
|
if (circular[tmp6]) {
|
|
tmp11 = circular;
|
|
if (circular[tmp6]) {
|
|
obj = circular;
|
|
arr1 = circular.push(tmp6);
|
|
tmp13 = circular;
|
|
if (!circular) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
tmp9 = DFS;
|
|
tmp10 = DFS(tmp6);
|
|
}
|
|
num = num + 1;
|
|
tmp4 = tmp5;
|
|
}
|
|
tmp14 = closure_1;
|
|
tmp15 = new.target;
|
|
if (typeof closure_1 !== "function") {
|
|
str3 = "Trying to call a non-function";
|
|
throwTypeErrorResult = HermesBuiltin.throwTypeError();
|
|
}
|
|
str = " -> ";
|
|
str2 = "Dependency Cycle Found: ";
|
|
tmp16 = globalThis;
|
|
_Error = Error;
|
|
tmp17 = new.target;
|
|
tmp18 = new.target;
|
|
error = new Error("Dependency Cycle Found: " + obj.join(" -> "));
|
|
tmp20 = error;
|
|
error.cyclePath = obj;
|
|
_Object = Object;
|
|
_Object2 = Object;
|
|
setPrototypeOfResult = Object.setPrototypeOf(error, Object.getPrototypeOf(tmp15));
|
|
_Error2 = Error;
|
|
if (Error.captureStackTrace) {
|
|
_Error3 = Error;
|
|
captureStackTraceResult = Error.captureStackTrace(error, tmp14);
|
|
}
|
|
throw error;
|
|
}
|
|
arr2 = circular.pop();
|
|
delete tmp2[tmp];
|
|
tmp24 = closure_1;
|
|
if (closure_1) {
|
|
tmp24 = 0 !== tmp4[arg0].length;
|
|
}
|
|
if (!tmp24) {
|
|
tmp25 = circular;
|
|
tmp24 = circular[arg0];
|
|
}
|
|
if (!tmp24) {
|
|
tmp26 = DFS;
|
|
arr3 = DFS.push(arg0);
|
|
tmp28 = circular;
|
|
circular[arg0] = true;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
const found = keys.filter((arg0) => 0 === outgoingEdges.incomingEdges[arg0].length);
|
|
const item1 = found.forEach((arg0) => {
|
|
DFS(arg0);
|
|
});
|
|
return items;
|
|
}
|
|
}
|
|
};
|
|
class tmp {
|
|
constructor(arg0) {
|
|
error = new Error("Dependency Cycle Found: " + arg0.join(" -> "));
|
|
error.cyclePath = arg0;
|
|
setPrototypeOfResult = Object.setPrototypeOf(error, Object.getPrototypeOf(this));
|
|
if (Error.captureStackTrace) {
|
|
_Error = Error;
|
|
tmp3 = f19125;
|
|
captureStackTraceResult = Error.captureStackTrace(error, f19125);
|
|
}
|
|
return error;
|
|
}
|
|
}
|
|
arg5.DepGraphCycleError = tmp;
|
|
let closure_1 = tmp;
|
|
tmp.prototype = Object.create(Error.prototype, { constructor: { value: Error, enumerable: false, writable: true, configurable: true } });
|
|
Object.setPrototypeOf(tmp, Error);
|