natural 0.1.27 → 0.2.1

package/lib/natural/tfidf/tfidf.js

@@ -28,13 +28,13 @@ var _ = require("underscore")._,
 
 function buildDocument(text, key) {
     var stopOut;
-    
+
     if(typeof text === 'string') {
         text = tokenizer.tokenize(text.toLowerCase());
         stopOut = true;
     } else if(!_.isArray(text)) {
-        return text;
         stopOut = false;
+        return text;
     }
 
     return text.reduce(function(document, term) {
@@ -63,21 +63,42 @@ function TfIdf(deserialized) {
     this._idfCache = {};
 }
 
+// backwards compatibility for < node 0.10
+function isEncoding(encoding) {
+    if (typeof Buffer.isEncoding !== 'undefined')
+        return Buffer.isEncoding(encoding);
+    switch ((encoding + '').toLowerCase()) {
+        case 'hex':
+        case 'utf8':
+        case 'utf-8':
+        case 'ascii':
+        case 'binary':
+        case 'base64':
+        case 'ucs2':
+        case 'ucs-2':
+        case 'utf16le':
+        case 'utf-16le':
+        case 'raw':
+            return true;
+    }
+    return false;
+}
+
 module.exports = TfIdf;
 TfIdf.tf = tf;
 
 TfIdf.prototype.idf = function(term, force) {
 
-    // Lookup the term in the New term-IDF caching, 
+    // Lookup the term in the New term-IDF caching,
     // this will cut search times down exponentially on large document sets.
-    if(this._idfCache[term] && typeof this._idfCache[term] !== "function" && force !== true)
+    if(this._idfCache[term] && this._idfCache.hasOwnProperty(term) && force !== true)
         return this._idfCache[term];
 
     var docsWithTerm = this.documents.reduce(function(count, document) {
         return count + (documentHasTerm(term, document) ? 1 : 0);
     }, 0);
 
-    var idf = Math.log((this.documents.length) / (docsWithTerm));
+    var idf = 1 + Math.log((this.documents.length) / ( 1 + docsWithTerm ));
 
     // Add the idf to the term cache and return it
     this._idfCache[term] = idf;
@@ -92,13 +113,12 @@ TfIdf.prototype.addDocument = function(document, key, restoreCache) {
     // make sure the cache is invalidated when new documents arrive
     if(restoreCache === true) {
         for(var term in this._idfCache) {
-            // invoking idf with the force option set will 
+            // invoking idf with the force option set will
             // force a recomputation of the idf, and it will
             // automatically refresh the cache value.
             this.idf(term, true);
         }
-    }
-    else {
+    }   else {
         this._idfCache = {};
     }
 };
@@ -107,15 +127,17 @@ TfIdf.prototype.addDocument = function(document, key, restoreCache) {
 // Otherwise, the cache will just be wiped clean
 TfIdf.prototype.addFileSync = function(path, encoding, key, restoreCache) {
     if(!encoding)
-        encoding = 'UTF-8';
-        
-    var document = fs.readFileSync(path, 'UTF-8');
+        encoding = 'utf8';
+    if(!isEncoding(encoding))
+        throw new Error('Invalid encoding: ' + encoding);
+
+    var document = fs.readFileSync(path, encoding);
     this.documents.push(buildDocument(document, key));
 
     // make sure the cache is invalidated when new documents arrive
     if(restoreCache === true) {
         for(var term in this._idfCache) {
-            // invoking idf with the force option set will 
+            // invoking idf with the force option set will
             // force a recomputation of the idf, and it will
             // automatically refresh the cache value.
             this.idf(term, true);
@@ -128,12 +150,14 @@ TfIdf.prototype.addFileSync = function(path, encoding, key, restoreCache) {
 
 TfIdf.prototype.tfidf = function(terms, d) {
     var _this = this;
-    
+
     if(!_.isArray(terms))
         terms = tokenizer.tokenize(terms.toString().toLowerCase());
 
     return terms.reduce(function(value, term) {
-        return value + (tf(term, _this.documents[d]) * _this.idf(term));
+        var idf = _this.idf(term);
+        idf = idf === Infinity ? 0 : idf;
+        return value + (tf(term, _this.documents[d]) * idf);
     }, 0.0);
 };
 
@@ -142,21 +166,28 @@ TfIdf.prototype.listTerms = function(d) {
 
     for(var term in this.documents[d]) {
         if(term != '__key')
-    	   terms.push({term: term, tfidf: this.tfidf(term, d)})
+           terms.push({term: term, tfidf: this.tfidf(term, d)});
     }
 
-    return terms.sort(function(x, y) { return y.tfidf - x.tfidf });
-}
+    return terms.sort(function(x, y) { return y.tfidf - x.tfidf; });
+};
 
 TfIdf.prototype.tfidfs = function(terms, callback) {
     var tfidfs = new Array(this.documents.length);
-    
+
     for(var i = 0; i < this.documents.length; i++) {
         tfidfs[i] = this.tfidf(terms, i);
-        
+
         if(callback)
             callback(i, tfidfs[i], this.documents[i].__key);
     }
 
     return tfidfs;
 };
+
+// Define a tokenizer other than the default "WordTokenizer"
+TfIdf.prototype.setTokenizer = function(t) {
+    if(!_.isFunction(t.tokenize))
+        throw new Error('Expected a valid Tokenizer');
+    tokenizer = t;
+};

package/lib/natural/tokenizers/aggressive_tokenizer_fr.js

@@ -0,0 +1,36 @@
+/*
+Copyright (c) 2011, Chris Umbel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+var Tokenizer = require('./tokenizer'),
+    util = require('util');
+
+var AggressiveTokenizer = function() {
+    Tokenizer.call(this);    
+};
+util.inherits(AggressiveTokenizer, Tokenizer);
+
+module.exports = AggressiveTokenizer;
+
+AggressiveTokenizer.prototype.tokenize = function(text) {
+    // break a string up into an array of tokens by anything non-word
+    return this.trim(text.split(/[^a-z0-9äâàéèëêïîöôùüûœç]+/i));
+};

package/lib/natural/tokenizers/aggressive_tokenizer_no.js

@@ -0,0 +1,39 @@
+/*
+Copyright (c) 2014, Kristoffer Brabrand
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+var Tokenizer = require('./tokenizer'),
+    normalizer = require('../normalizers/normalizer_no'),
+    util = require('util');
+
+var AggressiveTokenizer = function() {
+    Tokenizer.call(this);
+};
+util.inherits(AggressiveTokenizer, Tokenizer);
+
+module.exports = AggressiveTokenizer;
+
+AggressiveTokenizer.prototype.tokenize = function(text) {
+    text = normalizer.remove_diacritics(text);
+
+    // break a string up into an array of tokens by anything non-word
+    return this.trim(text.split(/[^A-Za-z0-9_æøåÆØÅäÄöÖüÜ]+/));
+};

package/lib/natural/tokenizers/tokenizer.js

@@ -28,10 +28,10 @@ var Tokenizer = function() {
 };
 
 Tokenizer.prototype.trim = function(array) {
-  if (array[array.length - 1] == '')
+  while (array[array.length - 1] == '')
     array.pop();
 
-  if (array[0] == '')
+  while (array[0] == '')
     array.shift();
 
   return array;

package/lib/natural/trie/trie.js

@@ -71,6 +71,53 @@ Trie.prototype.addStrings = function(list) {
 	}
 };
 
+/**
+ * A function to search the TRIE and return an array of
+ * words which have same prefix <prefix>
+ * for example if we had the following words in our database:
+ * a, ab, bc, cd, abc, abd
+ * and we search the string: a
+ * we will get :
+ * [a, ab, abc, abd]
+ **/
+Trie.prototype.keysWithPrefix = function(prefix) {
+    if(this.caseSensitive === false) {
+        prefix = prefix.toLowerCase();
+    }
+
+    function isEmpty (object) {
+        for (var key in object) if (object.hasOwnProperty(key)) return false;
+        return true;
+    }
+
+    function get (node, word) {
+        if(!node) return null;
+        if(word.length == 0) return node;
+        return get(node.dictionary[word[0]], word.substring(1));
+    }
+
+    function recurse ( node, stringAgg, resultsAgg) {
+        if (!node) return;
+
+        // Check if this is a word
+        if (node.$) {
+            resultsAgg.push(stringAgg);
+        }
+
+        if (isEmpty(node.dictionary)) {
+            return ;
+        }
+
+        for (var c in node.dictionary) {
+            recurse (node.dictionary[c],stringAgg + c, resultsAgg);
+        }
+    }
+
+    var results = [];
+    recurse (get(this, prefix), prefix, results);
+    return results;
+};
+
 /** 
  * A function to search the given string and return true if it lands
  * on on a word. Essentially testing if the word exists in the database.

package/lib/natural/util/bag.js

@@ -0,0 +1,50 @@
+/*
+ Copyright (c) 2014, Lee Wenzhu
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+'use strict';
+
+function Bag() {
+    this.dictionary = [];
+    this.nElement = 0;
+};
+
+Bag.prototype.add = function(element) {
+    this.dictionary.push(element);
+    return this;
+};
+
+Bag.prototype.isEmpty = function() {
+    return this.nElement > 0;
+};
+
+Bag.prototype.contains = function(item) {
+    return this.dictionary.indexOf(item) >= 0;
+};
+
+/**
+ * unpack the bag , and get all items
+ */
+Bag.prototype.unpack = function() {
+    // return a copy is better than original
+    return this.dictionary.slice();
+};
+
+module.exports = Bag;

package/lib/natural/util/edge_weighted_digraph.js

@@ -0,0 +1,112 @@
+/*
+ Copyright (c) 2014, Lee Wenzhu
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+'use strict';
+
+var util = require('util'),
+    Bag = require('./bag');
+
+var DirectedEdge = function(start, end, weight) {
+    this.start = start;
+    this.end = end;
+    this.weight = weight;
+};
+
+DirectedEdge.prototype.weight = function() {
+    return this.weight;
+};
+
+DirectedEdge.prototype.from = function() {
+    return this.start;
+};
+
+DirectedEdge.prototype.to = function() {
+    return this.end;
+};
+
+DirectedEdge.prototype.toString = function() {
+    return util.format('%s -> %s, %s', this.start, this.end, this.weight);
+};
+
+var EdgeWeightedDigraph = function() {
+    this.edgesNum = 0;
+    this.adj = []; // adjacency list
+};
+
+/**
+ * the number of vertexs saved.
+ */
+EdgeWeightedDigraph.prototype.v = function() {
+    return this.adj.length;
+};
+
+/**
+ * the number of edges saved.
+ */
+EdgeWeightedDigraph.prototype.e = function() {
+    return this.edgesNum;
+};
+
+EdgeWeightedDigraph.prototype.add = function(start, end, weight) {
+    var e = new DirectedEdge(start, end, weight);
+    this.addEdge(e);
+};
+
+EdgeWeightedDigraph.prototype.addEdge = function(e) {
+    if(!this.adj[e.from()]) {
+        this.adj[e.from()] = new Bag();
+    }
+    this.adj[e.from()].add(e);
+    this.edgesNum++;
+};
+
+/**
+ * use callback on all edges from v.
+ */
+EdgeWeightedDigraph.prototype.getAdj = function(v) {
+    if(!this.adj[v]) return [];
+    return this.adj[v].unpack();
+};
+
+/**
+ * use callback on all edges.
+ */
+EdgeWeightedDigraph.prototype.edges = function() {
+    var adj = this.adj;
+    var list = new Bag();
+    for(var i in adj) {
+        adj[i].unpack().forEach(function(item) {
+            list.add(item);
+        });
+    }
+    return list.unpack();
+};
+
+EdgeWeightedDigraph.prototype.toString = function() {
+    var result = [];
+    var list = this.edges();
+    list.forEach(function(edge) {
+        result.push(edge.toString());
+    });
+    return result.join('\n');
+};
+
+module.exports = EdgeWeightedDigraph;

package/lib/natural/util/longest_path_tree.js

@@ -0,0 +1,99 @@
+/*
+ Copyright (c) 2014, Lee Wenzhu
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+'use strict';
+
+var EdgeWeightedDigraph = require('./edge_weighted_digraph'),
+    Topological = require('./topological');
+
+/**
+  *  The LongestPathTree represents a data type for solving the
+  *  single-source longest paths problem in edge-weighted directed
+  *  acyclic graphs (DAGs). The edge weights can be positive, negative, or zero.
+  *  This implementation uses a topological-sort based algorithm.
+  *  the distTo() and hasPathTo() methods take
+  *  constant time and the pathTo() method takes time proportional to the
+  *  number of edges in the longest path returned.
+  */
+var LongestPathTree = function(digraph, start) {
+    var _this = this;
+    this.edgeTo = [];
+    this.distTo = [];
+    this.distTo[start] = 0.0;
+    this.start = start;
+    this.top = new Topological(digraph);
+    this.top.order().forEach(function(vertex){
+        _this.relaxVertex(digraph, vertex, _this);
+    });
+};
+
+LongestPathTree.prototype.relaxEdge = function(e) {
+    var distTo = this.distTo,
+        edgeTo = this.edgeTo;
+    var v = e.from(), w = e.to();
+    if (distTo[w] < distTo[v] + e.weight) {
+        distTo[w] = distTo[v] + e.weight;
+        edgeTo[w] = e;
+    }
+};
+
+/**
+ * relax a vertex v in the specified digraph g
+ * @param {EdgeWeightedDigraph} the apecified digraph
+ * @param {Vertex} v vertex to be relaxed
+ */
+LongestPathTree.prototype.relaxVertex = function(digraph, vertex, tree) {
+    var distTo = tree.distTo;
+    var edgeTo = tree.edgeTo;
+
+    digraph.getAdj(vertex).forEach(function(edge){
+        var w = edge.to();
+        distTo[w] = distTo[w] || 0.0;
+        distTo[vertex] = distTo[vertex] || 0.0;
+        if (distTo[w] < distTo[vertex] + edge.weight) {
+            // in case of the result of 0.28+0.34 is 0.62000001
+            distTo[w] = parseFloat((distTo[vertex] + edge.weight).toFixed(2));
+            edgeTo[w] = edge;
+        }
+    });
+
+};
+
+LongestPathTree.prototype.getDistTo = function(v) {
+    return this.distTo[v];
+};
+
+LongestPathTree.prototype.hasPathTo = function(v) {
+    return !!this.distTo[v];
+};
+
+LongestPathTree.prototype.pathTo = function(v) {
+    if (!this.hasPathTo(v)) return [];
+    var path = [];
+    var edgeTo = this.edgeTo;
+    for (var e = edgeTo[v]; !!e; e = edgeTo[e.from()]) {
+        path.push(e.to());
+    }
+    path.push(this.start);
+    return path.reverse();
+};
+
+module.exports = LongestPathTree;

package/lib/natural/util/shortest_path_tree.js

@@ -0,0 +1,100 @@
+/*
+ Copyright (c) 2014, Lee Wenzhu
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+'use strict';
+
+var EdgeWeightedDigraph = require('./edge_weighted_digraph'),
+    Topological = require('./topological');
+
+/**
+  *  The ShortestPathTree represents a data type for solving the
+  *  single-source shortest paths problem in edge-weighted directed
+  *  acyclic graphs (DAGs). The edge weights can be positive, negative, or zero.
+  *  This implementation uses a topological-sort based algorithm.
+  *  the distTo() and hasPathTo() methods take
+  *  constant time and the pathTo() method takes time proportional to the
+  *  number of edges in the longest path returned.
+  */
+var ShortestPathTree = function(digraph, start) {
+    var _this = this;
+    this.edgeTo = [];
+    this.distTo = [];
+    this.distTo[start] = 0.0;
+    this.start = start;
+    this.top = new Topological(digraph);
+    this.top.order().forEach(function(vertex){
+        _this.relaxVertex(digraph, vertex, _this);
+    });
+};
+
+ShortestPathTree.prototype.relaxEdge = function(e) {
+    var distTo = this.distTo,
+        edgeTo = this.edgeTo;
+    var v = e.from(), w = e.to();
+    if (distTo[w] > distTo[v] + e.weight) {
+        distTo[w] = distTo[v] + e.weight;
+        edgeTo[w] = e;
+    }
+};
+
+/**
+ * relax a vertex v in the specified digraph g
+ * @param {EdgeWeightedDigraph} the apecified digraph
+ * @param {Vertex} v vertex to be relaxed
+ */
+ShortestPathTree.prototype.relaxVertex = function(digraph, vertex, tree) {
+    var distTo = tree.distTo;
+    var edgeTo = tree.edgeTo;
+    digraph.getAdj(vertex).forEach(function(edge){
+        var w = edge.to();
+        distTo[w] = /\d/.test(distTo[w]) ? distTo[w] : Number.MAX_VALUE;
+        distTo[vertex] = distTo[vertex] || 0;
+        if (distTo[w] > distTo[vertex] + edge.weight) {
+            // in case of the result of 0.28+0.34 is 0.62000001
+            distTo[w] = parseFloat((distTo[vertex] + edge.weight).toFixed(2));
+            edgeTo[w] = edge;
+        }
+    });
+
+};
+
+ShortestPathTree.prototype.getDistTo = function(v) {
+    return this.distTo[v];
+};
+
+ShortestPathTree.prototype.hasPathTo = function(v) {
+    var dist = this.distTo[v];
+    if(v == this.start) return false;
+    return /\d/.test(dist) ? dist != Number.MAX_VALUE : false;
+};
+
+ShortestPathTree.prototype.pathTo = function(v) {
+    if (!this.hasPathTo(v) || v == this.start) return [];
+    var path = [];
+    var edgeTo = this.edgeTo;
+    for (var e = edgeTo[v]; !!e; e = edgeTo[e.from()]) {
+        path.push(e.to());
+    }
+    path.push(this.start);
+    return path.reverse();
+};
+
+module.exports = ShortestPathTree;