diff --git a/ext/jp/deinflector.js b/ext/jp/deinflector.js
index 0bc1c442..3dd233eb 100644
--- a/ext/jp/deinflector.js
+++ b/ext/jp/deinflector.js
@@ -47,7 +47,8 @@ class Deinflection {
             this.children.push(child);
         }
 
-        for (const [rule, variants] of rules) {
+        for (const rule in rules) {
+            const variants = rules[rule];
             for (const v of variants) {
                 let allowed = this.tags.length === 0;
                 for (const tag in this.tags) {
@@ -61,10 +62,10 @@ class Deinflection {
                     continue;
                 }
 
-                const term = self.term.slice(0, -v.kanaIn.length) + v.kanaOut;
+                const term = this.term.slice(0, -v.kanaIn.length) + v.kanaOut;
                 const child = new Deinflection(term, v.tagsOut, rule);
                 if (child.deinflect(validator, rules)) {
-                    this.children.append(child);
+                    this.children.push(child);
                 }
             }
         }
@@ -89,9 +90,9 @@ class Deinflection {
 
         const paths = [];
         for (const child of this.children) {
-            for (const path in child.gather()) {
+            for (const path of child.gather()) {
                 if (this.rule.length > 0) {
-                    path.rules.append(this.rule);
+                    path.rules.push(this.rule);
                 }
 
                 path.source = this.term;
diff --git a/ext/jp/dictionary.js b/ext/jp/dictionary.js
index 18a15ab0..e9e81503 100644
--- a/ext/jp/dictionary.js
+++ b/ext/jp/dictionary.js
@@ -56,7 +56,13 @@ class Dictionary {
     findTermInDict(term, dict) {
         return (dict.indices[term] || []).map(index => {
             const [e, r, g, t] = dict.defs[index];
-            return {id: index, expression: e, reading: r, glossary: g, tags: t};
+            return {
+                id:         index,
+                expression: e,
+                reading:    r,
+                glossary:   g,
+                tags:       t
+            };
         });
     }
 
@@ -67,6 +73,12 @@ class Dictionary {
         }
 
         const [c, k, o, g] = def;
-        return {id: kanji.charCodeAt(0), character: c, kunyomi: k, onyomi: o, glossary: g};
+        return {
+            id:        kanji.charCodeAt(0),
+            character: c,
+            kunyomi:   k,
+            onyomi:    o,
+            glossary:  g
+        };
     }
 }
diff --git a/ext/jp/translator.js b/ext/jp/translator.js
index 542871a9..39ef176c 100644
--- a/ext/jp/translator.js
+++ b/ext/jp/translator.js
@@ -36,7 +36,7 @@ class Translator {
         }
 
         $.when.apply($, loaders).done((rules, edict, enamdict, kanjidic) => {
-            this.deinflector.setRules(rules);
+            this.deinflector.setRules(rules[0]);
 
             this.dictionary.addTermDict(edict[0]);
             this.dictionary.addTermDict(enamdict[0]);
@@ -71,16 +71,21 @@ class Translator {
                     this.processTerm(groups, df.source, df.rules, df.root);
                 }
             }
-
-            const results = groups.sort(resultSorter);
-
-            let length = 0;
-            for (const result of results) {
-                length = Math.max(length, result.source.length);
-            }
-
-            return {results: results, length: length};
         }
+
+        let results = [];
+        for (const key in groups) {
+            results.push(groups[key]);
+        }
+
+        results = results.sort(this.resultSorter);
+
+        let length = 0;
+        for (const result of results) {
+            length = Math.max(length, result.source.length);
+        }
+
+        return {results: results, length: length};
     }
 
     findKanji(text) {
@@ -115,27 +120,27 @@ class Translator {
         const sl2 = v2.source.length;
 
         if (sl1 > sl2) {
-            return -1;
-        } else if (sl1 > sl2) {
             return 1;
+        } else if (sl1 > sl2) {
+            return -1;
         }
 
         const p1 = v1.tags.indexOf('P') >= 0;
         const p2 = v2.tags.indexOf('P') >= 0;
 
         if (p1 && !p2) {
-            return -1;
-        } else if (!p1 && p2) {
             return 1;
+        } else if (!p1 && p2) {
+            return -1;
         }
 
         const rl1 = v1.rules.length;
         const rl2 = v2.rules.length;
 
         if (rl1 < rl2) {
-            return -1;
-        } else if (rl2 > rl1) {
             return 1;
+        } else if (rl2 > rl1) {
+            return -1;
         }
 
         return 0;