@hpcc-js/util 3.3.8 → 3.3.10

package/dist/index.js

@@ -1,22 +1,31 @@
 var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
-const PKG_NAME = "@hpcc-js/util", PKG_VERSION = "3.2.0", BUILD_VERSION = "3.2.1";
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a, _b, _c, _d;
+const PKG_NAME = "@hpcc-js/util";
+const PKG_VERSION = "3.2.0";
+const BUILD_VERSION = "3.2.1";
 function find(o, predicate) {
-  if (o == null)
+  if (o == null) {
     throw new TypeError('"o" is null or not defined');
+  }
   const len = o.length >>> 0;
-  if (typeof predicate != "function")
+  if (typeof predicate !== "function") {
     throw new TypeError("predicate must be a function");
+  }
   const thisArg = arguments[1];
   let k = 0;
-  for (; k < len; ) {
+  while (k < len) {
     const kValue = o[k];
-    if (predicate.call(thisArg, kValue, k))
+    if (predicate.call(thisArg, kValue, k)) {
       return kValue;
+    }
     k++;
   }
+  return void 0;
 }
+__name(find, "find");
 function compare(before, after) {
   const retVal = {
     update: [],
@@ -25,156 +34,244 @@ function compare(before, after) {
   };
   for (const row of before) {
     const otherIdx = retVal.enter.indexOf(row);
-    otherIdx >= 0 ? (retVal.update.push(row), retVal.enter.splice(otherIdx, 1)) : retVal.exit.push(row);
+    if (otherIdx >= 0) {
+      retVal.update.push(row);
+      retVal.enter.splice(otherIdx, 1);
+    } else {
+      retVal.exit.push(row);
+    }
   }
   return retVal;
 }
+__name(compare, "compare");
 function compare2(before, after, idFunc, updateFunc = (before2, after2) => after2) {
   const retVal = {
     update: [],
     exit: [],
     enter: []
   };
-  if (before === after)
-    return retVal.update = before, retVal;
+  if (before === after) {
+    retVal.update = before;
+    return retVal;
+  }
   const unknownMap = {};
   after.forEach((item) => {
     unknownMap[idFunc(item)] = item;
   });
   for (const row of before) {
-    const id = idFunc(row), item = unknownMap[id];
-    item !== void 0 ? (delete unknownMap[id], retVal.update.push(updateFunc(row, item))) : retVal.exit.push(row);
+    const id = idFunc(row);
+    const item = unknownMap[id];
+    if (item !== void 0) {
+      delete unknownMap[id];
+      retVal.update.push(updateFunc(row, item));
+    } else {
+      retVal.exit.push(row);
+    }
   }
-  for (const key in unknownMap)
+  for (const key in unknownMap) {
     retVal.enter.push(unknownMap[key]);
+  }
   return retVal;
 }
+__name(compare2, "compare2");
 function pad(hash, len) {
-  for (; hash.length < len; )
+  while (hash.length < len) {
     hash = "0" + hash;
+  }
   return hash;
 }
+__name(pad, "pad");
 function fold(hash, text) {
-  if (text.length === 0)
+  if (text.length === 0) {
     return hash;
+  }
   for (let i = 0; i < text.length; ++i) {
     const chr = text.charCodeAt(i);
-    hash = (hash << 5) - hash + chr, hash |= 0;
+    hash = (hash << 5) - hash + chr;
+    hash |= 0;
   }
   return hash < 0 ? hash * -2 : hash;
 }
+__name(fold, "fold");
 function foldObject(hash, o, seen) {
-  return typeof o.hashSum == "function" ? o.hashSum() : Object.keys(o).sort().reduce((input, key) => foldValue(input, o[key], key, seen), hash);
+  if (typeof o.hashSum === "function") {
+    return o.hashSum();
+  }
+  return Object.keys(o).sort().reduce((input, key) => {
+    return foldValue(input, o[key], key, seen);
+  }, hash);
 }
+__name(foldObject, "foldObject");
 function foldValue(input, value, key, seen) {
   const hash = fold(fold(fold(input, key), toString(value)), typeof value);
-  return value === null ? fold(hash, "null") : value === void 0 ? fold(hash, "undefined") : typeof value == "object" ? seen.indexOf(value) !== -1 ? fold(hash, "[Circular]" + key) : (seen.push(value), foldObject(hash, value, seen)) : fold(hash, value.toString());
+  if (value === null) {
+    return fold(hash, "null");
+  }
+  if (value === void 0) {
+    return fold(hash, "undefined");
+  }
+  if (typeof value === "object") {
+    if (seen.indexOf(value) !== -1) {
+      return fold(hash, "[Circular]" + key);
+    }
+    seen.push(value);
+    return foldObject(hash, value, seen);
+  }
+  return fold(hash, value.toString());
 }
+__name(foldValue, "foldValue");
 function toString(o) {
   return Object.prototype.toString.call(o);
 }
+__name(toString, "toString");
 function hashSum(o) {
   return pad(foldValue(0, o, "", []).toString(16), 8);
 }
-class Cache {
-  constructor(calcID) {
-    __publicField(this, "_cache", {});
-    __publicField(this, "_calcID");
-    this._calcID = calcID;
-  }
+__name(hashSum, "hashSum");
+const _Cache = class _Cache {
+  _cache = {};
+  _calcID;
   static hash(...args) {
     return hashSum({ ...args });
   }
+  constructor(calcID) {
+    this._calcID = calcID;
+  }
   has(espObj) {
     return this._calcID(espObj) in this._cache;
   }
   set(obj) {
-    return this._cache[this._calcID(obj)] = obj, obj;
+    this._cache[this._calcID(obj)] = obj;
+    return obj;
   }
   get(espObj, factory) {
     const retVal = this._cache[this._calcID(espObj)];
-    return retVal || (factory ? this.set(factory()) : null);
-  }
-}
-class AsyncCache {
-  constructor(calcID) {
-    __publicField(this, "_cache", {});
-    __publicField(this, "_calcID");
-    this._calcID = calcID;
+    if (!retVal) {
+      return factory ? this.set(factory()) : null;
+    }
+    return retVal;
   }
+};
+__name(_Cache, "Cache");
+let Cache = _Cache;
+const _AsyncCache = class _AsyncCache {
+  _cache = {};
+  _calcID;
   static hash(...args) {
     return hashSum({ ...args });
   }
+  constructor(calcID) {
+    this._calcID = calcID;
+  }
   has(espObj) {
     return this._calcID(espObj) in this._cache;
   }
   set(espObj, obj) {
-    return this._cache[this._calcID(espObj)] = obj, obj;
+    this._cache[this._calcID(espObj)] = obj;
+    return obj;
   }
   get(espObj, factory) {
     const retVal = this._cache[this._calcID(espObj)];
-    return retVal || (factory ? this.set(espObj, factory()) : Promise.resolve(null));
+    if (!retVal) {
+      return factory ? this.set(espObj, factory()) : Promise.resolve(null);
+    }
+    return retVal;
   }
-}
+};
+__name(_AsyncCache, "AsyncCache");
+let AsyncCache = _AsyncCache;
 function debounce(fn, timeout) {
   const promises = {};
   return (...params) => {
     const hash = hashSum(params);
-    return promises[hash] || (promises[hash] = {
-      clockStart: Date.now(),
-      promise: fn(...params).then((response) => (timeout === void 0 ? promises[hash] = null : setTimeout(() => {
-        promises[hash] = null;
-      }, Math.max(timeout - (Date.now() - promises[hash].clockStart), 0)), response)).catch((e) => {
-        throw promises[hash] = null, e;
-      })
-    }), promises[hash].promise;
+    if (!promises[hash]) {
+      promises[hash] = {
+        clockStart: Date.now(),
+        promise: fn(...params).then((response) => {
+          if (timeout === void 0) {
+            promises[hash] = null;
+          } else {
+            setTimeout(() => {
+              promises[hash] = null;
+            }, Math.max(timeout - (Date.now() - promises[hash].clockStart), 0));
+          }
+          return response;
+        }).catch((e) => {
+          promises[hash] = null;
+          throw e;
+        })
+      };
+    }
+    return promises[hash].promise;
   };
 }
+__name(debounce, "debounce");
 function promiseTimeout(ms, promise) {
   let id;
   const timeout = new Promise((resolve, reject) => {
     id = setTimeout(() => {
-      clearTimeout(id), reject("Timed out in " + ms + "ms.");
+      clearTimeout(id);
+      reject("Timed out in " + ms + "ms.");
     }, ms);
   });
   return Promise.race([
     promise,
     timeout
-  ]).then((response) => (clearTimeout(id), response)).catch((e) => {
-    throw clearTimeout(id), e;
+  ]).then((response) => {
+    clearTimeout(id);
+    return response;
+  }).catch((e) => {
+    clearTimeout(id);
+    throw e;
   });
 }
-class AsyncOrderedQueue {
-  constructor() {
-    __publicField(this, "_q", []);
-  }
+__name(promiseTimeout, "promiseTimeout");
+const _AsyncOrderedQueue = class _AsyncOrderedQueue {
+  _q = [];
   isTop(p) {
     return this._q[0] === p;
   }
   push(p) {
-    const retVal = p.then((response) => this.isTop(retVal) ? (this._q.shift(), response) : new Promise((resolve, reject) => {
-      const intervalHandler = setInterval(() => {
-        this.isTop(retVal) && (clearInterval(intervalHandler), this._q.shift(), resolve(response));
-      }, 20);
-    }));
-    return this._q.push(retVal), retVal;
+    const retVal = p.then((response) => {
+      if (this.isTop(retVal)) {
+        this._q.shift();
+        return response;
+      }
+      return new Promise((resolve, reject) => {
+        const intervalHandler = setInterval(() => {
+          if (this.isTop(retVal)) {
+            clearInterval(intervalHandler);
+            this._q.shift();
+            resolve(response);
+          }
+        }, 20);
+      });
+    });
+    this._q.push(retVal);
+    return retVal;
   }
-}
+};
+__name(_AsyncOrderedQueue, "AsyncOrderedQueue");
+let AsyncOrderedQueue = _AsyncOrderedQueue;
 function sleep(ms) {
   return new Promise((resolve) => {
     setTimeout(() => resolve(), ms);
   });
 }
-class Dictionary {
+__name(sleep, "sleep");
+const _Dictionary = class _Dictionary {
+  store = {};
   constructor(attrs) {
-    __publicField(this, "store", {});
-    if (attrs)
-      for (const key in attrs)
+    if (attrs) {
+      for (const key in attrs) {
         this.set(key, attrs[key]);
+      }
+    }
   }
   set(key, value) {
     const retVal = this.store[key];
-    return this.store[key] = value, retVal;
+    this.store[key] = value;
+    return retVal;
   }
   get(key) {
     return this.store[key];
@@ -187,18 +284,22 @@ class Dictionary {
   }
   keys() {
     const retVal = [];
-    for (const key in this.store)
+    for (const key in this.store) {
       retVal.push(key);
+    }
     return retVal;
   }
   values() {
     const retVal = [];
-    for (const key in this.store)
+    for (const key in this.store) {
       retVal.push(this.store[key]);
+    }
     return retVal;
   }
-}
-class DictionaryNoCase extends Dictionary {
+};
+__name(_Dictionary, "Dictionary");
+let Dictionary = _Dictionary;
+const _DictionaryNoCase = class _DictionaryNoCase extends Dictionary {
   constructor(attrs) {
     super(attrs);
   }
@@ -214,113 +315,145 @@ class DictionaryNoCase extends Dictionary {
   remove(key) {
     return super.remove(key.toLowerCase());
   }
-}
+};
+__name(_DictionaryNoCase, "DictionaryNoCase");
+let DictionaryNoCase = _DictionaryNoCase;
 function espTime2Seconds(duration) {
-  if (duration) {
-    if (!isNaN(Number(duration)))
-      return Number(duration);
-  } else
+  if (!duration) {
     return 0;
+  } else {
+    if (!isNaN(Number(duration))) {
+      return Number(duration);
+    }
+  }
   const nsIndex = duration.indexOf("ns");
-  if (nsIndex !== -1)
+  if (nsIndex !== -1) {
     return parseFloat(duration.substr(0, nsIndex)) / 1e9;
+  }
   const msIndex = duration.indexOf("ms");
-  if (msIndex !== -1)
+  if (msIndex !== -1) {
     return parseFloat(duration.substr(0, msIndex)) / 1e3;
+  }
   const sIndex = duration.indexOf("s");
-  if (sIndex !== -1 && duration.indexOf("days") === -1)
+  if (sIndex !== -1 && duration.indexOf("days") === -1) {
     return parseFloat(duration.substr(0, sIndex));
-  const dayTimeParts = duration.split(" days "), days = dayTimeParts.length > 1 ? parseFloat(dayTimeParts[0]) : 0, time = dayTimeParts.length > 1 ? dayTimeParts[1] : dayTimeParts[0];
+  }
+  const dayTimeParts = duration.split(" days ");
+  const days = dayTimeParts.length > 1 ? parseFloat(dayTimeParts[0]) : 0;
+  const time = dayTimeParts.length > 1 ? dayTimeParts[1] : dayTimeParts[0];
   let secs = 0;
   const timeParts = time.split(":").reverse();
-  for (let j = 0; j < timeParts.length; ++j)
+  for (let j = 0; j < timeParts.length; ++j) {
     secs += parseFloat(timeParts[j]) * Math.pow(60, j);
+  }
   return days * 24 * 60 * 60 + secs;
 }
-let GraphItem$1 = class {
+__name(espTime2Seconds, "espTime2Seconds");
+let GraphItem$1 = (_a = class {
+  _graph;
+  parent;
+  props = {};
   constructor(graph, parent) {
-    __publicField(this, "_graph");
-    __publicField(this, "parent");
-    __publicField(this, "props", {});
-    this._graph = graph, this.parent = parent;
-  }
-}, Subgraph$1 = class Subgraph extends GraphItem$1 {
+    this._graph = graph;
+    this.parent = parent;
+  }
+}, __name(_a, "GraphItem"), _a);
+let Subgraph$1 = (_b = class extends GraphItem$1 {
+  subgraphs = [];
+  vertices = [];
+  edges = [];
+  _;
   constructor(graph, parent, _) {
     super(graph, parent);
-    __publicField(this, "subgraphs", []);
-    __publicField(this, "vertices", []);
-    __publicField(this, "edges", []);
-    __publicField(this, "_");
-    parent && parent._addSubgraph(this), this._ = _;
+    if (parent) {
+      parent._addSubgraph(this);
+    }
+    this._ = _;
   }
-  remove(full = !0) {
+  remove(full = true) {
     this._graph.removeSubgraph(this, full);
   }
   createSubgraph(_) {
     return this._graph.createSubgraph(this, _);
   }
   _addSubgraph(subgraph) {
-    if (this.subgraphs.indexOf(subgraph) >= 0)
+    if (this.subgraphs.indexOf(subgraph) >= 0) {
       throw new Error("Subgraph already exists");
+    }
     this.subgraphs.push(subgraph);
   }
   _removeSubgraph(subgraph) {
     const idx = this.subgraphs.indexOf(subgraph);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Subgraph does not exist");
+    }
     this.subgraphs.splice(idx, 1);
   }
   removeAllSubgraphs() {
-    for (let i = this.subgraphs.length - 1; i >= 0; --i)
-      this._graph.removeSubgraph(this.subgraphs[i], !0);
+    for (let i = this.subgraphs.length - 1; i >= 0; --i) {
+      this._graph.removeSubgraph(this.subgraphs[i], true);
+    }
   }
   createVertex(_) {
     return this._graph.createVertex(this, _);
   }
   _addVertex(vertex) {
-    if (this.vertices.indexOf(vertex) >= 0)
+    if (this.vertices.indexOf(vertex) >= 0) {
       throw new Error("Vertex already exists");
+    }
     this.vertices.push(vertex);
   }
   _removeVertex(vertex) {
     const idx = this.vertices.indexOf(vertex);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Vertex does not exist");
+    }
     this.vertices.splice(idx, 1);
   }
   removeAllVertices() {
-    for (let i = this.vertices.length - 1; i >= 0; --i)
-      this._graph.removeVertex(this.vertices[i], !0);
+    for (let i = this.vertices.length - 1; i >= 0; --i) {
+      this._graph.removeVertex(this.vertices[i], true);
+    }
   }
   createEdge(source, target, _) {
     return this._graph.createEdge(this, source, target, _);
   }
   _addEdge(edge) {
-    if (this.edges.indexOf(edge) >= 0)
+    if (this.edges.indexOf(edge) >= 0) {
       throw new Error("Edge already exists");
+    }
     this.edges.push(edge);
   }
   _removeEdge(edge) {
     const idx = this.edges.indexOf(edge);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Edge does not exist");
+    }
     this.edges.splice(idx, 1);
   }
   _add(item) {
-    item instanceof Subgraph ? this._addSubgraph(item) : item instanceof Vertex$1 ? this._addVertex(item) : this._addEdge(item);
-  }
-}, Vertex$1 = class extends GraphItem$1 {
-  constructor(graph, parent, _) {
-    super(graph, parent);
-    __publicField(this, "inEdges", []);
-    __publicField(this, "outEdges", []);
-    __publicField(this, "_");
-    parent._addVertex(this), this._ = _;
+    if (item instanceof _b) {
+      this._addSubgraph(item);
+    } else if (item instanceof Vertex$1) {
+      this._addVertex(item);
+    } else {
+      this._addEdge(item);
+    }
   }
+}, __name(_b, "Subgraph"), _b);
+let Vertex$1 = (_c = class extends GraphItem$1 {
+  inEdges = [];
+  outEdges = [];
   get edges() {
     return [...this.inEdges, ...this.outEdges];
   }
-  remove(full = !0, _) {
+  _;
+  constructor(graph, parent, _) {
+    super(graph, parent);
+    parent._addVertex(this);
+    this._ = _;
+  }
+  remove(full = true, _) {
     return this._graph.removeVertex(this, full, _);
   }
   addInEdge(edge) {
@@ -328,8 +461,9 @@ let GraphItem$1 = class {
   }
   removeInEdge(edge) {
     const idx = this.inEdges.indexOf(edge);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("In edge does not exist");
+    }
     this.inEdges.splice(idx, 1);
   }
   addOutEdge(edge) {
@@ -337,47 +471,67 @@ let GraphItem$1 = class {
   }
   removeOutEdge(edge) {
     const idx = this.outEdges.indexOf(edge);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Out edge does not exist");
+    }
     this.outEdges.splice(idx, 1);
   }
-}, Edge$1 = class extends GraphItem$1 {
+}, __name(_c, "Vertex"), _c);
+let Edge$1 = (_d = class extends GraphItem$1 {
+  source;
+  target;
+  _;
   constructor(graph, parent, source, target, _) {
     super(graph, parent);
-    __publicField(this, "source");
-    __publicField(this, "target");
-    __publicField(this, "_");
-    if (!source)
+    if (!source) {
       throw new Error("Missing source vertex");
-    if (!target)
+    }
+    if (!target) {
       throw new Error("Missing target vertex");
-    parent._addEdge(this), this.source = source, this.source.addOutEdge(this), this.target = target, this.target.addInEdge(this), this._ = _;
+    }
+    parent._addEdge(this);
+    this.source = source;
+    this.source.addOutEdge(this);
+    this.target = target;
+    this.target.addInEdge(this);
+    this._ = _;
   }
   remove() {
     this._graph.removeEdge(this);
   }
-};
-class Graph {
+}, __name(_d, "Edge"), _d);
+const _Graph = class _Graph {
+  root;
+  _allSubgraphs = [];
+  _allSubgraphsMap = {};
+  _allVertices = [];
+  _allVerticesMap = {};
+  _allEdges = [];
+  _allEdgesMap = {};
+  idOf;
   constructor(idOf = (item) => "" + item._, _) {
-    __publicField(this, "root");
-    __publicField(this, "_allSubgraphs", []);
-    __publicField(this, "_allSubgraphsMap", {});
-    __publicField(this, "_allVertices", []);
-    __publicField(this, "_allVerticesMap", {});
-    __publicField(this, "_allEdges", []);
-    __publicField(this, "_allEdgesMap", {});
-    __publicField(this, "idOf");
-    this.root = new Subgraph$1(this, null, _), this.idOf = idOf;
+    this.root = new Subgraph$1(this, null, _);
+    this.idOf = idOf;
   }
   createSubgraph(parent, _) {
     const retVal = new Subgraph$1(this, parent || this.root, _);
-    return this._allSubgraphs.push(retVal), this._allSubgraphsMap[this.idOf(retVal)] = retVal, retVal;
+    this._allSubgraphs.push(retVal);
+    this._allSubgraphsMap[this.idOf(retVal)] = retVal;
+    return retVal;
   }
-  removeSubgraph(subgraph, full = !0) {
+  removeSubgraph(subgraph, full = true) {
     const idx = this._allSubgraphs.indexOf(subgraph);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Subgraph does not exist");
-    this._allSubgraphs.splice(idx, 1), delete this._allSubgraphsMap[this.idOf(subgraph)], subgraph.parent && subgraph.parent._removeSubgraph(subgraph), subgraph.edges.forEach((edge) => full ? this.removeEdge(edge) : subgraph.parent._addEdge(edge)), subgraph.vertices.forEach((vertex) => full ? this.removeVertex(vertex, full) : subgraph.parent._addVertex(vertex)), subgraph.subgraphs.forEach(
+    }
+    this._allSubgraphs.splice(idx, 1);
+    delete this._allSubgraphsMap[this.idOf(subgraph)];
+    if (subgraph.parent) {
+      subgraph.parent._removeSubgraph(subgraph);
+    }
+    subgraph.edges.forEach((edge) => full ? this.removeEdge(edge) : subgraph.parent._addEdge(edge));
+    subgraph.vertices.forEach((vertex) => full ? this.removeVertex(vertex, full) : subgraph.parent._addVertex(vertex));
+    subgraph.subgraphs.forEach(
       (childSubgraph) => full ? this.removeSubgraph(childSubgraph, full) : subgraph.parent._addSubgraph(childSubgraph)
     );
   }
@@ -389,17 +543,29 @@ class Graph {
   }
   createVertex(parent, _) {
     const retVal = new Vertex$1(this, parent, _);
-    return this._allVertices.push(retVal), this._allVerticesMap[this.idOf(retVal)] = retVal, retVal;
+    this._allVertices.push(retVal);
+    this._allVerticesMap[this.idOf(retVal)] = retVal;
+    return retVal;
   }
-  removeVertex(vertex, full = !0, _) {
+  removeVertex(vertex, full = true, _) {
     const idx = this._allVertices.indexOf(vertex);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Vertex does not exist");
-    this._allVertices.splice(idx, 1), delete this._allVerticesMap[this.idOf(vertex)], vertex.parent && vertex.parent._removeVertex(vertex), full || vertex.inEdges.forEach((inEdge) => {
-      vertex.outEdges.forEach((outEdge) => {
-        this.createEdge(this.root, inEdge.source, outEdge.target, _ ? _(inEdge.source._, outEdge.target._) : void 0);
+    }
+    this._allVertices.splice(idx, 1);
+    delete this._allVerticesMap[this.idOf(vertex)];
+    if (vertex.parent) {
+      vertex.parent._removeVertex(vertex);
+    }
+    if (!full) {
+      vertex.inEdges.forEach((inEdge) => {
+        vertex.outEdges.forEach((outEdge) => {
+          this.createEdge(this.root, inEdge.source, outEdge.target, _ ? _(inEdge.source._, outEdge.target._) : void 0);
+        });
       });
-    }), vertex.inEdges.forEach((edge) => this.removeEdge(edge)), vertex.outEdges.forEach((edge) => this.removeEdge(edge));
+    }
+    vertex.inEdges.forEach((edge) => this.removeEdge(edge));
+    vertex.outEdges.forEach((edge) => this.removeEdge(edge));
   }
   get vertices() {
     return this._allVertices;
@@ -409,13 +575,22 @@ class Graph {
   }
   createEdge(parent, source, target, _) {
     const retVal = new Edge$1(this, parent, source, target, _);
-    return this._allEdges.push(retVal), this._allEdgesMap[this.idOf(retVal)] = retVal, retVal;
+    this._allEdges.push(retVal);
+    this._allEdgesMap[this.idOf(retVal)] = retVal;
+    return retVal;
   }
   removeEdge(edge) {
     const idx = this._allEdges.indexOf(edge);
-    if (idx < 0)
+    if (idx < 0) {
       throw new Error("Edge does not exist");
-    this._allEdges.splice(idx, 1), delete this._allEdgesMap[this.idOf(edge)], edge.parent && edge.parent._removeEdge(edge), edge.source.removeOutEdge(edge), edge.target.removeInEdge(edge);
+    }
+    this._allEdges.splice(idx, 1);
+    delete this._allEdgesMap[this.idOf(edge)];
+    if (edge.parent) {
+      edge.parent._removeEdge(edge);
+    }
+    edge.source.removeOutEdge(edge);
+    edge.target.removeInEdge(edge);
   }
   get edges() {
     return this._allEdges;
@@ -424,76 +599,112 @@ class Graph {
     return this._allEdgesMap[id];
   }
   _walk(parent, visitor) {
-    for (const subgraph of parent.subgraphs)
+    for (const subgraph of parent.subgraphs) {
       switch (visitor(subgraph)) {
         case "abort":
-          return !0;
+          return true;
         case "stepover":
           break;
         default:
-          if (this._walk(subgraph, visitor)) return !0;
+          if (this._walk(subgraph, visitor)) return true;
       }
-    for (const vertex of parent.vertices)
-      if (visitor(vertex) === "abort") return !0;
+    }
+    for (const vertex of parent.vertices) {
+      if (visitor(vertex) === "abort") return true;
+    }
   }
   walk(visitor) {
     this._walk(this.root, visitor);
-    for (const edge of this._allEdges)
-      if (visitor(edge) === "abort") return !0;
+    for (const edge of this._allEdges) {
+      if (visitor(edge) === "abort") return true;
+    }
   }
   clone() {
-    const ctor = this.constructor, retVal = new ctor(this.idOf, this.root._), map = ObjMap();
-    return map.put(this.root, retVal.root), this.walk((item) => {
+    const ctor = this.constructor;
+    const retVal = new ctor(this.idOf, this.root._);
+    const map = ObjMap();
+    map.put(this.root, retVal.root);
+    this.walk((item) => {
       const parent = map.get(item.parent);
-      if (item instanceof Subgraph$1)
+      if (item instanceof Subgraph$1) {
         map.put(item, parent.createSubgraph(item._));
-      else if (item instanceof Vertex$1)
+      } else if (item instanceof Vertex$1) {
         map.put(item, parent.createVertex(item._));
-      else if (item instanceof Edge$1) {
-        const source = map.get(item.source), target = map.get(item.target);
+      } else if (item instanceof Edge$1) {
+        const source = map.get(item.source);
+        const target = map.get(item.target);
         parent.createEdge(source, target, item._);
       }
-    }), retVal;
+    });
+    return retVal;
   }
-}
+};
+__name(_Graph, "Graph");
+let Graph = _Graph;
 function ObjMap() {
-  const keys = [], values = [];
+  const keys = [];
+  const values = [];
   return {
     put(key, value) {
       const index = keys.indexOf(key);
-      index === -1 ? (keys.push(key), values.push(value)) : values[index] = value;
+      if (index === -1) {
+        keys.push(key);
+        values.push(value);
+      } else {
+        values[index] = value;
+      }
     },
     get(key) {
       return values[keys.indexOf(key)];
     }
   };
 }
-class GraphItem2 {
-  constructor(g, _) {
-    __publicField(this, "_graph");
-    __publicField(this, "_");
-    this._graph = g, this._ = _;
-  }
+__name(ObjMap, "ObjMap");
+const _GraphItem = class _GraphItem {
+  _graph;
+  _;
   id() {
     return this._graph.id(this._);
   }
-}
-class ChildGraphItem extends GraphItem2 {
+  constructor(g, _) {
+    this._graph = g;
+    this._ = _;
+  }
+};
+__name(_GraphItem, "GraphItem");
+let GraphItem = _GraphItem;
+const _ChildGraphItem = class _ChildGraphItem extends GraphItem {
+  _parent;
   constructor(g, _) {
     super(g, _);
-    __publicField(this, "_parent");
   }
   clearParent() {
-    return this._parent && (this._parent.removeChild(this), delete this._parent), this;
+    if (this._parent) {
+      this._parent.removeChild(this);
+      delete this._parent;
+    }
+    return this;
   }
   parent(_) {
-    return arguments.length === 0 ? this._parent : (this._parent !== _ && (this._parent && this._parent.removeChild(this), this._parent = _, this._parent && this._parent.addChild(this)), this);
+    if (arguments.length === 0) return this._parent;
+    if (this._parent !== _) {
+      if (this._parent) {
+        this._parent.removeChild(this);
+      }
+      this._parent = _;
+      if (this._parent) {
+        this._parent.addChild(this);
+      }
+    }
+    return this;
   }
-}
-class Subgraph2 extends ChildGraphItem {
+};
+__name(_ChildGraphItem, "ChildGraphItem");
+let ChildGraphItem = _ChildGraphItem;
+const _Subgraph = class _Subgraph extends ChildGraphItem {
+  _children = [];
   constructor(g, _) {
     super(g, _);
-    __publicField(this, "_children", []);
   }
   children() {
     return this._children;
@@ -504,12 +715,14 @@ class Subgraph2 extends ChildGraphItem {
   removeChild(_) {
     this._children = this._children.filter((row) => row.id !== _.id);
   }
-}
-class Vertex2 extends ChildGraphItem {
+};
+__name(_Subgraph, "Subgraph");
+let Subgraph = _Subgraph;
+const _Vertex = class _Vertex extends ChildGraphItem {
+  _inEdges = [];
+  _outEdges = [];
   constructor(g, _) {
     super(g, _);
-    __publicField(this, "_inEdges", []);
-    __publicField(this, "_outEdges", []);
   }
   edges() {
     return [...this._inEdges, ...this._outEdges];
@@ -535,57 +748,74 @@ class Vertex2 extends ChildGraphItem {
   removeOutEdge(id) {
     this._outEdges = this._outEdges.filter((e) => e._.id !== id);
   }
-}
-class Edge2 extends ChildGraphItem {
+};
+__name(_Vertex, "Vertex");
+let Vertex = _Vertex;
+const _Edge = class _Edge extends ChildGraphItem {
+  _source;
+  _target;
   constructor(g, _, source, target) {
     super(g, _);
-    __publicField(this, "_source");
-    __publicField(this, "_target");
-    this._source = source, this._target = target;
+    this._source = source;
+    this._target = target;
   }
-}
-class Graph2 {
-  constructor(directed = !0) {
-    __publicField(this, "_directed");
-    __publicField(this, "_subgraphMap", {});
-    __publicField(this, "_vertexMap", {});
-    __publicField(this, "_edgeMap", {});
-    __publicField(this, "_idFunc", (_) => typeof _.id == "function" ? _.id() : _.id);
-    __publicField(this, "_sourceFunc", (_) => typeof _.source == "function" ? _.source() : _.source);
-    __publicField(this, "_targetFunc", (_) => typeof _.target == "function" ? _.target() : _.target);
-    __publicField(this, "_updateFunc", (before, after) => after);
+};
+__name(_Edge, "Edge");
+let Edge = _Edge;
+const _Graph2 = class _Graph2 {
+  _directed;
+  _subgraphMap = {};
+  _vertexMap = {};
+  _edgeMap = {};
+  constructor(directed = true) {
     this._directed = directed;
   }
   clear() {
-    return this._subgraphMap = {}, this._vertexMap = {}, this._edgeMap = {}, this;
+    this._subgraphMap = {};
+    this._vertexMap = {};
+    this._edgeMap = {};
+    return this;
   }
   clearParents() {
-    for (const key in this._subgraphMap)
+    for (const key in this._subgraphMap) {
       this._subgraphMap[key].clearParent();
-    for (const key in this._vertexMap)
+    }
+    for (const key in this._vertexMap) {
       this._vertexMap[key].clearParent();
+    }
     return this;
   }
   isDirected() {
     return this._directed;
   }
+  _idFunc = /* @__PURE__ */ __name((_) => typeof _.id === "function" ? _.id() : _.id, "_idFunc");
   idFunc(_) {
-    return this._idFunc = _, this;
+    this._idFunc = _;
+    return this;
   }
+  _sourceFunc = /* @__PURE__ */ __name((_) => typeof _.source === "function" ? _.source() : _.source, "_sourceFunc");
   sourceFunc(_) {
-    return this._sourceFunc = _, this;
+    this._sourceFunc = _;
+    return this;
   }
+  _targetFunc = /* @__PURE__ */ __name((_) => typeof _.target === "function" ? _.target() : _.target, "_targetFunc");
   targetFunc(_) {
-    return this._targetFunc = _, this;
+    this._targetFunc = _;
+    return this;
   }
+  _updateFunc = /* @__PURE__ */ __name((before, after) => after, "_updateFunc");
   updateFunc(_) {
-    return this._updateFunc = _, this;
+    this._updateFunc = _;
+    return this;
   }
   id(_) {
     return this._idFunc(_);
   }
   type(id) {
-    return this.subgraphExists(id) ? "S" : this.vertexExists(id) ? "V" : this.edgeExists(id) ? "E" : "";
+    if (this.subgraphExists(id)) return "S";
+    if (this.vertexExists(id)) return "V";
+    if (this.edgeExists(id)) return "E";
+    return "";
   }
   isSubgraph(_) {
     return this.subgraphExists(this.id(_));
@@ -603,6 +833,7 @@ class Graph2 {
     if (this.subgraphExists(id)) return this.subgraph(id);
     if (this.vertexExists(id)) return this.vertex(id);
     if (this.edgeExists(id)) return this.edge(id);
+    return void 0;
   }
   itemExists(id) {
     return this.edgeExists(id) || this.vertexExists(id) || this.subgraphExists(id);
@@ -610,14 +841,18 @@ class Graph2 {
   // Subgraphs  ---
   allSubgraphs() {
     const retVal = [];
-    for (const key in this._subgraphMap)
+    for (const key in this._subgraphMap) {
       retVal.push(this._subgraphMap[key]._);
+    }
     return retVal;
   }
   subgraphs() {
     const retVal = [];
-    for (const key in this._subgraphMap)
-      this._subgraphMap[key].parent() === void 0 && retVal.push(this._subgraphMap[key]._);
+    for (const key in this._subgraphMap) {
+      if (this._subgraphMap[key].parent() === void 0) {
+        retVal.push(this._subgraphMap[key]._);
+      }
+    }
     return retVal;
   }
   subgraphExists(id) {
@@ -638,29 +873,45 @@ class Graph2 {
   addSubgraph(s, parent) {
     const s_id = this._idFunc(s);
     if (this._subgraphMap[s_id]) throw new Error(`Subgraph '${s_id}' already exists.`);
-    const subgraph = new Subgraph2(this, s);
+    const subgraph = new Subgraph(this, s);
     if (parent) {
       const p_id = this._idFunc(parent);
       if (!this._subgraphMap[p_id]) throw new Error(`Subgraph '${p_id}' does not exist.`);
       subgraph.parent(this._subgraphMap[p_id]);
     }
-    return this._subgraphMap[s_id] = subgraph, this;
+    this._subgraphMap[s_id] = subgraph;
+    return this;
   }
   mergeSubgraphs(_subgraphs = []) {
     const sgDiff = compare2(this.allSubgraphs(), _subgraphs, (sg) => this._idFunc(sg), this._updateFunc);
-    return sgDiff.exit.forEach((sg) => this.removeSubgraph(this._idFunc(sg))), sgDiff.enter.forEach((sg) => this.addSubgraph(sg)), sgDiff.update.forEach((sg) => this.updateSubgraph(sg)), this;
+    sgDiff.exit.forEach((sg) => this.removeSubgraph(this._idFunc(sg)));
+    sgDiff.enter.forEach((sg) => this.addSubgraph(sg));
+    sgDiff.update.forEach((sg) => this.updateSubgraph(sg));
+    return this;
   }
   updateSubgraph(sg) {
-    const sg_id = this._idFunc(sg), subgraph = this._subgraphMap[sg_id];
+    const sg_id = this._idFunc(sg);
+    const subgraph = this._subgraphMap[sg_id];
     if (!subgraph) throw new Error(`Subgraph '${sg_id}' does not exist.`);
-    return subgraph._ = sg, this;
+    subgraph._ = sg;
+    return this;
   }
-  removeSubgraph(id, promoteChildren = !0) {
+  removeSubgraph(id, promoteChildren = true) {
     const sg = this._subgraphMap[id];
     if (!sg) throw new Error(`Subgraph '${id}' does not exist.`);
-    return sg.children().forEach((child) => {
-      promoteChildren ? child.parent(sg.parent()) : child instanceof Subgraph2 ? this.removeSubgraph(child.id()) : this.removeVertex(child.id());
-    }), delete this._subgraphMap[id], this;
+    sg.children().forEach((child) => {
+      if (promoteChildren) {
+        child.parent(sg.parent());
+      } else {
+        if (child instanceof Subgraph) {
+          this.removeSubgraph(child.id());
+        } else {
+          this.removeVertex(child.id());
+        }
+      }
+    });
+    delete this._subgraphMap[id];
+    return this;
   }
   subgraphParent(id, parentID) {
     const item = this._subgraphMap[id];
@@ -671,19 +922,24 @@ class Graph2 {
     }
     const parent = this._subgraphMap[parentID];
     if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
-    return item.parent(parent), this;
+    item.parent(parent);
+    return this;
   }
   // Vertices  ---
   allVertices() {
     const retVal = [];
-    for (const key in this._vertexMap)
+    for (const key in this._vertexMap) {
       retVal.push(this._vertexMap[key]._);
+    }
     return retVal;
   }
   vertices() {
     const retVal = [];
-    for (const key in this._vertexMap)
-      this._vertexMap[key].parent() === void 0 && retVal.push(this._vertexMap[key]._);
+    for (const key in this._vertexMap) {
+      if (this._vertexMap[key].parent() === void 0) {
+        retVal.push(this._vertexMap[key]._);
+      }
+    }
     return retVal;
   }
   vertexExists(id) {
@@ -694,14 +950,18 @@ class Graph2 {
   }
   allEdges() {
     const retVal = [];
-    for (const key in this._edgeMap)
+    for (const key in this._edgeMap) {
       retVal.push(this._edgeMap[key]._);
+    }
     return retVal;
   }
   edges() {
     const retVal = [];
-    for (const key in this._edgeMap)
-      this._edgeMap[key].parent() === void 0 && retVal.push(this._edgeMap[key]._);
+    for (const key in this._edgeMap) {
+      if (this._edgeMap[key].parent() === void 0) {
+        retVal.push(this._edgeMap[key]._);
+      }
+    }
     return retVal;
   }
   vertexEdges(vertexID) {
@@ -725,29 +985,37 @@ class Graph2 {
   addVertex(v, parent) {
     const v_id = this._idFunc(v);
     if (this._vertexMap[v_id]) throw new Error(`Vertex '${v_id}' already exists.`);
-    const vertex = new Vertex2(this, v);
+    const vertex = new Vertex(this, v);
     if (parent) {
       const p_id = this._idFunc(parent);
       if (!this.subgraphExists(p_id)) throw new Error(`Subgraph '${p_id}' does not exist.`);
       vertex.parent(this._subgraphMap[p_id]);
     }
-    return this._vertexMap[v_id] = vertex, this;
+    this._vertexMap[v_id] = vertex;
+    return this;
   }
   mergeVertices(_vertices) {
     const vDiff = compare2(this.allVertices(), _vertices, (v) => this._idFunc(v), this._updateFunc);
-    return vDiff.exit.forEach((v) => this.removeVertex(this._idFunc(v))), vDiff.enter.forEach((v) => this.addVertex(v)), vDiff.update.forEach((v) => this.updateVertex(v)), this;
+    vDiff.exit.forEach((v) => this.removeVertex(this._idFunc(v)));
+    vDiff.enter.forEach((v) => this.addVertex(v));
+    vDiff.update.forEach((v) => this.updateVertex(v));
+    return this;
   }
   updateVertex(v) {
-    const v_id = this._idFunc(v), vertex = this._vertexMap[v_id];
+    const v_id = this._idFunc(v);
+    const vertex = this._vertexMap[v_id];
     if (!vertex) throw new Error(`Vertex '${v_id}' does not exist.`);
-    return vertex._ = v, this;
+    vertex._ = v;
+    return this;
   }
   removeVertex(id) {
     const v = this._vertexMap[id];
     if (!v) throw new Error(`Vertex '${id}' does not exist.`);
-    return v.edges().forEach((e) => {
+    v.edges().forEach((e) => {
       this.removeEdge(e.id());
-    }), delete this._vertexMap[id], this;
+    });
+    delete this._vertexMap[id];
+    return this;
   }
   vertexParent(id, parentID) {
     const item = this._vertexMap[id];
@@ -758,7 +1026,8 @@ class Graph2 {
     }
     const parent = this._subgraphMap[parentID];
     if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
-    return item.parent(parent), this;
+    item.parent(parent);
+    return this;
   }
   // Edges  ---
   edgeExists(id) {
@@ -768,30 +1037,50 @@ class Graph2 {
     return this._edgeMap[id]._;
   }
   addEdge(e, parent) {
-    const e_id = this._idFunc(e), e_source = this._sourceFunc(e), e_target = this._targetFunc(e);
+    const e_id = this._idFunc(e);
+    const e_source = this._sourceFunc(e);
+    const e_target = this._targetFunc(e);
     if (this._edgeMap[e_id]) throw new Error(`Edge '${e_id}' already exists.`);
     if (!this.vertexExists(e_source)) throw new Error(`Edge Source '${e_source}' does not exist.`);
     if (!this.vertexExists(e_target)) throw new Error(`Edge Target '${e_target}' does not exist.`);
-    const edge = new Edge2(this, e, this._vertexMap[e_source], this._vertexMap[e_target]);
+    const edge = new Edge(this, e, this._vertexMap[e_source], this._vertexMap[e_target]);
     if (parent) {
       const p_id = this._idFunc(parent);
       if (!this.subgraphExists(p_id)) throw new Error(`Subgraph '${p_id}' does not exist.`);
       edge.parent(this._subgraphMap[p_id]);
     }
-    return this._edgeMap[e_id] = edge, this._vertexMap[e_source].addOutEdge(edge), this._vertexMap[e_target].addInEdge(edge), this;
+    this._edgeMap[e_id] = edge;
+    this._vertexMap[e_source].addOutEdge(edge);
+    this._vertexMap[e_target].addInEdge(edge);
+    return this;
   }
   mergeEdges(_edges) {
     const eDiff = compare2(this.allEdges(), _edges, (e) => this._idFunc(e), this._updateFunc);
-    return eDiff.exit.forEach((e) => this.removeEdge(this._idFunc(e))), eDiff.enter.forEach((e) => this.addEdge(e)), eDiff.update.forEach((e) => this.updateEdge(e)), this;
+    eDiff.exit.forEach((e) => this.removeEdge(this._idFunc(e)));
+    eDiff.enter.forEach((e) => this.addEdge(e));
+    eDiff.update.forEach((e) => this.updateEdge(e));
+    return this;
   }
   updateEdge(e) {
-    var _a, _b, _c, _d;
-    const e_id = this._idFunc(e), edge = this._edgeMap[e_id];
+    const e_id = this._idFunc(e);
+    const edge = this._edgeMap[e_id];
     if (!edge) throw new Error(`Edge '${e_id}' does not exist.`);
-    const old_source = edge._source.id(), new_source = this._sourceFunc(e);
-    old_source !== new_source && ((_a = this._vertexMap[old_source]) == null || _a.removeOutEdge(e_id), (_b = this._vertexMap[new_source]) == null || _b.addOutEdge(edge));
-    const old_target = edge._target.id(), new_target = this._targetFunc(e);
-    return old_target !== new_target && ((_c = this._vertexMap[old_target]) == null || _c.removeInEdge(e_id), (_d = this._vertexMap[new_target]) == null || _d.addInEdge(edge)), edge._ = e, edge._source = this._vertexMap[new_source], edge._target = this._vertexMap[new_target], this;
+    const old_source = edge._source.id();
+    const new_source = this._sourceFunc(e);
+    if (old_source !== new_source) {
+      this._vertexMap[old_source]?.removeOutEdge(e_id);
+      this._vertexMap[new_source]?.addOutEdge(edge);
+    }
+    const old_target = edge._target.id();
+    const new_target = this._targetFunc(e);
+    if (old_target !== new_target) {
+      this._vertexMap[old_target]?.removeInEdge(e_id);
+      this._vertexMap[new_target]?.addInEdge(edge);
+    }
+    edge._ = e;
+    edge._source = this._vertexMap[new_source];
+    edge._target = this._vertexMap[new_target];
+    return this;
   }
   removeEdge(id) {
     const e = this._edgeMap[id];
@@ -801,71 +1090,118 @@ class Graph2 {
     this._vertexMap[e_sourceID].removeOutEdge(id);
     const e_targetID = this._idFunc(e._target._);
     if (!this.vertexExists(e_targetID)) throw new Error(`Edge Target'${e_targetID}' does not exist.`);
-    return this._vertexMap[e_targetID].removeInEdge(id), delete this._edgeMap[id], this;
+    this._vertexMap[e_targetID].removeInEdge(id);
+    delete this._edgeMap[id];
+    return this;
   }
   _hwalk(item, formatter) {
-    return item instanceof Subgraph2 ? formatter("subgraph", item._, item.children().map((child) => this._hwalk(child, formatter))) : formatter("vertex", item._);
+    if (item instanceof Subgraph) {
+      return formatter("subgraph", item._, item.children().map((child) => this._hwalk(child, formatter)));
+    } else {
+      return formatter("vertex", item._);
+    }
   }
   hierarchy(formatter) {
     const retVal = [];
     for (const id in this._subgraphMap) {
       const sg = this._subgraphMap[id];
-      sg.parent() === void 0 && retVal.push(this._hwalk(sg, formatter));
+      if (sg.parent() === void 0) {
+        retVal.push(this._hwalk(sg, formatter));
+      }
     }
     for (const id in this._vertexMap) {
       const v = this._vertexMap[id];
-      v.parent() === void 0 && retVal.push(this._hwalk(v, formatter));
+      if (v.parent() === void 0) {
+        retVal.push(this._hwalk(v, formatter));
+      }
     }
     return retVal;
   }
   dijkstra(source, target) {
-    const edges = this.allEdges(), Q = new Set(), prev = {}, dist = {}, adj = {};
+    const edges = this.allEdges();
+    const Q = new Set();
+    const prev = {};
+    const dist = {};
+    const adj = {};
     function vertex_with_min_dist(Q2, dist2) {
-      let min_distance = 1 / 0, u2 = null;
-      return Q2.forEach((v) => {
-        dist2[v] < min_distance && (min_distance = dist2[v], u2 = v);
-      }), u2;
+      let min_distance = Infinity;
+      let u2 = null;
+      Q2.forEach((v) => {
+        if (dist2[v] < min_distance) {
+          min_distance = dist2[v];
+          u2 = v;
+        }
+      });
+      return u2;
     }
+    __name(vertex_with_min_dist, "vertex_with_min_dist");
     for (let i = 0; i < edges.length; i++) {
-      const v1 = this._sourceFunc(edges[i]), v2 = this._targetFunc(edges[i]), len2 = 1;
-      Q.add(v1), Q.add(v2), dist[v1] = 1 / 0, dist[v2] = 1 / 0, adj[v1] === void 0 && (adj[v1] = {}), adj[v2] === void 0 && (adj[v2] = {}), adj[v1][v2] = len2, adj[v2][v1] = len2;
+      const v1 = this._sourceFunc(edges[i]);
+      const v2 = this._targetFunc(edges[i]);
+      const len2 = 1;
+      Q.add(v1);
+      Q.add(v2);
+      dist[v1] = Infinity;
+      dist[v2] = Infinity;
+      if (adj[v1] === void 0) adj[v1] = {};
+      if (adj[v2] === void 0) adj[v2] = {};
+      adj[v1][v2] = len2;
+      adj[v2][v1] = len2;
     }
-    for (dist[source] = 0; Q.size; ) {
+    dist[source] = 0;
+    while (Q.size) {
       const u2 = vertex_with_min_dist(Q, dist);
       if (u2 === null) break;
       const neighbors = Object.keys(adj[u2]).filter((v) => Q.has(v));
-      if (Q.delete(u2), u2 === target) break;
+      Q.delete(u2);
+      if (u2 === target) break;
       for (const v of neighbors) {
         const alt = dist[u2] + adj[u2][v];
-        alt < dist[v] && (dist[v] = alt, prev[v] = u2);
+        if (alt < dist[v]) {
+          dist[v] = alt;
+          prev[v] = u2;
+        }
       }
     }
     let u = target;
     const ids = [u];
     let len = 0;
-    for (; prev[u] !== void 0; )
-      ids.unshift(prev[u]), len += adj[u][prev[u]], u = prev[u];
+    while (prev[u] !== void 0) {
+      ids.unshift(prev[u]);
+      len += adj[u][prev[u]];
+      u = prev[u];
+    }
     return { ids, len };
   }
   sort(v_id) {
-    const retVal = [], visited = {}, visit = (vertex, ancestors = []) => {
+    const retVal = [];
+    const visited = {};
+    const visit = /* @__PURE__ */ __name((vertex, ancestors = []) => {
       const v_id2 = vertex.id();
-      visited[v_id2] || (visited[v_id2] = !0, ancestors.push(vertex), vertex.outEdges().forEach((e) => {
-        ancestors.indexOf(e._target) < 0 && visit(e._target, [...ancestors]);
-      }), retVal.unshift(vertex._));
-    };
-    if (v_id)
+      if (visited[v_id2]) return;
+      visited[v_id2] = true;
+      ancestors.push(vertex);
+      vertex.outEdges().forEach((e) => {
+        if (ancestors.indexOf(e._target) < 0) {
+          visit(e._target, [...ancestors]);
+        }
+      });
+      retVal.unshift(vertex._);
+    }, "visit");
+    if (v_id) {
       visit(this._vertexMap[v_id]);
-    else
-      for (const key in this._vertexMap)
+    } else {
+      for (const key in this._vertexMap) {
         visit(this._vertexMap[key]);
+      }
+    }
     return retVal;
   }
-}
-class Set {
-  constructor() {
-    __publicField(this, "_content", []);
-  }
+};
+__name(_Graph2, "Graph2");
+let Graph2 = _Graph2;
+const _Set = class _Set {
+  _content = [];
   get size() {
     return this._content.length;
   }
@@ -873,124 +1209,184 @@ class Set {
     return this._content.indexOf(_) >= 0;
   }
   add(_) {
-    this.has(_) || this._content.push(_);
+    if (!this.has(_)) {
+      this._content.push(_);
+    }
   }
   delete(_) {
     const idx = this._content.indexOf(_);
-    idx >= 0 && this._content.splice(idx, 1);
+    if (idx >= 0) {
+      this._content.splice(idx, 1);
+    }
   }
   forEach(_) {
     this._content.forEach(_);
   }
-}
-const isArray$1 = Array.isArray, keyList = Object.keys, hasProp = Object.prototype.hasOwnProperty;
-function verboseDeepEquals(a, b, functionRefCompare = !1) {
-  if (a === b) return !0;
+};
+__name(_Set, "Set");
+let Set = _Set;
+const isArray$1 = Array.isArray;
+const keyList = Object.keys;
+const hasProp = Object.prototype.hasOwnProperty;
+function verboseDeepEquals(a, b, functionRefCompare = false) {
+  if (a === b) return true;
   if (a && b) {
-    if (typeof a == "object" && typeof b == "object") {
-      const arrA = isArray$1(a), arrB = isArray$1(b);
-      let i, length, key;
+    if (typeof a === "object" && typeof b === "object") {
+      const arrA = isArray$1(a);
+      const arrB = isArray$1(b);
+      let i;
+      let length;
+      let key;
       if (arrA && arrB) {
-        if (length = a.length, length !== b.length)
-          return console.warn(`lengths not equal: ${length} !== ${b.length}`), !1;
+        length = a.length;
+        if (length !== b.length) {
+          console.warn(`lengths not equal: ${length} !== ${b.length}`);
+          return false;
+        }
         for (i = length; i-- !== 0; )
-          if (!verboseDeepEquals(a[i], b[i], functionRefCompare))
-            return !1;
-        return !0;
+          if (!verboseDeepEquals(a[i], b[i], functionRefCompare)) {
+            return false;
+          }
+        return true;
+      }
+      if (arrA !== arrB) {
+        console.warn(`arrays not equal: ${arrA} !== ${arrB}`);
+        return false;
+      }
+      const dateA = a instanceof Date;
+      const dateB = b instanceof Date;
+      if (dateA !== dateB) {
+        console.warn(`dates not equal: ${dateA} !== ${dateB}`);
+        return false;
       }
-      if (arrA !== arrB)
-        return console.warn(`arrays not equal: ${arrA} !== ${arrB}`), !1;
-      const dateA = a instanceof Date, dateB = b instanceof Date;
-      if (dateA !== dateB)
-        return console.warn(`dates not equal: ${dateA} !== ${dateB}`), !1;
       if (dateA && dateB) {
         const retVal2 = a.getTime() === b.getTime();
-        return retVal2 || console.warn(`dates not equal: ${a.getTime()} !== ${b.getTime()}`), retVal2;
+        if (!retVal2) {
+          console.warn(`dates not equal: ${a.getTime()} !== ${b.getTime()}`);
+        }
+        return retVal2;
+      }
+      const regexpA = a instanceof RegExp;
+      const regexpB = b instanceof RegExp;
+      if (regexpA !== regexpB) {
+        console.warn(`regexps not equal: ${regexpA} !== ${regexpB}`);
+        return false;
       }
-      const regexpA = a instanceof RegExp, regexpB = b instanceof RegExp;
-      if (regexpA !== regexpB)
-        return console.warn(`regexps not equal: ${regexpA} !== ${regexpB}`), !1;
       if (regexpA && regexpB) {
         const retVal2 = a.toString() === b.toString();
-        return retVal2 || console.warn(`regexps not equal: ${a.toString()} !== ${b.toString()}`), retVal2;
+        if (!retVal2) {
+          console.warn(`regexps not equal: ${a.toString()} !== ${b.toString()}`);
+        }
+        return retVal2;
       }
       const keys = keyList(a);
-      if (length = keys.length, length !== keyList(b).length)
-        return console.warn(`key lengths not equal: ${length} !== ${keyList(b).length}`), !1;
-      for (i = length; i-- !== 0; )
-        if (!hasProp.call(b, keys[i]))
-          return console.warn(`${keys[i]} in a but not b`), !1;
+      length = keys.length;
+      if (length !== keyList(b).length) {
+        console.warn(`key lengths not equal: ${length} !== ${keyList(b).length}`);
+        return false;
+      }
       for (i = length; i-- !== 0; )
-        if (key = keys[i], !verboseDeepEquals(a[key], b[key], functionRefCompare))
-          return !1;
-      return !0;
-    } else if (!functionRefCompare && typeof a == "function" && typeof b == "function") {
+        if (!hasProp.call(b, keys[i])) {
+          console.warn(`${keys[i]} in a but not b`);
+          return false;
+        }
+      for (i = length; i-- !== 0; ) {
+        key = keys[i];
+        if (!verboseDeepEquals(a[key], b[key], functionRefCompare)) {
+          return false;
+        }
+      }
+      return true;
+    } else if (!functionRefCompare && typeof a === "function" && typeof b === "function") {
       const retVal2 = a.toString() === b.toString();
-      return retVal2 || console.warn(`functions not equal: ${a.toString()} !== ${b.toString()}`), retVal2;
+      if (!retVal2) {
+        console.warn(`functions not equal: ${a.toString()} !== ${b.toString()}`);
+      }
+      return retVal2;
     }
   }
   const retVal = a !== a && b !== b;
-  return retVal || console.warn(`values not equal: ${a} !== ${b}`), retVal;
+  if (!retVal) {
+    console.warn(`values not equal: ${a} !== ${b}`);
+  }
+  return retVal;
 }
-function deepEquals(a, b, functionRefCompare = !1) {
-  if (a === b) return !0;
+__name(verboseDeepEquals, "verboseDeepEquals");
+function deepEquals(a, b, functionRefCompare = false) {
+  if (a === b) return true;
   if (a && b) {
-    if (typeof a == "object" && typeof b == "object") {
-      const arrA = isArray$1(a), arrB = isArray$1(b);
-      let i, length, key;
+    if (typeof a === "object" && typeof b === "object") {
+      const arrA = isArray$1(a);
+      const arrB = isArray$1(b);
+      let i;
+      let length;
+      let key;
       if (arrA && arrB) {
-        if (length = a.length, length !== b.length) return !1;
+        length = a.length;
+        if (length !== b.length) return false;
         for (i = length; i-- !== 0; )
-          if (!deepEquals(a[i], b[i], functionRefCompare)) return !1;
-        return !0;
+          if (!deepEquals(a[i], b[i], functionRefCompare)) return false;
+        return true;
       }
-      if (arrA !== arrB) return !1;
-      const dateA = a instanceof Date, dateB = b instanceof Date;
-      if (dateA !== dateB) return !1;
+      if (arrA !== arrB) return false;
+      const dateA = a instanceof Date;
+      const dateB = b instanceof Date;
+      if (dateA !== dateB) return false;
       if (dateA && dateB) return a.getTime() === b.getTime();
-      const regexpA = a instanceof RegExp, regexpB = b instanceof RegExp;
-      if (regexpA !== regexpB) return !1;
+      const regexpA = a instanceof RegExp;
+      const regexpB = b instanceof RegExp;
+      if (regexpA !== regexpB) return false;
       if (regexpA && regexpB) return a.toString() === b.toString();
       const keys = keyList(a);
-      if (length = keys.length, length !== keyList(b).length)
-        return !1;
-      for (i = length; i-- !== 0; )
-        if (!hasProp.call(b, keys[i])) return !1;
+      length = keys.length;
+      if (length !== keyList(b).length)
+        return false;
       for (i = length; i-- !== 0; )
-        if (key = keys[i], !deepEquals(a[key], b[key], functionRefCompare)) return !1;
-      return !0;
-    } else if (!functionRefCompare && typeof a == "function" && typeof b == "function")
+        if (!hasProp.call(b, keys[i])) return false;
+      for (i = length; i-- !== 0; ) {
+        key = keys[i];
+        if (!deepEquals(a[key], b[key], functionRefCompare)) return false;
+      }
+      return true;
+    } else if (!functionRefCompare && typeof a === "function" && typeof b === "function") {
       return a.toString() === b.toString();
+    }
   }
   return a !== a && b !== b;
 }
-function update(origItem, newItem, functionRefCompare = !1) {
+__name(deepEquals, "deepEquals");
+function update(origItem, newItem, functionRefCompare = false) {
   return deepEquals(origItem, newItem, functionRefCompare) ? origItem : newItem;
 }
-const root = typeof globalThis < "u" ? globalThis : window, isBrowser = typeof window < "u" && root === window, isNode = typeof process < "u" && process.versions != null && process.versions.node != null, isCI = isNode && process.env != null && (process.env.TRAVIS != null || process.env.GITHUB_ACTIONS != null);
+__name(update, "update");
+const root = typeof globalThis !== "undefined" ? globalThis : window;
+const isBrowser = typeof window !== "undefined" && root === window;
+const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+const isCI = isNode && process.env != null && (process.env.TRAVIS != null || process.env.GITHUB_ACTIONS != null || process.env.CI != null);
 function getScriptSrc(partial) {
   const scripts = document.scripts || [];
   for (let i = document.scripts.length - 1; i >= 0; --i) {
     const script = scripts[i];
     if (script.src) {
       const idx = script.src.indexOf(partial);
-      if (idx >= 0)
+      if (idx >= 0) {
         return script.src.substring(0, idx);
+      }
     }
   }
   return "";
 }
-class Stack {
-  constructor() {
-    __publicField(this, "stack", []);
-  }
+__name(getScriptSrc, "getScriptSrc");
+const _Stack = class _Stack {
+  stack = [];
   /**
    * Push element onto the stack
    *
    * @param e - element to push
    */
   push(e) {
-    return this.stack.push(e), e;
+    this.stack.push(e);
+    return e;
   }
   /**
    * Pop element off the stack
@@ -1014,8 +1410,20 @@ class Stack {
   depth() {
     return this.stack.length;
   }
-}
-var Level = /* @__PURE__ */ ((Level2) => (Level2[Level2.debug = 0] = "debug", Level2[Level2.info = 1] = "info", Level2[Level2.notice = 2] = "notice", Level2[Level2.warning = 3] = "warning", Level2[Level2.error = 4] = "error", Level2[Level2.critical = 5] = "critical", Level2[Level2.alert = 6] = "alert", Level2[Level2.emergency = 7] = "emergency", Level2))(Level || {});
+};
+__name(_Stack, "Stack");
+let Stack = _Stack;
+var Level = /* @__PURE__ */ ((Level2) => {
+  Level2[Level2["debug"] = 0] = "debug";
+  Level2[Level2["info"] = 1] = "info";
+  Level2[Level2["notice"] = 2] = "notice";
+  Level2[Level2["warning"] = 3] = "warning";
+  Level2[Level2["error"] = 4] = "error";
+  Level2[Level2["critical"] = 5] = "critical";
+  Level2[Level2["alert"] = 6] = "alert";
+  Level2[Level2["emergency"] = 7] = "emergency";
+  return Level2;
+})(Level || {});
 const colours = {
   debug: "cyan",
   info: "green",
@@ -1026,39 +1434,58 @@ const colours = {
   alert: "magenta",
   emergency: "magenta"
 };
-class ConsoleWriter {
+const _ConsoleWriter = class _ConsoleWriter {
   write(dateTime, level, id, msg) {
-    isNode ? console.log(`[${dateTime}] ${Level[level].toUpperCase()} ${id}:  ${msg}`) : console.log(`[${dateTime}] %c${Level[level].toUpperCase()}%c ${id}:  ${msg}`, `color:${colours[Level[level]]}`, "");
-  }
-}
-class Logging {
-  constructor() {
-    __publicField(this, "_levelStack", new Stack());
-    __publicField(this, "_level", 1);
-    __publicField(this, "_filter", "");
-    __publicField(this, "_writer", new ConsoleWriter());
+    if (isNode) {
+      console.log(`[${dateTime}] ${Level[level].toUpperCase()} ${id}:  ${msg}`);
+    } else {
+      console.log(`[${dateTime}] %c${Level[level].toUpperCase()}%c ${id}:  ${msg}`, `color:${colours[Level[level]]}`, "");
+    }
   }
+};
+__name(_ConsoleWriter, "ConsoleWriter");
+let ConsoleWriter = _ConsoleWriter;
+const _Logging = class _Logging {
+  _levelStack = new Stack();
+  _level = 1;
+  _filter = "";
+  _writer = new ConsoleWriter();
   static Instance() {
     return this._instance || (this._instance = new this());
   }
+  constructor() {
+  }
   stringify(obj) {
     const cache = [];
     return JSON.stringify(obj, function(_key, value) {
-      if (typeof value == "object" && value !== null) {
-        if (cache.indexOf(value) !== -1)
+      if (typeof value === "object" && value !== null) {
+        if (cache.indexOf(value) !== -1) {
           return;
+        }
         cache.push(value);
       }
       return value;
     }, 2);
   }
   writer(_) {
-    return _ === void 0 ? this._writer : (this._writer = _, this);
+    if (_ === void 0) return this._writer;
+    this._writer = _;
+    return this;
   }
   log(level, id, msg) {
-    if (level < this._level || this._filter && this._filter !== id) return;
+    if (level < this._level) return;
+    if (this._filter && this._filter !== id) return;
     const dateTime = (/* @__PURE__ */ new Date()).toISOString();
-    this._writer.rawWrite ? this._writer.rawWrite(dateTime, level, id, msg) : (typeof msg != "string" && (msg = this.stringify(msg)), this._writer.write && this._writer.write(dateTime, level, id, msg));
+    if (this._writer.rawWrite) {
+      this._writer.rawWrite(dateTime, level, id, msg);
+    } else {
+      if (typeof msg !== "string") {
+        msg = this.stringify(msg);
+      }
+      if (this._writer.write) {
+        this._writer.write(dateTime, level, id, msg);
+      }
+    }
   }
   debug(id, msg) {
     this.log(0, id, msg);
@@ -1085,23 +1512,32 @@ class Logging {
     this.log(7, id, msg);
   }
   level(_) {
-    return _ === void 0 ? this._level : (this._level = _, this);
+    if (_ === void 0) return this._level;
+    this._level = _;
+    return this;
   }
   pushLevel(_) {
-    return this._levelStack.push(this._level), this._level = _, this;
+    this._levelStack.push(this._level);
+    this._level = _;
+    return this;
   }
   popLevel() {
-    return this._level = this._levelStack.pop(), this;
+    this._level = this._levelStack.pop();
+    return this;
   }
   filter(_) {
-    return _ === void 0 ? this._filter : (this._filter = _, this);
+    if (_ === void 0) return this._filter;
+    this._filter = _;
+    return this;
   }
-}
-__publicField(Logging, "_instance");
+};
+__name(_Logging, "Logging");
+__publicField(_Logging, "_instance");
+let Logging = _Logging;
 const logger = Logging.Instance();
-class ScopedLogging {
+const _ScopedLogging = class _ScopedLogging {
+  _scopeID;
   constructor(scopeID) {
-    __publicField(this, "_scopeID");
     this._scopeID = scopeID;
   }
   debug(msg) {
@@ -1129,102 +1565,141 @@ class ScopedLogging {
     logger.emergency(this._scopeID, msg);
   }
   pushLevel(_) {
-    return logger.pushLevel(_), this;
+    logger.pushLevel(_);
+    return this;
   }
   popLevel() {
-    return logger.popLevel(), this;
+    logger.popLevel();
+    return this;
   }
+};
+__name(_ScopedLogging, "ScopedLogging");
+let ScopedLogging = _ScopedLogging;
+function scopedLogger(scopeID, filter = false) {
+  if (filter) {
+    logger.filter(scopeID);
+  }
+  return new ScopedLogging(scopeID);
 }
-function scopedLogger(scopeID, filter = !1) {
-  return filter && logger.filter(scopeID), new ScopedLogging(scopeID);
-}
+__name(scopedLogger, "scopedLogger");
 function degreesToRadians(degrees) {
   return degrees * (Math.PI / 180);
 }
+__name(degreesToRadians, "degreesToRadians");
 function radiansToDegrees(radians) {
   return radians * (180 / Math.PI);
 }
+__name(radiansToDegrees, "radiansToDegrees");
 function polarToCartesian(r, theta) {
   return {
     x: r * Math.cos(theta),
     y: r * Math.sin(theta)
   };
 }
+__name(polarToCartesian, "polarToCartesian");
 function cartesianToPolar(x, y) {
   return {
     r: Math.sqrt(x * x + y * y),
     theta: Math.atan2(y, x)
   };
 }
+__name(cartesianToPolar, "cartesianToPolar");
 function normalizeRadians(radians, min = -Math.PI, max = Math.PI) {
   return normalize(radians, min, max);
 }
+__name(normalizeRadians, "normalizeRadians");
 function normalizeDegrees(degrees, min = -180, max = 180) {
   return normalize(degrees, min, max);
 }
+__name(normalizeDegrees, "normalizeDegrees");
 function normalize(value, min, max) {
-  const spread = max - min, offsetValue = value - min;
+  const spread = max - min;
+  const offsetValue = value - min;
   return offsetValue - Math.floor(offsetValue / spread) * spread + min;
 }
+__name(normalize, "normalize");
 function inner(prop, obj) {
-  if (!(prop === void 0 || obj === void 0)) {
-    for (const item of prop.split(".")) {
-      if (!obj.hasOwnProperty(item))
-        return;
-      obj = obj[item];
+  if (prop === void 0 || obj === void 0) return void 0;
+  for (const item of prop.split(".")) {
+    if (!obj.hasOwnProperty(item)) {
+      return void 0;
     }
-    return obj;
+    obj = obj[item];
   }
+  return obj;
 }
+__name(inner, "inner");
 function exists(prop, obj) {
   return inner(prop, obj) !== void 0;
 }
+__name(exists, "exists");
 function _mixin(dest, source) {
   const empty = {};
   for (const key in source) {
-    if (!source.hasOwnProperty(key) || key === "__proto__" || key === "constructor") continue;
+    if (!source.hasOwnProperty(key)) continue;
+    if (key === "__proto__" || key === "constructor") continue;
     let s = source[key];
-    s instanceof Array || typeof s == "object" && (s = deepMixin(dest[key], s)), (!(key in dest) || dest[key] !== s && (!(key in empty) || empty[key] !== s)) && (dest[key] = s);
+    if (s instanceof Array) ;
+    else if (typeof s === "object") {
+      s = deepMixin(dest[key], s);
+    }
+    if (!(key in dest) || dest[key] !== s && (!(key in empty) || empty[key] !== s)) {
+      dest[key] = s;
+    }
   }
   return dest;
 }
+__name(_mixin, "_mixin");
 function deepMixin(dest = {}, ...sources) {
-  if (typeof dest != "object") throw new Error(`Destination "${dest}" must be an object.`);
-  for (const source of sources)
+  if (typeof dest !== "object") throw new Error(`Destination "${dest}" must be an object.`);
+  for (const source of sources) {
     _mixin(dest, source);
+  }
   return dest;
 }
+__name(deepMixin, "deepMixin");
 function deepMixinT(dest = {}, ...sources) {
   return deepMixin(dest, ...sources);
 }
+__name(deepMixinT, "deepMixinT");
 function safeStringify(obj) {
   const cache = [];
   return JSON.stringify(obj, function(key, value) {
-    if (typeof value == "object" && value !== null) {
-      if (cache.indexOf(value) !== -1)
+    if (typeof value === "object" && value !== null) {
+      if (cache.indexOf(value) !== -1) {
         return;
+      }
       cache.push(value);
     }
     return value;
   });
 }
+__name(safeStringify, "safeStringify");
 function isArray(arg) {
-  return Array.isArray !== void 0 ? Array.isArray(arg) : Object.prototype.toString.call(arg) === "[object Array]";
+  if (Array.isArray !== void 0) {
+    return Array.isArray(arg);
+  }
+  return Object.prototype.toString.call(arg) === "[object Array]";
 }
+__name(isArray, "isArray");
 function classID2Meta(classID) {
-  const info = classID.split("_"), classInfo = info[1].split(".");
+  const info = classID.split("_");
+  const classInfo = info[1].split(".");
   return {
     module: `@hpcc-js/${info[0]}`,
     file: classInfo[0],
     class: classInfo[1] || classInfo[0]
   };
 }
-class ObserverHandle {
+__name(classID2Meta, "classID2Meta");
+const _ObserverHandle = class _ObserverHandle {
+  eventTarget;
+  eventID;
+  callback;
   constructor(eventTarget, eventID, callback) {
-    __publicField(this, "eventTarget");
-    __publicField(this, "eventID");
-    __publicField(this, "callback");
-    this.eventTarget = eventTarget, this.eventID = eventID, this.callback = callback;
+    this.eventTarget = eventTarget;
+    this.eventID = eventID;
+    this.callback = callback;
   }
   release() {
     this.eventTarget.removeObserver(this.eventID, this.callback);
@@ -1232,90 +1707,122 @@ class ObserverHandle {
   unwatch() {
     this.release();
   }
-}
-class Observable {
+};
+__name(_ObserverHandle, "ObserverHandle");
+let ObserverHandle = _ObserverHandle;
+const _Observable = class _Observable {
+  _eventObservers = {};
   constructor(...events) {
-    __publicField(this, "_eventObservers", {});
   }
   addObserver(eventID, callback) {
     let eventObservers = this._eventObservers[eventID];
-    return eventObservers || (eventObservers = [], this._eventObservers[eventID] = eventObservers), eventObservers.push(callback), new ObserverHandle(this, eventID, callback);
+    if (!eventObservers) {
+      eventObservers = [];
+      this._eventObservers[eventID] = eventObservers;
+    }
+    eventObservers.push(callback);
+    return new ObserverHandle(this, eventID, callback);
   }
   removeObserver(eventID, callback) {
     const eventObservers = this._eventObservers[eventID];
-    if (eventObservers)
-      for (let i = eventObservers.length - 1; i >= 0; --i)
-        eventObservers[i] === callback && eventObservers.splice(i, 1);
+    if (eventObservers) {
+      for (let i = eventObservers.length - 1; i >= 0; --i) {
+        if (eventObservers[i] === callback) {
+          eventObservers.splice(i, 1);
+        }
+      }
+    }
     return this;
   }
   dispatchEvent(eventID, ...args) {
     const eventObservers = this._eventObservers[eventID];
-    if (eventObservers)
-      for (const observer of eventObservers)
+    if (eventObservers) {
+      for (const observer of eventObservers) {
         observer(...args);
+      }
+    }
     return this;
   }
   _hasObserver(eventID) {
     const eventObservers = this._eventObservers[eventID];
-    for (const observer in eventObservers)
-      if (eventObservers[observer])
-        return !0;
-    return !1;
+    for (const observer in eventObservers) {
+      if (eventObservers[observer]) {
+        return true;
+      }
+    }
+    return false;
   }
   hasObserver(_eventID) {
-    if (_eventID !== void 0)
+    if (_eventID !== void 0) {
       return this._hasObserver(_eventID);
-    for (const eventID in this._eventObservers)
-      if (this._hasObserver(eventID))
-        return !0;
-    return !1;
+    }
+    for (const eventID in this._eventObservers) {
+      if (this._hasObserver(eventID)) {
+        return true;
+      }
+    }
+    return false;
   }
-}
+};
+__name(_Observable, "Observable");
+let Observable = _Observable;
 let requestAnimationFrame;
 (function() {
-  if (root.requestAnimationFrame)
+  if (root.requestAnimationFrame) {
     requestAnimationFrame = root.requestAnimationFrame;
-  else {
+  } else {
     let lastTime = 0;
-    requestAnimationFrame = function(callback) {
-      const currTime = (/* @__PURE__ */ new Date()).getTime(), timeToCall = Math.max(0, 16 - (currTime - lastTime)), id = setTimeout(() => callback(currTime + timeToCall), timeToCall);
-      return lastTime = currTime + timeToCall, id;
-    };
+    requestAnimationFrame = /* @__PURE__ */ __name(function(callback) {
+      const currTime = (/* @__PURE__ */ new Date()).getTime();
+      const timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      const id = setTimeout(() => callback(currTime + timeToCall), timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    }, "requestAnimationFrame");
   }
 })();
-class Message {
+const _Message = class _Message {
   get canConflate() {
-    return !1;
+    return false;
   }
   conflate(other) {
-    return !1;
+    return false;
   }
   void() {
-    return !1;
+    return false;
   }
-}
-class Dispatch {
+};
+__name(_Message, "Message");
+let Message = _Message;
+const _Dispatch = class _Dispatch {
+  _observerID = 0;
+  _observers = [];
+  _messageBuffer = [];
   constructor() {
-    __publicField(this, "_observerID", 0);
-    __publicField(this, "_observers", []);
-    __publicField(this, "_messageBuffer", []);
   }
   observers() {
     return this._observers;
   }
   messages() {
     const retVal = [];
-    return this._messageBuffer.forEach((msg) => {
-      retVal.some((msg2) => msg2.canConflate && msg2.conflate(msg)) || retVal.push(msg);
-    }), retVal;
+    this._messageBuffer.forEach((msg) => {
+      if (!retVal.some((msg2) => msg2.canConflate && msg2.conflate(msg))) {
+        retVal.push(msg);
+      }
+    });
+    return retVal;
   }
   dispatchAll() {
-    this.dispatch(this.messages()), this.flush();
+    this.dispatch(this.messages());
+    this.flush();
   }
   dispatch(messages) {
-    messages.length !== 0 && this.observers().forEach((o) => {
+    if (messages.length === 0) return;
+    this.observers().forEach((o) => {
       const msgs = messages.filter((m) => !m.void() && (o.type === void 0 || m instanceof o.type));
-      msgs.length && o.callback(msgs);
+      if (msgs.length) {
+        o.callback(msgs);
+      }
     });
   }
   hasObserver() {
@@ -1328,11 +1835,14 @@ class Dispatch {
     this.dispatch([msg]);
   }
   post(msg) {
-    this._messageBuffer.push(msg), requestAnimationFrame(() => this.dispatchAll());
+    this._messageBuffer.push(msg);
+    requestAnimationFrame(() => this.dispatchAll());
   }
   attach(callback, type) {
-    const context = this, id = ++this._observerID;
-    return this._observers.push({ id, type, callback }), {
+    const context = this;
+    const id = ++this._observerID;
+    this._observers.push({ id, type, callback });
+    return {
       release() {
         context._observers = context._observers.filter((o) => o.id !== id);
       },
@@ -1341,13 +1851,15 @@ class Dispatch {
       }
     };
   }
-}
-class XMLNode {
+};
+__name(_Dispatch, "Dispatch");
+let Dispatch = _Dispatch;
+const _XMLNode = class _XMLNode {
+  name = "";
+  $ = {};
+  _children = [];
+  content = "";
   constructor(name) {
-    __publicField(this, "name", "");
-    __publicField(this, "$", {});
-    __publicField(this, "_children", []);
-    __publicField(this, "content", "");
     this.name = name;
   }
   appendAttribute(key, val) {
@@ -1360,35 +1872,57 @@ class XMLNode {
     this._children.push(child);
   }
   children(tag) {
-    return tag === void 0 ? this._children : this._children.filter((xmlNode) => xmlNode.name === tag);
+    if (tag === void 0) {
+      return this._children;
+    }
+    return this._children.filter((xmlNode) => {
+      return xmlNode.name === tag;
+    });
   }
-}
-class SAXStackParser {
+};
+__name(_XMLNode, "XMLNode");
+let XMLNode = _XMLNode;
+const _SAXStackParser = class _SAXStackParser {
+  root;
+  stack = new Stack();
   constructor() {
-    __publicField(this, "root");
-    __publicField(this, "stack", new Stack());
   }
   walkDoc(node) {
     const xmlNode = this._startXMLNode(node);
-    if (node.attributes)
+    if (node.attributes) {
       for (let i = 0; i < node.attributes.length; ++i) {
         const attribute = node.attributes.item(i);
         this.attributes(attribute.nodeName, attribute.nodeValue);
       }
-    if (this.startXMLNode(xmlNode), node.childNodes)
+    }
+    this.startXMLNode(xmlNode);
+    if (node.childNodes) {
       for (let i = 0; i < node.childNodes.length; ++i) {
         const childNode = node.childNodes.item(i);
-        childNode.nodeType === childNode.TEXT_NODE ? this.characters(childNode.nodeValue) : this.walkDoc(childNode);
+        if (childNode.nodeType === childNode.TEXT_NODE) {
+          this.characters(childNode.nodeValue);
+        } else {
+          this.walkDoc(childNode);
+        }
       }
+    }
     this.endXMLNode(this.stack.pop());
   }
   _startXMLNode(node) {
     const newNode = new XMLNode(node.nodeName);
-    return this.stack.depth() ? this.stack.top().appendChild(newNode) : this.root = newNode, this.stack.push(newNode);
+    if (!this.stack.depth()) {
+      this.root = newNode;
+    } else {
+      this.stack.top().appendChild(newNode);
+    }
+    return this.stack.push(newNode);
   }
   parse(xml) {
-    const doc = new DOMParser().parseFromString(xml, "application/xml");
-    this.startDocument(), this.walkDoc(doc), this.endDocument();
+    const domParser = new DOMParser();
+    const doc = domParser.parseFromString(xml, "application/xml");
+    this.startDocument();
+    this.walkDoc(doc);
+    this.endDocument();
   }
   //  Callbacks  ---
   startDocument() {
@@ -1405,10 +1939,13 @@ class SAXStackParser {
   characters(text) {
     this.stack.top().appendContent(text);
   }
-}
-class XML2JSONParser extends SAXStackParser {
+};
+__name(_SAXStackParser, "SAXStackParser");
+let SAXStackParser = _SAXStackParser;
+const _XML2JSONParser = class _XML2JSONParser extends SAXStackParser {
   startXMLNode(node) {
-    switch (super.startXMLNode(node), node.name) {
+    super.startXMLNode(node);
+    switch (node.name) {
     }
   }
   endXMLNode(node) {
@@ -1416,50 +1953,73 @@ class XML2JSONParser extends SAXStackParser {
     }
     super.endXMLNode(node);
   }
-}
+};
+__name(_XML2JSONParser, "XML2JSONParser");
+let XML2JSONParser = _XML2JSONParser;
 function xml2json(xml) {
   const saxParser = new XML2JSONParser();
-  return saxParser.parse(xml), saxParser.root;
+  saxParser.parse(xml);
+  return saxParser.root;
 }
-class PropChangedMessage extends Message {
+__name(xml2json, "xml2json");
+const _PropChangedMessage = class _PropChangedMessage extends Message {
   constructor(property, newValue, oldValue) {
-    super(), this.property = property, this.newValue = newValue, this.oldValue = oldValue;
+    super();
+    this.property = property;
+    this.newValue = newValue;
+    this.oldValue = oldValue;
   }
   get canConflate() {
-    return !0;
+    return true;
   }
   conflate(other) {
-    return this.property === other.property ? (this.newValue = other.newValue, !0) : !1;
+    if (this.property === other.property) {
+      this.newValue = other.newValue;
+      return true;
+    }
+    return false;
   }
   void() {
     return deepEquals(this.newValue, this.oldValue);
   }
-}
-class StateObject {
-  constructor() {
-    __publicField(this, "_espState", {});
-    __publicField(this, "_dispatch", new Dispatch());
-    __publicField(this, "_monitorHandle");
-    __publicField(this, "_monitorTickCount", 0);
-  }
+};
+__name(_PropChangedMessage, "PropChangedMessage");
+let PropChangedMessage = _PropChangedMessage;
+const _StateObject = class _StateObject {
+  _espState = {};
+  _dispatch = new Dispatch();
+  _monitorHandle;
+  _monitorTickCount = 0;
   clear(newVals) {
-    this._espState = {}, newVals !== void 0 && this.set(newVals), this._monitorTickCount = 0;
+    this._espState = {};
+    if (newVals !== void 0) {
+      this.set(newVals);
+    }
+    this._monitorTickCount = 0;
   }
   get(key, defValue) {
-    return key === void 0 ? this._espState : this.has(key) ? this._espState[key] : defValue;
+    if (key === void 0) {
+      return this._espState;
+    }
+    return this.has(key) ? this._espState[key] : defValue;
   }
   set(keyOrNewVals, newVal) {
-    if (typeof keyOrNewVals == "string")
+    if (typeof keyOrNewVals === "string") {
       return this.setSingle(keyOrNewVals, newVal);
+    }
     this.setAll(keyOrNewVals);
   }
   setSingle(key, newVal) {
     const oldVal = this._espState[key];
-    this._espState[key] = newVal, this._dispatch.post(new PropChangedMessage(key, newVal, oldVal));
+    this._espState[key] = newVal;
+    this._dispatch.post(new PropChangedMessage(key, newVal, oldVal));
   }
   setAll(_) {
-    for (const key in _)
-      _.hasOwnProperty(key) && this.setSingle(key, _[key]);
+    for (const key in _) {
+      if (_.hasOwnProperty(key)) {
+        this.setSingle(key, _[key]);
+      }
+    }
   }
   has(key) {
     return this._espState[key] !== void 0;
@@ -1479,7 +2039,9 @@ class StateObject {
       return this._dispatch.attach((messages) => {
         const filteredMessages = messages.filter((m) => m.property === propIDOrCallback);
         if (filteredMessages.length) {
-          filteredMessages.length > 1 && console.warn("Should only be 1 message?");
+          if (filteredMessages.length > 1) {
+            console.warn("Should only be 1 message?");
+          }
           const event = filteredMessages[filteredMessages.length - 1];
           callback({
             id: event.property,
@@ -1491,17 +2053,19 @@ class StateObject {
     }
   }
   on(eventID, propIDOrCallback, callback) {
-    return this.addObserver(eventID, propIDOrCallback, callback), this;
+    this.addObserver(eventID, propIDOrCallback, callback);
+    return this;
   }
   isCallback(propIDOrCallback) {
-    return typeof propIDOrCallback == "function";
+    return typeof propIDOrCallback === "function";
   }
   hasEventListener() {
     return this._dispatch.hasObserver();
   }
   //  Monitoring  ---
-  async refresh(full = !1) {
-    return await Promise.resolve(), this;
+  async refresh(full = false) {
+    await Promise.resolve();
+    return this;
   }
   _monitor() {
     if (this._monitorHandle) {
@@ -1509,56 +2073,91 @@ class StateObject {
       return;
     }
     this._monitorHandle = setTimeout(() => {
-      (this.hasEventListener() ? this.refresh() : Promise.resolve()).then(() => {
+      const refreshPromise = this.hasEventListener() ? this.refresh() : Promise.resolve();
+      refreshPromise.then(() => {
         this._monitor();
-      }), delete this._monitorHandle;
+      });
+      delete this._monitorHandle;
     }, this._monitorTimeoutDuration());
   }
   _monitorTimeoutDuration() {
-    return ++this._monitorTickCount, this._monitorTickCount <= 1 ? 0 : 3e4;
+    ++this._monitorTickCount;
+    if (this._monitorTickCount <= 1) {
+      return 0;
+    }
+    return 3e4;
   }
-  watch(callback, triggerChange = !0) {
-    if (typeof callback != "function")
+  watch(callback, triggerChange = true) {
+    if (typeof callback !== "function") {
       throw new Error("Invalid Callback");
-    triggerChange && setTimeout(() => {
-      const props = this.get(), changes = [];
-      for (const key in props)
-        props.hasOwnProperty(props) && changes.push({ id: key, newValue: props[key], oldValue: void 0 });
-      callback(changes);
-    }, 0);
+    }
+    if (triggerChange) {
+      setTimeout(() => {
+        const props = this.get();
+        const changes = [];
+        for (const key in props) {
+          if (props.hasOwnProperty(props)) {
+            changes.push({ id: key, newValue: props[key], oldValue: void 0 });
+          }
+        }
+        callback(changes);
+      }, 0);
+    }
     const retVal = this.addObserver("changed", callback);
-    return this._monitor(), retVal;
+    this._monitor();
+    return retVal;
   }
-}
+};
+__name(_StateObject, "StateObject");
+let StateObject = _StateObject;
 function trim(str, char) {
-  if (typeof char != "string" || char.length === 0) return str;
-  for (; str.indexOf(char) === 0; )
+  if (typeof char !== "string") return str;
+  if (char.length === 0) return str;
+  while (str.indexOf(char) === 0) {
     str = str.substring(1);
-  for (; endsWith(str, char); )
+  }
+  while (endsWith(str, char)) {
     str = str.substring(0, str.length - 1);
+  }
   return str;
 }
+__name(trim, "trim");
 function endsWith(origString, searchString, position) {
   const subjectString = origString.toString();
-  (typeof position != "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) && (position = subjectString.length), position -= searchString.length;
+  if (typeof position !== "number" || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) {
+    position = subjectString.length;
+  }
+  position -= searchString.length;
   const lastIndex = subjectString.lastIndexOf(searchString, position);
   return lastIndex !== -1 && lastIndex === position;
 }
+__name(endsWith, "endsWith");
 function join(...segments) {
-  const parts = segments.reduce((parts2, segment) => (parts2.length > 0 && (segment = segment.replace(/^\//, "")), segment = segment.replace(/\/$/, ""), [...parts2, ...segment.split("/")]), []), resultParts = [];
-  for (const part of parts)
-    if (part !== ".") {
-      if (part === "..") {
-        resultParts.pop();
-        continue;
-      }
-      resultParts.push(part);
+  const parts = segments.reduce((parts2, segment) => {
+    if (parts2.length > 0) {
+      segment = segment.replace(/^\//, "");
+    }
+    segment = segment.replace(/\/$/, "");
+    return [...parts2, ...segment.split("/")];
+  }, []);
+  const resultParts = [];
+  for (const part of parts) {
+    if (part === ".") {
+      continue;
     }
+    if (part === "..") {
+      resultParts.pop();
+      continue;
+    }
+    resultParts.push(part);
+  }
   return resultParts.join("/");
 }
+__name(join, "join");
 function dirname(path) {
   return join(path, "..");
 }
+__name(dirname, "dirname");
 export {
   AsyncCache,
   AsyncOrderedQueue,