@workglow/util 0.0.122 → 0.0.124

package/dist/compress-browser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./compress/compress.browser";
+//# sourceMappingURL=compress-browser.d.ts.map

package/dist/compress-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-browser.d.ts","sourceRoot":"","sources":["../src/compress-browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,6BAA6B,CAAC"}

package/dist/compress-browser.js

@@ -0,0 +1,18 @@
+// src/compress/compress.browser.ts
+async function compress(input, algorithm = "gzip") {
+  const sourceBlob = new Blob([typeof input === "string" ? input : new Uint8Array(input)]);
+  const compressedStream = sourceBlob.stream().pipeThrough(new CompressionStream(algorithm));
+  const compressedBuffer = await new Response(compressedStream).arrayBuffer();
+  return new Uint8Array(compressedBuffer);
+}
+async function decompress(input, algorithm = "gzip") {
+  const sourceBlob = new Blob([new Uint8Array(input)]);
+  const decompressedStream = sourceBlob.stream().pipeThrough(new DecompressionStream(algorithm));
+  return await new Response(decompressedStream).text();
+}
+export {
+  decompress,
+  compress
+};
+
+//# debugId=BAC9C567FD515DD464756E2164756E21

package/dist/compress-browser.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compress/compress.browser.ts"],
+  "sourcesContent": [
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\n// Browser environment\n\nexport async function compress(\n  input: string | Uint8Array,\n  algorithm: \"gzip\" | \"br\" = \"gzip\"\n): Promise<Uint8Array> {\n  const sourceBlob = new Blob([typeof input === \"string\" ? input : new Uint8Array(input)]);\n  const compressedStream = sourceBlob\n    .stream()\n    .pipeThrough(new CompressionStream(algorithm as CompressionFormat));\n  const compressedBuffer = await new Response(compressedStream).arrayBuffer();\n  return new Uint8Array(compressedBuffer);\n}\n\nexport async function decompress(\n  input: Uint8Array,\n  algorithm: \"gzip\" | \"br\" = \"gzip\"\n): Promise<string> {\n  const sourceBlob = new Blob([new Uint8Array(input)]);\n  const decompressedStream = sourceBlob\n    .stream()\n    .pipeThrough(new DecompressionStream(algorithm as CompressionFormat));\n  return await new Response(decompressedStream).text();\n}\n"
+  ],
+  "mappings": ";AAQA,eAAsB,QAAQ,CAC5B,OACA,YAA2B,QACN;AAAA,EACrB,MAAM,aAAa,IAAI,KAAK,CAAC,OAAO,UAAU,WAAW,QAAQ,IAAI,WAAW,KAAK,CAAC,CAAC;AAAA,EACvF,MAAM,mBAAmB,WACtB,OAAO,EACP,YAAY,IAAI,kBAAkB,SAA8B,CAAC;AAAA,EACpE,MAAM,mBAAmB,MAAM,IAAI,SAAS,gBAAgB,EAAE,YAAY;AAAA,EAC1E,OAAO,IAAI,WAAW,gBAAgB;AAAA;AAGxC,eAAsB,UAAU,CAC9B,OACA,YAA2B,QACV;AAAA,EACjB,MAAM,aAAa,IAAI,KAAK,CAAC,IAAI,WAAW,KAAK,CAAC,CAAC;AAAA,EACnD,MAAM,qBAAqB,WACxB,OAAO,EACP,YAAY,IAAI,oBAAoB,SAA8B,CAAC;AAAA,EACtE,OAAO,MAAM,IAAI,SAAS,kBAAkB,EAAE,KAAK;AAAA;",
+  "debugId": "BAC9C567FD515DD464756E2164756E21",
+  "names": []
+}

package/dist/compress-node.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./compress/compress.node";
+//# sourceMappingURL=compress-node.d.ts.map

package/dist/compress-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compress-node.d.ts","sourceRoot":"","sources":["../src/compress-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,0BAA0B,CAAC"}

package/dist/compress-node.js

@@ -0,0 +1,25 @@
+// src/compress/compress.node.ts
+import { promisify } from "util";
+import zlib from "zlib";
+async function compress(input, algorithm = "gzip") {
+  const compressFn = algorithm === "br" ? zlib.brotliCompress : zlib.gzip;
+  const compressAsync = promisify(compressFn);
+  const compressAsyncTyped = compressAsync;
+  const sourceBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  const result = await compressAsyncTyped(sourceBuffer);
+  return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);
+}
+async function decompress(input, algorithm = "gzip") {
+  const decompressFn = algorithm === "br" ? zlib.brotliDecompress : zlib.gunzip;
+  const decompressAsync = promisify(decompressFn);
+  const decompressAsyncTyped = decompressAsync;
+  const sourceBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);
+  const resultBuffer = await decompressAsyncTyped(sourceBuffer);
+  return resultBuffer.toString();
+}
+export {
+  decompress,
+  compress
+};
+
+//# debugId=E6D2BBDC01A2C9D964756E2164756E21

package/dist/compress-node.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/compress/compress.node.ts"],
+  "sourcesContent": [
+    "/**\n * @license\n * Copyright 2025 Steven Roussey <sroussey@gmail.com>\n * SPDX-License-Identifier: Apache-2.0\n */\n\n// Node environment\n\nimport { promisify } from \"util\";\nimport zlib from \"zlib\";\n\nexport async function compress(\n  input: string | Buffer,\n  algorithm: \"gzip\" | \"br\" = \"gzip\"\n): Promise<Uint8Array> {\n  const compressFn = algorithm === \"br\" ? zlib.brotliCompress : zlib.gzip;\n  const compressAsync = promisify(compressFn);\n  const compressAsyncTyped = compressAsync as unknown as (\n    source: Buffer | Uint8Array | DataView\n  ) => Promise<Buffer>;\n  const sourceBuffer = Buffer.isBuffer(input) ? input : Buffer.from(input);\n  const result: Buffer = await compressAsyncTyped(sourceBuffer);\n  // Create a Uint8Array view over the Buffer without copying\n  return new Uint8Array(result.buffer, result.byteOffset, result.byteLength);\n}\n\nexport async function decompress(\n  input: Uint8Array,\n  algorithm: \"gzip\" | \"br\" = \"gzip\"\n): Promise<string> {\n  const decompressFn = algorithm === \"br\" ? zlib.brotliDecompress : zlib.gunzip;\n  const decompressAsync = promisify(decompressFn);\n  const decompressAsyncTyped = decompressAsync as unknown as (\n    source: Buffer | Uint8Array | DataView\n  ) => Promise<Buffer>;\n  const sourceBuffer = Buffer.isBuffer(input) ? (input as unknown as Buffer) : Buffer.from(input);\n  const resultBuffer: Buffer = await decompressAsyncTyped(sourceBuffer);\n  return resultBuffer.toString();\n}\n"
+  ],
+  "mappings": ";AAQA;AACA;AAEA,eAAsB,QAAQ,CAC5B,OACA,YAA2B,QACN;AAAA,EACrB,MAAM,aAAa,cAAc,OAAO,KAAK,iBAAiB,KAAK;AAAA,EACnE,MAAM,gBAAgB,UAAU,UAAU;AAAA,EAC1C,MAAM,qBAAqB;AAAA,EAG3B,MAAM,eAAe,OAAO,SAAS,KAAK,IAAI,QAAQ,OAAO,KAAK,KAAK;AAAA,EACvE,MAAM,SAAiB,MAAM,mBAAmB,YAAY;AAAA,EAE5D,OAAO,IAAI,WAAW,OAAO,QAAQ,OAAO,YAAY,OAAO,UAAU;AAAA;AAG3E,eAAsB,UAAU,CAC9B,OACA,YAA2B,QACV;AAAA,EACjB,MAAM,eAAe,cAAc,OAAO,KAAK,mBAAmB,KAAK;AAAA,EACvE,MAAM,kBAAkB,UAAU,YAAY;AAAA,EAC9C,MAAM,uBAAuB;AAAA,EAG7B,MAAM,eAAe,OAAO,SAAS,KAAK,IAAK,QAA8B,OAAO,KAAK,KAAK;AAAA,EAC9F,MAAM,eAAuB,MAAM,qBAAqB,YAAY;AAAA,EACpE,OAAO,aAAa,SAAS;AAAA;",
+  "debugId": "E6D2BBDC01A2C9D964756E2164756E21",
+  "names": []
+}

package/dist/graph-entry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright 2025 Steven Roussey <sroussey@gmail.com>
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from "./graph";
+//# sourceMappingURL=graph-entry.d.ts.map

package/dist/graph-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-entry.d.ts","sourceRoot":"","sources":["../src/graph-entry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,SAAS,CAAC"}

package/dist/graph-entry.js

@@ -0,0 +1,539 @@
+// src/utilities/BaseError.ts
+class BaseError {
+  static type = "BaseError";
+  message;
+  name;
+  stack;
+  constructor(message = "") {
+    this.message = message;
+    const constructor = this.constructor;
+    this.name = constructor.type ?? this.constructor.name;
+    if (typeof Error !== "undefined" && Error.captureStackTrace) {
+      const temp = { stack: "" };
+      Error.captureStackTrace(temp, this.constructor);
+      this.stack = temp.stack;
+    } else {
+      try {
+        throw new Error(message);
+      } catch (err) {
+        if (err instanceof Error) {
+          this.stack = err.stack;
+        }
+      }
+    }
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+}
+
+// src/graph/errors.ts
+class NodeAlreadyExistsError extends BaseError {
+  static type = "NodeAlreadyExistsError";
+  newNode;
+  oldNode;
+  identity;
+  constructor(newNode, oldNode, identity) {
+    super(`${JSON.stringify(newNode)} shares an identity (${String(identity)}) with ${JSON.stringify(oldNode)}`);
+    this.newNode = newNode;
+    this.oldNode = oldNode;
+    this.identity = identity;
+    this.name = "NodeAlreadyExistsError";
+    Object.setPrototypeOf(this, NodeAlreadyExistsError.prototype);
+  }
+}
+
+class NodeDoesntExistError extends BaseError {
+  static type = "NodeDoesntExistError";
+  identity;
+  constructor(identity) {
+    super(`A node with identity ${String(identity)} doesn't exist in the graph`);
+    this.identity = identity;
+    this.name = "NodeDoesntExistError";
+    Object.setPrototypeOf(this, NodeDoesntExistError.prototype);
+  }
+}
+
+class CycleError extends BaseError {
+  static type = "CycleError";
+  constructor(message) {
+    super(message);
+    this.name = "CycleError";
+    Object.setPrototypeOf(this, CycleError.prototype);
+  }
+}
+
+// src/events/EventEmitter.ts
+class EventEmitter {
+  listeners = {};
+  removeAllListeners(event) {
+    if (event) {
+      delete this.listeners[event];
+    } else {
+      this.listeners = {};
+    }
+    return this;
+  }
+  on(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener });
+    return this;
+  }
+  off(event, listener) {
+    const listeners = this.listeners[event];
+    if (!listeners)
+      return this;
+    const index = listeners.findIndex((l) => l.listener === listener);
+    if (index >= 0) {
+      listeners.splice(index, 1);
+    }
+    return this;
+  }
+  once(event, listener) {
+    const listeners = this.listeners[event] || (this.listeners[event] = []);
+    listeners.push({ listener, once: true });
+    return this;
+  }
+  waitOn(event) {
+    return new Promise((resolve) => {
+      const listener = (...args) => {
+        resolve(args);
+      };
+      this.once(event, listener);
+    });
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners[event];
+    if (listeners) {
+      listeners.forEach(({ listener }) => {
+        listener(...args);
+      });
+      this.listeners[event] = listeners.filter((l) => !l.once);
+    }
+  }
+  subscribe(event, listener) {
+    this.on(event, listener);
+    return () => this.off(event, listener);
+  }
+}
+
+// src/graph/graph.ts
+class Graph {
+  nodes;
+  adjacency;
+  nodeIdentity;
+  edgeIdentity;
+  constructor(nodeIdentity, edgeIdentity) {
+    this.nodes = new Map;
+    this.adjacency = [];
+    this.nodeIdentity = nodeIdentity;
+    this.edgeIdentity = edgeIdentity;
+  }
+  events = new EventEmitter;
+  on(name, fn) {
+    this.events.on.call(this.events, name, fn);
+  }
+  off(name, fn) {
+    this.events.off.call(this.events, name, fn);
+  }
+  emit(name, ...args) {
+    this.events.emit(name, ...args);
+  }
+  insert(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    if (isOverwrite) {
+      throw new NodeAlreadyExistsError(node, this.nodes.get(id), id);
+    }
+    this.nodes.set(id, node);
+    this.adjacency.map((adj) => adj.push(null));
+    this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
+    this.emit("node-added", id);
+    return id;
+  }
+  replace(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    if (!isOverwrite) {
+      throw new NodeDoesntExistError(id);
+    }
+    this.nodes.set(id, node);
+    this.emit("node-replaced", id);
+  }
+  upsert(node) {
+    const id = this.nodeIdentity(node);
+    const isOverwrite = this.nodes.has(id);
+    this.nodes.set(id, node);
+    if (!isOverwrite) {
+      this.adjacency.map((adj) => adj.push(null));
+      this.adjacency.push(new Array(this.adjacency.length + 1).fill(null));
+      this.emit("node-added", id);
+    } else {
+      this.emit("node-replaced", id);
+    }
+    return id;
+  }
+  addEdge(node1Identity, node2Identity, edge) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    const node1Exists = this.nodes.has(node1Identity);
+    const node2Exists = this.nodes.has(node2Identity);
+    if (!node1Exists) {
+      throw new NodeDoesntExistError(node1Identity);
+    }
+    if (!node2Exists) {
+      throw new NodeDoesntExistError(node2Identity);
+    }
+    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
+    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
+    if (this.adjacency[node1Index][node2Index] === null) {
+      this.adjacency[node1Index][node2Index] = [edge];
+    } else {
+      if (!this.adjacency[node1Index][node2Index].includes(edge)) {
+        this.adjacency[node1Index][node2Index].push(edge);
+      }
+    }
+    const id = this.edgeIdentity(edge, node1Identity, node2Identity);
+    this.emit("edge-added", id);
+    return id;
+  }
+  getNodes(compareFunc) {
+    const temp = Array.from(this.nodes.values());
+    if (compareFunc !== undefined) {
+      return temp.sort(compareFunc);
+    }
+    return temp;
+  }
+  getNode(nodeIdentity) {
+    return this.nodes.get(nodeIdentity);
+  }
+  hasNode(nodeIdentity) {
+    return this.nodes.has(nodeIdentity);
+  }
+  getEdges() {
+    const toReturn = [];
+    const nodeKeys = Array.from(this.nodes.keys());
+    this.adjacency.forEach((row, rowIndex) => {
+      const node1Identity = nodeKeys[rowIndex];
+      if (node1Identity != null) {
+        row.forEach((edges, colIndex) => {
+          if (edges !== null) {
+            const node2Identity = nodeKeys[colIndex];
+            if (node2Identity != null) {
+              for (const edge of edges) {
+                toReturn.push([node1Identity, node2Identity, edge]);
+              }
+            }
+          }
+        });
+      }
+    });
+    return toReturn;
+  }
+  outEdges(node1Identity) {
+    const nodeKeys = Array.from(this.nodes.keys());
+    const nodeIndex = nodeKeys.indexOf(node1Identity);
+    const toReturn = [];
+    this.adjacency[nodeIndex].forEach((edges, colIndex) => {
+      if (edges !== null) {
+        const node2Identity = nodeKeys[colIndex];
+        if (node2Identity != null) {
+          for (const edge of edges) {
+            toReturn.push([node1Identity, node2Identity, edge]);
+          }
+        }
+      }
+    });
+    return toReturn;
+  }
+  inEdges(node2Identity) {
+    const nodeKeys = Array.from(this.nodes.keys());
+    const node2Index = nodeKeys.indexOf(node2Identity);
+    const toReturn = [];
+    this.adjacency.forEach((row, rowIndex) => {
+      const node1Identity = nodeKeys[rowIndex];
+      const edges = row[node2Index];
+      if (edges !== null) {
+        for (const edge of edges) {
+          toReturn.push([node1Identity, node2Identity, edge]);
+        }
+      }
+    });
+    return toReturn;
+  }
+  nodeEdges(nodeIdentity) {
+    return [...this.outEdges(nodeIdentity), ...this.inEdges(nodeIdentity)];
+  }
+  removeEdge(node1Identity, node2Identity, edgeIdentity) {
+    const node1Exists = this.nodes.has(node1Identity);
+    const node2Exists = this.nodes.has(node2Identity);
+    if (!node1Exists) {
+      throw new NodeDoesntExistError(node1Identity);
+    }
+    if (!node2Exists) {
+      throw new NodeDoesntExistError(node2Identity);
+    }
+    const node1Index = Array.from(this.nodes.keys()).indexOf(node1Identity);
+    const node2Index = Array.from(this.nodes.keys()).indexOf(node2Identity);
+    if (edgeIdentity === undefined) {
+      this.adjacency[node1Index][node2Index] = null;
+    } else {
+      for (const row of this.adjacency) {
+        for (const edgelist of row) {
+          if (edgelist !== null) {
+            for (let edgeIndex = 0;edgeIndex < edgelist.length; edgeIndex++) {
+              if (this.edgeIdentity(edgelist[edgeIndex], node1Identity, node2Identity) === edgeIdentity) {
+                edgelist.splice(edgeIndex, 1);
+              }
+            }
+          }
+        }
+      }
+    }
+    this.emit("edge-removed", edgeIdentity);
+  }
+  remove(nodeIdentity) {
+    if (!this.nodes.has(nodeIdentity)) {
+      throw new NodeDoesntExistError(nodeIdentity);
+    }
+    this.nodes.delete(nodeIdentity);
+    const nodeIndex = Array.from(this.nodes.keys()).indexOf(nodeIdentity);
+    this.adjacency.splice(nodeIndex, 1);
+    this.adjacency.forEach((row) => row.splice(nodeIndex, 1));
+    this.emit("node-removed", nodeIdentity);
+  }
+  removeNode(nodeIdentity) {
+    return this.remove(nodeIdentity);
+  }
+  addNode(node) {
+    return this.insert(node);
+  }
+  addNodes(nodes) {
+    return nodes.map((node) => this.insert(node));
+  }
+  addEdges(edges) {
+    return edges.map(([node1Identity, node2Identity, edge]) => this.addEdge(node1Identity, node2Identity, edge));
+  }
+}
+
+// src/graph/directedGraph.ts
+class DirectedGraph extends Graph {
+  hasCycle = false;
+  isAcyclic() {
+    if (this.hasCycle !== undefined) {
+      return !this.hasCycle;
+    }
+    const nodeIndices = Array.from(this.nodes.keys());
+    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
+    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
+    let visitedNodes = 0;
+    while (toSearch.length > 0) {
+      const cur = toSearch.pop();
+      if (cur === undefined) {
+        continue;
+      }
+      const nodeIndex = nodeIndices.indexOf(cur[0]);
+      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
+        if (hasAdj !== null) {
+          const currentInDegree = nodeInDegrees.get(nodeIndices[index]);
+          if (currentInDegree !== undefined) {
+            nodeInDegrees.set(nodeIndices[index], currentInDegree - 1);
+            if (currentInDegree - 1 === 0) {
+              toSearch.push([nodeIndices[index], currentInDegree - 1]);
+            }
+          }
+        }
+      });
+      visitedNodes++;
+    }
+    this.hasCycle = !(visitedNodes === this.nodes.size);
+    return visitedNodes === this.nodes.size;
+  }
+  indegreeOfNode(nodeID) {
+    const nodeIdentities = Array.from(this.nodes.keys());
+    const indexOfNode = nodeIdentities.indexOf(nodeID);
+    if (indexOfNode === -1) {
+      throw new NodeDoesntExistError(nodeID);
+    }
+    return this.adjacency.reduce((carry, row) => {
+      return carry + (row[indexOfNode] == null ? 0 : 1);
+    }, 0);
+  }
+  addEdge(sourceNodeIdentity, targetNodeIdentity, edge, skipUpdatingCyclicality = false) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    if (this.hasCycle === false && !skipUpdatingCyclicality) {
+      this.hasCycle = this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity);
+    } else if (skipUpdatingCyclicality) {
+      this.hasCycle = undefined;
+    }
+    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge);
+  }
+  canReachFrom(startNode, endNode) {
+    const nodeIdentities = Array.from(this.nodes.keys());
+    const startNodeIndex = nodeIdentities.indexOf(startNode);
+    const endNodeIndex = nodeIdentities.indexOf(endNode);
+    if (this.adjacency[startNodeIndex][endNodeIndex] != null) {
+      return true;
+    }
+    return this.adjacency[startNodeIndex].reduce((carry, edge, index) => {
+      if (carry || edge === null) {
+        return carry;
+      }
+      return this.canReachFrom(nodeIdentities[index], endNode);
+    }, false);
+  }
+  wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity) {
+    return this.hasCycle || sourceNodeIdentity === targetNodeIdentity || this.canReachFrom(targetNodeIdentity, sourceNodeIdentity);
+  }
+  getSubGraphStartingFrom(startNodeIdentity) {
+    const nodeIndices = Array.from(this.nodes.keys());
+    const initalNode = this.nodes.get(startNodeIdentity);
+    if (initalNode == null) {
+      throw new NodeDoesntExistError(startNodeIdentity);
+    }
+    const recur = (startNodeIdentity2, nodesToInclude) => {
+      let toReturn = [...nodesToInclude];
+      const nodeIndex = nodeIndices.indexOf(startNodeIdentity2);
+      this.adjacency[nodeIndex].forEach((hasAdj, index) => {
+        if (hasAdj !== null && nodesToInclude.find((n) => this.nodeIdentity(n) === nodeIndices[index]) == null) {
+          const newNode = this.nodes.get(nodeIndices[index]);
+          if (newNode != null) {
+            toReturn = [...recur(nodeIndices[index], toReturn), newNode];
+          }
+        }
+      });
+      return toReturn;
+    };
+    const newGraph = new DirectedGraph(this.nodeIdentity, this.edgeIdentity);
+    const nodeList = recur(startNodeIdentity, [initalNode]);
+    const includeIdents = nodeList.map((t) => this.nodeIdentity(t));
+    Array.from(this.nodes.values()).forEach((n) => {
+      if (includeIdents.includes(this.nodeIdentity(n))) {
+        newGraph.insert(n);
+      }
+    });
+    newGraph.adjacency = this.subAdj(nodeList);
+    return newGraph;
+  }
+  subAdj(include) {
+    const includeIdents = include.map((t) => this.nodeIdentity(t));
+    const nodeIndices = Array.from(this.nodes.keys());
+    return this.adjacency.reduce((carry, cur, index) => {
+      if (includeIdents.includes(nodeIndices[index])) {
+        return [...carry, cur.filter((_, index2) => includeIdents.includes(nodeIndices[index2]))];
+      } else {
+        return carry;
+      }
+    }, []);
+  }
+  getEdges() {
+    return super.getEdges();
+  }
+  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
+    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
+    this.hasCycle = undefined;
+  }
+  remove(nodeIdentity) {
+    super.remove(nodeIdentity);
+    this.hasCycle = undefined;
+  }
+  addEdges(edges) {
+    return super.addEdges(edges);
+  }
+}
+
+// src/graph/directedAcyclicGraph.ts
+class DirectedAcyclicGraph extends DirectedGraph {
+  _topologicallySortedNodes;
+  static fromDirectedGraph(graph) {
+    if (!graph.isAcyclic()) {
+      throw new CycleError("Can't convert that graph to a DAG because it contains a cycle");
+    }
+    const toRet = new DirectedAcyclicGraph(graph.nodeIdentity, graph.edgeIdentity);
+    toRet.nodes = graph.nodes;
+    toRet.adjacency = graph.adjacency;
+    return toRet;
+  }
+  addEdge(sourceNodeIdentity, targetNodeIdentity, edge) {
+    if (edge === undefined) {
+      edge = true;
+    }
+    if (this.wouldAddingEdgeCreateCycle(sourceNodeIdentity, targetNodeIdentity)) {
+      throw new CycleError(`Can't add edge from ${String(sourceNodeIdentity)} to ${String(targetNodeIdentity)} it would create a cycle`);
+    }
+    this._topologicallySortedNodes = undefined;
+    return super.addEdge(sourceNodeIdentity, targetNodeIdentity, edge, true);
+  }
+  insert(node) {
+    if (this._topologicallySortedNodes !== undefined) {
+      this._topologicallySortedNodes = [node, ...this._topologicallySortedNodes];
+    }
+    return super.insert(node);
+  }
+  topologicallySortedNodes() {
+    if (this._topologicallySortedNodes !== undefined) {
+      return this._topologicallySortedNodes;
+    }
+    const nodeIndices = Array.from(this.nodes.keys());
+    const nodeInDegrees = new Map(Array.from(this.nodes.keys()).map((n) => [n, this.indegreeOfNode(n)]));
+    const adjCopy = this.adjacency.map((a) => [...a]);
+    const toSearch = Array.from(nodeInDegrees).filter((pair) => pair[1] === 0);
+    if (toSearch.length === this.nodes.size) {
+      const arrayOfNodes = Array.from(this.nodes.values());
+      this._topologicallySortedNodes = arrayOfNodes;
+      return arrayOfNodes;
+    }
+    const toReturn = [];
+    while (toSearch.length > 0) {
+      const n = toSearch.pop();
+      if (n === undefined) {
+        throw new Error("Unexpected empty array");
+      }
+      const curNode = this.nodes.get(n[0]);
+      if (curNode == null) {
+        throw new Error("This should never happen");
+      }
+      toReturn.push(curNode);
+      adjCopy[nodeIndices.indexOf(n[0])]?.forEach((edge, index) => {
+        if (edge !== null) {
+          adjCopy[nodeIndices.indexOf(n[0])][index] = null;
+          const target = nodeInDegrees.get(nodeIndices[index]);
+          if (target !== undefined) {
+            nodeInDegrees.set(nodeIndices[index], target - 1);
+            if (target - 1 === 0) {
+              toSearch.push([nodeIndices[index], 0]);
+            }
+          } else {
+            throw new Error("This should never happen");
+          }
+        }
+      });
+    }
+    this._topologicallySortedNodes = toReturn;
+    return toReturn;
+  }
+  getSubGraphStartingFrom(startNodeIdentity) {
+    return DirectedAcyclicGraph.fromDirectedGraph(super.getSubGraphStartingFrom(startNodeIdentity));
+  }
+  removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity) {
+    super.removeEdge(sourceNodeIdentity, targetNodeIdentity, edgeIdentity);
+    this._topologicallySortedNodes = undefined;
+  }
+  remove(nodeIdentity) {
+    super.remove(nodeIdentity);
+    this._topologicallySortedNodes = undefined;
+  }
+}
+export {
+  NodeDoesntExistError,
+  NodeAlreadyExistsError,
+  Graph,
+  DirectedGraph,
+  DirectedAcyclicGraph,
+  CycleError
+};
+
+//# debugId=1E5D727E61CDDE0164756E2164756E21