data-structure-typed 2.2.6 → 2.2.8

package/dist/leetcode/directed-graph.mjs

@@ -0,0 +1,1733 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var uuidV4 =  __name(function() {
+  return "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".replace(/[x]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}, "uuidV4");
+var arrayRemove =  __name(function(array, predicate) {
+  let i = -1, len = array ? array.length : 0;
+  const result = [];
+  while (++i < len) {
+    const value = array[i];
+    if (predicate(value, i, array)) {
+      result.push(value);
+      Array.prototype.splice.call(array, i--, 1);
+      len--;
+    }
+  }
+  return result;
+}, "arrayRemove");
+var IterableEntryBase = class {
+  static {
+    __name(this, "IterableEntryBase");
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *entries() {
+    for (const item of this) {
+      yield item;
+    }
+  }
+  *keys() {
+    for (const item of this) {
+      yield item[0];
+    }
+  }
+  *values() {
+    for (const item of this) {
+      yield item[1];
+    }
+  }
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (!predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (predicate.call(thisArg, item[1], item[0], index++, this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      callbackfn.call(thisArg, value, key, index++, this);
+    }
+  }
+  find(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      if (callbackfn.call(thisArg, value, key, index++, this)) return item;
+    }
+    return;
+  }
+  has(key) {
+    for (const item of this) {
+      const [itemKey] = item;
+      if (itemKey === key) return true;
+    }
+    return false;
+  }
+  hasValue(value) {
+    for (const [, elementValue] of this) {
+      if (elementValue === value) return true;
+    }
+    return false;
+  }
+  get(key) {
+    for (const item of this) {
+      const [itemKey, value] = item;
+      if (itemKey === key) return value;
+    }
+    return;
+  }
+  reduce(callbackfn, initialValue) {
+    let accumulator = initialValue;
+    let index = 0;
+    for (const item of this) {
+      const [key, value] = item;
+      accumulator = callbackfn(accumulator, value, key, index++, this);
+    }
+    return accumulator;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var IterableElementBase = class {
+  static {
+    __name(this, "IterableElementBase");
+  }
+  constructor(options) {
+    if (options) {
+      const { toElementFn } = options;
+      if (typeof toElementFn === "function") this._toElementFn = toElementFn;
+      else if (toElementFn) throw new TypeError("toElementFn must be a function type");
+    }
+  }
+  _toElementFn;
+  get toElementFn() {
+    return this._toElementFn;
+  }
+  *[Symbol.iterator](...args) {
+    yield* this._getIterator(...args);
+  }
+  *values() {
+    for (const item of this) yield item;
+  }
+  every(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (!predicate(item, index++, this)) return false;
+      } else {
+        const fn = predicate;
+        if (!fn.call(thisArg, item, index++, this)) return false;
+      }
+    }
+    return true;
+  }
+  some(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return true;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return true;
+      }
+    }
+    return false;
+  }
+  forEach(callbackfn, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        callbackfn(item, index++, this);
+      } else {
+        const fn = callbackfn;
+        fn.call(thisArg, item, index++, this);
+      }
+    }
+  }
+  find(predicate, thisArg) {
+    let index = 0;
+    for (const item of this) {
+      if (thisArg === void 0) {
+        if (predicate(item, index++, this)) return item;
+      } else {
+        const fn = predicate;
+        if (fn.call(thisArg, item, index++, this)) return item;
+      }
+    }
+    return;
+  }
+  has(element) {
+    for (const ele of this) if (ele === element) return true;
+    return false;
+  }
+  reduce(callbackfn, initialValue) {
+    let index = 0;
+    const iter = this[Symbol.iterator]();
+    let acc;
+    if (arguments.length >= 2) {
+      acc = initialValue;
+    } else {
+      const first = iter.next();
+      if (first.done) throw new TypeError("Reduce of empty structure with no initial value");
+      acc = first.value;
+      index = 1;
+    }
+    for (const value of iter) {
+      acc = callbackfn(acc, value, index++, this);
+    }
+    return acc;
+  }
+  toArray() {
+    return [...this];
+  }
+  toVisual() {
+    return [...this];
+  }
+  print() {
+    console.log(this.toVisual());
+  }
+};
+var Heap = class _Heap extends IterableElementBase {
+  static {
+    __name(this, "Heap");
+  }
+  _equals = Object.is;
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { comparator } = options;
+      if (comparator) this._comparator = comparator;
+    }
+    this.addMany(elements);
+  }
+  _elements = [];
+  get elements() {
+    return this._elements;
+  }
+  get size() {
+    return this.elements.length;
+  }
+  get leaf() {
+    return this.elements[this.size - 1] ?? void 0;
+  }
+  static from(elements, options) {
+    return new this(elements, options);
+  }
+  static heapify(elements, options) {
+    return new _Heap(elements, options);
+  }
+  add(element) {
+    this._elements.push(element);
+    return this._bubbleUp(this.elements.length - 1);
+  }
+  addMany(elements) {
+    const flags = [];
+    for (const el of elements) {
+      if (this.toElementFn) {
+        const ok = this.add(this.toElementFn(el));
+        flags.push(ok);
+      } else {
+        const ok = this.add(el);
+        flags.push(ok);
+      }
+    }
+    return flags;
+  }
+  poll() {
+    if (this.elements.length === 0) return;
+    const value = this.elements[0];
+    const last = this.elements.pop();
+    if (this.elements.length) {
+      this.elements[0] = last;
+      this._sinkDown(0, this.elements.length >> 1);
+    }
+    return value;
+  }
+  peek() {
+    return this.elements[0];
+  }
+  isEmpty() {
+    return this.size === 0;
+  }
+  clear() {
+    this._elements = [];
+  }
+  refill(elements) {
+    this._elements = Array.from(elements);
+    return this.fix();
+  }
+  has(element) {
+    for (const el of this.elements) if (this._equals(el, element)) return true;
+    return false;
+  }
+  delete(element) {
+    let index = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (this._equals(this.elements[i], element)) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return false;
+    if (index === 0) {
+      this.poll();
+    } else if (index === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(index, 1, this.elements.pop());
+      this._bubbleUp(index);
+      this._sinkDown(index, this.elements.length >> 1);
+    }
+    return true;
+  }
+  deleteBy(predicate) {
+    let idx = -1;
+    for (let i = 0; i < this.elements.length; i++) {
+      if (predicate(this.elements[i], i, this)) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx < 0) return false;
+    if (idx === 0) {
+      this.poll();
+    } else if (idx === this.elements.length - 1) {
+      this.elements.pop();
+    } else {
+      this.elements.splice(idx, 1, this.elements.pop());
+      this._bubbleUp(idx);
+      this._sinkDown(idx, this.elements.length >> 1);
+    }
+    return true;
+  }
+  setEquality(equals) {
+    this._equals = equals;
+    return this;
+  }
+  dfs(order = "PRE") {
+    const result = [];
+    const _dfs =  __name((index) => {
+      const left = 2 * index + 1, right = left + 1;
+      if (index < this.size) {
+        if (order === "IN") {
+          _dfs(left);
+          result.push(this.elements[index]);
+          _dfs(right);
+        } else if (order === "PRE") {
+          result.push(this.elements[index]);
+          _dfs(left);
+          _dfs(right);
+        } else if (order === "POST") {
+          _dfs(left);
+          _dfs(right);
+          result.push(this.elements[index]);
+        }
+      }
+    }, "_dfs");
+    _dfs(0);
+    return result;
+  }
+  fix() {
+    const results = [];
+    for (let i = Math.floor(this.size / 2) - 1; i >= 0; i--) {
+      results.push(this._sinkDown(i, this.elements.length >> 1));
+    }
+    return results;
+  }
+  sort() {
+    const visited = [];
+    const cloned = this._createInstance();
+    for (const x of this.elements) cloned.add(x);
+    while (!cloned.isEmpty()) {
+      const top = cloned.poll();
+      if (top !== void 0) visited.push(top);
+    }
+    return visited;
+  }
+  clone() {
+    const next = this._createInstance();
+    for (const x of this.elements) next.add(x);
+    return next;
+  }
+  filter(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      if (thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this)) {
+        out.add(x);
+      } else {
+        i++;
+      }
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const { comparator, toElementFn, ...rest } = options ?? {};
+    if (!comparator) throw new TypeError("Heap.map requires options.comparator for EM");
+    const out = this._createLike([], { ...rest, comparator, toElementFn });
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const out = this._createInstance();
+    let i = 0;
+    for (const x of this) {
+      const v = thisArg === void 0 ? callback(x, i++, this) : callback.call(thisArg, x, i++, this);
+      out.add(v);
+    }
+    return out;
+  }
+  _DEFAULT_COMPARATOR =  __name((a, b) => {
+    if (typeof a === "object" || typeof b === "object") {
+      throw TypeError("When comparing object types, define a custom comparator in options.");
+    }
+    if (a > b) return 1;
+    if (a < b) return -1;
+    return 0;
+  }, "_DEFAULT_COMPARATOR");
+  _comparator = this._DEFAULT_COMPARATOR;
+  get comparator() {
+    return this._comparator;
+  }
+  *_getIterator() {
+    for (const element of this.elements) yield element;
+  }
+  _bubbleUp(index) {
+    const element = this.elements[index];
+    while (index > 0) {
+      const parent = index - 1 >> 1;
+      const parentItem = this.elements[parent];
+      if (this.comparator(parentItem, element) <= 0) break;
+      this.elements[index] = parentItem;
+      index = parent;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  _sinkDown(index, halfLength) {
+    const element = this.elements[index];
+    while (index < halfLength) {
+      let left = index << 1 | 1;
+      const right = left + 1;
+      let minItem = this.elements[left];
+      if (right < this.elements.length && this.comparator(minItem, this.elements[right]) > 0) {
+        left = right;
+        minItem = this.elements[right];
+      }
+      if (this.comparator(minItem, element) >= 0) break;
+      this.elements[index] = minItem;
+      index = left;
+    }
+    this.elements[index] = element;
+    return true;
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    const next = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...options ?? {} });
+    return next;
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+  _spawnLike(options) {
+    return this._createLike([], options);
+  }
+};
+var LinearBase = class _LinearBase extends IterableElementBase {
+  static {
+    __name(this, "LinearBase");
+  }
+  constructor(options) {
+    super(options);
+    if (options) {
+      const { maxLen } = options;
+      if (typeof maxLen === "number" && maxLen > 0 && maxLen % 1 === 0) this._maxLen = maxLen;
+    }
+  }
+  _maxLen = -1;
+  get maxLen() {
+    return this._maxLen;
+  }
+  indexOf(searchElement, fromIndex = 0) {
+    if (this.length === 0) return -1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    if (fromIndex < 0) fromIndex = 0;
+    for (let i = fromIndex; i < this.length; i++) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  lastIndexOf(searchElement, fromIndex = this.length - 1) {
+    if (this.length === 0) return -1;
+    if (fromIndex >= this.length) fromIndex = this.length - 1;
+    if (fromIndex < 0) fromIndex = this.length + fromIndex;
+    for (let i = fromIndex; i >= 0; i--) {
+      const element = this.at(i);
+      if (element === searchElement) return i;
+    }
+    return -1;
+  }
+  findIndex(predicate, thisArg) {
+    for (let i = 0; i < this.length; i++) {
+      const item = this.at(i);
+      if (item !== void 0 && predicate.call(thisArg, item, i, this)) return i;
+    }
+    return -1;
+  }
+  concat(...items) {
+    const newList = this.clone();
+    for (const item of items) {
+      if (item instanceof _LinearBase) {
+        newList.pushMany(item);
+      } else {
+        newList.push(item);
+      }
+    }
+    return newList;
+  }
+  sort(compareFn) {
+    const arr = this.toArray();
+    arr.sort(compareFn);
+    this.clear();
+    for (const item of arr) this.push(item);
+    return this;
+  }
+  splice(start, deleteCount = 0, ...items) {
+    const removedList = this._createInstance();
+    start = start < 0 ? this.length + start : start;
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    for (let i = 0; i < deleteCount; i++) {
+      const removed = this.deleteAt(start);
+      if (removed !== void 0) {
+        removedList.push(removed);
+      }
+    }
+    for (let i = 0; i < items.length; i++) {
+      this.addAt(start + i, items[i]);
+    }
+    return removedList;
+  }
+  join(separator = ",") {
+    return this.toArray().join(separator);
+  }
+  toReversedArray() {
+    const array = [];
+    for (let i = this.length - 1; i >= 0; i--) {
+      array.push(this.at(i));
+    }
+    return array;
+  }
+  reduceRight(callbackfn, initialValue) {
+    let accumulator = initialValue ?? 0;
+    for (let i = this.length - 1; i >= 0; i--) {
+      accumulator = callbackfn(accumulator, this.at(i), i, this);
+    }
+    return accumulator;
+  }
+  slice(start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    const newList = this._createInstance();
+    for (let i = start; i < end; i++) {
+      newList.push(this.at(i));
+    }
+    return newList;
+  }
+  fill(value, start = 0, end = this.length) {
+    start = start < 0 ? this.length + start : start;
+    end = end < 0 ? this.length + end : end;
+    if (start < 0) start = 0;
+    if (end > this.length) end = this.length;
+    if (start >= end) return this;
+    for (let i = start; i < end; i++) {
+      this.setAt(i, value);
+    }
+    return this;
+  }
+};
+var Queue = class _Queue extends LinearBase {
+  static {
+    __name(this, "Queue");
+  }
+  constructor(elements = [], options) {
+    super(options);
+    if (options) {
+      const { autoCompactRatio = 0.5 } = options;
+      this._autoCompactRatio = autoCompactRatio;
+    }
+    this.pushMany(elements);
+  }
+  _elements = [];
+  get elements() {
+    return this._elements;
+  }
+  _offset = 0;
+  get offset() {
+    return this._offset;
+  }
+  _autoCompactRatio = 0.5;
+  get autoCompactRatio() {
+    return this._autoCompactRatio;
+  }
+  set autoCompactRatio(value) {
+    this._autoCompactRatio = value;
+  }
+  get length() {
+    return this.elements.length - this._offset;
+  }
+  get first() {
+    return this.length > 0 ? this.elements[this._offset] : void 0;
+  }
+  get last() {
+    return this.length > 0 ? this.elements[this.elements.length - 1] : void 0;
+  }
+  static fromArray(elements) {
+    return new _Queue(elements);
+  }
+  isEmpty() {
+    return this.length === 0;
+  }
+  push(element) {
+    this.elements.push(element);
+    if (this._maxLen > 0 && this.length > this._maxLen) this.shift();
+    return true;
+  }
+  pushMany(elements) {
+    const ans = [];
+    for (const el of elements) {
+      if (this.toElementFn) ans.push(this.push(this.toElementFn(el)));
+      else ans.push(this.push(el));
+    }
+    return ans;
+  }
+  shift() {
+    if (this.length === 0) return void 0;
+    const first = this.first;
+    this._offset += 1;
+    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
+    return first;
+  }
+  delete(element) {
+    for (let i = this._offset; i < this.elements.length; i++) {
+      if (Object.is(this.elements[i], element)) {
+        this.elements.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  }
+  at(index) {
+    if (index < 0 || index >= this.length) return void 0;
+    return this._elements[this._offset + index];
+  }
+  deleteAt(index) {
+    if (index < 0 || index >= this.length) return void 0;
+    const gi = this._offset + index;
+    const [deleted] = this.elements.splice(gi, 1);
+    return deleted;
+  }
+  addAt(index, newElement) {
+    if (index < 0 || index > this.length) return false;
+    this._elements.splice(this._offset + index, 0, newElement);
+    return true;
+  }
+  setAt(index, newElement) {
+    if (index < 0 || index >= this.length) return false;
+    this._elements[this._offset + index] = newElement;
+    return true;
+  }
+  reverse() {
+    this._elements = this.elements.slice(this._offset).reverse();
+    this._offset = 0;
+    return this;
+  }
+  clear() {
+    this._elements = [];
+    this._offset = 0;
+  }
+  compact() {
+    this._elements = this.elements.slice(this._offset);
+    this._offset = 0;
+    return true;
+  }
+  splice(start, deleteCount = 0, ...items) {
+    start = Math.max(0, Math.min(start, this.length));
+    deleteCount = Math.max(0, Math.min(deleteCount, this.length - start));
+    const gi = this._offset + start;
+    const removedArray = this._elements.splice(gi, deleteCount, ...items);
+    if (this.elements.length > 0 && this.offset / this.elements.length > this.autoCompactRatio) this.compact();
+    const removed = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    removed._setAutoCompactRatio(this._autoCompactRatio);
+    removed.pushMany(removedArray);
+    return removed;
+  }
+  clone() {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setAutoCompactRatio(this._autoCompactRatio);
+    for (let i = this._offset; i < this.elements.length; i++) out.push(this.elements[i]);
+    return out;
+  }
+  filter(predicate, thisArg) {
+    const out = this._createInstance({ toElementFn: this.toElementFn, maxLen: this._maxLen });
+    out._setAutoCompactRatio(this._autoCompactRatio);
+    let index = 0;
+    for (const v of this) {
+      if (predicate.call(thisArg, v, index, this)) out.push(v);
+      index++;
+    }
+    return out;
+  }
+  map(callback, options, thisArg) {
+    const out = new this.constructor([], {
+      toElementFn: options?.toElementFn,
+      maxLen: options?.maxLen ?? this._maxLen,
+      autoCompactRatio: options?.autoCompactRatio ?? this._autoCompactRatio
+    });
+    let index = 0;
+    for (const v of this)
+      out.push(thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this));
+    return out;
+  }
+  mapSame(callback, thisArg) {
+    const Ctor = this.constructor;
+    const out = new Ctor([], {
+      toElementFn: this.toElementFn,
+      maxLen: this._maxLen,
+      autoCompactRatio: this._autoCompactRatio
+    });
+    out._setAutoCompactRatio?.(this._autoCompactRatio);
+    let index = 0;
+    for (const v of this) {
+      const mv = thisArg === void 0 ? callback(v, index++, this) : callback.call(thisArg, v, index++, this);
+      out.push(mv);
+    }
+    return out;
+  }
+  _setAutoCompactRatio(value) {
+    this._autoCompactRatio = value;
+  }
+  *_getIterator() {
+    for (let i = this._offset; i < this.elements.length; i++) yield this.elements[i];
+  }
+  *_getReverseIterator() {
+    for (let i = this.length - 1; i >= 0; i--) {
+      const cur = this.at(i);
+      if (cur !== void 0) yield cur;
+    }
+  }
+  _createInstance(options) {
+    const Ctor = this.constructor;
+    return new Ctor([], options);
+  }
+  _createLike(elements = [], options) {
+    const Ctor = this.constructor;
+    return new Ctor(elements, options);
+  }
+};
+var AbstractVertex = class {
+  static {
+    __name(this, "AbstractVertex");
+  }
+  key;
+  value;
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var AbstractEdge = class {
+  static {
+    __name(this, "AbstractEdge");
+  }
+  value;
+  weight;
+  constructor(weight, value) {
+    this.weight = weight !== void 0 ? weight : 1;
+    this.value = value;
+    this._hashCode = uuidV4();
+  }
+  _hashCode;
+  get hashCode() {
+    return this._hashCode;
+  }
+};
+var AbstractGraph = class extends IterableEntryBase {
+  static {
+    __name(this, "AbstractGraph");
+  }
+  constructor(options) {
+    super();
+    const graph = options?.graph;
+    this._options = { defaultEdgeWeight: 1, ...graph ?? {} };
+  }
+  _options = { defaultEdgeWeight: 1 };
+  get options() {
+    return this._options;
+  }
+  _vertexMap =  new Map();
+  get vertexMap() {
+    return this._vertexMap;
+  }
+  set vertexMap(v) {
+    this._vertexMap = v;
+  }
+  get size() {
+    return this._vertexMap.size;
+  }
+  getVertex(vertexKey) {
+    return this._vertexMap.get(vertexKey) || void 0;
+  }
+  hasVertex(vertexOrKey) {
+    return this._vertexMap.has(this._getVertexKey(vertexOrKey));
+  }
+  addVertex(keyOrVertex, value) {
+    if (keyOrVertex instanceof AbstractVertex) {
+      return this._addVertex(keyOrVertex);
+    } else {
+      const newVertex = this.createVertex(keyOrVertex, value);
+      return this._addVertex(newVertex);
+    }
+  }
+  isVertexKey(potentialKey) {
+    const potentialKeyType = typeof potentialKey;
+    return potentialKeyType === "string" || potentialKeyType === "number";
+  }
+  removeManyVertices(vertexMap) {
+    const removed = [];
+    for (const v of vertexMap) {
+      removed.push(this.deleteVertex(v));
+    }
+    return removed.length > 0;
+  }
+  hasEdge(v1, v2) {
+    const edge = this.getEdge(v1, v2);
+    return !!edge;
+  }
+  addEdge(srcOrEdge, dest, weight, value) {
+    if (srcOrEdge instanceof AbstractEdge) {
+      return this._addEdge(srcOrEdge);
+    } else {
+      if (dest instanceof AbstractVertex || typeof dest === "string" || typeof dest === "number") {
+        if (!(this.hasVertex(srcOrEdge) && this.hasVertex(dest))) return false;
+        if (srcOrEdge instanceof AbstractVertex) srcOrEdge = srcOrEdge.key;
+        if (dest instanceof AbstractVertex) dest = dest.key;
+        const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
+        return this._addEdge(newEdge);
+      } else {
+        throw new Error("dest must be a Vertex or vertex key while srcOrEdge is an Edge");
+      }
+    }
+  }
+  setEdgeWeight(srcOrKey, destOrKey, weight) {
+    const edge = this.getEdge(srcOrKey, destOrKey);
+    if (edge) {
+      edge.weight = weight;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  getAllPathsBetween(v1, v2, limit = 1e3) {
+    const paths = [];
+    const vertex1 = this._getVertex(v1);
+    const vertex2 = this._getVertex(v2);
+    if (!(vertex1 && vertex2)) {
+      return [];
+    }
+    const stack = [];
+    stack.push({ vertex: vertex1, path: [vertex1] });
+    while (stack.length > 0) {
+      const { vertex, path } = stack.pop();
+      if (vertex === vertex2) {
+        paths.push(path);
+        if (paths.length >= limit) return paths;
+      }
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!path.includes(neighbor)) {
+          const newPath = [...path, neighbor];
+          stack.push({ vertex: neighbor, path: newPath });
+        }
+      }
+    }
+    return paths;
+  }
+  getPathSumWeight(path) {
+    let sum = 0;
+    for (let i = 0; i < path.length; i++) {
+      sum += this.getEdge(path[i], path[i + 1])?.weight || 0;
+    }
+    return sum;
+  }
+  getMinCostBetween(v1, v2, isWeight) {
+    if (isWeight === void 0) isWeight = false;
+    if (isWeight) {
+      const allPaths = this.getAllPathsBetween(v1, v2);
+      let min = Number.MAX_SAFE_INTEGER;
+      for (const path of allPaths) {
+        min = Math.min(this.getPathSumWeight(path), min);
+      }
+      return min;
+    } else {
+      const vertex2 = this._getVertex(v2);
+      const vertex1 = this._getVertex(v1);
+      if (!(vertex1 && vertex2)) {
+        return void 0;
+      }
+      const visited =  new Map();
+      const queue = new Queue([vertex1]);
+      visited.set(vertex1, true);
+      let cost = 0;
+      while (queue.length > 0) {
+        for (let i = 0, layerSize = queue.length; i < layerSize; i++) {
+          const cur = queue.shift();
+          if (cur === vertex2) {
+            return cost;
+          }
+          if (cur !== void 0) {
+            const neighbors = this.getNeighbors(cur);
+            for (const neighbor of neighbors) {
+              if (!visited.has(neighbor)) {
+                visited.set(neighbor, true);
+                queue.push(neighbor);
+              }
+            }
+          }
+        }
+        cost++;
+      }
+      return void 0;
+    }
+  }
+  getMinPathBetween(v1, v2, isWeight, isDFS = false) {
+    if (isWeight === void 0) isWeight = false;
+    if (isWeight) {
+      if (isDFS) {
+        const allPaths = this.getAllPathsBetween(v1, v2, 1e4);
+        let min = Number.MAX_SAFE_INTEGER;
+        let minIndex = -1;
+        let index = 0;
+        for (const path of allPaths) {
+          const pathSumWeight = this.getPathSumWeight(path);
+          if (pathSumWeight < min) {
+            min = pathSumWeight;
+            minIndex = index;
+          }
+          index++;
+        }
+        return allPaths[minIndex] || void 0;
+      } else {
+        return this.dijkstra(v1, v2, true, true)?.minPath ?? [];
+      }
+    } else {
+      let minPath = [];
+      const vertex1 = this._getVertex(v1);
+      const vertex2 = this._getVertex(v2);
+      if (!(vertex1 && vertex2)) return [];
+      const dfs =  __name((cur, dest, visiting, path) => {
+        visiting.add(cur);
+        if (cur === dest) {
+          minPath = [vertex1, ...path];
+          return;
+        }
+        const neighbors = this.getNeighbors(cur);
+        for (const neighbor of neighbors) {
+          if (!visiting.has(neighbor)) {
+            path.push(neighbor);
+            dfs(neighbor, dest, visiting, path);
+            path.pop();
+          }
+        }
+        visiting.delete(cur);
+      }, "dfs");
+      dfs(vertex1, vertex2,  new Set(), []);
+      return minPath;
+    }
+  }
+  dijkstraWithoutHeap(src, dest = void 0, getMinDist = false, genPaths = false) {
+    let minDist = Number.MAX_SAFE_INTEGER;
+    let minDest = void 0;
+    let minPath = [];
+    const paths = [];
+    const vertexMap = this._vertexMap;
+    const distMap =  new Map();
+    const seen =  new Set();
+    const preMap =  new Map();
+    const srcVertex = this._getVertex(src);
+    const destVertex = dest ? this._getVertex(dest) : void 0;
+    if (!srcVertex) {
+      return void 0;
+    }
+    for (const vertex of vertexMap) {
+      const vertexOrKey = vertex[1];
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
+    }
+    distMap.set(srcVertex, 0);
+    preMap.set(srcVertex, void 0);
+    const getMinOfNoSeen =  __name(() => {
+      let min = Number.MAX_SAFE_INTEGER;
+      let minV = void 0;
+      for (const [key, value] of distMap) {
+        if (!seen.has(key)) {
+          if (value < min) {
+            min = value;
+            minV = key;
+          }
+        }
+      }
+      return minV;
+    }, "getMinOfNoSeen");
+    const getPaths =  __name((minV) => {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minV) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    }, "getPaths");
+    for (let i = 1; i < vertexMap.size; i++) {
+      const cur = getMinOfNoSeen();
+      if (cur) {
+        seen.add(cur);
+        if (destVertex && destVertex === cur) {
+          if (getMinDist) {
+            minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
+          }
+          if (genPaths) {
+            getPaths(destVertex);
+          }
+          return { distMap, preMap, seen, paths, minDist, minPath };
+        }
+        const neighbors = this.getNeighbors(cur);
+        for (const neighbor of neighbors) {
+          if (!seen.has(neighbor)) {
+            const edge = this.getEdge(cur, neighbor);
+            if (edge) {
+              const curFromMap = distMap.get(cur);
+              const neighborFromMap = distMap.get(neighbor);
+              if (curFromMap !== void 0 && neighborFromMap !== void 0) {
+                if (edge.weight + curFromMap < neighborFromMap) {
+                  distMap.set(neighbor, edge.weight + curFromMap);
+                  preMap.set(neighbor, cur);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (getMinDist)
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
+        }
+      });
+    if (genPaths) getPaths(minDest);
+    return { distMap, preMap, seen, paths, minDist, minPath };
+  }
+  dijkstra(src, dest = void 0, getMinDist = false, genPaths = false) {
+    let minDist = Number.MAX_SAFE_INTEGER;
+    let minDest = void 0;
+    let minPath = [];
+    const paths = [];
+    const vertexMap = this._vertexMap;
+    const distMap =  new Map();
+    const seen =  new Set();
+    const preMap =  new Map();
+    const srcVertex = this._getVertex(src);
+    const destVertex = dest ? this._getVertex(dest) : void 0;
+    if (!srcVertex) return void 0;
+    for (const vertex of vertexMap) {
+      const vertexOrKey = vertex[1];
+      if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Number.MAX_SAFE_INTEGER);
+    }
+    const heap = new Heap([], { comparator:  __name((a, b) => a.key - b.key, "comparator") });
+    heap.add({ key: 0, value: srcVertex });
+    distMap.set(srcVertex, 0);
+    preMap.set(srcVertex, void 0);
+    const getPaths =  __name((minV) => {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minV) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    }, "getPaths");
+    while (heap.size > 0) {
+      const curHeapNode = heap.poll();
+      const dist = curHeapNode?.key;
+      const cur = curHeapNode?.value;
+      if (dist !== void 0) {
+        if (cur) {
+          seen.add(cur);
+          if (destVertex && destVertex === cur) {
+            if (getMinDist) {
+              minDist = distMap.get(destVertex) || Number.MAX_SAFE_INTEGER;
+            }
+            if (genPaths) {
+              getPaths(destVertex);
+            }
+            return { distMap, preMap, seen, paths, minDist, minPath };
+          }
+          const neighbors = this.getNeighbors(cur);
+          for (const neighbor of neighbors) {
+            if (!seen.has(neighbor)) {
+              const weight = this.getEdge(cur, neighbor)?.weight;
+              if (typeof weight === "number") {
+                const distSrcToNeighbor = distMap.get(neighbor);
+                if (distSrcToNeighbor !== void 0) {
+                  if (dist + weight < distSrcToNeighbor) {
+                    heap.add({ key: dist + weight, value: neighbor });
+                    preMap.set(neighbor, cur);
+                    distMap.set(neighbor, dist + weight);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    if (getMinDist) {
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
+        }
+      });
+    }
+    if (genPaths) {
+      getPaths(minDest);
+    }
+    return { distMap, preMap, seen, paths, minDist, minPath };
+  }
+  bellmanFord(src, scanNegativeCycle, getMin, genPath) {
+    if (getMin === void 0) getMin = false;
+    if (genPath === void 0) genPath = false;
+    const srcVertex = this._getVertex(src);
+    const paths = [];
+    const distMap =  new Map();
+    const preMap =  new Map();
+    let min = Number.MAX_SAFE_INTEGER;
+    let minPath = [];
+    let hasNegativeCycle;
+    if (scanNegativeCycle) hasNegativeCycle = false;
+    if (!srcVertex) return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
+    const vertexMap = this._vertexMap;
+    const numOfVertices = vertexMap.size;
+    const edgeMap = this.edgeSet();
+    const numOfEdges = edgeMap.length;
+    this._vertexMap.forEach((vertex) => {
+      distMap.set(vertex, Number.MAX_SAFE_INTEGER);
+    });
+    distMap.set(srcVertex, 0);
+    for (let i = 1; i < numOfVertices; ++i) {
+      for (let j = 0; j < numOfEdges; ++j) {
+        const ends = this.getEndsOfEdge(edgeMap[j]);
+        if (ends) {
+          const [s, d] = ends;
+          const weight = edgeMap[j].weight;
+          const sWeight = distMap.get(s);
+          const dWeight = distMap.get(d);
+          if (sWeight !== void 0 && dWeight !== void 0) {
+            if (distMap.get(s) !== Number.MAX_SAFE_INTEGER && sWeight + weight < dWeight) {
+              distMap.set(d, sWeight + weight);
+              if (genPath) preMap.set(d, s);
+            }
+          }
+        }
+      }
+    }
+    let minDest = void 0;
+    if (getMin) {
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < min) {
+            min = d;
+            if (genPath) minDest = v;
+          }
+        }
+      });
+    }
+    if (genPath) {
+      for (const vertex of vertexMap) {
+        const vertexOrKey = vertex[1];
+        if (vertexOrKey instanceof AbstractVertex) {
+          const path = [vertexOrKey];
+          let parent = preMap.get(vertexOrKey);
+          while (parent !== void 0) {
+            path.push(parent);
+            parent = preMap.get(parent);
+          }
+          const reversed = path.reverse();
+          if (vertex[1] === minDest) minPath = reversed;
+          paths.push(reversed);
+        }
+      }
+    }
+    for (let j = 0; j < numOfEdges; ++j) {
+      const ends = this.getEndsOfEdge(edgeMap[j]);
+      if (ends) {
+        const [s] = ends;
+        const weight = edgeMap[j].weight;
+        const sWeight = distMap.get(s);
+        if (sWeight) {
+          if (sWeight !== Number.MAX_SAFE_INTEGER && sWeight + weight < sWeight) hasNegativeCycle = true;
+        }
+      }
+    }
+    return { hasNegativeCycle, distMap, preMap, paths, min, minPath };
+  }
+  floydWarshall() {
+    const idAndVertices = [...this._vertexMap];
+    const n = idAndVertices.length;
+    const costs = [];
+    const predecessor = [];
+    for (let i = 0; i < n; i++) {
+      costs[i] = [];
+      predecessor[i] = [];
+      for (let j = 0; j < n; j++) {
+        predecessor[i][j] = void 0;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        costs[i][j] = this.getEdge(idAndVertices[i][1], idAndVertices[j][1])?.weight || Number.MAX_SAFE_INTEGER;
+      }
+    }
+    for (let k = 0; k < n; k++) {
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          if (costs[i][j] > costs[i][k] + costs[k][j]) {
+            costs[i][j] = costs[i][k] + costs[k][j];
+            predecessor[i][j] = idAndVertices[k][1];
+          }
+        }
+      }
+    }
+    return { costs, predecessor };
+  }
+  getCycles(isInclude2Cycle = false) {
+    const cycles = [];
+    const visited =  new Set();
+    const dfs =  __name((vertex, currentPath, visited2) => {
+      if (visited2.has(vertex)) {
+        if ((!isInclude2Cycle && currentPath.length > 2 || isInclude2Cycle && currentPath.length >= 2) && currentPath[0] === vertex.key) {
+          cycles.push([...currentPath]);
+        }
+        return;
+      }
+      visited2.add(vertex);
+      currentPath.push(vertex.key);
+      for (const neighbor of this.getNeighbors(vertex)) {
+        if (neighbor) dfs(neighbor, currentPath, visited2);
+      }
+      visited2.delete(vertex);
+      currentPath.pop();
+    }, "dfs");
+    for (const vertex of this.vertexMap.values()) {
+      dfs(vertex, [], visited);
+    }
+    const uniqueCycles =  new Map();
+    for (const cycle of cycles) {
+      const sorted = [...cycle].sort().toString();
+      if (uniqueCycles.has(sorted)) continue;
+      else {
+        uniqueCycles.set(sorted, cycle);
+      }
+    }
+    return [...uniqueCycles].map((cycleString) => cycleString[1]);
+  }
+  filter(predicate, thisArg) {
+    const filtered = [];
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index, this)) {
+        filtered.push([key, value]);
+      }
+      index++;
+    }
+    return this._createLike(filtered, this._snapshotOptions());
+  }
+  filterEntries(predicate, thisArg) {
+    const filtered = [];
+    let index = 0;
+    for (const [key, value] of this) {
+      if (predicate.call(thisArg, value, key, index, this)) {
+        filtered.push([key, value]);
+      }
+      index++;
+    }
+    return filtered;
+  }
+  map(callback, thisArg) {
+    const mapped = [];
+    let index = 0;
+    for (const [key, value] of this) {
+      mapped.push(callback.call(thisArg, value, key, index, this));
+      index++;
+    }
+    return mapped;
+  }
+  clone() {
+    return this._createLike(void 0, this._snapshotOptions());
+  }
+  *_getIterator() {
+    for (const vertex of this._vertexMap.values()) {
+      yield [vertex.key, vertex.value];
+    }
+  }
+  _snapshotOptions() {
+    return { graph: { ...this._options } };
+  }
+  _createInstance(_options) {
+    const Ctor = this.constructor;
+    const instance = new Ctor();
+    const graph = _options?.graph;
+    if (graph) instance._options = { ...instance._options, ...graph };
+    else instance._options = { ...instance._options, ...this._options };
+    return instance;
+  }
+  _createLike(iter, options) {
+    const g = this._createInstance(options);
+    if (iter) {
+      for (const [k, v] of iter) {
+        g.addVertex(k, v);
+      }
+    } else {
+      for (const [k, v] of this) {
+        g.addVertex(k, v);
+      }
+    }
+    const edges = this.edgeSet();
+    for (const e of edges) {
+      const ends = this.getEndsOfEdge(e);
+      if (!ends) continue;
+      const [va, vb] = ends;
+      const ka = va.key;
+      const kb = vb.key;
+      const hasA = g.hasVertex ? g.hasVertex(ka) : false;
+      const hasB = g.hasVertex ? g.hasVertex(kb) : false;
+      if (hasA && hasB) {
+        const w = e.weight;
+        const val = e.value;
+        const newEdge = g.createEdge(ka, kb, w, val);
+        g._addEdge(newEdge);
+      }
+    }
+    return g;
+  }
+  _addVertex(newVertex) {
+    if (this.hasVertex(newVertex)) {
+      return false;
+    }
+    this._vertexMap.set(newVertex.key, newVertex);
+    return true;
+  }
+  _getVertex(vertexOrKey) {
+    const vertexKey = this._getVertexKey(vertexOrKey);
+    return this._vertexMap.get(vertexKey) || void 0;
+  }
+  _getVertexKey(vertexOrKey) {
+    return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
+  }
+};
+var DirectedVertex = class extends AbstractVertex {
+  static {
+    __name(this, "DirectedVertex");
+  }
+  constructor(key, value) {
+    super(key, value);
+  }
+};
+var DirectedEdge = class extends AbstractEdge {
+  static {
+    __name(this, "DirectedEdge");
+  }
+  src;
+  dest;
+  constructor(src, dest, weight, value) {
+    super(weight, value);
+    this.src = src;
+    this.dest = dest;
+  }
+};
+var DirectedGraph = class _DirectedGraph extends AbstractGraph {
+  static {
+    __name(this, "DirectedGraph");
+  }
+  constructor(options) {
+    super(options);
+  }
+  _outEdgeMap =  new Map();
+  get outEdgeMap() {
+    return this._outEdgeMap;
+  }
+  set outEdgeMap(v) {
+    this._outEdgeMap = v;
+  }
+  _inEdgeMap =  new Map();
+  get inEdgeMap() {
+    return this._inEdgeMap;
+  }
+  set inEdgeMap(v) {
+    this._inEdgeMap = v;
+  }
+  static fromKeys(keys) {
+    const g = new _DirectedGraph({
+      vertexValueInitializer:  __name((k) => k, "vertexValueInitializer")
+    });
+    for (const k of keys) g.addVertex(k);
+    return g;
+  }
+  static fromEntries(entries) {
+    const g = new _DirectedGraph();
+    for (const [k, v] of entries) g.addVertex(k, v);
+    return g;
+  }
+  createVertex(key, value) {
+    return new DirectedVertex(key, value);
+  }
+  createEdge(src, dest, weight, value) {
+    return new DirectedEdge(src, dest, weight ?? this.options.defaultEdgeWeight ?? 1, value);
+  }
+  getEdge(srcOrKey, destOrKey) {
+    let edgeMap = [];
+    if (srcOrKey !== void 0 && destOrKey !== void 0) {
+      const src = this._getVertex(srcOrKey);
+      const dest = this._getVertex(destOrKey);
+      if (src && dest) {
+        const srcOutEdges = this._outEdgeMap.get(src);
+        if (srcOutEdges) {
+          edgeMap = srcOutEdges.filter((edge) => edge.dest === dest.key);
+        }
+      }
+    }
+    return edgeMap[0] || void 0;
+  }
+  deleteEdgeSrcToDest(srcOrKey, destOrKey) {
+    const src = this._getVertex(srcOrKey);
+    const dest = this._getVertex(destOrKey);
+    let removed = void 0;
+    if (!src || !dest) {
+      return void 0;
+    }
+    const srcOutEdges = this._outEdgeMap.get(src);
+    if (srcOutEdges) {
+      arrayRemove(srcOutEdges, (edge) => edge.dest === dest.key);
+    }
+    const destInEdges = this._inEdgeMap.get(dest);
+    if (destInEdges) {
+      removed = arrayRemove(destInEdges, (edge) => edge.src === src.key)[0] || void 0;
+    }
+    return removed;
+  }
+  deleteEdge(edgeOrSrcVertexKey, destVertexKey) {
+    let removed = void 0;
+    let src, dest;
+    if (this.isVertexKey(edgeOrSrcVertexKey)) {
+      if (this.isVertexKey(destVertexKey)) {
+        src = this._getVertex(edgeOrSrcVertexKey);
+        dest = this._getVertex(destVertexKey);
+      } else {
+        return;
+      }
+    } else {
+      src = this._getVertex(edgeOrSrcVertexKey.src);
+      dest = this._getVertex(edgeOrSrcVertexKey.dest);
+    }
+    if (src && dest) {
+      const srcOutEdges = this._outEdgeMap.get(src);
+      if (srcOutEdges && srcOutEdges.length > 0) {
+        arrayRemove(srcOutEdges, (edge) => edge.src === src.key && edge.dest === dest?.key);
+      }
+      const destInEdges = this._inEdgeMap.get(dest);
+      if (destInEdges && destInEdges.length > 0) {
+        removed = arrayRemove(destInEdges, (edge) => edge.src === src.key && edge.dest === dest.key)[0];
+      }
+    }
+    return removed;
+  }
+  deleteVertex(vertexOrKey) {
+    let vertexKey;
+    let vertex;
+    if (this.isVertexKey(vertexOrKey)) {
+      vertex = this.getVertex(vertexOrKey);
+      vertexKey = vertexOrKey;
+    } else {
+      vertex = vertexOrKey;
+      vertexKey = this._getVertexKey(vertexOrKey);
+    }
+    if (vertex) {
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        this.deleteEdgeSrcToDest(vertex, neighbor);
+      }
+      this._outEdgeMap.delete(vertex);
+      this._inEdgeMap.delete(vertex);
+    }
+    return this._vertexMap.delete(vertexKey);
+  }
+  deleteEdgesBetween(v1, v2) {
+    const removed = [];
+    if (v1 && v2) {
+      const v1ToV2 = this.deleteEdgeSrcToDest(v1, v2);
+      const v2ToV1 = this.deleteEdgeSrcToDest(v2, v1);
+      if (v1ToV2) removed.push(v1ToV2);
+      if (v2ToV1) removed.push(v2ToV1);
+    }
+    return removed;
+  }
+  incomingEdgesOf(vertexOrKey) {
+    const target = this._getVertex(vertexOrKey);
+    if (target) {
+      return this.inEdgeMap.get(target) || [];
+    }
+    return [];
+  }
+  outgoingEdgesOf(vertexOrKey) {
+    const target = this._getVertex(vertexOrKey);
+    if (target) {
+      return this._outEdgeMap.get(target) || [];
+    }
+    return [];
+  }
+  degreeOf(vertexOrKey) {
+    return this.outDegreeOf(vertexOrKey) + this.inDegreeOf(vertexOrKey);
+  }
+  inDegreeOf(vertexOrKey) {
+    return this.incomingEdgesOf(vertexOrKey).length;
+  }
+  outDegreeOf(vertexOrKey) {
+    return this.outgoingEdgesOf(vertexOrKey).length;
+  }
+  edgesOf(vertexOrKey) {
+    return [...this.outgoingEdgesOf(vertexOrKey), ...this.incomingEdgesOf(vertexOrKey)];
+  }
+  getEdgeSrc(e) {
+    return this._getVertex(e.src);
+  }
+  getEdgeDest(e) {
+    return this._getVertex(e.dest);
+  }
+  getDestinations(vertex) {
+    if (vertex === void 0) {
+      return [];
+    }
+    const destinations = [];
+    const outgoingEdges = this.outgoingEdgesOf(vertex);
+    for (const outEdge of outgoingEdges) {
+      const child = this.getEdgeDest(outEdge);
+      if (child) {
+        destinations.push(child);
+      }
+    }
+    return destinations;
+  }
+  topologicalSort(propertyName) {
+    propertyName = propertyName ?? "key";
+    const statusMap =  new Map();
+    for (const entry of this.vertexMap) {
+      statusMap.set(entry[1], 0);
+    }
+    let sorted = [];
+    let hasCycle = false;
+    const dfs =  __name((cur) => {
+      statusMap.set(cur, 1);
+      const children = this.getDestinations(cur);
+      for (const child of children) {
+        const childStatus = statusMap.get(child);
+        if (childStatus === 0) {
+          dfs(child);
+        } else if (childStatus === 1) {
+          hasCycle = true;
+        }
+      }
+      statusMap.set(cur, 2);
+      sorted.push(cur);
+    }, "dfs");
+    for (const entry of this.vertexMap) {
+      if (statusMap.get(entry[1]) === 0) {
+        dfs(entry[1]);
+      }
+    }
+    if (hasCycle) return void 0;
+    if (propertyName === "key") sorted = sorted.map((vertex) => vertex instanceof DirectedVertex ? vertex.key : vertex);
+    return sorted.reverse();
+  }
+  edgeSet() {
+    let edgeMap = [];
+    this._outEdgeMap.forEach((outEdges) => {
+      edgeMap = [...edgeMap, ...outEdges];
+    });
+    return edgeMap;
+  }
+  getNeighbors(vertexOrKey) {
+    const neighbors = [];
+    const vertex = this._getVertex(vertexOrKey);
+    if (vertex) {
+      const outEdges = this.outgoingEdgesOf(vertex);
+      for (const outEdge of outEdges) {
+        const neighbor = this._getVertex(outEdge.dest);
+        if (neighbor) {
+          neighbors.push(neighbor);
+        }
+      }
+    }
+    return neighbors;
+  }
+  getEndsOfEdge(edge) {
+    if (!this.hasEdge(edge.src, edge.dest)) {
+      return void 0;
+    }
+    const v1 = this._getVertex(edge.src);
+    const v2 = this._getVertex(edge.dest);
+    if (v1 && v2) {
+      return [v1, v2];
+    } else {
+      return void 0;
+    }
+  }
+  isEmpty() {
+    return this.vertexMap.size === 0 && this.inEdgeMap.size === 0 && this.outEdgeMap.size === 0;
+  }
+  clear() {
+    this._vertexMap =  new Map();
+    this._inEdgeMap =  new Map();
+    this._outEdgeMap =  new Map();
+  }
+  clone() {
+    return super.clone();
+  }
+  tarjan() {
+    const dfnMap =  new Map();
+    const lowMap =  new Map();
+    const SCCs =  new Map();
+    let time = 0;
+    const stack = [];
+    const inStack =  new Set();
+    const dfs =  __name((vertex) => {
+      dfnMap.set(vertex, time);
+      lowMap.set(vertex, time);
+      time++;
+      stack.push(vertex);
+      inStack.add(vertex);
+      const neighbors = this.getNeighbors(vertex);
+      for (const neighbor of neighbors) {
+        if (!dfnMap.has(neighbor)) {
+          dfs(neighbor);
+          lowMap.set(vertex, Math.min(lowMap.get(vertex), lowMap.get(neighbor)));
+        } else if (inStack.has(neighbor)) {
+          lowMap.set(vertex, Math.min(lowMap.get(vertex), dfnMap.get(neighbor)));
+        }
+      }
+      if (dfnMap.get(vertex) === lowMap.get(vertex)) {
+        const SCC = [];
+        let poppedVertex;
+        do {
+          poppedVertex = stack.pop();
+          inStack.delete(poppedVertex);
+          SCC.push(poppedVertex);
+        } while (poppedVertex !== vertex);
+        SCCs.set(SCCs.size, SCC);
+      }
+    }, "dfs");
+    for (const vertex of this.vertexMap.values()) {
+      if (!dfnMap.has(vertex)) {
+        dfs(vertex);
+      }
+    }
+    return { dfnMap, lowMap, SCCs };
+  }
+  getDFNMap() {
+    return this.tarjan().dfnMap;
+  }
+  getLowMap() {
+    return this.tarjan().lowMap;
+  }
+  getSCCs() {
+    return this.tarjan().SCCs;
+  }
+  _addEdge(edge) {
+    if (!(this.hasVertex(edge.src) && this.hasVertex(edge.dest))) {
+      return false;
+    }
+    const srcVertex = this._getVertex(edge.src);
+    const destVertex = this._getVertex(edge.dest);
+    if (srcVertex && destVertex) {
+      const srcOutEdges = this._outEdgeMap.get(srcVertex);
+      if (srcOutEdges) {
+        srcOutEdges.push(edge);
+      } else {
+        this._outEdgeMap.set(srcVertex, [edge]);
+      }
+      const destInEdges = this._inEdgeMap.get(destVertex);
+      if (destInEdges) {
+        destInEdges.push(edge);
+      } else {
+        this._inEdgeMap.set(destVertex, [edge]);
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+export {
+  DirectedEdge,
+  DirectedGraph,
+  DirectedVertex
+};