de-compromise 0.1.1 → 0.1.2

package/src/01-one/tagset/tags/nouns.js

@@ -2,6 +2,7 @@ const entity = ['Person', 'Place', 'Organization']
 
 export default {
   Noun: {
+    aliases: [null, 'Nomen', 'Substantiv'],
     not: ['Verb', 'Adjective', 'Adverb', 'Value', 'Determiner'],
   },
   Singular: {
@@ -9,6 +10,7 @@ export default {
     not: ['Plural'],
   },
   ProperNoun: {
+    aliases: [null, 'Eigenname'],
     is: 'Noun',
   },
   Person: {
@@ -17,34 +19,42 @@ export default {
     not: ['Place', 'Organization', 'Date'],
   },
   FirstName: {
+    aliases: [null, 'Vorname'],
     is: 'Person',
   },
   MaleName: {
+    aliases: [null, 'Männername'],
     is: 'FirstName',
     not: ['FemaleName', 'LastName'],
   },
   FemaleName: {
+    aliases: [null, 'Frauenname'],
     is: 'FirstName',
     not: ['MaleName', 'LastName'],
   },
   LastName: {
+    aliases: [null, 'Nachname'],
     is: 'Person',
     not: ['FirstName'],
   },
   Honorific: {
+    aliases: [null, 'Titel'],
     is: 'Noun',
     not: ['FirstName', 'LastName', 'Value'],
   },
   Place: {
+    aliases: [null, 'Ort'],
     is: 'Singular',
     not: ['Person', 'Organization'],
   },
   Country: {
+    aliases: [null, 'Land'],
     is: 'Place',
     also: ['ProperNoun'],
     not: ['City'],
   },
   City: {
+    aliases: [null, 'Stadt'],
     is: 'Place',
     also: ['ProperNoun'],
     not: ['Country'],
@@ -54,19 +64,24 @@ export default {
     also: ['ProperNoun'],
   },
   Address: {
+    aliases: [null, 'Adresse'],
     // is: 'Place',
   },
   Organization: {
+    aliases: [null, 'Organisation'],
     is: 'ProperNoun',
     not: ['Person', 'Place'],
   },
   SportsTeam: {
+    aliases: [null, 'Mannschaft'],
     is: 'Organization',
   },
   School: {
+    aliases: [null, 'Schule'],
     is: 'Organization',
   },
   Company: {
+    aliases: [null, 'Unternehmen'],
     is: 'Organization',
   },
   Plural: {
@@ -74,9 +89,11 @@ export default {
     not: ['Singular'],
   },
   Uncountable: {
+    aliases: [null, 'Unzählbar'],
     is: 'Noun',
   },
   Pronoun: {
+    aliases: [null, 'Pronomen'],
     is: 'Noun',
     not: entity,
   },
@@ -85,31 +102,39 @@ export default {
     not: entity,
   },
   Activity: {
+    aliases: [null, 'Aktivität'],
     is: 'Noun',
     not: ['Person', 'Place'],
   },
   Unit: {
+    aliases: [null, 'Einheit'],
     is: 'Noun',
     not: entity,
   },
   Demonym: {
+    aliases: [null, 'Einwohnername'],
     is: 'Noun',
     also: ['ProperNoun'],
     not: entity,
   },
   // standalone — 'meinem' is #Possessive as both a determiner ('meinem Freund')
   // and a pronoun ('das ist meins')
-  Possessive: {},
+  Possessive: {
+    aliases: [null, 'Possessiv'],
+  },
   // german genders
   MaleNoun: {
+    aliases: [null, 'Maskulinum'],
     is: 'Noun',
     not: ['FemaleNoun', 'NeuterNoun'],
   },
   FemaleNoun: {
+    aliases: [null, 'Femininum'],
     is: 'Noun',
     not: ['MaleNoun', 'NeuterNoun'],
   },
   NeuterNoun: {
+    aliases: [null, 'Neutrum'],
     is: 'Noun',
     not: ['MaleNoun', 'FemaleNoun'],
   },

package/src/01-one/tagset/tags/values.js

@@ -1,27 +1,34 @@
 export default {
   Value: {
+    aliases: [null, 'Zahl'],
     not: ['Verb', 'Adjective', 'Adverb'],
   },
   Ordinal: {
+    aliases: [null, 'Ordinalzahl'],
     is: 'Value',
     not: ['Cardinal'],
   },
   Cardinal: {
+    aliases: [null, 'Kardinalzahl'],
     is: 'Value',
     not: ['Ordinal'],
   },
   Fraction: {
+    aliases: [null, 'Bruchzahl'],
     is: 'Value',
     not: ['Noun'],
   },
   Multiple: {
+    aliases: [null, 'Vielfaches'],
     is: 'Value',
   },
   RomanNumeral: {
+    aliases: [null, 'RömischeZahl'],
     is: 'Cardinal',
     not: ['TextValue'],
   },
   TextValue: {
+    aliases: [null, 'Zahlwort'],
     is: 'Value',
     not: ['NumericValue'],
   },
@@ -35,13 +42,16 @@ export default {
   },
 
   NumericValue: {
+    aliases: [null, 'Numerisch'],
     is: 'Value',
     not: ['TextValue'],
   },
   Money: {
+    aliases: [null, 'Geld'],
     is: 'Cardinal',
   },
   Percent: {
+    aliases: [null, 'Prozent'],
     is: 'Value',
   },
 }

package/src/01-one/tagset/tags/verbs.js

@@ -3,62 +3,80 @@ export default {
     not: ['Noun', 'Adjective', 'Adverb', 'Value', 'Expression'],
   },
   PresentTense: {
+    aliases: [null, 'Präsens'],
     is: 'Verb',
     not: ['PastTense'],
   },
   Infinitive: {
+    aliases: [null, 'Infinitiv'],
     is: 'PresentTense',
     not: ['Gerund'],
   },
   Imperative: {
+    aliases: [null, 'Imperativ'],
     is: 'Infinitive',
   },
   Subjunctive: {
+    aliases: [null, 'Konjunktiv'],
     is: 'Verb',
   },
   Participle: {
+    aliases: [null, 'Partizip'],
     is: 'Verb',
   },
   Gerund: {
     is: 'PresentTense',
     not: ['Copula'],
   },
+  // any past form - 'ging', and also 'gegangen'
   PastTense: {
+    aliases: [null, 'Vergangenheit'],
     is: 'Verb',
     not: ['PresentTense', 'Gerund'],
   },
   Copula: {
+    aliases: [null, 'Kopula'],
     is: 'Verb',
   },
   Modal: {
+    aliases: [null, 'Modalverb'],
     is: 'Verb',
     not: ['Infinitive'],
   },
   PerfectTense: {
+    aliases: [null, 'Perfekt'],
     is: 'Verb',
     not: ['Gerund'],
   },
   Pluperfect: {
+    aliases: [null, 'Plusquamperfekt'],
     is: 'Verb',
   },
   PhrasalVerb: {
+    aliases: [null, 'Partikelverb'],
     is: 'Verb',
   },
+  // a separable prefix - the 'an' in 'ich rufe dich an'
   Particle: {
+    aliases: [null, 'Verbpartikel'],
     is: 'PhrasalVerb',
     not: ['PastTense', 'PresentTense', 'Copula', 'Gerund'],
   },
   Auxiliary: {
+    aliases: [null, 'Hilfsverb'],
     is: 'Verb',
     not: ['PastTense', 'PresentTense', 'Gerund', 'Conjunction'],
   },
   FirstPerson: {
+    aliases: [null, 'ErstePerson'],
     is: 'Verb'
   },
   SecondPerson: {
+    aliases: [null, 'ZweitePerson'],
     is: 'Verb'
   },
   ThirdPerson: {
+    aliases: [null, 'DrittePerson'],
     is: 'Verb'
   },
 }

package/src/01-one/tokenizer/is-sentence.js

@@ -21,9 +21,9 @@ const isSentence = function (str, abbrevs) {
   if (hasEllipse.test(str) === true) {
     return false
   }
-  let txt = str.replace(/[.!?\u203D\u2E18\u203C\u2047-\u2049] *$/, '')
-  let words = txt.split(' ')
-  let lastWord = words[words.length - 1].toLowerCase()
+  const txt = str.replace(/[.!?\u203D\u2E18\u203C\u2047-\u2049] *$/, '')
+  const words = txt.split(' ')
+  const lastWord = words[words.length - 1].toLowerCase()
   // check for 'Mr.'
   if (abbrevs.hasOwnProperty(lastWord) === true) {
     return false

package/src/01-one/tokenizer/unicode.js

@@ -10,7 +10,7 @@
 // ü  | Ü
 // ß
 
-let compact = {
+const compact = {
   '!': '¡',
   '?': '¿Ɂ',
   '"': '“”"❝❞',
@@ -46,7 +46,7 @@ let compact = {
   ß: 'β' //greek beta to german Eszett surrogate
 }
 //decompress data into two hashes
-let unicode = {}
+const unicode = {}
 Object.keys(compact).forEach(function (k) {
   compact[k].split('').forEach(function (s) {
     unicode[s] = k

package/src/02-two/preTagger/compute/1st-pass/regex.js

@@ -13,10 +13,10 @@ const doRegs = function (str, regs) {
 }
 
 const checkRegex = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let term = terms[i]
-  let { regexText, regexNormal, regexNumbers } = world.model.two
-  let normal = term.machine || term.normal
+  const setTag = world.methods.one.setTag
+  const term = terms[i]
+  const { regexText, regexNormal, regexNumbers } = world.model.two
+  const normal = term.machine || term.normal
   let text = term.text
   // keep dangling apostrophe?
   if (hasApostrophe.test(term.post) && !hasApostrophe.test(term.pre)) {

package/src/02-two/preTagger/compute/1st-pass/titlecase.js

@@ -4,8 +4,8 @@ const isTitleCase = function (str) {
 
 // add a noun to any non-0 index titlecased word, with no existing tag
 const titleCaseNoun = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let term = terms[i]
+  const setTag = world.methods.one.setTag
+  const term = terms[i]
   // don't over-write any tags
   // if (term.tags.size > 0) {
   //   return

package/src/02-two/preTagger/compute/1st-pass/year.js

@@ -28,10 +28,10 @@ const seemsOkay = function (term) {
 
 // recognize '1993' as a year
 const tagYear = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
+  const setTag = world.methods.one.setTag
   const term = terms[i]
   if (term.tags.has('NumericValue') && term.tags.has('Cardinal') && term.normal.length === 4) {
-    let num = Number(term.normal)
+    const num = Number(term.normal)
     // number between 1400 and 2100
     if (num && !isNaN(num)) {
       if (num > min && num < max) {

package/src/02-two/preTagger/compute/2nd-pass/acronym.js

@@ -12,7 +12,7 @@ const oneLetterWord = {
 }
 // just uppercase acronyms, no periods - 'UNOCHA'
 const isNoPeriodAcronym = function (term, model) {
-  let str = term.text
+  const str = term.text
   // ensure it's all upper-case
   if (isUpperCase.test(str) === false) {
     return false
@@ -49,8 +49,8 @@ const isNoPeriodAcronym = function (term, model) {
 }
 
 const isAcronym = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let term = terms[i]
+  const setTag = world.methods.one.setTag
+  const term = terms[i]
   //these are not acronyms
   if (term.tags.has('RomanNumeral') || term.tags.has('Acronym')) {
     return null

package/src/02-two/preTagger/compute/2nd-pass/fallback.js

@@ -7,8 +7,8 @@ const hasNoVerb = function (terms) {
 }
 
 const fallback = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let term = terms[i]
+  const setTag = world.methods.one.setTag
+  const term = terms[i]
   if (term.tags.size === 0) {
 
     // is it first-word titlecase?

package/src/02-two/preTagger/compute/2nd-pass/prefix-lookup.js

@@ -7,9 +7,9 @@ const prefixLoop = function (str = '', prefixes = []) {
     max = len - 3
   }
   for (let i = max; i > 2; i -= 1) {
-    let prefix = str.substring(0, i)
+    const prefix = str.substring(0, i)
     if (prefixes[prefix.length].hasOwnProperty(prefix) === true) {
-      let tag = prefixes[prefix.length][prefix]
+      const tag = prefixes[prefix.length][prefix]
       return tag
     }
   }
@@ -18,10 +18,10 @@ const prefixLoop = function (str = '', prefixes = []) {
 
 // give 'overwork' the same tag as 'work'
 const checkPrefix = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let term = terms[i]
+  const setTag = world.methods.one.setTag
+  const term = terms[i]
   if (term.tags.size === 0) {
-    let tag = prefixLoop(term.normal, world.model.two.prefixPatterns)
+    const tag = prefixLoop(term.normal, world.model.two.prefixPatterns)
     if (tag !== null) {
       setTag([term], tag, world, false, '2-prefix')
       term.confidence = 0.5

package/src/02-two/preTagger/compute/2nd-pass/suffix-lookup.js

@@ -7,10 +7,10 @@ const suffixLoop = function (str = '', suffixes = []) {
     max = len - 1
   }
   for (let i = max; i > 1; i -= 1) {
-    let suffix = str.substr(len - i, len)
+    const suffix = str.substr(len - i, len)
     if (suffixes[suffix.length].hasOwnProperty(suffix) === true) {
       // console.log(suffix)
-      let tag = suffixes[suffix.length][suffix]
+      const tag = suffixes[suffix.length][suffix]
       return tag
     }
   }
@@ -19,9 +19,9 @@ const suffixLoop = function (str = '', suffixes = []) {
 
 // decide tag from the ending of the word
 const suffixCheck = function (terms, i, world) {
-  let setTag = world.methods.one.setTag
-  let suffixes = world.model.two.suffixPatterns
-  let term = terms[i]
+  const setTag = world.methods.one.setTag
+  const suffixes = world.model.two.suffixPatterns
+  const term = terms[i]
   if (term.tags.size === 0) {
     let tag = suffixLoop(term.normal, suffixes)
     if (tag !== null) {

package/src/02-two/preTagger/compute/index.js

@@ -32,7 +32,7 @@ const secondPass = function (terms, world) {
 
 
 const tagger = function (view) {
-  let world = view.world
+  const world = view.world
   view.docs.forEach(terms => {
     firstPass(terms, world)
     secondPass(terms, world)

package/src/03-three/adjectives/api.js

@@ -16,9 +16,9 @@ const api = function (View) {
       const methods = this.methods.two.transform.adjective
       const { inflect, toRoot } = methods
       return getNth(this, n).map(m => {
-        let str = getRoot(m, methods)
-        let root = toRoot(str) || str
-        let res = inflect(root)
+        const str = getRoot(m, methods)
+        const root = toRoot(str) || str
+        const res = inflect(root)
         res.infinitive = root
         return res
       }, [])

package/src/03-three/nouns/api.js

@@ -17,7 +17,7 @@ const matchCase = function (m, str) {
 // 'hunde' → 'hund' → 'hunde' round-trips, so it is already a plural,
 // even when the tagger could not tell - 'die Hunde' vs 'der Kunde'
 const isPluralForm = function (methods, str) {
-  let single = methods.toSingular(str)
+  const single = methods.toSingular(str)
   return single !== str && methods.toPlural(single).one === str
 }
 
@@ -30,7 +30,7 @@ const api = function (View) {
     conjugate(n) {
       const methods = this.methods.two.transform.noun
       return getNth(this, n).map(m => {
-        let root = getRoot(m)
+        const root = getRoot(m)
         return {
           singular: root,
           plural: methods.toPlural(root).one,
@@ -47,19 +47,19 @@ const api = function (View) {
         if (isPluralForm(methods, m.text('normal'))) {
           return m
         }
-        let str = getRoot(m)
-        let plural = methods.toPlural(str).one
+        const str = getRoot(m)
+        const plural = methods.toPlural(str).one
         return m.replaceWith(matchCase(m, plural))
       })
     }
     toSingular(n) {
       const methods = this.methods.two.transform.noun
       return getNth(this, n).not('#Singular').map(m => {
-        let str = m.text('normal')
+        const str = m.text('normal')
         if (!m.has('#Plural') && !isPluralForm(methods, str)) {
           return m
         }
-        let singular = methods.toSingular(str)
+        const singular = methods.toSingular(str)
         return m.replaceWith(matchCase(m, singular))
       })
     }

package/src/03-three/numbers/api.js

@@ -18,10 +18,10 @@ const api = function (View) {
       return getNth(this, n).map(parse).map(o => o.num)
     }
     json(n) {
-      let doc = getNth(this, n)
+      const doc = getNth(this, n)
       return doc.map(p => {
-        let json = p.toView().json(n)[0]
-        let parsed = parse(p)
+        const json = p.toView().json(n)[0]
+        const parsed = parse(p)
         json.number = {
           prefix: parsed.prefix,
           num: parsed.num,
@@ -46,14 +46,14 @@ const api = function (View) {
 
     /** convert to numeric form like '8' or '8th' */
     toNumber() {
-      let m = this.if('#TextValue')
-      let res = m.map(val => {
-        let obj = parse(val)
+      const m = this.if('#TextValue')
+      const res = m.map(val => {
+        const obj = parse(val)
         if (obj.num === null) {
           return val
         }
-        let fmt = val.has('#Ordinal') ? 'Ordinal' : 'Cardinal'
-        let str = format(obj, fmt)
+        const fmt = val.has('#Ordinal') ? 'Ordinal' : 'Cardinal'
+        const str = format(obj, fmt)
         if (str) {
           val.replaceWith(str, { tags: true })
           val.tag('NumericValue')
@@ -64,17 +64,17 @@ const api = function (View) {
     }
     /** convert to numeric form like 'eight' or 'eighth' */
     toText() {
-      let m = this
-      let res = m.map(val => {
+      const m = this
+      const res = m.map(val => {
         if (val.has('#TextValue')) {
           return val
         }
-        let obj = parse(val)
+        const obj = parse(val)
         if (obj.num === null) {
           return val
         }
-        let fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
-        let str = format(obj, fmt)
+        const fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
+        const str = format(obj, fmt)
         if (str) {
           val.replaceWith(str, { tags: true })
           val.tag('TextValue')
@@ -85,17 +85,17 @@ const api = function (View) {
     }
     /** convert ordinal to cardinal form, like 'eight', or '8' */
     toCardinal() {
-      let m = this
-      let res = m.map(val => {
+      const m = this
+      const res = m.map(val => {
         if (!val.has('#Ordinal')) {
           return val
         }
-        let obj = parse(val)
+        const obj = parse(val)
         if (obj.num === null) {
           return val
         }
-        let fmt = val.has('#TextValue') ? 'TextCardinal' : 'Cardinal'
-        let str = format(obj, fmt)
+        const fmt = val.has('#TextValue') ? 'TextCardinal' : 'Cardinal'
+        const str = format(obj, fmt)
         if (str) {
           val.replaceWith(str, { tags: true })
           val.tag('Cardinal')
@@ -106,17 +106,17 @@ const api = function (View) {
     }
     /** convert cardinal to ordinal form, like 'eighth', or '8th' */
     toOrdinal() {
-      let m = this
-      let res = m.map(val => {
+      const m = this
+      const res = m.map(val => {
         if (val.has('#Ordinal')) {
           return val
         }
-        let obj = parse(val)
+        const obj = parse(val)
         if (obj.num === null) {
           return val
         }
-        let fmt = val.has('#TextValue') ? 'TextOrdinal' : 'Ordinal'
-        let str = format(obj, fmt)
+        const fmt = val.has('#TextValue') ? 'TextOrdinal' : 'Ordinal'
+        const str = format(obj, fmt)
         if (str) {
           val.replaceWith(str, { tags: true })
           val.tag('Ordinal')
@@ -129,28 +129,28 @@ const api = function (View) {
     /** return only numbers that are == n */
     isEqual(n) {
       return this.filter((val) => {
-        let num = parse(val).num
+        const num = parse(val).num
         return num === n
       })
     }
     /** return only numbers that are > n*/
     greaterThan(n) {
       return this.filter((val) => {
-        let num = parse(val).num
+        const num = parse(val).num
         return num > n
       })
     }
     /** return only numbers that are < n*/
     lessThan(n) {
       return this.filter((val) => {
-        let num = parse(val).num
+        const num = parse(val).num
         return num < n
       })
     }
     /** return only numbers > min and < max */
     between(min, max) {
       return this.filter((val) => {
-        let num = parse(val).num
+        const num = parse(val).num
         return num > min && num < max
       })
     }
@@ -162,9 +162,9 @@ const api = function (View) {
       if (typeof n === 'string') {
         n = parse(n).num
       }
-      let m = this
-      let res = m.map((val) => {
-        let obj = parse(val)
+      const m = this
+      const res = m.map((val) => {
+        const obj = parse(val)
         obj.num = n
         if (obj.num === null) {
           return val
@@ -195,9 +195,9 @@ const api = function (View) {
       if (typeof n === 'string') {
         n = parse(n).num
       }
-      let m = this
-      let res = m.map((val) => {
-        let obj = parse(val)
+      const m = this
+      const res = m.map((val) => {
+        const obj = parse(val)
         if (obj.num === null) {
           return val
         }
@@ -206,7 +206,7 @@ const api = function (View) {
         if (obj.isText) {
           fmt = val.has('#Ordinal') ? 'TextOrdinal' : 'TextCardinal'
         }
-        let str = format(obj, fmt)
+        const str = format(obj, fmt)
         if (str) {
           val.replaceWith(str, { tags: true })
           // handle plural/singular unit
@@ -230,7 +230,7 @@ const api = function (View) {
     }
     // overloaded - keep Numbers class
     update(pointer) {
-      let m = new Numbers(this.document, pointer)
+      const m = new Numbers(this.document, pointer)
       m._cache = this._cache // share this full thing
       return m
     }