@hpcc-js/util 3.3.12 → 3.4.0

package/dist/index.js

@@ -1,2224 +1,1949 @@
-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;
+//#region src/__package__.ts
 const PKG_NAME = "@hpcc-js/util";
-const PKG_VERSION = "3.2.0";
-const BUILD_VERSION = "3.2.1";
+const PKG_VERSION = "3.4.0";
+const BUILD_VERSION = "3.15.0";
+
+//#endregion
+//#region src/array.ts
 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++;
-  }
-  return void 0;
+	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++;
+	}
 }
-__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;
 }
-__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;
+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(compare2, "compare2");
+
+//#endregion
+//#region src/hashSum.ts
 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);
 }
-__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;
-  }
+
+//#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(_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;
-  }
+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(_AsyncCache, "AsyncCache");
-let AsyncCache = _AsyncCache;
+
+//#endregion
+//#region src/debounce.ts
 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;
+	});
 }
-__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;
-  }
+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(_AsyncOrderedQueue, "AsyncOrderedQueue");
-let AsyncOrderedQueue = _AsyncOrderedQueue;
 function sleep(ms) {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(), ms);
-  });
+	return new Promise((resolve) => {
+		setTimeout(() => resolve(), ms);
+	});
 }
-__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;
-  }
+
+//#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(_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());
-  }
+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(_DictionaryNoCase, "DictionaryNoCase");
-let DictionaryNoCase = _DictionaryNoCase;
+
+//#endregion
+//#region src/esp.ts
 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;
 }
-__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;
-  }
+
+//#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(_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)];
+		}
+	};
 }
-__name(ObjMap, "ObjMap");
-const _GraphItem = class _GraphItem {
-  _graph;
-  _;
-  id() {
-    return this._graph.id(this._);
-  }
-  constructor(g, _) {
-    this._graph = g;
-    this._ = _;
-  }
+
+//#endregion
+//#region src/graph2.ts
+var GraphItem$1 = class {
+	_graph;
+	_;
+	id() {
+		return this._graph.id(this._);
+	}
+	constructor(g, _) {
+		this._graph = g;
+		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 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(_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 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(_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 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(_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 Edge$1 = class extends ChildGraphItem {
+	_source;
+	_target;
+	constructor(g, _, source, target) {
+		super(g, _);
+		this._source = source;
+		this._target = target;
+	}
 };
-__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 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(_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(_);
-  }
+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(_Set, "Set");
-let Set = _Set;
-const isArray$1 = Array.isArray;
-const keyList = Object.keys;
-const hasProp = Object.prototype.hasOwnProperty;
+
+//#endregion
+//#region src/immutable.ts
+var isArray$1 = Array.isArray;
+var keyList = Object.keys;
+var 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 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;
+	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;
 }
-__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;
 }
-__name(update, "update");
+
+//#endregion
+//#region src/platform.ts
 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 "";
 }
-__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/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(_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"
+
+//#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"
 };
-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 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]]}`, "");
+	}
 };
-__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;
-  }
+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(_Logging, "Logging");
-__publicField(_Logging, "_instance");
-let Logging = _Logging;
 const logger = Logging.Instance();
-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;
-  }
+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;
+	}
 };
-__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);
 }
-__name(scopedLogger, "scopedLogger");
+
+//#endregion
+//#region src/math.ts
+/**
+* degreesToRadians - converts degrees to radians
+* Usage: degreesToRadians(1080);
+*
+* @param degrees
+* @returns Number radians
+*/
 function degreesToRadians(degrees) {
-  return degrees * (Math.PI / 180);
+	return degrees * (Math.PI / 180);
 }
-__name(degreesToRadians, "degreesToRadians");
+/**
+* radiansToDegrees - converts radians to degrees
+* Usage: radiansToDegrees(7);
+*
+* @param radians
+* @returns Number degreees
+*/
 function radiansToDegrees(radians) {
-  return radians * (180 / Math.PI);
+	return radians * (180 / Math.PI);
 }
-__name(radiansToDegrees, "radiansToDegrees");
+/**
+* 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 }
+*/
 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)
+	};
 }
-__name(polarToCartesian, "polarToCartesian");
+/**
+* cartesianToPolar - converts (x, y) to {r, theta}
+* Usage: cartesianToPolar(100, 200);
+*
+* @param x
+* @param y
+* @returns { r: number, theta: number }
+*/
 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)
+	};
 }
-__name(cartesianToPolar, "cartesianToPolar");
+/**
+* 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
+*/
 function normalizeRadians(radians, min = -Math.PI, max = Math.PI) {
-  return normalize(radians, min, max);
+	return normalize(radians, min, max);
 }
-__name(normalizeRadians, "normalizeRadians");
+/**
+* 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
+*/
 function normalizeDegrees(degrees, min = -180, max = 180) {
-  return normalize(degrees, min, max);
+	return normalize(degrees, min, max);
 }
-__name(normalizeDegrees, "normalizeDegrees");
+/**
+* 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
+*/
 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;
 }
-__name(normalize, "normalize");
+
+//#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
+*/
 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 void 0;
-    }
-    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;
+		obj = obj[item];
+	}
+	return obj;
 }
-__name(inner, "inner");
+/**
+* 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
+*/
 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;
 }
-__name(_mixin, "_mixin");
+/**
+* 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
+*/
 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;
 }
-__name(deepMixin, "deepMixin");
+/**
+* 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
+*/
 function deepMixinT(dest = {}, ...sources) {
-  return deepMixin(dest, ...sources);
+	return deepMixin(dest, ...sources);
 }
-__name(deepMixinT, "deepMixinT");
+/**
+* safeStingify - JSONsimilar to .stringify, except ignores circular references.
+* Usage:  safeStingify(object);
+*
+* @param obj - any object.
+*/
 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]
+	};
 }
-__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();
-  }
+
+//#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(_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;
-  }
+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(_Observable, "Observable");
-let Observable = _Observable;
-let requestAnimationFrame;
+
+//#endregion
+//#region src/dispatch.ts
+var requestAnimationFrame;
 (function() {
-  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");
-  }
+	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;
+		};
+	}
 })();
-const _Message = class _Message {
-  get canConflate() {
-    return false;
-  }
-  conflate(other) {
-    return false;
-  }
-  void() {
-    return false;
-  }
+var Message = class {
+	get canConflate() {
+		return false;
+	}
+	conflate(other) {
+		return false;
+	}
+	void() {
+		return false;
+	}
 };
-__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();
-      }
-    };
-  }
+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(_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;
-    });
-  }
+
+//#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(_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 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(_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);
-  }
+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(_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;
 }
-__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);
-  }
+
+//#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(_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;
-  }
+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(_StateObject, "StateObject");
-let StateObject = _StateObject;
+
+//#endregion
+//#region src/string.ts
 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;
 }
-__name(endsWith, "endsWith");
+
+//#endregion
+//#region src/url.ts
 function join(...segments) {
-  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("/");
+	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("/");
 }
-__name(join, "join");
 function dirname(path) {
-  return join(path, "..");
+	return join(path, "..");
 }
-__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
+
+//#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