natural 6.12.0 → 7.0.0

package/lib/natural/inflectors/fr/count_inflector.js

@@ -38,27 +38,26 @@ THE SOFTWARE.
  *   * CountInflector(2, undefined, undefined, ALTERNATIVE); // "2nd"
  */
 
-const CountInflector = function () {
-}
+class CountInflectorFr {
+  /**
+   * @param {number|string} i
+   * @return {string}
+   */
+  nth (i) {
+    return i.toString() + this.nthForm(i)
+  }
 
-/**
- * @param {number|string} i
- * @return {string}
- */
-CountInflector.nth = function (i) {
-  return i.toString() + nthForm(i)
-}
+  /**
+   * @param {number|string} i
+   * @return {string}
+   */
+  nthForm (i) {
+    if (i === 1 || i === 'I') {
+      return 'er'
+    }
 
-/**
- * @param {number|string} i
- * @return {string}
- */
-function nthForm (i) {
-  if (i === 1 || i === 'I') {
-    return 'er'
+    return 'e'
   }
-
-  return 'e'
 }
 
-module.exports = CountInflector
+module.exports = CountInflectorFr

package/lib/natural/inflectors/index.d.ts

@@ -20,7 +20,14 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
-export class NounInflector {
+export class SingularPluralInflector {
+  singularize (token: string): string
+  pluralize (token: string): string
+  addSingular (pattern: RegExp, replacement: string): void
+  addPlural (pattern: RegExp, replacement: string): void
+}
+
+export class NounInflector extends SingularPluralInflector {
   pluralize (token: string): string
   singularize (token: string): string
 }
@@ -28,10 +35,12 @@ export class NounInflector {
 export class NounInflectorFr extends NounInflector {}
 export class NounInflectorJa extends NounInflector {}
 
-export let CountInflector: {
-  nth: (i: number) => string
+export class CountInflector {
+  nth: (i: number | string) => string
 }
 
+export class CountInflectorFr extends CountInflector {}
+
 export class PresentVerbInflector {
   pluralize (token: string): string
   singularize (token: string): string

package/lib/natural/inflectors/index.js

@@ -25,5 +25,8 @@ THE SOFTWARE.
 exports.NounInflector = require('./noun_inflector')
 exports.NounInflectorFr = require('./fr/noun_inflector')
 exports.NounInflectorJa = require('./ja/noun_inflector')
+
 exports.PresentVerbInflector = require('./present_verb_inflector')
+
 exports.CountInflector = require('./count_inflector')
+exports.CountInflectorFr = require('./fr/count_inflector')

package/lib/natural/ngrams/index.d.ts

@@ -22,12 +22,12 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 */
 
-import { Tokenizer } from '../tokenizers'
+import type { Tokenizer } from '../tokenizers'
 
 declare interface NGramsStats {
   ngrams: string[][]
-  frequencies: { [key: string]: number | undefined }
-  Nr: { [key: number]: number | undefined }
+  frequencies: Record<string, number>
+  Nr: Record<number, number>
   numberOfNgrams: number
 }
 
@@ -36,8 +36,8 @@ declare interface NGramsFunctions {
   // value, method signatures are necessary. Key collisions occur with property signatures.
   /* eslint-disable @typescript-eslint/method-signature-style */
   setTokenizer (t: Tokenizer): void
-  ngrams (sequence: string | string[], n: number, startSymbol: string | undefined, endSymbol: string | undefined, stats: true): NGramsStats
-  ngrams (sequence: string | string[], n: number, startSymbol?: string, endSymbol?: string, stats?: boolean): string[][]
+  ngrams (sequence: string | string[], n: number, startSymbol: string | undefined | null, endSymbol: string | undefined | null, stats: true): NGramsStats
+  ngrams (sequence: string | string[], n: number, startSymbol?: string | undefined | null, endSymbol?: string, stats?: boolean): string[][]
   bigrams (sequence: string | string[], startSymbol: string | undefined, endSymbol: string | undefined, stats: true): NGramsStats
   bigrams (sequence: string | string[], startSymbol?: string, endSymbol?: string, stats?: boolean): string[][]
   trigrams (sequence: string | string[], startSymbol: string | undefined, endSymbol: string | undefined, stats: true): NGramsStats

package/lib/natural/normalizers/index.d.ts

@@ -24,5 +24,28 @@ THE SOFTWARE.
 
 export function normalize (tokens: string | string[]): string[]
 // eslint-disable-next-line @typescript-eslint/naming-convention
-export function normalize_ja (str: string): string
+export function normalizeJa (str: string): string
+export function normalizeNo (str: string): string
+export function normalizeSv (str: string): string
 export function removeDiacritics (str: string): string
+
+export class Converters {
+  alphabetFH: (str: string) => string
+  alphabetHF: (str: string) => string
+  numbersFH: (str: string) => string
+  numbersHF: (str: string) => string
+  punctuationFH: (str: string) => string
+  punctuationHF: (str: string) => string
+  symbolFH: (str: string) => string
+  symbolHF: (str: string) => string
+  purePunctuationFH: (str: string) => string
+  purePunctuationHF: (str: string) => string
+  katakanaFH: (str: string) => string
+  katakanaHF: (str: string) => string
+  static fixFullwidthKana: (str: string) => string
+  static normalize: (str: string) => string
+  hiraganaToKatakana (str: string): string
+  katakanaToHiragana (str: string): string
+}
+
+type FixCompositeSymbolsTable = Record<string, string>

package/lib/natural/normalizers/index.js

@@ -23,5 +23,8 @@ THE SOFTWARE.
 'use strict'
 
 exports.normalize = require('./normalizer').normalizeTokens
-exports.normalize_ja = require('./normalizer_ja').normalizeJa
+exports.normalizeJa = require('./normalizer_ja').normalizeJa
+exports.normalizeNo = require('./normalizer_no').removeDiacritics
+exports.normalizeSv = require('./normalizer_sv')
+exports.Converters = require('./normalizer_ja').Converters
 exports.removeDiacritics = require('./remove_diacritics')

package/lib/natural/normalizers/normalizer_ja.js

@@ -48,7 +48,7 @@
 
 const flip = require('../util/utils.js').flip
 const merge = require('../util/utils.js').merge
-const replacer = require('../util/utils').replacer
+const replacer = require('../util/utils.js').replacer
 
 // From http://fernweh.jp/b/mb_convert_kana_js/
 const conversionTables = {
@@ -522,73 +522,110 @@ conversionTables.normalize = merge(
   conversionTables.halfwidthToFullwidth.katakana
 )
 
-const 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)
-  },
-
-  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)
-  },
-
-  fixFullwidthKana: replacer(fixFullwidthKana),
-  normalize: replacer(conversionTables.normalize)
-}
-
-const fixCompositeSymbols = replacer(fixCompositeSymbolsTable)
-
-/**
- * Convert hiragana to fullwidth katakana.
- * According to http://jsperf.com/converting-japanese, these implementations are
- * faster than using lookup tables.
- *
- * @param {string} str A string.
- * @return {string} A string not containing hiragana.
- */
-converters.hiraganaToKatakana = function (str) {
-  str = converters.halfwidthToFullwidth.katakana(str)
-  str = converters.fixFullwidthKana(str)
-
-  str = str.replace(/ゝ/g, 'ヽ')
-  str = str.replace(/ゞ/g, 'ヾ')
-  // str = str.replace(/?/g, '𛀀'); // Letter archaic E
-
-  str = str.replace(/[ぁ-ゖ]/g, function (str) {
-    return String.fromCharCode(str.charCodeAt(0) + 96)
-  })
-
-  return str
-}
-
-/**
- * Convert katakana to hiragana.
- *
- * @param {string} str A string.
- * @return {string} A string not containing katakana.
- */
-converters.katakanaToHiragana = function (str) {
-  str = converters.halfwidthToFullwidth.katakana(str)
-  str = converters.fixFullwidthKana(str)
-
-  str = str.replace(/ヽ/g, 'ゝ')
-  str = str.replace(/ヾ/g, 'ゞ')
-  // str = str.replace(/?/g, '𛀁'); // Letter archaic E
-
-  str = str.replace(/[ァ-ヶ]/g, function (str) {
-    return String.fromCharCode(str.charCodeAt(0) - 96)
-  })
-
-  return str
+class Converters {
+  alphabetFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.alphabet)(str)
+  }
+
+  numbersFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.numbers)(str)
+  }
+
+  symbolFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.symbol)(str)
+  }
+
+  purePunctuationFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.purePunctuation)(str)
+  }
+
+  punctuationFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.punctuation)(str)
+  }
+
+  katakanaFH (str) {
+    return replacer(conversionTables.fullwidthToHalfwidth.katakana)(str)
+  }
+
+  static fixFullwidthKana (str) {
+    return replacer(fixFullwidthKana)(str)
+  }
+
+  static normalize (str) {
+    return replacer(conversionTables.normalize)(str)
+  }
+
+  alphabetHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.alphabet)(str)
+  }
+
+  numbersHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.numbers)(str)
+  }
+
+  symbolHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.symbol)(str)
+  }
+
+  purePunctuationHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.purePunctuation)(str)
+  }
+
+  punctuationHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.punctuation)(str)
+  }
+
+  katakanaHF (str) {
+    return replacer(conversionTables.halfwidthToFullwidth.katakana)(str)
+  }
+
+  static fixCompositeSymbols (str) {
+    return replacer(fixCompositeSymbolsTable)(str)
+  }
+
+  /**
+   * Convert hiragana to fullwidth katakana.
+   * According to http://jsperf.com/converting-japanese, these implementations are
+   * faster than using lookup tables.
+   *
+   * @param {string} str A string.
+   * @return {string} A string not containing hiragana.
+   */
+  hiraganaToKatakana (str) {
+    str = this.katakanaHF(str)
+    str = Converters.fixFullwidthKana(str)
+
+    str = str.replace(/ゝ/g, 'ヽ')
+    str = str.replace(/ゞ/g, 'ヾ')
+    // str = str.replace(/?/g, '𛀀'); // Letter archaic E
+
+    str = str.replace(/[ぁ-ゖ]/g, function (str) {
+      return String.fromCharCode(str.charCodeAt(0) + 96)
+    })
+
+    return str
+  }
+
+  /**
+   * Convert katakana to hiragana.
+   *
+   * @param {string} str A string.
+   * @return {string} A string not containing katakana.
+   */
+  katakanaToHiragana (str) {
+    str = this.katakanaHF(str)
+    str = Converters.fixFullwidthKana(str)
+
+    str = str.replace(/ヽ/g, 'ゝ')
+    str = str.replace(/ヾ/g, 'ゞ')
+    // str = str.replace(/?/g, '𛀁'); // Letter archaic E
+
+    str = str.replace(/[ァ-ヶ]/g, function (str) {
+      return String.fromCharCode(str.charCodeAt(0) - 96)
+    })
+
+    return str
+  }
 }
 
 /**
@@ -610,14 +647,14 @@ const normalizeJa = function (str) {
     .replace(/(..)々々/g, '$1$1')
     .replace(/(.)々/g, '$1$1')
 
-  str = converters.normalize(str)
-  str = converters.fixFullwidthKana(str)
+  str = Converters.normalize(str)
+  str = Converters.fixFullwidthKana(str)
 
   // Replace composite symbols.
-  str = fixCompositeSymbols(str)
+  str = Converters.fixCompositeSymbols(str)
 
   return str
 }
 
 exports.normalizeJa = normalizeJa
-exports.converters = converters
+exports.Converters = Converters

package/lib/natural/phonetics/dm_soundex.js

@@ -22,6 +22,8 @@ THE SOFTWARE.
 
 'use strict'
 
+const Phonetic = require('./phonetic')
+
 /*
  * Daitch-Mokotoff Soundex Coding
  *
@@ -195,69 +197,68 @@ const codes = {
 }
 /* jscpd:ignore-end */
 
-function process (word, codeLength) {
-  codeLength = codeLength || 6
-  word = word.toUpperCase()
-  let output = ''
+class SoundExDM extends Phonetic {
+  process (word, codeLength) {
+    codeLength = codeLength || 6
+    word = word.toUpperCase()
+    let output = ''
+
+    let pos = 0; let lastCode = -1
+    while (pos < word.length) {
+      const substr = word.slice(pos)
+      const rules = this.findRules(substr)
 
-  let pos = 0; let lastCode = -1
-  while (pos < word.length) {
-    const substr = word.slice(pos)
-    const rules = findRules(substr)
+      let code
+      if (pos === 0) {
+        // at the beginning of the word
+        code = rules.mapping[0]
+      } else if (substr[rules.length] && this.findRules(substr[rules.length]).mapping[0] === 0) {
+        // before a vowel
+        code = rules.mapping[1]
+      } else {
+        // any other situation
+        code = rules.mapping[2]
+      }
 
-    let code
-    if (pos === 0) {
-      // at the beginning of the word
-      code = rules.mapping[0]
-    } else if (substr[rules.length] && findRules(substr[rules.length]).mapping[0] === 0) {
-      // before a vowel
-      code = rules.mapping[1]
-    } else {
-      // any other situation
-      code = rules.mapping[2]
+      if ((code !== -1) && (code !== lastCode)) output += code
+      lastCode = code
+      pos += rules.length
     }
 
-    if ((code !== -1) && (code !== lastCode)) output += code
-    lastCode = code
-    pos += rules.length
+    return this.normalizeLength(output, codeLength)
   }
 
-  return normalizeLength(output, codeLength)
-}
-
-function findRules (str) {
-  let state = codes[str[0]]
-  let legalState = state || [[-1, -1, -1]]
-  let charsInvolved = 1
+  findRules (str) {
+    let state = codes[str[0]]
+    let legalState = state || [[-1, -1, -1]]
+    let charsInvolved = 1
 
-  for (let offs = 1; offs < str.length; offs++) {
-    if (!state || !state[str[offs]]) break
+    for (let offs = 1; offs < str.length; offs++) {
+      if (!state || !state[str[offs]]) break
 
-    state = state[str[offs]]
-    if (state[0]) {
-      legalState = state
-      charsInvolved = offs + 1
+      state = state[str[offs]]
+      if (state[0]) {
+        legalState = state
+        charsInvolved = offs + 1
+      }
     }
-  }
 
-  return {
-    length: charsInvolved,
-    mapping: legalState[0]
+    return {
+      length: charsInvolved,
+      mapping: legalState[0]
+    }
   }
-}
 
-/**
- * Pad right with zeroes or cut excess symbols to fit length
- */
-function normalizeLength (token, length) {
-  length = length || 6
-  if (token.length < length) {
-    token += (new Array(length - token.length + 1)).join('0')
+  /**
+   * Pad right with zeroes or cut excess symbols to fit length
+   */
+  normalizeLength (token, length) {
+    length = length || 6
+    if (token.length < length) {
+      token += (new Array(length - token.length + 1)).join('0')
+    }
+    return token.slice(0, length)
   }
-  return token.slice(0, length)
 }
 
-const Phonetic = require('./phonetic')
-const soundex = new Phonetic()
-soundex.process = process
-module.exports = soundex
+module.exports = SoundExDM