natural 0.1.27 → 0.2.1

package/lib/natural/ngrams/ngrams.js

@@ -24,19 +24,25 @@ var _ = require("underscore")._,
     Tokenizer = require('../tokenizers/regexp_tokenizer').WordTokenizer,
     tokenizer = new Tokenizer();
 
-exports.ngrams = function(sequence, n) {
-    return ngrams(sequence, n);
+exports.setTokenizer = function(t) {
+    if(!_.isFunction(t.tokenize))
+        throw new Error('Expected a valid Tokenizer');
+    tokenizer = t;
 }
 
-exports.bigrams = function(sequence) {
-    return ngrams(sequence, 2);
+exports.ngrams = function(sequence, n, startSymbol, endSymbol) {
+    return ngrams(sequence, n, startSymbol, endSymbol);
 }
 
-exports.trigrams = function(sequence) {
-    return ngrams(sequence, 3);
+exports.bigrams = function(sequence, startSymbol, endSymbol) {
+    return ngrams(sequence, 2, startSymbol, endSymbol);
 }
 
-var ngrams = function(sequence, n) {
+exports.trigrams = function(sequence, startSymbol, endSymbol) {
+    return ngrams(sequence, 3, startSymbol, endSymbol);
+}
+
+var ngrams = function(sequence, n, startSymbol, endSymbol) {
     var result = [];
     
     if (!_(sequence).isArray()) {
@@ -44,10 +50,41 @@ var ngrams = function(sequence, n) {
     }
 
     var count = _.max([0, sequence.length - n + 1]);
-    
+
+    // Check for left padding    
+    if(typeof startSymbol !== "undefined" && startSymbol !== null) {
+        // Create an array of (n) start symbols
+        var blanks = [];
+        for(var i = 0 ; i < n ; i++) {
+            blanks.push(startSymbol);
+        }
+
+        // Create the left padding
+        for(var p = n - 1 ; p > 0 ; p--) {
+            // Create a tuple of (p) start symbols and (n - p) words
+            result.push(blanks.slice(0, p).concat(sequence.slice(0, n - p)));
+        }
+    }
+
+    // Build the complete ngrams
     for (var i = 0; i < count; i++) {
         result.push(sequence.slice(i, i + n));
     }
+
+    // Check for right padding
+    if(typeof endSymbol !== "undefined" && endSymbol !== null) {
+        // Create an array of (n) end symbols
+        var blanks = [];
+        for(var i = 0 ; i < n ; i++) {
+            blanks.push(endSymbol);
+        }
+
+        // create the right padding
+        for(var p = n - 1 ; p > 0 ; p--) {
+            // Create a tuple of (p) start symbols and (n - p) words
+            result.push(sequence.slice(sequence.length - p, sequence.length).concat(blanks.slice(0, n - p)));
+        }
+    }
     
     return result;
 }

package/lib/natural/ngrams/ngrams_zh.js

@@ -0,0 +1,83 @@
+/*
+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.
+*/
+
+var _ = require("underscore")._;
+
+exports.ngrams = function(sequence, n, startSymbol, endSymbol) {
+    return ngrams(sequence, n, startSymbol, endSymbol);
+}
+
+exports.bigrams = function(sequence, startSymbol, endSymbol) {
+    return ngrams(sequence, 2, startSymbol, endSymbol);
+}
+
+exports.trigrams = function(sequence, startSymbol, endSymbol) {
+    return ngrams(sequence, 3, startSymbol, endSymbol);
+}
+
+var ngrams = function(sequence, n, startSymbol, endSymbol) {
+    var result = [], i;
+    
+    if (!_(sequence).isArray()) {
+        sequence = sequence.split('');
+    }
+
+    var count = _.max([0, sequence.length - n + 1]);
+
+    // Check for left padding    
+    if(typeof startSymbol !== "undefined" && startSymbol !== null) {
+        // Create an array of (n) start symbols
+        var blanks = [];
+        for(i = 0 ; i < n ; i++) {
+            blanks.push(startSymbol);
+        }
+
+        // Create the left padding
+        for(var p = n - 1 ; p > 0 ; p--) {
+            // Create a tuple of (p) start symbols and (n - p) words
+            result.push(blanks.slice(0, p).concat(sequence.slice(0, n - p)));
+        }
+    }
+
+    // Build the complete ngrams
+    for (i = 0; i < count; i++) {
+        result.push(sequence.slice(i, i + n));
+    }
+
+    // Check for right padding
+    if(typeof endSymbol !== "undefined" && endSymbol !== null) {
+        // Create an array of (n) end symbols
+        var blanks = [];
+        for(var i = 0 ; i < n ; i++) {
+            blanks.push(endSymbol);
+        }
+
+        // create the right padding
+        for(var p = n - 1 ; p > 0 ; p--) {
+            // Create a tuple of (p) start symbols and (n - p) words
+            result.push(sequence.slice(sequence.length - p, sequence.length).concat(blanks.slice(0, n - p)));
+        }
+    }
+    
+    return result;
+};
+

package/lib/natural/normalizers/normalizer.js

@@ -30,7 +30,7 @@
 var replacer = require('../util/utils').replacer;
 
 var conversionTable = {
-	"can't":"cannot",
+	"can't":"can not",
 	"won't":"will not",
 	"couldn't've":"could not have",
 	"i'm":"I am",
@@ -43,7 +43,7 @@ var rules = [
 	{ regex: /([azAZ]*)\'[lL][lL]/g, output: "$1 will" },
 	{ regex: /([azAZ]*)\'[rR][eE]/g, output: "$1 are" },
 	{ regex: /([azAZ]*)\'[vV][eE]/g, output: "$1 have" },
-	{ regex: /([azAZ]*)\'[dD]/g, output: "$1 would" },
+	{ regex: /([azAZ]*)\'[dD]/g, output: "$1 would" }
 ];
 
 // Accepts a list of tokens to expand.
@@ -51,44 +51,36 @@ var normalize_tokens = function(tokens) {
 	if(typeof tokens === "string") {
 		tokens = [tokens];
 	}
+        var results = [];
 	var rule_count = rules.length;
 	var num_tokens = tokens.length;
-	for(var i = 0 ; i < num_tokens ; i++) {
-		var token = tokens[i];
-
-		// check the covnersion table.
-		if(conversionTable[token.toLowerCase()]) {
-			tokens.splice.apply(tokens, [i, 1].concat(token.replace(token, conversionTable[token.toLowerCase()]).split(/\W+/)));
-
-			// reset the tokens counter
-			// NOTE: This may not be ideal, the idea is that messing with the array
-			// could affect looping over it. Need to find out if theres ever going to 
-			// be a case where a rule conversion could result in another contraction which needs to
-			// be expanded, if that is the case, we need this.
-			i = 0;
-			var num_tokens = tokens.length;
-		}
-		// Apply the rules
-		else { 
-			for(var r = 0 ; r < rule_count ; r++) {
-				var rule = rules[r];
-				if(token.match(rule.regex)) {
-					tokens.splice.apply(tokens, [i, 1].concat(token.replace(rule.regex, rule.output).split(/\W+/)));
-
-					// reset the tokens counter
-					// NOTE: This may not be ideal, the idea is that messing with the array
-					// could affect looping over it. Need to find out if theres ever going to 
-					// be a case where a rule conversion could result in another contraction which needs to
-					// be expanded, if that is the case, we need this.
-					i = 0;
-					var num_tokens = tokens.length;
-					break ;
-				}
-			}
-		}
-	}
-
-	return tokens;
+        var i, token, r, rule;
+    
+        for (i = 0; i < num_tokens; i++) {
+            token = tokens[i];
+            // Check the conversion table
+            if (conversionTable[token.toLowerCase()]) {
+                results = results.concat(conversionTable[token.toLowerCase()].split(/\W+/));
+            }
+            
+            // Apply the rules
+            else {
+                var matched = false;
+                for ( r = 0; r < rule_count; r++) {
+                    rule = rules[r];
+                    if (token.match(rule.regex)) {
+                        results = results.concat(token.replace(rule.regex, rule.output).split(/\W+/));
+                        matched = true;
+                        break;
+                    }
+                }
+                if (!matched) {
+                    results.push(token);
+                }
+            }
+        }
+
+	return results;
 };
 
 

package/lib/natural/normalizers/normalizer_ja.js

@@ -120,26 +120,21 @@ var conversionTables = {
       '９': '9'
     },
 
-    punctuation: {
+    symbol: {
       '＿': '_',
       '－': '-',
-      '・': '･',
       '，': ',',
-      '、': '､',
       '；': ';',
       '：': ':',
       '！': '!',
       '？': '?',
       '．': '.',
-      '。': '｡',
       '（': '(',
       '）': ')',
       '［': '[',
       '］': ']',
       '｛': '{',
       '｝': '}',
-      '「': '｢',
-      '」': '｣',
       '＠': '@',
       '＊': '*',
       '＼': '\\',
@@ -154,7 +149,7 @@ var conversionTables = {
       '＝': '=',
       '＞': '>',
       '｜': '|',
-      '～': '~',
+      // Never converted: '～': '~',
       '≪': '«',
       '≫': '»',
       '─': '-',
@@ -162,6 +157,16 @@ var conversionTables = {
       '＂': '"'
     },
 
+    purePunctuation: {
+      '、': '､',
+      '。': '｡',
+      '・': '･',
+      '「': '｢',
+      '」': '｣'
+    },
+
+    punctuation: {},
+
     katakana: {
       '゛': 'ﾞ',
       '゜': 'ﾟ',
@@ -492,9 +497,17 @@ var fixCompositeSymbolsTable = {
   '㍗': 'ワット'
 };
 
+// punctuation is pure_punctuation
+conversionTables.fullwidthToHalfwidth.punctuation = merge(
+    conversionTables.fullwidthToHalfwidth.symbol,
+    conversionTables.fullwidthToHalfwidth.purePunctuation
+)
+
 // Fill in the conversion tables with the flipped tables.
 conversionTables.halfwidthToFullwidth.alphabet = flip(conversionTables.fullwidthToHalfwidth.alphabet);
 conversionTables.halfwidthToFullwidth.numbers = flip(conversionTables.fullwidthToHalfwidth.numbers);
+conversionTables.halfwidthToFullwidth.symbol = flip(conversionTables.fullwidthToHalfwidth.symbol);
+conversionTables.halfwidthToFullwidth.purePunctuation = flip(conversionTables.fullwidthToHalfwidth.purePunctuation);
 conversionTables.halfwidthToFullwidth.punctuation = flip(conversionTables.fullwidthToHalfwidth.punctuation);
 conversionTables.halfwidthToFullwidth.katakana = flip(conversionTables.fullwidthToHalfwidth.katakana);
 
@@ -502,7 +515,8 @@ conversionTables.halfwidthToFullwidth.katakana = flip(conversionTables.fullwidth
 conversionTables.normalize = merge(
     conversionTables.fullwidthToHalfwidth.alphabet,
     conversionTables.fullwidthToHalfwidth.numbers,
-    conversionTables.halfwidthToFullwidth.punctuation,
+    conversionTables.fullwidthToHalfwidth.symbol,
+    conversionTables.halfwidthToFullwidth.purePunctuation,
     conversionTables.halfwidthToFullwidth.katakana
     );
 
@@ -510,6 +524,8 @@ var converters = {
   fullwidthToHalfwidth: {
     alphabet: replacer(conversionTables.fullwidthToHalfwidth.alphabet),
     numbers: replacer(conversionTables.fullwidthToHalfwidth.numbers),
+    symbol: replacer(conversionTables.fullwidthToHalfwidth.symbol),
+    purePunctuation: replacer(conversionTables.fullwidthToHalfwidth.purePunctuation),
     punctuation: replacer(conversionTables.fullwidthToHalfwidth.punctuation),
     katakana: replacer(conversionTables.fullwidthToHalfwidth.katakana)
   },
@@ -517,6 +533,8 @@ var converters = {
   halfwidthToFullwidth: {
     alphabet: replacer(conversionTables.halfwidthToFullwidth.alphabet),
     numbers: replacer(conversionTables.halfwidthToFullwidth.numbers),
+    symbol: replacer(conversionTables.halfwidthToFullwidth.symbol),
+    purePunctuation: replacer(conversionTables.halfwidthToFullwidth.purePunctuation),
     punctuation: replacer(conversionTables.halfwidthToFullwidth.punctuation),
     katakana: replacer(conversionTables.halfwidthToFullwidth.katakana)
   },

package/lib/natural/normalizers/normalizer_no.js

@@ -0,0 +1,59 @@
+/*
+ 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.
+ */
+
+/**
+ * Remove commonly used diacritic marks from a string as these
+ * are not used in a consistent manner. Leave only ä, ö, ü.
+ */
+var remove_diacritics = function(text) {
+    text = text.replace('à', 'a');
+    text = text.replace('À', 'A');
+    text = text.replace('á', 'a');
+    text = text.replace('Á', 'A');
+    text = text.replace('â', 'a');
+    text = text.replace('Â', 'A');
+    text = text.replace('ç', 'c');
+    text = text.replace('Ç', 'C');
+    text = text.replace('è', 'e');
+    text = text.replace('È', 'E');
+    text = text.replace('é', 'e');
+    text = text.replace('É', 'E');
+    text = text.replace('ê', 'e');
+    text = text.replace('Ê', 'E');
+    text = text.replace('î', 'i');
+    text = text.replace('Î', 'I');
+    text = text.replace('ñ', 'n');
+    text = text.replace('Ñ', 'N');
+    text = text.replace('ó', 'o');
+    text = text.replace('Ó', 'O');
+    text = text.replace('ô', 'o');
+    text = text.replace('Ô', 'O');
+    text = text.replace('û', 'u');
+    text = text.replace('Û', 'U');
+    text = text.replace('š', 's');
+    text = text.replace('Š', 'S');
+
+    return text;
+};
+
+// export the relevant stuff.
+exports.remove_diacritics = remove_diacritics;

package/lib/natural/phonetics/double_metaphone.js

@@ -66,7 +66,8 @@ function process(token, maxLength) {
     }
 
     function handleC() {
-        if(pos > 1 && !isVowel(token[pos - 2]) 
+
+        if(pos >= 1 && !isVowel(token[pos - 2]) 
                 && token[pos - 1] == 'A' && token[pos + 1] == 'H'
                     && (token[pos + 2] != 'I' && token[pos + 2] != 'I')
                         || subMatch(-2, 4, ['BACHER', 'MACHER'])) {
@@ -74,7 +75,9 @@ function process(token, maxLength) {
             pos++;
         } else if(pos == 0 && token.substring(1, 6) == 'EASAR') {
             add('S');
-            pos++;
+            add('S');
+            add('R');
+            pos += 6;
         } else if(token.substring(pos + 1, pos + 4) == 'HIA') {
             add('K');
             pos++;
@@ -84,7 +87,7 @@ function process(token, maxLength) {
                 pos++;
             } else if(pos == 0 
                         && (subMatch(1, 6, ['HARAC', 'HARIS']) 
-                            || subMatch(1, 3, ['HOR', 'HUM', 'HIA', 'HEM']))
+                            || subMatch(1, 4, ['HOR', 'HUM', 'HIA', 'HEM']))
                         && token.substring(pos + 1, pos + 5) != 'HORE') {
                 add('K');
                 pos++;
@@ -96,6 +99,7 @@ function process(token, maxLength) {
                         && subMatch(2, 3, ['B', 'F', 'H', 'L', 'M', 'N', 'R', 'V', 'W']))) {
                     add('K');
                 } else if(pos > 0) {
+
                     if(token.substring(0, 2) == 'MC') {
                         add('K');
                     } else {
@@ -415,6 +419,7 @@ function process(token, maxLength) {
     }
 
     while(pos < token.length) {
+
     	switch(token[pos]) {
 	        case 'A': case 'E': case 'I': case 'O': case 'U': case 'Y': 	        
 	        case 'Ê': case 'É': case 'É': case'À':
@@ -488,7 +493,7 @@ function process(token, maxLength) {
         }
 
     	pos++;
-    }    
+    }
 
     return [truncate(primary, maxLength), truncate(secondary, maxLength)];
 }

package/lib/natural/phonetics/metaphone.js

@@ -38,7 +38,11 @@ function dropBafterMAtEnd(token) {
 }
 
 function cTransform(token) {
+    
+
     token = token.replace(/([^s]|^)(c)(h)/g, '$1x$3').trim();
+
+
     token = token.replace(/cia/g, 'xia');
     token = token.replace(/c(i|e|y)/g, 's$1');
     token = token.replace(/c/g, 'k'); 
@@ -61,6 +65,7 @@ function dropG(token) {
 }
 
 function transformG(token) {
+    token = token.replace(/gh/g, 'f'); 
     token = token.replace(/([^g]|^)(g)(i|e|y)/g, '$1j$3');
     token = token.replace(/gg/g, 'g');
     token = token.replace(/g/g, 'k');    
@@ -69,7 +74,7 @@ function transformG(token) {
 }
 
 function dropH(token) {
-    return token.replace(/([aeiou])h([^aeiou])/g, '$1$2');
+    return token.replace(/([aeiou])h([^aeiou]|$)/g, '$1$2');
 }
 
 function transformCK(token) {

package/lib/natural/phonetics/soundex.js

@@ -47,7 +47,7 @@ function transformR(token) {
 }
 
 function condense(token) {
-    return token.replace(/(\d)[hw]?\1+/g, '$1').replace(/[hw]/g, '');
+    return token.replace(/(\d)?\1+/g, '$1');
 }
 
 function padRight0(token) {
@@ -57,16 +57,20 @@ function padRight0(token) {
         return token;
 }
 
+function transform(token) {
+    return transformLipps(transformThroats(
+        transformToungue(transformL(transformHum(transformR(token))))));
+}
+
 var SoundEx = new Phonetic();
 module.exports = SoundEx;
 
 SoundEx.process = function(token, maxLength) {
-    token = token.toLowerCase();
-    
-    return token.charAt(0).toUpperCase() + padRight0(condense(transformLipps(transformThroats(
-        transformToungue(transformL(transformHum(transformR(
-            token.substr(1, token.length - 1).replace(/[aeiouy]/g, '')))))))
-                )).substr(0, (maxLength && maxLength - 1) || 3);
+    token = token.toLowerCase();    
+    var transformed = condense(transform(token.substr(1, token.length - 1))); // anything that isn't a digit goes
+    // deal with duplicate INITIAL consonant SOUNDS
+    transformed = transformed.replace(new RegExp("^" + transform(token.charAt(0))), '');
+    return token.charAt(0).toUpperCase() + padRight0(transformed.replace(/\D/g, '')).substr(0, (maxLength && maxLength - 1) || 3);
 };
 
 // export for tests;

package/lib/natural/spellcheck/spellcheck.js

@@ -0,0 +1,80 @@
+
+var Trie = require('../trie/trie');
+
+// Probabilistic spellchecker based on http://norvig.com/spell-correct.html
+// The general idea is simple. Given a word, the spellchecker calculates all strings that are some user-defined edit distance away. Of those many candidates, it filters the ones that are not words and then returns an array of possible corrections in order of decreasing probability, based on the edit distance and the candidate's frequency in the input corpus
+// Words that are an edit distance of n away from the mispelled word are considered infinitely more probable than words that are of an edit distance >n
+
+// wordlist is a corpus (an array) from which word probabilities are calculated (so something like /usr/share/dict/words (on OSX) will work okay, but real world text will work better)
+function Spellcheck(wordlist) {
+    this.trie = new Trie();
+    this.trie.addStrings(wordlist);
+    this.word2frequency = {};
+    for(var i in wordlist) {
+        if(!this.word2frequency[wordlist[i]]) {
+            this.word2frequency[wordlist[i]] = 0;
+        }
+        this.word2frequency[wordlist[i]]++;
+    }
+}
+
+Spellcheck.prototype.isCorrect = function(word) {
+    return this.trie.contains(word);
+}
+
+// Returns a list of suggested corrections, from highest to lowest probability 
+// maxDistance is the maximum edit distance 
+// According to Norvig, literature suggests that 80% to 95% of spelling errors are an edit distance of 1 away from the correct word. This is good, because there are roughly 54n+25 strings 1 edit distance away from any given string of length n. So after maxDistance = 2, this becomes very slow.
+Spellcheck.prototype.getCorrections = function(word, maxDistance) {
+    var self = this;
+    if(!maxDistance) maxDistance = 1;
+    var edits = this.editsWithMaxDistance(word, maxDistance);
+    edits = edits.slice(1,edits.length);
+    edits = edits.map(function(editList) {
+       return editList.filter(function(word) { return self.isCorrect(word); })
+                      .map(function(word) { return [word, self.word2frequency[word]]; })
+                      .sort(function(a,b) { return a[1] > b[1] ? -1 : 1; })
+                      .map(function(wordscore) { return wordscore[0]; });
+    });
+    var flattened = [];
+    for(var i in edits) {
+        if(edits[i].length) flattened = flattened.concat(edits[i]);
+    }
+    return flattened.filter(function (v, i, a) { return a.indexOf(v) == i });
+}
+
+// Returns all edits that are 1 edit-distance away from the input word
+Spellcheck.prototype.edits = function(word) {
+    var alphabet = 'abcdefghijklmnopqrstuvwxyz';
+    var edits = [];
+    for(var i=0; i<word.length+1; i++) {
+        if(i>0) edits.push(word.slice(0,i-1)+word.slice(i,word.length)); // deletes
+        if(i>0 && i<word.length+1) edits.push(word.slice(0,i-1) + word.slice(i,i+1) + word.slice(i-1, i) + word.slice(i+1,word.length)); // transposes
+        for(var k=0; k<alphabet.length; k++) {
+            if(i>0) edits.push(word.slice(0,i-1)+alphabet[k]+word.slice(i,word.length)); // replaces
+            edits.push(word.slice(0,i)+alphabet[k]+word.slice(i,word.length)); // inserts
+        }
+    }
+    // Deduplicate edits
+    edits = edits.filter(function (v, i, a) { return a.indexOf(v) == i });
+    return edits;
+}
+
+// Returns all edits that are up to "distance" edit distance away from the input word
+Spellcheck.prototype.editsWithMaxDistance = function(word, distance) { 
+    return this.editsWithMaxDistanceHelper(distance, [[word]]);
+}
+
+Spellcheck.prototype.editsWithMaxDistanceHelper = function(distanceCounter, distance2edits) {
+    if(distanceCounter == 0) return distance2edits;
+    var currentDepth = distance2edits.length-1;
+    var words = distance2edits[currentDepth];
+    var edits = this.edits(words[0]);
+    distance2edits[currentDepth+1] = [];
+    for(var i in words) {
+        distance2edits[currentDepth+1] = distance2edits[currentDepth+1].concat(this.edits(words[i]));
+    }
+    return this.editsWithMaxDistanceHelper(distanceCounter-1, distance2edits);
+}
+
+module.exports = Spellcheck;

package/lib/natural/stemmers/lancaster_rules.js

@@ -80,7 +80,7 @@ exports.rules = {
             "size": "3"
         }, 
         {
-            "appendage": "s", 
+            "appendage": "ss", 
             "continuation": false, 
             "intact": false, 
             "pattern": "ceed", 
@@ -163,7 +163,7 @@ exports.rules = {
             "size": "2"
         }, 
         {
-            "appendage": "c", 
+            "appendage": "ct", 
             "continuation": false, 
             "intact": false, 
             "pattern": "guish", 
@@ -374,7 +374,7 @@ exports.rules = {
             "size": "4"
         }, 
         {
-            "appendage": "c", 
+            "appendage": "ct", 
             "continuation": false, 
             "intact": false, 
             "pattern": "xion", 
@@ -598,7 +598,7 @@ exports.rules = {
             "size": "2"
         }, 
         {
-            "appendage": "i", 
+            "appendage": "iv", 
             "continuation": false, 
             "intact": false, 
             "pattern": "cept",