Refactor to improve bundle size

Author: wooorm

lib/add.js

@@ -9,10 +9,8 @@ var NO_CODES = []
 // Add `value` to the checker.
 function add(value, model) {
   var self = this
-  var dict = self.data
-  var codes = dict[model] || NO_CODES
 
-  push(dict, value, codes, self)
+  push(self.data, value, self.data[model] || NO_CODES, self)
 
   return self
 }

lib/dictionary.js

@@ -7,36 +7,28 @@ module.exports = add
 // Add a dictionary file.
 function add(buf) {
   var self = this
-  var compound = self.compoundRules
-  var compoundCodes = self.compoundRuleCodes
   var index = -1
-  var length = compound.length
   var rule
   var source
   var character
   var offset
-  var count
 
   parse(buf, self, self.data)
 
   // Regenerate compound expressions.
-  while (++index < length) {
-    rule = compound[index]
+  while (++index < self.compoundRules.length) {
+    rule = self.compoundRules[index]
     source = ''
-
     offset = -1
-    count = rule.length
 
-    while (++offset < count) {
+    while (++offset < rule.length) {
       character = rule.charAt(offset)
-
-      source +=
-        compoundCodes[character].length === 0
-          ? character
-          : '(?:' + compoundCodes[character].join('|') + ')'
+      source += self.compoundRuleCodes[character].length
+        ? '(?:' + self.compoundRuleCodes[character].join('|') + ')'
+        : character
     }
 
-    compound[index] = new RegExp(source, 'i')
+    self.compoundRules[index] = new RegExp(source, 'i')
   }
 
   return self

lib/index.js

@@ -18,8 +18,7 @@ proto.personal = require('./personal.js')
 
 // Construct a new spelling context.
 function NSpell(aff, dic) {
-  var length
-  var index
+  var index = -1
   var dictionaries
 
   if (!(this instanceof NSpell)) {
@@ -57,14 +56,11 @@ function NSpell(aff, dic) {
   this.rules = aff.rules
   this.flags = aff.flags
 
-  length = dictionaries ? dictionaries.length : 0
-  index = -1
-
-  while (++index < length) {
-    dic = dictionaries[index]
-
-    if (dic && dic.dic) {
-      this.dictionary(dic.dic)
+  if (dictionaries) {
+    while (++index < dictionaries.length) {
+      if (dictionaries[index].dic) {
+        this.dictionary(dictionaries[index].dic)
+      }
     }
   }
 }

lib/personal.js

@@ -5,22 +5,19 @@ module.exports = add
 // Add a dictionary.
 function add(buf) {
   var self = this
-  var flags = self.flags
   var lines = buf.toString('utf8').split('\n')
-  var length = lines.length
   var index = -1
   var line
   var forbidden
   var word
-  var model
   var flag
 
   // Ensure there’s a key for `FORBIDDENWORD`: `false` cannot be set through an
   // affix file so its safe to use as a magic constant.
-  flag = flags.FORBIDDENWORD || false
-  flags.FORBIDDENWORD = flag
+  if (self.flags.FORBIDDENWORD === undefined) self.flags.FORBIDDENWORD = false
+  flag = self.flags.FORBIDDENWORD
 
-  while (++index < length) {
+  while (++index < lines.length) {
     line = lines[index].trim()
 
     if (!line) {
@@ -29,14 +26,13 @@ function add(buf) {
 
     line = line.split('/')
     word = line[0]
-    model = line[1]
     forbidden = word.charAt(0) === '*'
 
     if (forbidden) {
       word = word.slice(1)
     }
 
-    self.add(word, model)
+    self.add(word, line[1])
 
     if (forbidden) {
       self.data[word].push(flag)

lib/spell.js

@@ -8,15 +8,15 @@ module.exports = spell
 // Check spelling of `word`.
 function spell(word) {
   var self = this
-  var dict = self.data
-  var flags = self.flags
   var value = form(self, word, true)
 
   // Hunspell also provides `root` (root word of the input word), and `compound`
   // (whether `word` was compound).
   return {
     correct: self.correct(word),
-    forbidden: Boolean(value && flag(flags, 'FORBIDDENWORD', dict[value])),
-    warn: Boolean(value && flag(flags, 'WARN', dict[value]))
+    forbidden: Boolean(
+      value && flag(self.flags, 'FORBIDDENWORD', self.data[value])
+    ),
+    warn: Boolean(value && flag(self.flags, 'WARN', self.data[value]))
   }
 }