compromise-speech 0.1.1 → 0.2.0

package/src/syllables/split/find-cuts/02-boundaries.js

@@ -0,0 +1,86 @@
+import compoundPrefixes from './_compound-prefixes.js'
+
+// Turn vowel spans into cut positions by assigning the consonants between them.
+// Consonant clusters allowed to start a chunk; the picker checks longest first.
+const onset = new Set([
+  'bl', 'br', 'ch', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gr',
+  'ph', 'pl', 'pr', 'qu', 'sh', 'sk', 'sl', 'sm', 'sn', 'sp',
+  'st', 'sw', 'th', 'tr', 'tw', 'wh', 'scr', 'shr', 'spl', 'spr', 'str', 'thr',
+])
+
+// Applied in order after onset placement; later rules take precedence.
+// left/right are offsets from the surrounding vowel groups' edges.
+// minLeft only moves a boundary forward, preserving a longer consonant cluster.
+// gap matches intervening letters; tail matches the complete remaining spelling.
+const adjustments = [
+  { minGap: 1, maxGap: 1, gap: /^x$/, left: 1 }, // box-es
+  { minGap: 2, gap: /^(.)\1/, minLeft: 1 }, // rab-bit
+  { minGap: 2, tail: /^ed$/, right: -1 }, // res-ted
+  { minGap: 2, gap: /^sh$/, tail: /^(es|ing)$/, right: 0 }, // wish-ing
+  { minGap: 2, gap: /l$/, tail: /^e(?:[sd]|['’](?:s|d|ll|re|ve))?$/, right: -2 }, // bot-tle, ta-bles, bub-bled
+  { minGap: 2, gap: /l$/, tail: /^e(?:ments?|ships?|ness(?:es)?|less|ful(?:ly)?|ly)(?:['’]s)?$/, right: -2 }, // set-tle-ment, bat-tle-ships
+  { minGap: 1, gap: /l$/, tail: /^ess(?:ly|ness(?:es)?)?$/, right: -1 }, // help-less: keep the suffix intact
+  { minGap: 3, gap: /^ssl$/, tail: /^y$/, right: -1 }, // help-less-ly, not help-les-sly
+  { minGap: 1, gap: /^(?:s|th)$/, tail: /^m(?:s|['’]s)?$/, right: 0 }, // chas-m, rhyth-m
+  { minGap: 1, tail: /^n['’]t$/, right: 0 }, // could-n't: keep the base consonants together
+  { minGap: 1, gap: /^[-‐‑–—]+$/, right: 0 }, // re-enter: keep the hyphen on the left
+]
+
+// Choose one cut between each pair of vowel spans, preserving their count.
+const pickBoundaries = (word, vowelSpans) => {
+  const cuts = []
+  // Keep recognized compound components intact, such as side-walk and some-one.
+  const compoundCuts = compoundPrefixes.flatMap(pattern => {
+    const match = pattern.exec(word)
+    return match ? [match[0].length] : []
+  })
+  for (let i = 1; i < vowelSpans.length; i += 1) {
+    // The gap contains the letters not assigned to either vowel span.
+    const left = vowelSpans[i - 1].end
+    const right = vowelSpans[i].start
+    const gap = word.slice(left, right)
+    // Match full suffixes so long endings are not mistaken for shorter ones.
+    const tail = word.slice(right)
+    // Adjacent vowels split directly; a single consonant starts the next chunk.
+    let cut = left
+    if (gap.length > 1) {
+      cut = right - 1
+      // Prefer the longest recognized consonant cluster at the next chunk's start.
+      for (let size = Math.min(3, gap.length); size > 1; size -= 1) {
+        if (onset.has(gap.slice(-size))) {
+          cut = right - size
+          break
+        }
+      }
+    }
+    // Apply every matching adjustment in order, allowing specific rules to override.
+    adjustments.forEach(rule => {
+      if (
+        gap.length < rule.minGap ||
+        (rule.maxGap !== undefined && gap.length > rule.maxGap) ||
+        (rule.gap && !rule.gap.test(gap)) ||
+        (rule.tail && !rule.tail.test(tail))
+      ) {
+        return
+      }
+      // Exact offsets replace the cut; minLeft only advances an earlier cut.
+      if (rule.left !== undefined) {
+        cut = left + rule.left
+      } else if (rule.right !== undefined) {
+        cut = right + rule.right
+      } else {
+        cut = Math.max(cut, left + rule.minLeft)
+      }
+    })
+    // A compound boundary overrides ordinary consonant placement within this gap.
+    compoundCuts.forEach(boundary => {
+      if (boundary >= left && boundary <= right) {
+        cut = boundary
+      }
+    })
+    cuts.push(cut)
+  }
+  return cuts
+}
+
+export default pickBoundaries

package/src/syllables/split/find-cuts/_compound-prefixes.js

@@ -0,0 +1,22 @@
+// Match a compound's left component, including its silent e.
+// Both vowel counting and boundary placement use these same spelling rules.
+const compoundPrefixes = [
+  /^note(?=book)/, // note-book: silent e and a boundary after the complete base
+  /^side(?=kick|line|show|step|stream|track|walk|water|way|winder|wise)/,
+  /^some(?=bod|one|time|where)/,
+  /^none(?=such)/, // none-such retains the silent e of none
+  /^goose(?=berr)/, // goose-berry and goose-berries
+  /^above(?=board|ground)/,
+  /^a?fore(?=clos|taste|said|mentioned)/,
+  /^ware(?=house|housing)/,
+  /^space(?=port|ship)/,
+  /^race(?=horse)/,
+  /^lake(?=side)/,
+  /^white(?=side)/,
+  /^state(?=side)/,
+  /^juke(?=box)/,
+  /^police(?=woman|women|man|men)/,
+  /^(?:sale|spoke)s?(?=woman|women|man|men)/,
+]
+
+export default compoundPrefixes

package/src/syllables/split/find-cuts/index.js

@@ -0,0 +1,27 @@
+import checkExceptions from './00-exceptions.js'
+import vowelSpan from './01-vowel-span.js'
+import pickBoundaries from './02-boundaries.js'
+
+const findCuts = str => {
+  // Exact exceptions and their plural forms take priority over spelling rules.
+  const found = checkExceptions(str)
+  if (found !== null) {
+    return found
+  }
+  // Keep apostrophe suffixes intact so vowel rules can recognize an extra syllable.
+  const vowelSpans = vowelSpan(str)
+  const cuts = pickBoundaries(str, vowelSpans)
+  // An exception may supply base-word cuts without overriding a syllabic suffix.
+  const key = str.replace(/['’](?:s|d|ll|re|ve)$/, '')
+  // Without a suffix, the initial lookup already checked this word.
+  if (key === str) {
+    return cuts
+  }
+  const baseCuts = checkExceptions(key)
+  if (baseCuts !== null) {
+    return baseCuts.concat(cuts.filter(cut => cut >= key.length))
+  }
+  return cuts
+}
+
+export default findCuts

package/src/syllables/split/index.js

@@ -0,0 +1,22 @@
+import findCuts from './find-cuts/index.js'
+import { applyCuts, normalize, pushCutsBack } from './_lib.js'
+
+// Pass the original term text through; the tokenizer owns pre/post punctuation.
+const splitTerm = (term, options = {}) => {
+  if (!term.text) {
+    return []
+  }
+  let str = term.text
+  if (options.normalize) {
+    str = term.normal || term.text
+  }
+  // we can split on a normalized string
+  const { clean, prefix } = normalize(str)
+  let cuts = findCuts(clean)
+  if (prefix && prefix.length > 0) {
+    cuts = pushCutsBack(cuts, prefix)
+  }
+  return applyCuts(str, cuts)
+}
+
+export default splitTerm

package/types/index.d.cts

@@ -0,0 +1,9 @@
+import type esmPlugin from './index.d.ts' with { 'resolution-mode': 'import' }
+import type * as types from './index.d.ts' with { 'resolution-mode': 'import' }
+
+declare const plugin: typeof esmPlugin
+declare namespace plugin {
+  export type SpeechMethods = types.SpeechMethods
+}
+
+export = plugin

package/{index.d.ts → types/index.d.ts}

@@ -8,6 +8,6 @@ export interface SpeechMethods {
 }
 
 /** extended compromise lib **/
-declare const nlpSpeech: nlp.TypedPlugin<SpeechMethods>
+declare const nlpSpeech: nlp.TypedPlugin<SpeechMethods> & { version: string }
 
 export default nlpSpeech

package/src/compute/index.js

@@ -1,7 +0,0 @@
-import soundsLike from './soundsLike/index.js'
-import syllables from './syllables/index.js'
-
-export default {
-  soundsLike,
-  syllables
-}

package/src/compute/syllables/index.js

@@ -1,13 +0,0 @@
-import getSyllables from './syllables.js'
-
-// const defaultObj = { normal: true, text: true, terms: false }
-
-const syllables = function (view) {
-  view.docs.forEach(terms => {
-    terms.forEach(term => {
-      term.syllables = getSyllables(term.normal || term.text)
-    })
-  })
-}
-
-export default syllables

package/src/compute/syllables/postProcess.js

@@ -1,107 +0,0 @@
-const starts_with_single_vowel_combos = /^(eu)/i
-const joining_consonant_vowel = /^[^aeiou]e([^d]|$)/
-const cvcv_same_consonant = /^([^aeiouy])[aeiouy]\1[aeiouy]/
-const cvcv_same_vowel = /^[^aeiouy]([aeiouy])[^aeiouy]\1/
-const cvcv_known_consonants = /^([tg][aeiouy]){2}/
-const only_one_or_more_c = /^[^aeiouy]+$/
-
-const ends_with_vowel = /[aeiouy]$/
-const starts_with_consonant_vowel = /^[^aeiouy]h?[aeiouy]/
-
-const ones = [
-  /^[^aeiou]?ion/,
-  /^[^aeiou]?ised/,
-  /^[^aeiou]?iled/,
-
-  // -ing, -ent
-  /[aeiou]n[gt]$/,
-
-  // -ate, -age
-  /\wa[gt]e$/,
-]
-
-//suffix fixes
-const postprocess = function (arr) {
-  //trim whitespace
-  arr = arr.map(function (w) {
-    return w.trim()
-  })
-  arr = arr.filter(function (w) {
-    return w !== ''
-  })
-  // if (arr.length > 2) {
-  //   return arr;
-  // }
-  let l = arr.length
-  if (l > 1) {
-    let suffix = arr[l - 2] + arr[l - 1]
-    for (let i = 0; i < ones.length; i++) {
-      if (suffix.match(ones[i])) {
-        arr[l - 2] = arr[l - 2] + arr[l - 1]
-        arr.pop()
-      }
-    }
-  }
-
-  // since the open syllable detection is overzealous,
-  // sometimes need to rejoin incorrect splits
-  if (arr.length > 1) {
-    let first_is_open =
-      (arr[0].length === 1 || arr[0].match(starts_with_consonant_vowel)) &&
-      arr[0].match(ends_with_vowel)
-    let second_is_joining = arr[1].match(joining_consonant_vowel)
-
-    if (first_is_open && second_is_joining) {
-      let possible_combination = arr[0] + arr[1]
-      let probably_separate_syllables =
-        possible_combination.match(cvcv_same_consonant) ||
-        possible_combination.match(cvcv_same_vowel) ||
-        possible_combination.match(cvcv_known_consonants)
-
-      if (!probably_separate_syllables) {
-        arr[0] = arr[0] + arr[1]
-        arr.splice(1, 1)
-      }
-    }
-  }
-
-  if (arr.length > 1) {
-    let second_to_last_is_open =
-      arr[arr.length - 2].match(starts_with_consonant_vowel) &&
-      arr[arr.length - 2].match(ends_with_vowel)
-    let last_is_joining =
-      arr[arr.length - 1].match(joining_consonant_vowel) &&
-      ones.every(re => !arr[arr.length - 1].match(re))
-
-    if (second_to_last_is_open && last_is_joining) {
-      let possible_combination = arr[arr.length - 2] + arr[arr.length - 1]
-      let probably_separate_syllables =
-        possible_combination.match(cvcv_same_consonant) ||
-        possible_combination.match(cvcv_same_vowel) ||
-        possible_combination.match(cvcv_known_consonants)
-
-      if (!probably_separate_syllables) {
-        arr[arr.length - 2] = arr[arr.length - 2] + arr[arr.length - 1]
-        arr.splice(arr.length - 1, 1)
-      }
-    }
-  }
-
-  if (arr.length > 1) {
-    let single = arr[0] + arr[1]
-    if (single.match(starts_with_single_vowel_combos)) {
-      arr[0] = single
-      arr.splice(1, 1)
-    }
-  }
-
-  if (arr.length > 1) {
-    if (arr[arr.length - 1].match(only_one_or_more_c)) {
-      arr[arr.length - 2] = arr[arr.length - 2] + arr[arr.length - 1]
-      arr.splice(arr.length - 1, 1)
-    }
-  }
-
-  return arr
-}
-export default postprocess

package/src/compute/syllables/syllables.js

@@ -1,90 +0,0 @@
-//chop a string into pronounced syllables
-import postProcess from './postProcess.js'
-
-const all_spaces = / +/g
-const ends_with_vowel = /[aeiouy]$/
-const starts_with_consonant_vowel = /^[^aeiouy]h?[aeiouy]/
-const starts_with_e_then_specials = /^e[sm]/
-const starts_with_e = /^e/
-const ends_with_noisy_vowel_combos = /(eo|eu|ia|oa|ua|ui)$/i
-const aiouy = /[aiouy]/
-const ends_with_ee = /ee$/
-// const whitespace_dash = /\s\-/
-
-//method is nested because it's called recursively
-const doWord = function (w) {
-  let all = []
-  let chars = w.split('')
-  let before = ''
-  let after = ''
-  let current = ''
-  for (let i = 0; i < chars.length; i++) {
-    before = chars.slice(0, i).join('')
-    current = chars[i]
-    after = chars.slice(i + 1, chars.length).join('')
-    let candidate = before + chars[i]
-
-    //it's a consonant that comes after a vowel
-    if (before.match(ends_with_vowel) && !current.match(ends_with_vowel)) {
-      if (after.match(starts_with_e_then_specials)) {
-        candidate += 'e'
-        after = after.replace(starts_with_e, '')
-      }
-      all.push(candidate)
-      return all.concat(doWord(after))
-    }
-
-    //unblended vowels ('noisy' vowel combinations)
-    if (candidate.match(ends_with_noisy_vowel_combos)) {
-      //'io' is noisy, not in 'ion'
-      all.push(before)
-      all.push(current)
-      return all.concat(doWord(after)) //recursion
-    }
-
-    // if candidate is followed by a CV, assume consecutive open syllables
-    if (candidate.match(ends_with_vowel) && after.match(starts_with_consonant_vowel)) {
-      all.push(candidate)
-      return all.concat(doWord(after))
-    }
-  }
-  //if still running, end last syllable
-  if (w.match(aiouy) || w.match(ends_with_ee)) {
-    //allow silent trailing e
-    all.push(w)
-  } else if (w) {
-    let last = all.length - 1
-    if (last < 0) {
-      last = 0
-    }
-    all[last] = (all[last] || '') + w //append it to the last one
-  }
-  return all
-}
-
-let syllables = function (str) {
-  let all = []
-  if (!str) {
-    return all
-  }
-  str = str.replace(/[.,?]/g, '')
-  str.split(all_spaces).map(s => {
-    all = all.concat(doWord(s))
-  })
-
-  // str.split(whitespace_dash).forEach(doWord)
-  all = postProcess(all)
-
-  //for words like 'tree' and 'free'
-  if (all.length === 0) {
-    all = [str]
-  }
-  //filter blanks
-  all = all.filter(s => s)
-
-  return all
-}
-
-// console.log(syllables('civilised'))
-
-export default syllables