@hpcc-js/util 3.4.0 → 3.4.1

package/dist/index.js

@@ -1,1949 +1,2224 @@
-//#region src/__package__.ts
+var __defProp = Object.defineProperty;
+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.4.0";
-const BUILD_VERSION = "3.15.0";
-
-//#endregion
-//#region src/array.ts
+const PKG_VERSION = "3.4.1";
+const BUILD_VERSION = "3.15.1";
 function find(o, predicate) {
-	if (o == null) throw new TypeError("\"o\" is null or not defined");
-	const len = o.length >>> 0;
-	if (typeof predicate !== "function") throw new TypeError("predicate must be a function");
-	const thisArg = arguments[1];
-	let k = 0;
-	while (k < len) {
-		const kValue = o[k];
-		if (predicate.call(thisArg, kValue, k)) return kValue;
-		k++;
-	}
+  if (o == null) {
+    throw new TypeError('"o" is null or not defined');
+  }
+  const len = o.length >>> 0;
+  if (typeof predicate !== "function") {
+    throw new TypeError("predicate must be a function");
+  }
+  const thisArg = arguments[1];
+  let k = 0;
+  while (k < len) {
+    const kValue = o[k];
+    if (predicate.call(thisArg, kValue, k)) {
+      return kValue;
+    }
+    k++;
+  }
+  return void 0;
 }
+__name(find, "find");
 function compare(before, after) {
-	const retVal = {
-		update: [],
-		exit: [],
-		enter: [...after]
-	};
-	for (const row of before) {
-		const otherIdx = retVal.enter.indexOf(row);
-		if (otherIdx >= 0) {
-			retVal.update.push(row);
-			retVal.enter.splice(otherIdx, 1);
-		} else retVal.exit.push(row);
-	}
-	return retVal;
+  const retVal = {
+    update: [],
+    exit: [],
+    enter: [...after]
+  };
+  for (const row of before) {
+    const otherIdx = retVal.enter.indexOf(row);
+    if (otherIdx >= 0) {
+      retVal.update.push(row);
+      retVal.enter.splice(otherIdx, 1);
+    } else {
+      retVal.exit.push(row);
+    }
+  }
+  return retVal;
 }
-function compare2(before, after, idFunc, updateFunc = (before$1, after$1) => after$1) {
-	const retVal = {
-		update: [],
-		exit: [],
-		enter: []
-	};
-	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);
-		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) retVal.enter.push(unknownMap[key]);
-	return retVal;
+__name(compare, "compare");
+function compare2(before, after, idFunc, updateFunc = (before2, after2) => after2) {
+  const retVal = {
+    update: [],
+    exit: [],
+    enter: []
+  };
+  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);
+    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) {
+    retVal.enter.push(unknownMap[key]);
+  }
+  return retVal;
 }
-
-//#endregion
-//#region src/hashSum.ts
+__name(compare2, "compare2");
 function pad(hash, len) {
-	while (hash.length < len) hash = "0" + hash;
-	return hash;
+  while (hash.length < len) {
+    hash = "0" + hash;
+  }
+  return hash;
 }
+__name(pad, "pad");
 function fold(hash, text) {
-	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;
-	}
-	return hash < 0 ? hash * -2 : hash;
+  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;
+  }
+  return hash < 0 ? hash * -2 : hash;
 }
+__name(fold, "fold");
 function foldObject(hash, o, seen) {
-	if (typeof o.hashSum === "function") return o.hashSum();
-	return Object.keys(o).sort().reduce((input, key) => {
-		return 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);
-	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());
+  const hash = fold(fold(fold(input, key), toString(value)), typeof value);
+  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);
+  return Object.prototype.toString.call(o);
 }
+__name(toString, "toString");
 function hashSum(o) {
-	return pad(foldValue(0, o, "", []).toString(16), 8);
+  return pad(foldValue(0, o, "", []).toString(16), 8);
 }
-
-//#endregion
-//#region src/cache.ts
-var Cache = class {
-	_cache = {};
-	_calcID;
-	static hash(...args) {
-		return hashSum({ ...args });
-	}
-	constructor(calcID) {
-		this._calcID = calcID;
-	}
-	has(espObj) {
-		return this._calcID(espObj) in this._cache;
-	}
-	set(obj) {
-		this._cache[this._calcID(obj)] = obj;
-		return obj;
-	}
-	get(espObj, factory) {
-		const retVal = this._cache[this._calcID(espObj)];
-		if (!retVal) return factory ? this.set(factory()) : null;
-		return retVal;
-	}
+__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) {
+    this._cache[this._calcID(obj)] = obj;
+    return obj;
+  }
+  get(espObj, factory) {
+    const retVal = this._cache[this._calcID(espObj)];
+    if (!retVal) {
+      return factory ? this.set(factory()) : null;
+    }
+    return retVal;
+  }
 };
-var AsyncCache = class {
-	_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) {
-		this._cache[this._calcID(espObj)] = obj;
-		return obj;
-	}
-	get(espObj, factory) {
-		const retVal = this._cache[this._calcID(espObj)];
-		if (!retVal) return factory ? this.set(espObj, factory()) : Promise.resolve(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) {
+    this._cache[this._calcID(espObj)] = obj;
+    return obj;
+  }
+  get(espObj, factory) {
+    const retVal = this._cache[this._calcID(espObj)];
+    if (!retVal) {
+      return factory ? this.set(espObj, factory()) : Promise.resolve(null);
+    }
+    return retVal;
+  }
 };
-
-//#endregion
-//#region src/debounce.ts
+__name(_AsyncCache, "AsyncCache");
+let AsyncCache = _AsyncCache;
 function debounce(fn, timeout) {
-	const promises = {};
-	return (...params) => {
-		const hash = hashSum(params);
-		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;
-	};
+  const promises = {};
+  return (...params) => {
+    const hash = hashSum(params);
+    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.");
-		}, ms);
-	});
-	return Promise.race([promise, timeout]).then((response) => {
-		clearTimeout(id);
-		return response;
-	}).catch((e) => {
-		clearTimeout(id);
-		throw e;
-	});
+  let id;
+  const timeout = new Promise((resolve, reject) => {
+    id = setTimeout(() => {
+      clearTimeout(id);
+      reject("Timed out in " + ms + "ms.");
+    }, ms);
+  });
+  return Promise.race([
+    promise,
+    timeout
+  ]).then((response) => {
+    clearTimeout(id);
+    return response;
+  }).catch((e) => {
+    clearTimeout(id);
+    throw e;
+  });
 }
-var AsyncOrderedQueue = class {
-	_q = [];
-	isTop(p) {
-		return this._q[0] === p;
-	}
-	push(p) {
-		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(promiseTimeout, "promiseTimeout");
+const _AsyncOrderedQueue = class _AsyncOrderedQueue {
+  _q = [];
+  isTop(p) {
+    return this._q[0] === p;
+  }
+  push(p) {
+    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);
-	});
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), ms);
+  });
 }
-
-//#endregion
-//#region src/dictionary.ts
-var Dictionary = class {
-	store = {};
-	constructor(attrs) {
-		if (attrs) for (const key in attrs) this.set(key, attrs[key]);
-	}
-	set(key, value) {
-		const retVal = this.store[key];
-		this.store[key] = value;
-		return retVal;
-	}
-	get(key) {
-		return this.store[key];
-	}
-	has(key) {
-		return this.store[key] !== void 0;
-	}
-	remove(key) {
-		delete this.store[key];
-	}
-	keys() {
-		const retVal = [];
-		for (const key in this.store) retVal.push(key);
-		return retVal;
-	}
-	values() {
-		const retVal = [];
-		for (const key in this.store) retVal.push(this.store[key]);
-		return retVal;
-	}
+__name(sleep, "sleep");
+const _Dictionary = class _Dictionary {
+  store = {};
+  constructor(attrs) {
+    if (attrs) {
+      for (const key in attrs) {
+        this.set(key, attrs[key]);
+      }
+    }
+  }
+  set(key, value) {
+    const retVal = this.store[key];
+    this.store[key] = value;
+    return retVal;
+  }
+  get(key) {
+    return this.store[key];
+  }
+  has(key) {
+    return this.store[key] !== void 0;
+  }
+  remove(key) {
+    delete this.store[key];
+  }
+  keys() {
+    const retVal = [];
+    for (const key in this.store) {
+      retVal.push(key);
+    }
+    return retVal;
+  }
+  values() {
+    const retVal = [];
+    for (const key in this.store) {
+      retVal.push(this.store[key]);
+    }
+    return retVal;
+  }
 };
-var DictionaryNoCase = class extends Dictionary {
-	constructor(attrs) {
-		super(attrs);
-	}
-	set(key, value) {
-		return super.set(key.toLowerCase(), value);
-	}
-	get(key) {
-		return super.get(key.toLowerCase());
-	}
-	has(key) {
-		return super.has(key.toLowerCase());
-	}
-	remove(key) {
-		return super.remove(key.toLowerCase());
-	}
+__name(_Dictionary, "Dictionary");
+let Dictionary = _Dictionary;
+const _DictionaryNoCase = class _DictionaryNoCase extends Dictionary {
+  constructor(attrs) {
+    super(attrs);
+  }
+  set(key, value) {
+    return super.set(key.toLowerCase(), value);
+  }
+  get(key) {
+    return super.get(key.toLowerCase());
+  }
+  has(key) {
+    return super.has(key.toLowerCase());
+  }
+  remove(key) {
+    return super.remove(key.toLowerCase());
+  }
 };
-
-//#endregion
-//#region src/esp.ts
+__name(_DictionaryNoCase, "DictionaryNoCase");
+let DictionaryNoCase = _DictionaryNoCase;
 function espTime2Seconds(duration) {
-	if (!duration) return 0;
-	else if (!isNaN(Number(duration))) return Number(duration);
-	const nsIndex = duration.indexOf("ns");
-	if (nsIndex !== -1) return parseFloat(duration.substr(0, nsIndex)) / 1e9;
-	const msIndex = duration.indexOf("ms");
-	if (msIndex !== -1) return parseFloat(duration.substr(0, msIndex)) / 1e3;
-	const sIndex = duration.indexOf("s");
-	if (sIndex !== -1 && duration.indexOf("days") === -1) return parseFloat(duration.substr(0, sIndex));
-	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) secs += parseFloat(timeParts[j]) * Math.pow(60, j);
-	return days * 24 * 60 * 60 + secs;
+  if (!duration) {
+    return 0;
+  } else {
+    if (!isNaN(Number(duration))) {
+      return Number(duration);
+    }
+  }
+  const nsIndex = duration.indexOf("ns");
+  if (nsIndex !== -1) {
+    return parseFloat(duration.substr(0, nsIndex)) / 1e9;
+  }
+  const msIndex = duration.indexOf("ms");
+  if (msIndex !== -1) {
+    return parseFloat(duration.substr(0, msIndex)) / 1e3;
+  }
+  const sIndex = duration.indexOf("s");
+  if (sIndex !== -1 && duration.indexOf("days") === -1) {
+    return parseFloat(duration.substr(0, sIndex));
+  }
+  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) {
+    secs += parseFloat(timeParts[j]) * Math.pow(60, j);
+  }
+  return days * 24 * 60 * 60 + secs;
 }
-
-//#endregion
-//#region src/graph.ts
-var GraphItem = class {
-	_graph;
-	parent;
-	props = {};
-	constructor(graph, parent) {
-		this._graph = graph;
-		this.parent = parent;
-	}
-};
-var Subgraph = class Subgraph extends GraphItem {
-	subgraphs = [];
-	vertices = [];
-	edges = [];
-	_;
-	constructor(graph, parent, _) {
-		super(graph, parent);
-		if (parent) parent._addSubgraph(this);
-		this._ = _;
-	}
-	remove(full = true) {
-		this._graph.removeSubgraph(this, full);
-	}
-	createSubgraph(_) {
-		return this._graph.createSubgraph(this, _);
-	}
-	_addSubgraph(subgraph) {
-		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) 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], true);
-	}
-	createVertex(_) {
-		return this._graph.createVertex(this, _);
-	}
-	_addVertex(vertex) {
-		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) 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], true);
-	}
-	createEdge(source, target, _) {
-		return this._graph.createEdge(this, source, target, _);
-	}
-	_addEdge(edge) {
-		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) throw new Error("Edge does not exist");
-		this.edges.splice(idx, 1);
-	}
-	_add(item) {
-		if (item instanceof Subgraph) this._addSubgraph(item);
-		else if (item instanceof Vertex) this._addVertex(item);
-		else this._addEdge(item);
-	}
-};
-var Vertex = class extends GraphItem {
-	inEdges = [];
-	outEdges = [];
-	get edges() {
-		return [...this.inEdges, ...this.outEdges];
-	}
-	_;
-	constructor(graph, parent, _) {
-		super(graph, parent);
-		parent._addVertex(this);
-		this._ = _;
-	}
-	remove(full = true, _) {
-		return this._graph.removeVertex(this, full, _);
-	}
-	addInEdge(edge) {
-		this.inEdges.push(edge);
-	}
-	removeInEdge(edge) {
-		const idx = this.inEdges.indexOf(edge);
-		if (idx < 0) throw new Error("In edge does not exist");
-		this.inEdges.splice(idx, 1);
-	}
-	addOutEdge(edge) {
-		this.outEdges.push(edge);
-	}
-	removeOutEdge(edge) {
-		const idx = this.outEdges.indexOf(edge);
-		if (idx < 0) throw new Error("Out edge does not exist");
-		this.outEdges.splice(idx, 1);
-	}
-};
-var Edge = class extends GraphItem {
-	source;
-	target;
-	_;
-	constructor(graph, parent, source, target, _) {
-		super(graph, parent);
-		if (!source) throw new Error("Missing source vertex");
-		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._ = _;
-	}
-	remove() {
-		this._graph.removeEdge(this);
-	}
-};
-var Graph = class {
-	root;
-	_allSubgraphs = [];
-	_allSubgraphsMap = {};
-	_allVertices = [];
-	_allVerticesMap = {};
-	_allEdges = [];
-	_allEdgesMap = {};
-	idOf;
-	constructor(idOf = (item) => "" + item._, _) {
-		this.root = new Subgraph(this, null, _);
-		this.idOf = idOf;
-	}
-	createSubgraph(parent, _) {
-		const retVal = new Subgraph(this, parent || this.root, _);
-		this._allSubgraphs.push(retVal);
-		this._allSubgraphsMap[this.idOf(retVal)] = retVal;
-		return retVal;
-	}
-	removeSubgraph(subgraph, full = true) {
-		const idx = this._allSubgraphs.indexOf(subgraph);
-		if (idx < 0) throw new Error("Subgraph does not exist");
-		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));
-	}
-	get subgraphs() {
-		return this._allSubgraphs;
-	}
-	subgraph(id) {
-		return this._allSubgraphsMap[id];
-	}
-	createVertex(parent, _) {
-		const retVal = new Vertex(this, parent, _);
-		this._allVertices.push(retVal);
-		this._allVerticesMap[this.idOf(retVal)] = retVal;
-		return retVal;
-	}
-	removeVertex(vertex, full = true, _) {
-		const idx = this._allVertices.indexOf(vertex);
-		if (idx < 0) throw new Error("Vertex does not exist");
-		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));
-	}
-	get vertices() {
-		return this._allVertices;
-	}
-	vertex(id) {
-		return this._allVerticesMap[id];
-	}
-	createEdge(parent, source, target, _) {
-		const retVal = new Edge(this, parent, source, target, _);
-		this._allEdges.push(retVal);
-		this._allEdgesMap[this.idOf(retVal)] = retVal;
-		return retVal;
-	}
-	removeEdge(edge) {
-		const idx = this._allEdges.indexOf(edge);
-		if (idx < 0) throw new Error("Edge does not exist");
-		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;
-	}
-	edge(id) {
-		return this._allEdgesMap[id];
-	}
-	_walk(parent, visitor) {
-		for (const subgraph of parent.subgraphs) switch (visitor(subgraph)) {
-			case "abort": return true;
-			case "stepover": break;
-			default: if (this._walk(subgraph, visitor)) return true;
-		}
-		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 true;
-	}
-	clone() {
-		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) map.put(item, parent.createSubgraph(item._));
-			else if (item instanceof Vertex) map.put(item, parent.createVertex(item._));
-			else if (item instanceof Edge) {
-				const source = map.get(item.source);
-				const target = map.get(item.target);
-				parent.createEdge(source, target, item._);
-			}
-		});
-		return retVal;
-	}
+__name(espTime2Seconds, "espTime2Seconds");
+let GraphItem$1 = (_a = class {
+  _graph;
+  parent;
+  props = {};
+  constructor(graph, parent) {
+    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);
+    if (parent) {
+      parent._addSubgraph(this);
+    }
+    this._ = _;
+  }
+  remove(full = true) {
+    this._graph.removeSubgraph(this, full);
+  }
+  createSubgraph(_) {
+    return this._graph.createSubgraph(this, _);
+  }
+  _addSubgraph(subgraph) {
+    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) {
+      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], true);
+    }
+  }
+  createVertex(_) {
+    return this._graph.createVertex(this, _);
+  }
+  _addVertex(vertex) {
+    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) {
+      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], true);
+    }
+  }
+  createEdge(source, target, _) {
+    return this._graph.createEdge(this, source, target, _);
+  }
+  _addEdge(edge) {
+    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) {
+      throw new Error("Edge does not exist");
+    }
+    this.edges.splice(idx, 1);
+  }
+  _add(item) {
+    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];
+  }
+  _;
+  constructor(graph, parent, _) {
+    super(graph, parent);
+    parent._addVertex(this);
+    this._ = _;
+  }
+  remove(full = true, _) {
+    return this._graph.removeVertex(this, full, _);
+  }
+  addInEdge(edge) {
+    this.inEdges.push(edge);
+  }
+  removeInEdge(edge) {
+    const idx = this.inEdges.indexOf(edge);
+    if (idx < 0) {
+      throw new Error("In edge does not exist");
+    }
+    this.inEdges.splice(idx, 1);
+  }
+  addOutEdge(edge) {
+    this.outEdges.push(edge);
+  }
+  removeOutEdge(edge) {
+    const idx = this.outEdges.indexOf(edge);
+    if (idx < 0) {
+      throw new Error("Out edge does not exist");
+    }
+    this.outEdges.splice(idx, 1);
+  }
+}, __name(_c, "Vertex"), _c);
+let Edge$1 = (_d = class extends GraphItem$1 {
+  source;
+  target;
+  _;
+  constructor(graph, parent, source, target, _) {
+    super(graph, parent);
+    if (!source) {
+      throw new Error("Missing source vertex");
+    }
+    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._ = _;
+  }
+  remove() {
+    this._graph.removeEdge(this);
+  }
+}, __name(_d, "Edge"), _d);
+const _Graph = class _Graph {
+  root;
+  _allSubgraphs = [];
+  _allSubgraphsMap = {};
+  _allVertices = [];
+  _allVerticesMap = {};
+  _allEdges = [];
+  _allEdgesMap = {};
+  idOf;
+  constructor(idOf = (item) => "" + item._, _) {
+    this.root = new Subgraph$1(this, null, _);
+    this.idOf = idOf;
+  }
+  createSubgraph(parent, _) {
+    const retVal = new Subgraph$1(this, parent || this.root, _);
+    this._allSubgraphs.push(retVal);
+    this._allSubgraphsMap[this.idOf(retVal)] = retVal;
+    return retVal;
+  }
+  removeSubgraph(subgraph, full = true) {
+    const idx = this._allSubgraphs.indexOf(subgraph);
+    if (idx < 0) {
+      throw new Error("Subgraph does not exist");
+    }
+    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)
+    );
+  }
+  get subgraphs() {
+    return this._allSubgraphs;
+  }
+  subgraph(id) {
+    return this._allSubgraphsMap[id];
+  }
+  createVertex(parent, _) {
+    const retVal = new Vertex$1(this, parent, _);
+    this._allVertices.push(retVal);
+    this._allVerticesMap[this.idOf(retVal)] = retVal;
+    return retVal;
+  }
+  removeVertex(vertex, full = true, _) {
+    const idx = this._allVertices.indexOf(vertex);
+    if (idx < 0) {
+      throw new Error("Vertex does not exist");
+    }
+    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));
+  }
+  get vertices() {
+    return this._allVertices;
+  }
+  vertex(id) {
+    return this._allVerticesMap[id];
+  }
+  createEdge(parent, source, target, _) {
+    const retVal = new Edge$1(this, parent, source, target, _);
+    this._allEdges.push(retVal);
+    this._allEdgesMap[this.idOf(retVal)] = retVal;
+    return retVal;
+  }
+  removeEdge(edge) {
+    const idx = this._allEdges.indexOf(edge);
+    if (idx < 0) {
+      throw new Error("Edge does not exist");
+    }
+    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;
+  }
+  edge(id) {
+    return this._allEdgesMap[id];
+  }
+  _walk(parent, visitor) {
+    for (const subgraph of parent.subgraphs) {
+      switch (visitor(subgraph)) {
+        case "abort":
+          return true;
+        case "stepover":
+          break;
+        default:
+          if (this._walk(subgraph, visitor)) return true;
+      }
+    }
+    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 true;
+    }
+  }
+  clone() {
+    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) {
+        map.put(item, parent.createSubgraph(item._));
+      } else if (item instanceof Vertex$1) {
+        map.put(item, parent.createVertex(item._));
+      } else if (item instanceof Edge$1) {
+        const source = map.get(item.source);
+        const target = map.get(item.target);
+        parent.createEdge(source, target, item._);
+      }
+    });
+    return retVal;
+  }
 };
+__name(_Graph, "Graph");
+let Graph = _Graph;
 function ObjMap() {
-	const keys = [];
-	const values = [];
-	return {
-		put(key, value) {
-			const index = keys.indexOf(key);
-			if (index === -1) {
-				keys.push(key);
-				values.push(value);
-			} else values[index] = value;
-		},
-		get(key) {
-			return values[keys.indexOf(key)];
-		}
-	};
+  const keys = [];
+  const values = [];
+  return {
+    put(key, value) {
+      const index = keys.indexOf(key);
+      if (index === -1) {
+        keys.push(key);
+        values.push(value);
+      } else {
+        values[index] = value;
+      }
+    },
+    get(key) {
+      return values[keys.indexOf(key)];
+    }
+  };
 }
-
-//#endregion
-//#region src/graph2.ts
-var GraphItem$1 = class {
-	_graph;
-	_;
-	id() {
-		return this._graph.id(this._);
-	}
-	constructor(g, _) {
-		this._graph = g;
-		this._ = _;
-	}
+__name(ObjMap, "ObjMap");
+const _GraphItem = class _GraphItem {
+  _graph;
+  _;
+  id() {
+    return this._graph.id(this._);
+  }
+  constructor(g, _) {
+    this._graph = g;
+    this._ = _;
+  }
 };
-var ChildGraphItem = class extends GraphItem$1 {
-	_parent;
-	constructor(g, _) {
-		super(g, _);
-	}
-	clearParent() {
-		if (this._parent) {
-			this._parent.removeChild(this);
-			delete this._parent;
-		}
-		return this;
-	}
-	parent(_) {
-		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;
-	}
+__name(_GraphItem, "GraphItem");
+let GraphItem = _GraphItem;
+const _ChildGraphItem = class _ChildGraphItem extends GraphItem {
+  _parent;
+  constructor(g, _) {
+    super(g, _);
+  }
+  clearParent() {
+    if (this._parent) {
+      this._parent.removeChild(this);
+      delete this._parent;
+    }
+    return this;
+  }
+  parent(_) {
+    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;
+  }
 };
-var Subgraph$1 = class extends ChildGraphItem {
-	_children = [];
-	constructor(g, _) {
-		super(g, _);
-	}
-	children() {
-		return this._children;
-	}
-	addChild(_) {
-		this._children.push(_);
-	}
-	removeChild(_) {
-		this._children = this._children.filter((row) => row.id !== _.id);
-	}
+__name(_ChildGraphItem, "ChildGraphItem");
+let ChildGraphItem = _ChildGraphItem;
+const _Subgraph = class _Subgraph extends ChildGraphItem {
+  _children = [];
+  constructor(g, _) {
+    super(g, _);
+  }
+  children() {
+    return this._children;
+  }
+  addChild(_) {
+    this._children.push(_);
+  }
+  removeChild(_) {
+    this._children = this._children.filter((row) => row.id !== _.id);
+  }
 };
-var Vertex$1 = class extends ChildGraphItem {
-	_inEdges = [];
-	_outEdges = [];
-	constructor(g, _) {
-		super(g, _);
-	}
-	edges() {
-		return [...this._inEdges, ...this._outEdges];
-	}
-	edgeCount() {
-		return this._outEdges.length + this._inEdges.length;
-	}
-	inEdges() {
-		return this._inEdges;
-	}
-	addInEdge(e) {
-		this._inEdges.push(e);
-	}
-	removeInEdge(id) {
-		this._inEdges = this._inEdges.filter((e) => e._.id !== id);
-	}
-	outEdges() {
-		return this._outEdges;
-	}
-	addOutEdge(e) {
-		this._outEdges.push(e);
-	}
-	removeOutEdge(id) {
-		this._outEdges = this._outEdges.filter((e) => e._.id !== id);
-	}
+__name(_Subgraph, "Subgraph");
+let Subgraph = _Subgraph;
+const _Vertex = class _Vertex extends ChildGraphItem {
+  _inEdges = [];
+  _outEdges = [];
+  constructor(g, _) {
+    super(g, _);
+  }
+  edges() {
+    return [...this._inEdges, ...this._outEdges];
+  }
+  edgeCount() {
+    return this._outEdges.length + this._inEdges.length;
+  }
+  inEdges() {
+    return this._inEdges;
+  }
+  addInEdge(e) {
+    this._inEdges.push(e);
+  }
+  removeInEdge(id) {
+    this._inEdges = this._inEdges.filter((e) => e._.id !== id);
+  }
+  outEdges() {
+    return this._outEdges;
+  }
+  addOutEdge(e) {
+    this._outEdges.push(e);
+  }
+  removeOutEdge(id) {
+    this._outEdges = this._outEdges.filter((e) => e._.id !== id);
+  }
 };
-var Edge$1 = class extends ChildGraphItem {
-	_source;
-	_target;
-	constructor(g, _, source, target) {
-		super(g, _);
-		this._source = source;
-		this._target = target;
-	}
+__name(_Vertex, "Vertex");
+let Vertex = _Vertex;
+const _Edge = class _Edge extends ChildGraphItem {
+  _source;
+  _target;
+  constructor(g, _, source, target) {
+    super(g, _);
+    this._source = source;
+    this._target = target;
+  }
 };
-var Graph2 = class {
-	_directed;
-	_subgraphMap = {};
-	_vertexMap = {};
-	_edgeMap = {};
-	constructor(directed = true) {
-		this._directed = directed;
-	}
-	clear() {
-		this._subgraphMap = {};
-		this._vertexMap = {};
-		this._edgeMap = {};
-		return this;
-	}
-	clearParents() {
-		for (const key in this._subgraphMap) this._subgraphMap[key].clearParent();
-		for (const key in this._vertexMap) this._vertexMap[key].clearParent();
-		return this;
-	}
-	isDirected() {
-		return this._directed;
-	}
-	_idFunc = (_) => typeof _.id === "function" ? _.id() : _.id;
-	idFunc(_) {
-		this._idFunc = _;
-		return this;
-	}
-	_sourceFunc = (_) => typeof _.source === "function" ? _.source() : _.source;
-	sourceFunc(_) {
-		this._sourceFunc = _;
-		return this;
-	}
-	_targetFunc = (_) => typeof _.target === "function" ? _.target() : _.target;
-	targetFunc(_) {
-		this._targetFunc = _;
-		return this;
-	}
-	_updateFunc = (before, after) => after;
-	updateFunc(_) {
-		this._updateFunc = _;
-		return this;
-	}
-	id(_) {
-		return this._idFunc(_);
-	}
-	type(id) {
-		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(_));
-	}
-	isVertex(_) {
-		return this.vertexExists(this.id(_));
-	}
-	isEdge(_) {
-		return this.edgeExists(this.id(_));
-	}
-	allItems() {
-		return [
-			...this.allSubgraphs(),
-			...this.allVertices(),
-			...this.allEdges()
-		];
-	}
-	item(id) {
-		if (this.subgraphExists(id)) return this.subgraph(id);
-		if (this.vertexExists(id)) return this.vertex(id);
-		if (this.edgeExists(id)) return this.edge(id);
-	}
-	itemExists(id) {
-		return this.edgeExists(id) || this.vertexExists(id) || this.subgraphExists(id);
-	}
-	allSubgraphs() {
-		const retVal = [];
-		for (const key in this._subgraphMap) retVal.push(this._subgraphMap[key]._);
-		return retVal;
-	}
-	subgraphs() {
-		const retVal = [];
-		for (const key in this._subgraphMap) if (this._subgraphMap[key].parent() === void 0) retVal.push(this._subgraphMap[key]._);
-		return retVal;
-	}
-	subgraphExists(id) {
-		return !!this._subgraphMap[id];
-	}
-	subgraph(id) {
-		return this._subgraphMap[id]._;
-	}
-	subgraphSubgraphs(id) {
-		return this._subgraphMap[id].children().filter((child) => this.isSubgraph(child._)).map((child) => child._);
-	}
-	subgraphVertices(id) {
-		return this._subgraphMap[id].children().filter((child) => this.isVertex(child._)).map((child) => child._);
-	}
-	subgraphEdges(id) {
-		return this._subgraphMap[id].children().filter((child) => this.isEdge(child._)).map((child) => child._);
-	}
-	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 Subgraph$1(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]);
-		}
-		this._subgraphMap[s_id] = subgraph;
-		return this;
-	}
-	mergeSubgraphs(_subgraphs = []) {
-		const sgDiff = compare2(this.allSubgraphs(), _subgraphs, (sg) => this._idFunc(sg), this._updateFunc);
-		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);
-		const subgraph = this._subgraphMap[sg_id];
-		if (!subgraph) throw new Error(`Subgraph '${sg_id}' does not exist.`);
-		subgraph._ = sg;
-		return this;
-	}
-	removeSubgraph(id, promoteChildren = true) {
-		const sg = this._subgraphMap[id];
-		if (!sg) throw new Error(`Subgraph '${id}' does not exist.`);
-		sg.children().forEach((child) => {
-			if (promoteChildren) child.parent(sg.parent());
-			else if (child instanceof Subgraph$1) this.removeSubgraph(child.id());
-			else this.removeVertex(child.id());
-		});
-		delete this._subgraphMap[id];
-		return this;
-	}
-	subgraphParent(id, parentID) {
-		const item = this._subgraphMap[id];
-		if (!item) throw new Error(`Subgraph '${id}' does not exist.`);
-		if (parentID === void 0) {
-			const parent$1 = item.parent();
-			return parent$1 ? parent$1._ : void 0;
-		}
-		const parent = this._subgraphMap[parentID];
-		if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
-		item.parent(parent);
-		return this;
-	}
-	allVertices() {
-		const retVal = [];
-		for (const key in this._vertexMap) retVal.push(this._vertexMap[key]._);
-		return retVal;
-	}
-	vertices() {
-		const retVal = [];
-		for (const key in this._vertexMap) if (this._vertexMap[key].parent() === void 0) retVal.push(this._vertexMap[key]._);
-		return retVal;
-	}
-	vertexExists(id) {
-		return !!this._vertexMap[id];
-	}
-	vertex(id) {
-		return this._vertexMap[id]._;
-	}
-	allEdges() {
-		const retVal = [];
-		for (const key in this._edgeMap) retVal.push(this._edgeMap[key]._);
-		return retVal;
-	}
-	edges() {
-		const retVal = [];
-		for (const key in this._edgeMap) if (this._edgeMap[key].parent() === void 0) retVal.push(this._edgeMap[key]._);
-		return retVal;
-	}
-	vertexEdges(vertexID) {
-		return this._vertexMap[vertexID].edges().map((e) => e._);
-	}
-	inEdges(vertexID) {
-		return this._vertexMap[vertexID].inEdges().map((e) => e._);
-	}
-	outEdges(vertexID) {
-		return this._vertexMap[vertexID].outEdges().map((e) => e._);
-	}
-	_neighbors(id) {
-		return [...this._vertexMap[id].outEdges().map((e) => e._target), ...this._vertexMap[id].inEdges().map((e) => e._source)];
-	}
-	neighbors(id) {
-		return this._neighbors(id).map((n) => n._);
-	}
-	singleNeighbors(id) {
-		return this._neighbors(id).filter((n) => n.edgeCount() === 1).map((n) => n._);
-	}
-	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 Vertex$1(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]);
-		}
-		this._vertexMap[v_id] = vertex;
-		return this;
-	}
-	mergeVertices(_vertices) {
-		const vDiff = compare2(this.allVertices(), _vertices, (v) => this._idFunc(v), this._updateFunc);
-		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);
-		const vertex = this._vertexMap[v_id];
-		if (!vertex) throw new Error(`Vertex '${v_id}' does not exist.`);
-		vertex._ = v;
-		return this;
-	}
-	removeVertex(id) {
-		const v = this._vertexMap[id];
-		if (!v) throw new Error(`Vertex '${id}' does not exist.`);
-		v.edges().forEach((e) => {
-			this.removeEdge(e.id());
-		});
-		delete this._vertexMap[id];
-		return this;
-	}
-	vertexParent(id, parentID) {
-		const item = this._vertexMap[id];
-		if (!item) throw new Error(`Vertex '${id}' does not exist.`);
-		if (parentID === void 0) {
-			const parent$1 = item.parent();
-			return parent$1 ? parent$1._ : void 0;
-		}
-		const parent = this._subgraphMap[parentID];
-		if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
-		item.parent(parent);
-		return this;
-	}
-	edgeExists(id) {
-		return !!this._edgeMap[id];
-	}
-	edge(id) {
-		return this._edgeMap[id]._;
-	}
-	addEdge(e, parent) {
-		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 Edge$1(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]);
-		}
-		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);
-		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) {
-		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();
-		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];
-		if (!e) throw new Error(`Edge '${id}' does not exist.`);
-		const e_sourceID = this._idFunc(e._source._);
-		if (!this.vertexExists(e_sourceID)) throw new Error(`Edge Source'${e_sourceID}' does not exist.`);
-		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.`);
-		this._vertexMap[e_targetID].removeInEdge(id);
-		delete this._edgeMap[id];
-		return this;
-	}
-	_hwalk(item, formatter) {
-		if (item instanceof Subgraph$1) 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];
-			if (sg.parent() === void 0) retVal.push(this._hwalk(sg, formatter));
-		}
-		for (const id in this._vertexMap) {
-			const v = this._vertexMap[id];
-			if (v.parent() === void 0) retVal.push(this._hwalk(v, formatter));
-		}
-		return retVal;
-	}
-	dijkstra(source, target) {
-		const edges = this.allEdges();
-		const Q = new Set();
-		const prev = {};
-		const dist = {};
-		const adj = {};
-		function vertex_with_min_dist(Q$1, dist$1) {
-			let min_distance = Infinity;
-			let u$1 = null;
-			Q$1.forEach((v) => {
-				if (dist$1[v] < min_distance) {
-					min_distance = dist$1[v];
-					u$1 = v;
-				}
-			});
-			return u$1;
-		}
-		for (let i = 0; i < edges.length; i++) {
-			const v1 = this._sourceFunc(edges[i]);
-			const v2 = this._targetFunc(edges[i]);
-			const len$1 = 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] = len$1;
-			adj[v2][v1] = len$1;
-		}
-		dist[source] = 0;
-		while (Q.size) {
-			const u$1 = vertex_with_min_dist(Q, dist);
-			if (u$1 === null) break;
-			const neighbors = Object.keys(adj[u$1]).filter((v) => Q.has(v));
-			Q.delete(u$1);
-			if (u$1 === target) break;
-			for (const v of neighbors) {
-				const alt = dist[u$1] + adj[u$1][v];
-				if (alt < dist[v]) {
-					dist[v] = alt;
-					prev[v] = u$1;
-				}
-			}
-		}
-		let u = target;
-		const ids = [u];
-		let len = 0;
-		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 = [];
-		const visited = {};
-		const visit = (vertex, ancestors = []) => {
-			const v_id$1 = vertex.id();
-			if (visited[v_id$1]) return;
-			visited[v_id$1] = true;
-			ancestors.push(vertex);
-			vertex.outEdges().forEach((e) => {
-				if (ancestors.indexOf(e._target) < 0) visit(e._target, [...ancestors]);
-			});
-			retVal.unshift(vertex._);
-		};
-		if (v_id) visit(this._vertexMap[v_id]);
-		else for (const key in this._vertexMap) visit(this._vertexMap[key]);
-		return retVal;
-	}
+__name(_Edge, "Edge");
+let Edge = _Edge;
+const _Graph2 = class _Graph2 {
+  _directed;
+  _subgraphMap = {};
+  _vertexMap = {};
+  _edgeMap = {};
+  constructor(directed = true) {
+    this._directed = directed;
+  }
+  clear() {
+    this._subgraphMap = {};
+    this._vertexMap = {};
+    this._edgeMap = {};
+    return this;
+  }
+  clearParents() {
+    for (const key in this._subgraphMap) {
+      this._subgraphMap[key].clearParent();
+    }
+    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(_) {
+    this._idFunc = _;
+    return this;
+  }
+  _sourceFunc = /* @__PURE__ */ __name((_) => typeof _.source === "function" ? _.source() : _.source, "_sourceFunc");
+  sourceFunc(_) {
+    this._sourceFunc = _;
+    return this;
+  }
+  _targetFunc = /* @__PURE__ */ __name((_) => typeof _.target === "function" ? _.target() : _.target, "_targetFunc");
+  targetFunc(_) {
+    this._targetFunc = _;
+    return this;
+  }
+  _updateFunc = /* @__PURE__ */ __name((before, after) => after, "_updateFunc");
+  updateFunc(_) {
+    this._updateFunc = _;
+    return this;
+  }
+  id(_) {
+    return this._idFunc(_);
+  }
+  type(id) {
+    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(_));
+  }
+  isVertex(_) {
+    return this.vertexExists(this.id(_));
+  }
+  isEdge(_) {
+    return this.edgeExists(this.id(_));
+  }
+  allItems() {
+    return [...this.allSubgraphs(), ...this.allVertices(), ...this.allEdges()];
+  }
+  item(id) {
+    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);
+  }
+  // Subgraphs  ---
+  allSubgraphs() {
+    const retVal = [];
+    for (const key in this._subgraphMap) {
+      retVal.push(this._subgraphMap[key]._);
+    }
+    return retVal;
+  }
+  subgraphs() {
+    const retVal = [];
+    for (const key in this._subgraphMap) {
+      if (this._subgraphMap[key].parent() === void 0) {
+        retVal.push(this._subgraphMap[key]._);
+      }
+    }
+    return retVal;
+  }
+  subgraphExists(id) {
+    return !!this._subgraphMap[id];
+  }
+  subgraph(id) {
+    return this._subgraphMap[id]._;
+  }
+  subgraphSubgraphs(id) {
+    return this._subgraphMap[id].children().filter((child) => this.isSubgraph(child._)).map((child) => child._);
+  }
+  subgraphVertices(id) {
+    return this._subgraphMap[id].children().filter((child) => this.isVertex(child._)).map((child) => child._);
+  }
+  subgraphEdges(id) {
+    return this._subgraphMap[id].children().filter((child) => this.isEdge(child._)).map((child) => child._);
+  }
+  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 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]);
+    }
+    this._subgraphMap[s_id] = subgraph;
+    return this;
+  }
+  mergeSubgraphs(_subgraphs = []) {
+    const sgDiff = compare2(this.allSubgraphs(), _subgraphs, (sg) => this._idFunc(sg), this._updateFunc);
+    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);
+    const subgraph = this._subgraphMap[sg_id];
+    if (!subgraph) throw new Error(`Subgraph '${sg_id}' does not exist.`);
+    subgraph._ = sg;
+    return this;
+  }
+  removeSubgraph(id, promoteChildren = true) {
+    const sg = this._subgraphMap[id];
+    if (!sg) throw new Error(`Subgraph '${id}' does not exist.`);
+    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];
+    if (!item) throw new Error(`Subgraph '${id}' does not exist.`);
+    if (parentID === void 0) {
+      const parent2 = item.parent();
+      return parent2 ? parent2._ : void 0;
+    }
+    const parent = this._subgraphMap[parentID];
+    if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
+    item.parent(parent);
+    return this;
+  }
+  // Vertices  ---
+  allVertices() {
+    const retVal = [];
+    for (const key in this._vertexMap) {
+      retVal.push(this._vertexMap[key]._);
+    }
+    return retVal;
+  }
+  vertices() {
+    const retVal = [];
+    for (const key in this._vertexMap) {
+      if (this._vertexMap[key].parent() === void 0) {
+        retVal.push(this._vertexMap[key]._);
+      }
+    }
+    return retVal;
+  }
+  vertexExists(id) {
+    return !!this._vertexMap[id];
+  }
+  vertex(id) {
+    return this._vertexMap[id]._;
+  }
+  allEdges() {
+    const retVal = [];
+    for (const key in this._edgeMap) {
+      retVal.push(this._edgeMap[key]._);
+    }
+    return retVal;
+  }
+  edges() {
+    const retVal = [];
+    for (const key in this._edgeMap) {
+      if (this._edgeMap[key].parent() === void 0) {
+        retVal.push(this._edgeMap[key]._);
+      }
+    }
+    return retVal;
+  }
+  vertexEdges(vertexID) {
+    return this._vertexMap[vertexID].edges().map((e) => e._);
+  }
+  inEdges(vertexID) {
+    return this._vertexMap[vertexID].inEdges().map((e) => e._);
+  }
+  outEdges(vertexID) {
+    return this._vertexMap[vertexID].outEdges().map((e) => e._);
+  }
+  _neighbors(id) {
+    return [...this._vertexMap[id].outEdges().map((e) => e._target), ...this._vertexMap[id].inEdges().map((e) => e._source)];
+  }
+  neighbors(id) {
+    return this._neighbors(id).map((n) => n._);
+  }
+  singleNeighbors(id) {
+    return this._neighbors(id).filter((n) => n.edgeCount() === 1).map((n) => n._);
+  }
+  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 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]);
+    }
+    this._vertexMap[v_id] = vertex;
+    return this;
+  }
+  mergeVertices(_vertices) {
+    const vDiff = compare2(this.allVertices(), _vertices, (v) => this._idFunc(v), this._updateFunc);
+    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);
+    const vertex = this._vertexMap[v_id];
+    if (!vertex) throw new Error(`Vertex '${v_id}' does not exist.`);
+    vertex._ = v;
+    return this;
+  }
+  removeVertex(id) {
+    const v = this._vertexMap[id];
+    if (!v) throw new Error(`Vertex '${id}' does not exist.`);
+    v.edges().forEach((e) => {
+      this.removeEdge(e.id());
+    });
+    delete this._vertexMap[id];
+    return this;
+  }
+  vertexParent(id, parentID) {
+    const item = this._vertexMap[id];
+    if (!item) throw new Error(`Vertex '${id}' does not exist.`);
+    if (parentID === void 0) {
+      const parent2 = item.parent();
+      return parent2 ? parent2._ : void 0;
+    }
+    const parent = this._subgraphMap[parentID];
+    if (!parent) throw new Error(`Vertex parent '${parent}' does not exist.`);
+    item.parent(parent);
+    return this;
+  }
+  // Edges  ---
+  edgeExists(id) {
+    return !!this._edgeMap[id];
+  }
+  edge(id) {
+    return this._edgeMap[id]._;
+  }
+  addEdge(e, parent) {
+    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 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]);
+    }
+    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);
+    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) {
+    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();
+    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];
+    if (!e) throw new Error(`Edge '${id}' does not exist.`);
+    const e_sourceID = this._idFunc(e._source._);
+    if (!this.vertexExists(e_sourceID)) throw new Error(`Edge Source'${e_sourceID}' does not exist.`);
+    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.`);
+    this._vertexMap[e_targetID].removeInEdge(id);
+    delete this._edgeMap[id];
+    return this;
+  }
+  _hwalk(item, formatter) {
+    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];
+      if (sg.parent() === void 0) {
+        retVal.push(this._hwalk(sg, formatter));
+      }
+    }
+    for (const id in this._vertexMap) {
+      const v = this._vertexMap[id];
+      if (v.parent() === void 0) {
+        retVal.push(this._hwalk(v, formatter));
+      }
+    }
+    return retVal;
+  }
+  dijkstra(source, target) {
+    const edges = this.allEdges();
+    const Q = new Set();
+    const prev = {};
+    const dist = {};
+    const adj = {};
+    function vertex_with_min_dist(Q2, dist2) {
+      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]);
+      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;
+    }
+    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));
+      Q.delete(u2);
+      if (u2 === target) break;
+      for (const v of neighbors) {
+        const alt = dist[u2] + adj[u2][v];
+        if (alt < dist[v]) {
+          dist[v] = alt;
+          prev[v] = u2;
+        }
+      }
+    }
+    let u = target;
+    const ids = [u];
+    let len = 0;
+    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 = [];
+    const visited = {};
+    const visit = /* @__PURE__ */ __name((vertex, ancestors = []) => {
+      const v_id2 = vertex.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) {
+        visit(this._vertexMap[key]);
+      }
+    }
+    return retVal;
+  }
 };
-var Set = class {
-	_content = [];
-	get size() {
-		return this._content.length;
-	}
-	has(_) {
-		return this._content.indexOf(_) >= 0;
-	}
-	add(_) {
-		if (!this.has(_)) this._content.push(_);
-	}
-	delete(_) {
-		const idx = this._content.indexOf(_);
-		if (idx >= 0) this._content.splice(idx, 1);
-	}
-	forEach(_) {
-		this._content.forEach(_);
-	}
+__name(_Graph2, "Graph2");
+let Graph2 = _Graph2;
+const _Set = class _Set {
+  _content = [];
+  get size() {
+    return this._content.length;
+  }
+  has(_) {
+    return this._content.indexOf(_) >= 0;
+  }
+  add(_) {
+    if (!this.has(_)) {
+      this._content.push(_);
+    }
+  }
+  delete(_) {
+    const idx = this._content.indexOf(_);
+    if (idx >= 0) {
+      this._content.splice(idx, 1);
+    }
+  }
+  forEach(_) {
+    this._content.forEach(_);
+  }
 };
-
-//#endregion
-//#region src/immutable.ts
-var isArray$1 = Array.isArray;
-var keyList = Object.keys;
-var hasProp = Object.prototype.hasOwnProperty;
+__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);
-			const arrB = isArray$1(b);
-			let i;
-			let length;
-			let key;
-			if (arrA && arrB) {
-				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 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 (dateA && dateB) {
-				const retVal$1 = a.getTime() === b.getTime();
-				if (!retVal$1) console.warn(`dates not equal: ${a.getTime()} !== ${b.getTime()}`);
-				return retVal$1;
-			}
-			const regexpA = a instanceof RegExp;
-			const regexpB = b instanceof RegExp;
-			if (regexpA !== regexpB) {
-				console.warn(`regexps not equal: ${regexpA} !== ${regexpB}`);
-				return false;
-			}
-			if (regexpA && regexpB) {
-				const retVal$1 = a.toString() === b.toString();
-				if (!retVal$1) console.warn(`regexps not equal: ${a.toString()} !== ${b.toString()}`);
-				return retVal$1;
-			}
-			const keys = keyList(a);
-			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 (!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 retVal$1 = a.toString() === b.toString();
-			if (!retVal$1) console.warn(`functions not equal: ${a.toString()} !== ${b.toString()}`);
-			return retVal$1;
-		}
-	}
-	const retVal = a !== a && b !== b;
-	if (!retVal) console.warn(`values not equal: ${a} !== ${b}`);
-	return retVal;
+  if (a === b) return true;
+  if (a && b) {
+    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) {
+        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 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 (dateA && dateB) {
+        const retVal2 = a.getTime() === b.getTime();
+        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;
+      }
+      if (regexpA && regexpB) {
+        const retVal2 = a.toString() === b.toString();
+        if (!retVal2) {
+          console.warn(`regexps not equal: ${a.toString()} !== ${b.toString()}`);
+        }
+        return retVal2;
+      }
+      const keys = keyList(a);
+      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 (!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();
+      if (!retVal2) {
+        console.warn(`functions not equal: ${a.toString()} !== ${b.toString()}`);
+      }
+      return retVal2;
+    }
+  }
+  const retVal = a !== a && b !== b;
+  if (!retVal) {
+    console.warn(`values not equal: ${a} !== ${b}`);
+  }
+  return retVal;
 }
+__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);
-			const arrB = isArray$1(b);
-			let i;
-			let length;
-			let key;
-			if (arrA && arrB) {
-				length = a.length;
-				if (length !== b.length) return false;
-				for (i = length; i-- !== 0;) if (!deepEquals(a[i], b[i], functionRefCompare)) return false;
-				return true;
-			}
-			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;
-			const regexpB = b instanceof RegExp;
-			if (regexpA !== regexpB) return false;
-			if (regexpA && regexpB) return a.toString() === b.toString();
-			const keys = keyList(a);
-			length = keys.length;
-			if (length !== keyList(b).length) return false;
-			for (i = length; i-- !== 0;) 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;
+  if (a === b) return true;
+  if (a && b) {
+    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) {
+        length = a.length;
+        if (length !== b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (!deepEquals(a[i], b[i], functionRefCompare)) return false;
+        return true;
+      }
+      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;
+      const regexpB = b instanceof RegExp;
+      if (regexpA !== regexpB) return false;
+      if (regexpA && regexpB) return a.toString() === b.toString();
+      const keys = keyList(a);
+      length = keys.length;
+      if (length !== keyList(b).length)
+        return false;
+      for (i = length; i-- !== 0; )
+        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;
 }
+__name(deepEquals, "deepEquals");
 function update(origItem, newItem, functionRefCompare = false) {
-	return deepEquals(origItem, newItem, functionRefCompare) ? origItem : newItem;
+  return deepEquals(origItem, newItem, functionRefCompare) ? origItem : newItem;
 }
-
-//#endregion
-//#region src/platform.ts
+__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) return script.src.substring(0, idx);
-		}
-	}
-	return "";
+  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) {
+        return script.src.substring(0, idx);
+      }
+    }
+  }
+  return "";
 }
-
-//#endregion
-//#region src/stack.ts
-/**
-* A generic Stack
-*/
-var Stack = class {
-	stack = [];
-	/**
-	* Push element onto the stack
-	*
-	* @param e - element to push
-	*/
-	push(e) {
-		this.stack.push(e);
-		return e;
-	}
-	/**
-	* Pop element off the stack
-	*/
-	pop() {
-		return this.stack.pop();
-	}
-	/**
-	* Top item on the stack
-	*
-	* @returns Top element on the stack
-	*/
-	top() {
-		return this.stack.length ? this.stack[this.stack.length - 1] : void 0;
-	}
-	/**
-	* Depth of stack
-	*
-	* @returns Depth
-	*/
-	depth() {
-		return this.stack.length;
-	}
+__name(getScriptSrc, "getScriptSrc");
+const _Stack = class _Stack {
+  stack = [];
+  /**
+   * Push element onto the stack
+   *
+   * @param e - element to push
+   */
+  push(e) {
+    this.stack.push(e);
+    return e;
+  }
+  /**
+   * Pop element off the stack
+   */
+  pop() {
+    return this.stack.pop();
+  }
+  /**
+   * Top item on the stack
+   *
+   * @returns Top element on the stack
+   */
+  top() {
+    return this.stack.length ? this.stack[this.stack.length - 1] : void 0;
+  }
+  /**
+   * Depth of stack
+   *
+   * @returns Depth
+   */
+  depth() {
+    return this.stack.length;
+  }
 };
-
-//#endregion
-//#region src/logging.ts
-let Level = /* @__PURE__ */ function(Level$1) {
-	Level$1[Level$1["debug"] = 0] = "debug";
-	Level$1[Level$1["info"] = 1] = "info";
-	Level$1[Level$1["notice"] = 2] = "notice";
-	Level$1[Level$1["warning"] = 3] = "warning";
-	Level$1[Level$1["error"] = 4] = "error";
-	Level$1[Level$1["critical"] = 5] = "critical";
-	Level$1[Level$1["alert"] = 6] = "alert";
-	Level$1[Level$1["emergency"] = 7] = "emergency";
-	return Level$1;
-}({});
-var colours = {
-	debug: "cyan",
-	info: "green",
-	notice: "grey",
-	warning: "blue",
-	error: "red",
-	critical: "magenta",
-	alert: "magenta",
-	emergency: "magenta"
+__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",
+  notice: "grey",
+  warning: "blue",
+  error: "red",
+  critical: "magenta",
+  alert: "magenta",
+  emergency: "magenta"
 };
-var ConsoleWriter = class {
-	write(dateTime, level, id, msg) {
-		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]]}`, "");
-	}
+const _ConsoleWriter = class _ConsoleWriter {
+  write(dateTime, level, id, msg) {
+    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]]}`, "");
+    }
+  }
 };
-var Logging = class {
-	static _instance;
-	_levelStack = new Stack();
-	_level = Level.info;
-	_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) return;
-				cache.push(value);
-			}
-			return value;
-		}, 2);
-	}
-	writer(_) {
-		if (_ === void 0) return this._writer;
-		this._writer = _;
-		return this;
-	}
-	log(level, id, msg) {
-		if (level < this._level) return;
-		if (this._filter && this._filter !== id) return;
-		const dateTime = (/* @__PURE__ */ new Date()).toISOString();
-		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(Level.debug, id, msg);
-	}
-	info(id, msg) {
-		this.log(Level.info, id, msg);
-	}
-	notice(id, msg) {
-		this.log(Level.notice, id, msg);
-	}
-	warning(id, msg) {
-		this.log(Level.warning, id, msg);
-	}
-	error(id, msg) {
-		this.log(Level.error, id, msg);
-	}
-	critical(id, msg) {
-		this.log(Level.critical, id, msg);
-	}
-	alert(id, msg) {
-		this.log(Level.alert, id, msg);
-	}
-	emergency(id, msg) {
-		this.log(Level.emergency, id, msg);
-	}
-	level(_) {
-		if (_ === void 0) return this._level;
-		this._level = _;
-		return this;
-	}
-	pushLevel(_) {
-		this._levelStack.push(this._level);
-		this._level = _;
-		return this;
-	}
-	popLevel() {
-		this._level = this._levelStack.pop();
-		return this;
-	}
-	filter(_) {
-		if (_ === void 0) return this._filter;
-		this._filter = _;
-		return this;
-	}
+__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) {
+          return;
+        }
+        cache.push(value);
+      }
+      return value;
+    }, 2);
+  }
+  writer(_) {
+    if (_ === void 0) return this._writer;
+    this._writer = _;
+    return this;
+  }
+  log(level, id, msg) {
+    if (level < this._level) return;
+    if (this._filter && this._filter !== id) return;
+    const dateTime = (/* @__PURE__ */ new Date()).toISOString();
+    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);
+  }
+  info(id, msg) {
+    this.log(1, id, msg);
+  }
+  notice(id, msg) {
+    this.log(2, id, msg);
+  }
+  warning(id, msg) {
+    this.log(3, id, msg);
+  }
+  error(id, msg) {
+    this.log(4, id, msg);
+  }
+  critical(id, msg) {
+    this.log(5, id, msg);
+  }
+  alert(id, msg) {
+    this.log(6, id, msg);
+  }
+  emergency(id, msg) {
+    this.log(7, id, msg);
+  }
+  level(_) {
+    if (_ === void 0) return this._level;
+    this._level = _;
+    return this;
+  }
+  pushLevel(_) {
+    this._levelStack.push(this._level);
+    this._level = _;
+    return this;
+  }
+  popLevel() {
+    this._level = this._levelStack.pop();
+    return this;
+  }
+  filter(_) {
+    if (_ === void 0) return this._filter;
+    this._filter = _;
+    return this;
+  }
 };
+__name(_Logging, "Logging");
+__publicField(_Logging, "_instance");
+let Logging = _Logging;
 const logger = Logging.Instance();
-var ScopedLogging = class {
-	_scopeID;
-	constructor(scopeID) {
-		this._scopeID = scopeID;
-	}
-	debug(msg) {
-		logger.debug(this._scopeID, msg);
-	}
-	info(msg) {
-		logger.info(this._scopeID, msg);
-	}
-	notice(msg) {
-		logger.notice(this._scopeID, msg);
-	}
-	warning(msg) {
-		logger.warning(this._scopeID, msg);
-	}
-	error(msg) {
-		logger.error(this._scopeID, msg);
-	}
-	critical(msg) {
-		logger.critical(this._scopeID, msg);
-	}
-	alert(msg) {
-		logger.alert(this._scopeID, msg);
-	}
-	emergency(msg) {
-		logger.emergency(this._scopeID, msg);
-	}
-	pushLevel(_) {
-		logger.pushLevel(_);
-		return this;
-	}
-	popLevel() {
-		logger.popLevel();
-		return this;
-	}
+const _ScopedLogging = class _ScopedLogging {
+  _scopeID;
+  constructor(scopeID) {
+    this._scopeID = scopeID;
+  }
+  debug(msg) {
+    logger.debug(this._scopeID, msg);
+  }
+  info(msg) {
+    logger.info(this._scopeID, msg);
+  }
+  notice(msg) {
+    logger.notice(this._scopeID, msg);
+  }
+  warning(msg) {
+    logger.warning(this._scopeID, msg);
+  }
+  error(msg) {
+    logger.error(this._scopeID, msg);
+  }
+  critical(msg) {
+    logger.critical(this._scopeID, msg);
+  }
+  alert(msg) {
+    logger.alert(this._scopeID, msg);
+  }
+  emergency(msg) {
+    logger.emergency(this._scopeID, msg);
+  }
+  pushLevel(_) {
+    logger.pushLevel(_);
+    return this;
+  }
+  popLevel() {
+    logger.popLevel();
+    return this;
+  }
 };
+__name(_ScopedLogging, "ScopedLogging");
+let ScopedLogging = _ScopedLogging;
 function scopedLogger(scopeID, filter = false) {
-	if (filter) logger.filter(scopeID);
-	return new ScopedLogging(scopeID);
+  if (filter) {
+    logger.filter(scopeID);
+  }
+  return new ScopedLogging(scopeID);
 }
-
-//#endregion
-//#region src/math.ts
-/**
-* degreesToRadians - converts degrees to radians
-* Usage: degreesToRadians(1080);
-*
-* @param degrees
-* @returns Number radians
-*/
+__name(scopedLogger, "scopedLogger");
 function degreesToRadians(degrees) {
-	return degrees * (Math.PI / 180);
+  return degrees * (Math.PI / 180);
 }
-/**
-* radiansToDegrees - converts radians to degrees
-* Usage: radiansToDegrees(7);
-*
-* @param radians
-* @returns Number degreees
-*/
+__name(degreesToRadians, "degreesToRadians");
 function radiansToDegrees(radians) {
-	return radians * (180 / Math.PI);
+  return radians * (180 / Math.PI);
 }
-/**
-* polarToCartesian - converts (r, theta) to {x, y}
-* Usage: polarToCartesian(5, Math.PI);
-*
-* @param r radius
-* @param theta angle in radians
-* @returns { x: number, y: number }
-*/
+__name(radiansToDegrees, "radiansToDegrees");
 function polarToCartesian(r, theta) {
-	return {
-		x: r * Math.cos(theta),
-		y: r * Math.sin(theta)
-	};
+  return {
+    x: r * Math.cos(theta),
+    y: r * Math.sin(theta)
+  };
 }
-/**
-* cartesianToPolar - converts (x, y) to {r, theta}
-* Usage: cartesianToPolar(100, 200);
-*
-* @param x
-* @param y
-* @returns { r: number, theta: number }
-*/
+__name(polarToCartesian, "polarToCartesian");
 function cartesianToPolar(x, y) {
-	return {
-		r: Math.sqrt(x * x + y * y),
-		theta: Math.atan2(y, x)
-	};
+  return {
+    r: Math.sqrt(x * x + y * y),
+    theta: Math.atan2(y, x)
+  };
 }
-/**
-* normalizeRadians - normalizes a radian value to within the provided range
-* Usage: normalizeRadians(7);
-*
-* @param radians value to be normalized
-* @param min lower limit
-* @param max upper limit
-* @returns Number normalized to within the provided range
-*/
+__name(cartesianToPolar, "cartesianToPolar");
 function normalizeRadians(radians, min = -Math.PI, max = Math.PI) {
-	return normalize(radians, min, max);
+  return normalize(radians, min, max);
 }
-/**
-* normalizeDegrees - normalizes a degree value to within the provided range
-* Usage: normalizeDegrees(1080);
-*
-* @param degrees value to be normalized
-* @param min lower limit
-* @param max upper limit
-* @returns Number normalized to within the provided range
-*/
+__name(normalizeRadians, "normalizeRadians");
 function normalizeDegrees(degrees, min = -180, max = 180) {
-	return normalize(degrees, min, max);
+  return normalize(degrees, min, max);
 }
-/**
-* normalize - normalizes a value to within the provided range
-* Usage: normalize(1000, 0, 365);
-*
-* @param value value to be normalized
-* @param min lower limit
-* @param max upper limit
-* @returns Number normalized to within the provided range
-*/
+__name(normalizeDegrees, "normalizeDegrees");
 function normalize(value, min, max) {
-	const spread = max - min;
-	const offsetValue = value - min;
-	return offsetValue - Math.floor(offsetValue / spread) * spread + min;
+  const spread = max - min;
+  const offsetValue = value - min;
+  return offsetValue - Math.floor(offsetValue / spread) * spread + min;
 }
-
-//#endregion
-//#region src/object.ts
-/**
-* inner - return inner property of Object
-* Usage:  inner("some.prop.to.locate", obj);
-*
-* @param prop - property to locate
-* @param obj - object to locate property in
-*/
+__name(normalize, "normalize");
 function inner(prop, obj) {
-	if (prop === void 0 || obj === void 0) return void 0;
-	for (const item of prop.split(".")) {
-		if (!obj.hasOwnProperty(item)) return;
-		obj = obj[item];
-	}
-	return obj;
+  if (prop === void 0 || obj === void 0) return void 0;
+  for (const item of prop.split(".")) {
+    if (!obj.hasOwnProperty(item)) {
+      return void 0;
+    }
+    obj = obj[item];
+  }
+  return obj;
 }
-/**
-* exists - return true if inner property of Object exists
-* Usage:  exists("some.prop.to.locate", obj);
-*
-* @param prop - property to locate
-* @param obj - object to locate property in
-*/
+__name(inner, "inner");
 function exists(prop, obj) {
-	return inner(prop, obj) !== void 0;
+  return inner(prop, obj) !== void 0;
 }
+__name(exists, "exists");
 function _mixin(dest, source) {
-	const empty = {};
-	for (const key in source) {
-		if (!source.hasOwnProperty(key)) continue;
-		if (key === "__proto__" || key === "constructor") continue;
-		let s = source[key];
-		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;
+  const empty = {};
+  for (const key in source) {
+    if (!source.hasOwnProperty(key)) continue;
+    if (key === "__proto__" || key === "constructor") continue;
+    let s = source[key];
+    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;
 }
-/**
-* deepMixin - combine several objects from right to left
-* Usage:  deepMixin({a: "a"}, {b: "b"});
-*
-* @param dest - target object to mix into.
-* @param sources - objects to mix in
-*/
+__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) _mixin(dest, source);
-	return dest;
+  if (typeof dest !== "object") throw new Error(`Destination "${dest}" must be an object.`);
+  for (const source of sources) {
+    _mixin(dest, source);
+  }
+  return dest;
 }
-/**
-* deepMixinT - combine several objects of Partial<T> from right to left
-* Usage:  deepMixinT<MyInterface>({a: "a"}, {b: "b"});
-*
-* Note:  Only provided as a convenience, so user gets auto completion based on destination type.
-*
-* @param dest - target object to mix into.
-* @param sources - objects to mix in
-*/
+__name(deepMixin, "deepMixin");
 function deepMixinT(dest = {}, ...sources) {
-	return deepMixin(dest, ...sources);
+  return deepMixin(dest, ...sources);
 }
-/**
-* safeStingify - JSONsimilar to .stringify, except ignores circular references.
-* Usage:  safeStingify(object);
-*
-* @param obj - any object.
-*/
+__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) return;
-			cache.push(value);
-		}
-		return value;
-	});
+  const cache = [];
+  return JSON.stringify(obj, function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      if (cache.indexOf(value) !== -1) {
+        return;
+      }
+      cache.push(value);
+    }
+    return value;
+  });
 }
+__name(safeStringify, "safeStringify");
 function isArray(arg) {
-	if (Array.isArray !== void 0) return Array.isArray(arg);
-	return 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("_");
-	const classInfo = info[1].split(".");
-	return {
-		module: `@hpcc-js/${info[0]}`,
-		file: classInfo[0],
-		class: classInfo[1] || classInfo[0]
-	};
+  const info = classID.split("_");
+  const classInfo = info[1].split(".");
+  return {
+    module: `@hpcc-js/${info[0]}`,
+    file: classInfo[0],
+    class: classInfo[1] || classInfo[0]
+  };
 }
-
-//#endregion
-//#region src/observer.ts
-var ObserverHandle = class {
-	eventTarget;
-	eventID;
-	callback;
-	constructor(eventTarget, eventID, callback) {
-		this.eventTarget = eventTarget;
-		this.eventID = eventID;
-		this.callback = callback;
-	}
-	release() {
-		this.eventTarget.removeObserver(this.eventID, this.callback);
-	}
-	unwatch() {
-		this.release();
-	}
+__name(classID2Meta, "classID2Meta");
+const _ObserverHandle = class _ObserverHandle {
+  eventTarget;
+  eventID;
+  callback;
+  constructor(eventTarget, eventID, callback) {
+    this.eventTarget = eventTarget;
+    this.eventID = eventID;
+    this.callback = callback;
+  }
+  release() {
+    this.eventTarget.removeObserver(this.eventID, this.callback);
+  }
+  unwatch() {
+    this.release();
+  }
 };
-var Observable = class {
-	_eventObservers = {};
-	constructor(...events) {}
-	addObserver(eventID, callback) {
-		let eventObservers = this._eventObservers[eventID];
-		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) 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) observer(...args);
-		return this;
-	}
-	_hasObserver(eventID) {
-		const eventObservers = this._eventObservers[eventID];
-		for (const observer in eventObservers) if (eventObservers[observer]) return true;
-		return false;
-	}
-	hasObserver(_eventID) {
-		if (_eventID !== void 0) return this._hasObserver(_eventID);
-		for (const eventID in this._eventObservers) if (this._hasObserver(eventID)) return true;
-		return false;
-	}
+__name(_ObserverHandle, "ObserverHandle");
+let ObserverHandle = _ObserverHandle;
+const _Observable = class _Observable {
+  _eventObservers = {};
+  constructor(...events) {
+  }
+  addObserver(eventID, callback) {
+    let eventObservers = this._eventObservers[eventID];
+    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) {
+        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) {
+        observer(...args);
+      }
+    }
+    return this;
+  }
+  _hasObserver(eventID) {
+    const eventObservers = this._eventObservers[eventID];
+    for (const observer in eventObservers) {
+      if (eventObservers[observer]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasObserver(_eventID) {
+    if (_eventID !== void 0) {
+      return this._hasObserver(_eventID);
+    }
+    for (const eventID in this._eventObservers) {
+      if (this._hasObserver(eventID)) {
+        return true;
+      }
+    }
+    return false;
+  }
 };
-
-//#endregion
-//#region src/dispatch.ts
-var requestAnimationFrame;
+__name(_Observable, "Observable");
+let Observable = _Observable;
+let requestAnimationFrame;
 (function() {
-	if (root.requestAnimationFrame) requestAnimationFrame = root.requestAnimationFrame;
-	else {
-		let lastTime = 0;
-		requestAnimationFrame = 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;
-		};
-	}
+  if (root.requestAnimationFrame) {
+    requestAnimationFrame = root.requestAnimationFrame;
+  } else {
+    let lastTime = 0;
+    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");
+  }
 })();
-var Message = class {
-	get canConflate() {
-		return false;
-	}
-	conflate(other) {
-		return false;
-	}
-	void() {
-		return false;
-	}
+const _Message = class _Message {
+  get canConflate() {
+    return false;
+  }
+  conflate(other) {
+    return false;
+  }
+  void() {
+    return false;
+  }
 };
-var Dispatch = class {
-	_observerID = 0;
-	_observers = [];
-	_messageBuffer = [];
-	constructor() {}
-	observers() {
-		return this._observers;
-	}
-	messages() {
-		const 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();
-	}
-	dispatch(messages) {
-		if (messages.length === 0) return;
-		this.observers().forEach((o) => {
-			const msgs = messages.filter((m) => !m.void() && (o.type === void 0 || m instanceof o.type));
-			if (msgs.length) o.callback(msgs);
-		});
-	}
-	hasObserver() {
-		return this._observers.length > 0;
-	}
-	flush() {
-		this._messageBuffer = [];
-	}
-	send(msg) {
-		this.dispatch([msg]);
-	}
-	post(msg) {
-		this._messageBuffer.push(msg);
-		requestAnimationFrame(() => this.dispatchAll());
-	}
-	attach(callback, type) {
-		const context = this;
-		const id = ++this._observerID;
-		this._observers.push({
-			id,
-			type,
-			callback
-		});
-		return {
-			release() {
-				context._observers = context._observers.filter((o) => o.id !== id);
-			},
-			unwatch() {
-				this.release();
-			}
-		};
-	}
+__name(_Message, "Message");
+let Message = _Message;
+const _Dispatch = class _Dispatch {
+  _observerID = 0;
+  _observers = [];
+  _messageBuffer = [];
+  constructor() {
+  }
+  observers() {
+    return this._observers;
+  }
+  messages() {
+    const 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();
+  }
+  dispatch(messages) {
+    if (messages.length === 0) return;
+    this.observers().forEach((o) => {
+      const msgs = messages.filter((m) => !m.void() && (o.type === void 0 || m instanceof o.type));
+      if (msgs.length) {
+        o.callback(msgs);
+      }
+    });
+  }
+  hasObserver() {
+    return this._observers.length > 0;
+  }
+  flush() {
+    this._messageBuffer = [];
+  }
+  send(msg) {
+    this.dispatch([msg]);
+  }
+  post(msg) {
+    this._messageBuffer.push(msg);
+    requestAnimationFrame(() => this.dispatchAll());
+  }
+  attach(callback, type) {
+    const context = this;
+    const id = ++this._observerID;
+    this._observers.push({ id, type, callback });
+    return {
+      release() {
+        context._observers = context._observers.filter((o) => o.id !== id);
+      },
+      unwatch() {
+        this.release();
+      }
+    };
+  }
 };
-
-//#endregion
-//#region src/saxParser.ts
-var XMLNode = class {
-	name = "";
-	$ = {};
-	_children = [];
-	content = "";
-	constructor(name) {
-		this.name = name;
-	}
-	appendAttribute(key, val) {
-		this.$[key] = val;
-	}
-	appendContent(content) {
-		this.content += content;
-	}
-	appendChild(child) {
-		this._children.push(child);
-	}
-	children(tag) {
-		if (tag === void 0) return this._children;
-		return this._children.filter((xmlNode) => {
-			return xmlNode.name === tag;
-		});
-	}
+__name(_Dispatch, "Dispatch");
+let Dispatch = _Dispatch;
+const _XMLNode = class _XMLNode {
+  name = "";
+  $ = {};
+  _children = [];
+  content = "";
+  constructor(name) {
+    this.name = name;
+  }
+  appendAttribute(key, val) {
+    this.$[key] = val;
+  }
+  appendContent(content) {
+    this.content += content;
+  }
+  appendChild(child) {
+    this._children.push(child);
+  }
+  children(tag) {
+    if (tag === void 0) {
+      return this._children;
+    }
+    return this._children.filter((xmlNode) => {
+      return xmlNode.name === tag;
+    });
+  }
 };
-var SAXStackParser = class {
-	root;
-	stack = new Stack();
-	constructor() {}
-	walkDoc(node) {
-		const xmlNode = this._startXMLNode(node);
-		if (node.attributes) for (let i = 0; i < node.attributes.length; ++i) {
-			const attribute = node.attributes.item(i);
-			this.attributes(attribute.nodeName, attribute.nodeValue);
-		}
-		this.startXMLNode(xmlNode);
-		if (node.childNodes) for (let i = 0; i < node.childNodes.length; ++i) {
-			const childNode = node.childNodes.item(i);
-			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);
-		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();
-	}
-	startDocument() {}
-	endDocument() {}
-	startXMLNode(node) {}
-	endXMLNode(node) {}
-	attributes(key, val) {
-		this.stack.top().appendAttribute(key, val);
-	}
-	characters(text) {
-		this.stack.top().appendContent(text);
-	}
+__name(_XMLNode, "XMLNode");
+let XMLNode = _XMLNode;
+const _SAXStackParser = class _SAXStackParser {
+  root;
+  stack = new Stack();
+  constructor() {
+  }
+  walkDoc(node) {
+    const xmlNode = this._startXMLNode(node);
+    if (node.attributes) {
+      for (let i = 0; i < node.attributes.length; ++i) {
+        const attribute = node.attributes.item(i);
+        this.attributes(attribute.nodeName, attribute.nodeValue);
+      }
+    }
+    this.startXMLNode(xmlNode);
+    if (node.childNodes) {
+      for (let i = 0; i < node.childNodes.length; ++i) {
+        const childNode = node.childNodes.item(i);
+        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);
+    if (!this.stack.depth()) {
+      this.root = newNode;
+    } else {
+      this.stack.top().appendChild(newNode);
+    }
+    return this.stack.push(newNode);
+  }
+  parse(xml) {
+    const domParser = new DOMParser();
+    const doc = domParser.parseFromString(xml, "application/xml");
+    this.startDocument();
+    this.walkDoc(doc);
+    this.endDocument();
+  }
+  //  Callbacks  ---
+  startDocument() {
+  }
+  endDocument() {
+  }
+  startXMLNode(node) {
+  }
+  endXMLNode(node) {
+  }
+  attributes(key, val) {
+    this.stack.top().appendAttribute(key, val);
+  }
+  characters(text) {
+    this.stack.top().appendContent(text);
+  }
 };
-var XML2JSONParser = class extends SAXStackParser {
-	startXMLNode(node) {
-		super.startXMLNode(node);
-		switch (node.name) {
-			case "xs:element": break;
-			case "xs:simpleType": break;
-			default: break;
-		}
-	}
-	endXMLNode(node) {
-		switch (node.name) {
-			case "xs:element": break;
-			case "xs:simpleType": break;
-			default: break;
-		}
-		super.endXMLNode(node);
-	}
+__name(_SAXStackParser, "SAXStackParser");
+let SAXStackParser = _SAXStackParser;
+const _XML2JSONParser = class _XML2JSONParser extends SAXStackParser {
+  startXMLNode(node) {
+    super.startXMLNode(node);
+    switch (node.name) {
+    }
+  }
+  endXMLNode(node) {
+    switch (node.name) {
+    }
+    super.endXMLNode(node);
+  }
 };
+__name(_XML2JSONParser, "XML2JSONParser");
+let XML2JSONParser = _XML2JSONParser;
 function xml2json(xml) {
-	const saxParser = new XML2JSONParser();
-	saxParser.parse(xml);
-	return saxParser.root;
+  const saxParser = new XML2JSONParser();
+  saxParser.parse(xml);
+  return saxParser.root;
 }
-
-//#endregion
-//#region src/stateful.ts
-var PropChangedMessage = class extends Message {
-	constructor(property, newValue, oldValue) {
-		super();
-		this.property = property;
-		this.newValue = newValue;
-		this.oldValue = oldValue;
-	}
-	get canConflate() {
-		return true;
-	}
-	conflate(other) {
-		if (this.property === other.property) {
-			this.newValue = other.newValue;
-			return true;
-		}
-		return false;
-	}
-	void() {
-		return deepEquals(this.newValue, this.oldValue);
-	}
+__name(xml2json, "xml2json");
+const _PropChangedMessage = class _PropChangedMessage extends Message {
+  constructor(property, newValue, oldValue) {
+    super();
+    this.property = property;
+    this.newValue = newValue;
+    this.oldValue = oldValue;
+  }
+  get canConflate() {
+    return true;
+  }
+  conflate(other) {
+    if (this.property === other.property) {
+      this.newValue = other.newValue;
+      return true;
+    }
+    return false;
+  }
+  void() {
+    return deepEquals(this.newValue, this.oldValue);
+  }
 };
-var StateObject = class {
-	_espState = {};
-	_dispatch = new Dispatch();
-	_monitorHandle;
-	_monitorTickCount = 0;
-	clear(newVals) {
-		this._espState = {};
-		if (newVals !== void 0) this.set(newVals);
-		this._monitorTickCount = 0;
-	}
-	get(key, defValue) {
-		if (key === void 0) return this._espState;
-		return this.has(key) ? this._espState[key] : defValue;
-	}
-	set(keyOrNewVals, newVal) {
-		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));
-	}
-	setAll(_) {
-		for (const key in _) if (_.hasOwnProperty(key)) this.setSingle(key, _[key]);
-	}
-	has(key) {
-		return this._espState[key] !== void 0;
-	}
-	addObserver(eventID, propIDOrCallback, callback) {
-		if (this.isCallback(propIDOrCallback)) {
-			if (eventID !== "changed") throw new Error("Invalid eventID:  " + eventID);
-			return this._dispatch.attach((messages) => {
-				propIDOrCallback(messages.map((m) => ({
-					id: m.property,
-					oldValue: m.oldValue,
-					newValue: m.newValue
-				})));
-			});
-		} else {
-			if (eventID !== "propChanged") throw new Error("Invalid eventID:  " + eventID);
-			return this._dispatch.attach((messages) => {
-				const filteredMessages = messages.filter((m) => m.property === propIDOrCallback);
-				if (filteredMessages.length) {
-					if (filteredMessages.length > 1) console.warn("Should only be 1 message?");
-					const event = filteredMessages[filteredMessages.length - 1];
-					callback({
-						id: event.property,
-						oldValue: event.oldValue,
-						newValue: event.newValue
-					});
-				}
-			});
-		}
-	}
-	on(eventID, propIDOrCallback, callback) {
-		this.addObserver(eventID, propIDOrCallback, callback);
-		return this;
-	}
-	isCallback(propIDOrCallback) {
-		return typeof propIDOrCallback === "function";
-	}
-	hasEventListener() {
-		return this._dispatch.hasObserver();
-	}
-	async refresh(full = false) {
-		await Promise.resolve();
-		return this;
-	}
-	_monitor() {
-		if (this._monitorHandle) {
-			this._monitorTickCount = 0;
-			return;
-		}
-		this._monitorHandle = setTimeout(() => {
-			(this.hasEventListener() ? this.refresh() : Promise.resolve()).then(() => {
-				this._monitor();
-			});
-			delete this._monitorHandle;
-		}, this._monitorTimeoutDuration());
-	}
-	_monitorTimeoutDuration() {
-		++this._monitorTickCount;
-		if (this._monitorTickCount <= 1) return 0;
-		return 3e4;
-	}
-	watch(callback, triggerChange = true) {
-		if (typeof callback !== "function") throw new Error("Invalid Callback");
-		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);
-		this._monitor();
-		return retVal;
-	}
+__name(_PropChangedMessage, "PropChangedMessage");
+let PropChangedMessage = _PropChangedMessage;
+const _StateObject = class _StateObject {
+  _espState = {};
+  _dispatch = new Dispatch();
+  _monitorHandle;
+  _monitorTickCount = 0;
+  clear(newVals) {
+    this._espState = {};
+    if (newVals !== void 0) {
+      this.set(newVals);
+    }
+    this._monitorTickCount = 0;
+  }
+  get(key, defValue) {
+    if (key === void 0) {
+      return this._espState;
+    }
+    return this.has(key) ? this._espState[key] : defValue;
+  }
+  set(keyOrNewVals, newVal) {
+    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));
+  }
+  setAll(_) {
+    for (const key in _) {
+      if (_.hasOwnProperty(key)) {
+        this.setSingle(key, _[key]);
+      }
+    }
+  }
+  has(key) {
+    return this._espState[key] !== void 0;
+  }
+  addObserver(eventID, propIDOrCallback, callback) {
+    if (this.isCallback(propIDOrCallback)) {
+      if (eventID !== "changed") throw new Error("Invalid eventID:  " + eventID);
+      return this._dispatch.attach((messages) => {
+        propIDOrCallback(messages.map((m) => ({
+          id: m.property,
+          oldValue: m.oldValue,
+          newValue: m.newValue
+        })));
+      });
+    } else {
+      if (eventID !== "propChanged") throw new Error("Invalid eventID:  " + eventID);
+      return this._dispatch.attach((messages) => {
+        const filteredMessages = messages.filter((m) => m.property === propIDOrCallback);
+        if (filteredMessages.length) {
+          if (filteredMessages.length > 1) {
+            console.warn("Should only be 1 message?");
+          }
+          const event = filteredMessages[filteredMessages.length - 1];
+          callback({
+            id: event.property,
+            oldValue: event.oldValue,
+            newValue: event.newValue
+          });
+        }
+      });
+    }
+  }
+  on(eventID, propIDOrCallback, callback) {
+    this.addObserver(eventID, propIDOrCallback, callback);
+    return this;
+  }
+  isCallback(propIDOrCallback) {
+    return typeof propIDOrCallback === "function";
+  }
+  hasEventListener() {
+    return this._dispatch.hasObserver();
+  }
+  //  Monitoring  ---
+  async refresh(full = false) {
+    await Promise.resolve();
+    return this;
+  }
+  _monitor() {
+    if (this._monitorHandle) {
+      this._monitorTickCount = 0;
+      return;
+    }
+    this._monitorHandle = setTimeout(() => {
+      const refreshPromise = this.hasEventListener() ? this.refresh() : Promise.resolve();
+      refreshPromise.then(() => {
+        this._monitor();
+      });
+      delete this._monitorHandle;
+    }, this._monitorTimeoutDuration());
+  }
+  _monitorTimeoutDuration() {
+    ++this._monitorTickCount;
+    if (this._monitorTickCount <= 1) {
+      return 0;
+    }
+    return 3e4;
+  }
+  watch(callback, triggerChange = true) {
+    if (typeof callback !== "function") {
+      throw new Error("Invalid Callback");
+    }
+    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);
+    this._monitor();
+    return retVal;
+  }
 };
-
-//#endregion
-//#region src/string.ts
+__name(_StateObject, "StateObject");
+let StateObject = _StateObject;
 function trim(str, char) {
-	if (typeof char !== "string") return str;
-	if (char.length === 0) return str;
-	while (str.indexOf(char) === 0) str = str.substring(1);
-	while (endsWith(str, char)) str = str.substring(0, str.length - 1);
-	return str;
+  if (typeof char !== "string") return str;
+  if (char.length === 0) return str;
+  while (str.indexOf(char) === 0) {
+    str = str.substring(1);
+  }
+  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();
-	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;
+  const subjectString = origString.toString();
+  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;
 }
-
-//#endregion
-//#region src/url.ts
+__name(endsWith, "endsWith");
 function join(...segments) {
-	const parts = segments.reduce((parts$1, segment) => {
-		if (parts$1.length > 0) segment = segment.replace(/^\//, "");
-		segment = segment.replace(/\/$/, "");
-		return [...parts$1, ...segment.split("/")];
-	}, []);
-	const resultParts = [];
-	for (const part of parts) {
-		if (part === ".") continue;
-		if (part === "..") {
-			resultParts.pop();
-			continue;
-		}
-		resultParts.push(part);
-	}
-	return resultParts.join("/");
+  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, "..");
+  return join(path, "..");
 }
-
-//#endregion
-export { AsyncCache, AsyncOrderedQueue, BUILD_VERSION, Cache, Dictionary, DictionaryNoCase, Dispatch, Edge, Graph, Graph2, GraphItem, Level, Logging, Message, Observable, PKG_NAME, PKG_VERSION, SAXStackParser, ScopedLogging, Stack, StateObject, Subgraph, Vertex, XMLNode, cartesianToPolar, classID2Meta, compare, compare2, debounce, deepEquals, deepMixin, deepMixinT, degreesToRadians, dirname, endsWith, espTime2Seconds, exists, find, getScriptSrc, hashSum, inner, isArray, isBrowser, isCI, isNode, join, logger, normalize, normalizeDegrees, normalizeRadians, polarToCartesian, promiseTimeout, radiansToDegrees, root, safeStringify, scopedLogger, sleep, trim, update, verboseDeepEquals, xml2json };
-//# sourceMappingURL=index.js.map
+__name(dirname, "dirname");
+export {
+  AsyncCache,
+  AsyncOrderedQueue,
+  BUILD_VERSION,
+  Cache,
+  Dictionary,
+  DictionaryNoCase,
+  Dispatch,
+  Edge$1 as Edge,
+  Graph,
+  Graph2,
+  GraphItem$1 as GraphItem,
+  Level,
+  Logging,
+  Message,
+  Observable,
+  PKG_NAME,
+  PKG_VERSION,
+  SAXStackParser,
+  ScopedLogging,
+  Stack,
+  StateObject,
+  Subgraph$1 as Subgraph,
+  Vertex$1 as Vertex,
+  XMLNode,
+  cartesianToPolar,
+  classID2Meta,
+  compare,
+  compare2,
+  debounce,
+  deepEquals,
+  deepMixin,
+  deepMixinT,
+  degreesToRadians,
+  dirname,
+  endsWith,
+  espTime2Seconds,
+  exists,
+  find,
+  getScriptSrc,
+  hashSum,
+  inner,
+  isArray,
+  isBrowser,
+  isCI,
+  isNode,
+  join,
+  logger,
+  normalize,
+  normalizeDegrees,
+  normalizeRadians,
+  polarToCartesian,
+  promiseTimeout,
+  radiansToDegrees,
+  root,
+  safeStringify,
+  scopedLogger,
+  sleep,
+  trim,
+  update,
+  verboseDeepEquals,
+  xml2json
+};
+//# sourceMappingURL=index.js.map