function deps(file: string, exists: string[]): string[] {
     let _deps = requires(fs.readFileSync(file, "utf-8"))
                 .map(dep => path.resolve(path.dirname(file), `${dep}.js`))
                 .filter(fs.existsSync)
                 .filter(dep => exists.indexOf(dep) == -1);
     return _.uniq(_deps.concat(_.flatten(_deps.map(d => deps(d, exists.concat(_deps))))));
 }

 /**
  * Subscribes to some paths in state. Allows the user to track a subset of
  * data within the state that will be sent to them every time it changes.
  *
  * @param command The command received from the reactotron app.
  */
 function subscribe(command: any) {
   const trackedNode = trackedNodes[command.mstNodeName || "default"]
   const paths: string[] = (command && command.payload && command.payload.paths) || []
   if (trackedNode && trackedNode.node && paths) {
     subscriptions = uniq(flatten(paths))
     const state = getSnapshot(trackedNode.node)
     sendSubscriptions(state)
   }
 }

function deepMerge(v1, v2) {
  if (Array.isArray(v1) && Array.isArray(v2)) {
    return R.uniq(R.concat(v1, v2));
  }
  else if (typeof v1 === 'object' && typeof v2 === 'object') {
    return R.mergeWith(deepMerge, v1, v2);
  }
  else {
    return v2;
  }
}

const getVocabularyRecursive = (node: AbstractNode): string[] => {
  if (node instanceof Leaf) {
    return node.getNewVocabulary();
  }
  const internalNode = node as InternalNode;

  return R.uniq([
    ...internalNode.getNewVocabulary(),
    ...R.flatten<string>(
      R.map(getVocabularyRecursive, internalNode.getChildren())
    )
  ]);
};

			.map(res => R.uniq(res))

function generateOrBranch(modules: PrereqTree[]) {
  const children = R.uniq(modules);
  return { or: children };
}