@workglow/util 0.0.122 → 0.0.123

package/dist/node.js

@@ -430,624 +430,6 @@ class BaseError {
     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/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;
-  }
-}
-// src/json-schema/FromSchema.ts
-var FromSchemaDefaultOptions = {
-  parseNotKeyword: true,
-  parseIfThenElseKeywords: true,
-  keepDefaultedPropertiesOptional: true,
-  references: false,
-  deserialize: false
-};
-// src/json-schema/parsePartialJson.ts
-function parsePartialJson(text) {
-  const trimmed = text.trim();
-  if (!trimmed)
-    return;
-  try {
-    const result = JSON.parse(trimmed);
-    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
-      return result;
-    }
-    return;
-  } catch {}
-  if (trimmed[0] !== "{")
-    return;
-  const repaired = repairJson(trimmed);
-  if (repaired === undefined)
-    return;
-  try {
-    const result = JSON.parse(repaired);
-    if (typeof result === "object" && result !== null && !Array.isArray(result)) {
-      return result;
-    }
-    return;
-  } catch {
-    return;
-  }
-}
-function repairJson(text) {
-  let result = "";
-  let i = 0;
-  const len = text.length;
-  const stack = [];
-  let inString = false;
-  let escaped = false;
-  let lastSafeEnd = 0;
-  while (i < len) {
-    const ch = text[i];
-    if (escaped) {
-      escaped = false;
-      result += ch;
-      i++;
-      continue;
-    }
-    if (ch === "\\") {
-      escaped = true;
-      result += ch;
-      i++;
-      continue;
-    }
-    if (inString) {
-      if (ch === '"') {
-        inString = false;
-        result += ch;
-        i++;
-        lastSafeEnd = result.length;
-        continue;
-      }
-      result += ch;
-      i++;
-      continue;
-    }
-    switch (ch) {
-      case '"':
-        inString = true;
-        result += ch;
-        i++;
-        break;
-      case "{":
-        stack.push("}");
-        result += ch;
-        i++;
-        break;
-      case "[":
-        stack.push("]");
-        result += ch;
-        i++;
-        break;
-      case "}":
-        if (stack.length > 0 && stack[stack.length - 1] === "}") {
-          stack.pop();
-          result += ch;
-          i++;
-          lastSafeEnd = result.length;
-        } else {
-          return closeStack(result, stack);
-        }
-        break;
-      case "]":
-        if (stack.length > 0 && stack[stack.length - 1] === "]") {
-          stack.pop();
-          result += ch;
-          i++;
-          lastSafeEnd = result.length;
-        } else {
-          return closeStack(result, stack);
-        }
-        break;
-      default:
-        result += ch;
-        i++;
-        break;
-    }
-  }
-  if (inString) {
-    result += '"';
-  }
-  if (stack.length === 0) {
-    return result;
-  }
-  return closeStack(cleanTrailing(result), stack);
-}
-function cleanTrailing(text) {
-  let s = text.trimEnd();
-  let changed = true;
-  while (changed) {
-    changed = false;
-    const trimmed = s.trimEnd();
-    if (trimmed.endsWith(",")) {
-      s = trimmed.slice(0, -1);
-      changed = true;
-      continue;
-    }
-    if (trimmed.endsWith(":")) {
-      const withoutColon = trimmed.slice(0, -1).trimEnd();
-      if (withoutColon.endsWith('"')) {
-        const keyStart = withoutColon.lastIndexOf('"', withoutColon.length - 2);
-        if (keyStart >= 0) {
-          let before = withoutColon.slice(0, keyStart).trimEnd();
-          if (before.endsWith(",")) {
-            before = before.slice(0, -1);
-          }
-          s = before;
-          changed = true;
-          continue;
-        }
-      }
-      s = withoutColon;
-      changed = true;
-      continue;
-    }
-    const bareTokenMatch = trimmed.match(/,\s*"[^"]*"\s*:\s*(?:tru|fal|nul|true|false|null|[\d.eE+-]+)$/);
-    if (bareTokenMatch) {
-      const valueStr = trimmed.slice(trimmed.lastIndexOf(":") + 1).trim();
-      try {
-        JSON.parse(valueStr);
-      } catch {
-        s = trimmed.slice(0, bareTokenMatch.index).trimEnd();
-        if (s.endsWith(","))
-          s = s.slice(0, -1);
-        changed = true;
-        continue;
-      }
-    }
-  }
-  return s;
-}
-function closeStack(text, stack) {
-  let result = text;
-  for (let i = stack.length - 1;i >= 0; i--) {
-    result += stack[i];
-  }
-  return result;
-}
 // src/utilities/objectOfArraysAsArrayOfObjects.ts
 function objectOfArraysAsArrayOfObjects(data) {
   const keys = Object.keys(data);
@@ -1354,236 +736,6 @@ function objectOfArraysAsArrayOfObjects(data) {
     }
   });
 }
-// src/vector/TypedArray.ts
-function isTypedArray(value) {
-  return ArrayBuffer.isView(value) && !(value instanceof DataView);
-}
-var TypedArrayType = null;
-var TypedArraySchemaOptions = {
-  ...FromSchemaDefaultOptions,
-  deserialize: [
-    {
-      pattern: { type: "array", format: "TypedArray:Float64Array" },
-      output: Float64Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Float32Array" },
-      output: Float32Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Float16Array" },
-      output: Float16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Int16Array" },
-      output: Int16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Int8Array" },
-      output: Int8Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Uint8Array" },
-      output: Uint8Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray:Uint16Array" },
-      output: Uint16Array
-    },
-    {
-      pattern: { type: "array", format: "TypedArray" },
-      output: TypedArrayType
-    }
-  ]
-};
-var TypedArraySchema = (annotations = {}) => {
-  return {
-    type: "array",
-    format: "TypedArray",
-    title: "Typed Array",
-    description: "A typed array (Float32Array, Int8Array, etc.)",
-    ...annotations
-  };
-};
-
-// src/vector/Tensor.ts
-var TensorType = {
-  FLOAT16: "float16",
-  FLOAT32: "float32",
-  FLOAT64: "float64",
-  INT8: "int8",
-  UINT8: "uint8",
-  INT16: "int16",
-  UINT16: "uint16"
-};
-var TensorSchema = (annotations = {}) => ({
-  type: "object",
-  properties: {
-    type: {
-      type: "string",
-      enum: Object.values(TensorType),
-      title: "Type",
-      description: "The type of the tensor"
-    },
-    data: TypedArraySchema({
-      title: "Data",
-      description: "The data of the tensor"
-    }),
-    shape: {
-      type: "array",
-      items: { type: "number" },
-      title: "Shape",
-      description: "The shape of the tensor (dimensions)",
-      minItems: 1,
-      default: [1]
-    },
-    normalized: {
-      type: "boolean",
-      title: "Normalized",
-      description: "Whether the tensor data is normalized",
-      default: false
-    }
-  },
-  required: ["data"],
-  additionalProperties: false,
-  ...annotations
-});
-// src/vector/TypedArrayUtils.ts
-var WIDTH_RANK = {
-  Float64Array: 6,
-  Float32Array: 5,
-  Float16Array: 4,
-  Int16Array: 3,
-  Uint16Array: 3,
-  Int8Array: 2,
-  Uint8Array: 2
-};
-function getWidthRank(arr) {
-  return WIDTH_RANK[arr.constructor.name] ?? 0;
-}
-function widestConstructor(sources) {
-  let best = sources[0];
-  for (let i = 1;i < sources.length; i++) {
-    if (getWidthRank(sources[i]) > getWidthRank(best))
-      best = sources[i];
-  }
-  return best.constructor;
-}
-function createTypedArrayFrom(sources, values) {
-  const Ctor = widestConstructor(sources);
-  const result = new Ctor(values.length);
-  for (let i = 0;i < values.length; i++)
-    result[i] = values[i];
-  return result;
-}
-// src/vector/VectorSimilarityUtils.ts
-function cosineSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let dotProduct = 0;
-  let normA = 0;
-  let normB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dotProduct += a[i] * b[i];
-    normA += a[i] * a[i];
-    normB += b[i] * b[i];
-  }
-  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
-  if (denominator === 0) {
-    return 0;
-  }
-  return dotProduct / denominator;
-}
-function jaccardSimilarity(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let globalMin = a[0];
-  for (let i = 0;i < a.length; i++) {
-    globalMin = Math.min(globalMin, a[i], b[i]);
-  }
-  const shift = globalMin < 0 ? -globalMin : 0;
-  let minSum = 0;
-  let maxSum = 0;
-  for (let i = 0;i < a.length; i++) {
-    const shiftedA = a[i] + shift;
-    const shiftedB = b[i] + shift;
-    minSum += Math.min(shiftedA, shiftedB);
-    maxSum += Math.max(shiftedA, shiftedB);
-  }
-  return maxSum === 0 ? 0 : minSum / maxSum;
-}
-function hammingDistance(a, b) {
-  if (a.length !== b.length) {
-    throw new Error("Vectors must have the same length");
-  }
-  let differences = 0;
-  for (let i = 0;i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      differences++;
-    }
-  }
-  return differences / a.length;
-}
-function hammingSimilarity(a, b) {
-  return 1 - hammingDistance(a, b);
-}
-// src/vector/VectorUtils.ts
-function magnitude(arr) {
-  return Math.sqrt(arr.reduce((acc, val) => acc + val * val, 0));
-}
-function inner(arr1, arr2) {
-  if (arr1.length !== arr2.length) {
-    throw new Error("Vectors must have the same length to compute inner product.");
-  }
-  return arr1.reduce((acc, val, i) => acc + val * arr2[i], 0);
-}
-function normalize(vector, throwOnZero = true, float32 = false) {
-  const mag = magnitude(vector);
-  if (mag === 0) {
-    if (throwOnZero) {
-      throw new Error("Cannot normalize a zero vector.");
-    }
-    return vector;
-  }
-  const normalized = Array.from(vector).map((val) => Number(val) / mag);
-  if (float32) {
-    return new Float32Array(normalized);
-  }
-  if (vector instanceof Float64Array) {
-    return new Float64Array(normalized);
-  }
-  if (vector instanceof Float16Array) {
-    return new Float16Array(normalized);
-  }
-  if (vector instanceof Float32Array) {
-    return new Float32Array(normalized);
-  }
-  if (vector instanceof Int8Array) {
-    return new Int8Array(normalized);
-  }
-  if (vector instanceof Uint8Array) {
-    return new Uint8Array(normalized);
-  }
-  if (vector instanceof Int16Array) {
-    return new Int16Array(normalized);
-  }
-  if (vector instanceof Uint16Array) {
-    return new Uint16Array(normalized);
-  }
-  return new Float32Array(normalized);
-}
-function normalizeNumberArray(values, throwOnZero = false) {
-  const norm = magnitude(values);
-  if (norm === 0) {
-    if (throwOnZero) {
-      throw new Error("Cannot normalize a zero vector.");
-    }
-    return values;
-  }
-  return values.map((v) => v / norm);
-}
 // src/worker/WorkerManager.ts
 class WorkerManager {
   workers = new Map;
@@ -2213,70 +1365,6 @@ function getTelemetryProvider() {
 function setTelemetryProvider(provider) {
   globalServiceRegistry.registerInstance(TELEMETRY_PROVIDER, provider);
 }
-// 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();
-}
-// src/media/image.ts
-function parseDataUri(dataUri) {
-  const match = dataUri.match(/^data:([^;]+);base64,(.+)$/);
-  if (!match) {
-    throw new Error("Invalid base64 data URI");
-  }
-  return {
-    mimeType: match[1],
-    base64: match[2]
-  };
-}
-
-// src/media/image.node.ts
-async function dataUriToBlob(string) {
-  const { mimeType, base64 } = parseDataUri(string);
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0;i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return new Blob([bytes], { type: mimeType });
-}
-async function convertImageDataToUseableForm(imageData, supports) {
-  if (imageData === null || imageData === undefined) {
-    throw new Error("Image data is null or undefined");
-  }
-  if (supports.includes("Blob") && imageData instanceof Blob) {
-    return imageData;
-  }
-  if (supports.includes("ImageBinary") && typeof imageData === "object" && "data" in imageData && "width" in imageData && "height" in imageData && "channels" in imageData) {
-    return {
-      data: imageData.data,
-      width: imageData.width,
-      height: imageData.height,
-      channels: imageData.channels
-    };
-  }
-  if (supports.includes("Blob") && typeof imageData === "string") {
-    return await dataUriToBlob(imageData);
-  }
-  if (supports.includes("DataUri") && typeof imageData === "string" && imageData.startsWith("data:")) {
-    return imageData;
-  }
-  throw new Error(`Unsupported image data type: ${typeof imageData}`);
-}
 // src/worker/Worker.node.ts
 import { Worker as NodeWorker, isMainThread, parentPort } from "worker_threads";
 import { pathToFileURL } from "url";
@@ -2514,19 +1602,9 @@ export {
   serialize,
   resolveCredential,
   registerInputResolver,
-  parsePartialJson,
-  parseDataUri,
   parentPort,
   objectOfArraysAsArrayOfObjects,
-  normalizeNumberArray,
-  normalize,
   makeFingerprint,
-  magnitude,
-  jaccardSimilarity,
-  isTypedArray,
-  inner,
-  hammingSimilarity,
-  hammingDistance,
   globalServiceRegistry,
   globalContainer,
   getTelemetryProvider,
@@ -2538,12 +1616,7 @@ export {
   deriveKey,
   deepEqual,
   decrypt,
-  decompress,
-  createTypedArrayFrom,
   createServiceToken,
-  cosineSimilarity,
-  convertImageDataToUseableForm,
-  compress,
   collectPropertyValues,
   bufToBase64,
   base64ToBuf,
@@ -2552,27 +1625,17 @@ export {
   Worker,
   WORKER_SERVER,
   WORKER_MANAGER,
-  TypedArraySchema,
-  TensorType,
-  TensorSchema,
   TELEMETRY_PROVIDER,
   SpanStatusCode,
   ServiceRegistry,
   OTelTelemetryProvider,
   NullLogger,
   NoopTelemetryProvider,
-  NodeDoesntExistError,
-  NodeAlreadyExistsError,
   LOGGER,
   InMemoryCredentialStore,
   INPUT_RESOLVERS,
-  Graph,
-  FromSchemaDefaultOptions,
   EventEmitter,
   EnvCredentialStore,
-  DirectedGraph,
-  DirectedAcyclicGraph,
-  CycleError,
   Container,
   ConsoleTelemetryProvider,
   ConsoleLogger,
@@ -2581,4 +1644,4 @@ export {
   BaseError
 };
 
-//# debugId=7BB129A722446D6A64756E2164756E21
+//# debugId=542A5A44460369BC64756E2164756E21