echogarden 0.12.2 → 1.0.0

package/src/math/VectorMath.ts

@@ -2,7 +2,7 @@ import createMedianFilter from 'moving-median'
 
 export function covarianceMatrixOfSamples(samples: number[][], weights?: number[], biased = false) {
 	if (samples.length == 0) {
-		throw new Error("No vectors given")
+		throw new Error('No vectors given')
 	}
 
 	const { centeredVectors: centeredSamples, mean } = centerVectors(samples, weights)
@@ -22,7 +22,7 @@ export function covarianceMatrixOfCenteredSamples(centeredSamples: number[][], b
 	const sampleCount = centeredSamples.length
 
 	if (sampleCount == 0) {
-		throw new Error("No vectors given")
+		throw new Error('No vectors given')
 	}
 
 	const sampleSizeMetric = biased || sampleCount == 1 ? sampleCount : sampleCount - 1
@@ -64,7 +64,7 @@ export function weightedCovarianceMatrixOfCenteredSamples(centeredSamples: numbe
 	const sampleCount = centeredSamples.length
 
 	if (sampleCount == 0) {
-		throw new Error("No vectors given")
+		throw new Error('No vectors given')
 	}
 
 	const featureCount = centeredSamples[0].length
@@ -165,7 +165,7 @@ export function scaleToSumTo1(vector: number[]) {
 	}
 
 	if (sum == Infinity) {
-		throw new Error("Vector sum is infinite")
+		throw new Error('Vector sum is infinite')
 	}
 
 	for (let i = 0; i < vector.length; i++) {
@@ -177,9 +177,9 @@ export function scaleToSumTo1(vector: number[]) {
 	return scaledVector
 }
 
-export function normalizeVector(vector: number[], kind: "population" | "sample" = "population") {
+export function normalizeVector(vector: number[], kind: 'population' | 'sample' = 'population') {
 	if (vector.length == 0) {
-		throw new Error("Vector is empty")
+		throw new Error('Vector is empty')
 	}
 
 	const mean = meanOfVector(vector)
@@ -196,7 +196,7 @@ export function normalizeVector(vector: number[], kind: "population" | "sample"
 	return { normalizedVector, mean, stdDeviation }
 }
 
-export function normalizeVectors(vectors: number[][], kind: "population" | "sample" = "population") {
+export function normalizeVectors(vectors: number[][], kind: 'population' | 'sample' = 'population') {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
@@ -296,18 +296,18 @@ export function weightedMeanOfVectors(vectors: number[][], weights: number[]) {
 	return result
 }
 
-export function stdDeviationOfVectors(vectors: number[][], kind: "population" | "sample" = "population", mean?: number[]) {
+export function stdDeviationOfVectors(vectors: number[][], kind: 'population' | 'sample' = 'population', mean?: number[]) {
 	return varianceOfVectors(vectors, kind, mean).map(v => Math.sqrt(v))
 }
 
-export function varianceOfVectors(vectors: number[][], kind: "population" | "sample" = "population", mean?: number[]) {
+export function varianceOfVectors(vectors: number[][], kind: 'population' | 'sample' = 'population', mean?: number[]) {
 	const vectorCount = vectors.length
 
 	if (vectorCount == 0) {
 		return []
 	}
 
-	const sampleSizeMetric = kind == "population" || vectorCount == 1 ? vectorCount : vectorCount - 1
+	const sampleSizeMetric = kind == 'population' || vectorCount == 1 ? vectorCount : vectorCount - 1
 	const featureCount = vectors[0].length
 
 	if (!mean) {
@@ -331,7 +331,7 @@ export function varianceOfVectors(vectors: number[][], kind: "population" | "sam
 
 export function meanOfVector(vector: number[]) {
 	if (vector.length == 0) {
-		throw new Error("Vector is empty")
+		throw new Error('Vector is empty')
 	}
 
 	return sumVector(vector) / vector.length
@@ -339,22 +339,22 @@ export function meanOfVector(vector: number[]) {
 
 export function medianOfVector(vector: number[]) {
 	if (vector.length == 0) {
-		throw new Error("Vector is empty")
+		throw new Error('Vector is empty')
 	}
 
 	return vector[Math.floor(vector.length / 2)]
 }
 
-export function stdDeviationOfVector(vector: number[], kind: "population" | "sample" = "population", mean?: number) {
+export function stdDeviationOfVector(vector: number[], kind: 'population' | 'sample' = 'population', mean?: number) {
 	return Math.sqrt(varianceOfVector(vector, kind, mean))
 }
 
-export function varianceOfVector(vector: number[], kind: "population" | "sample" = "population", mean?: number) {
+export function varianceOfVector(vector: number[], kind: 'population' | 'sample' = 'population', mean?: number) {
 	if (vector.length == 0) {
-		throw new Error("Vector is empty")
+		throw new Error('Vector is empty')
 	}
 
-	const sampleSizeMetric = kind == "population" || vector.length == 1 ? vector.length : vector.length - 1
+	const sampleSizeMetric = kind == 'population' || vector.length == 1 ? vector.length : vector.length - 1
 
 	if (mean == null) {
 		mean = meanOfVector(vector)
@@ -370,7 +370,7 @@ export function varianceOfVector(vector: number[], kind: "population" | "sample"
 }
 
 export function logOfVector(vector: number[], minVal = 1e-40) {
-	return vector.map(value => Math.log(minVal + value))
+	return vector.map(value => Math.log(value + minVal))
 }
 
 export function expOfVector(vector: number[]) {
@@ -418,7 +418,7 @@ export function movingAverageOfWindow3(vector: number[]) {
 
 export function averageMeanSquaredError(actual: number[][], expected: number[][]) {
 	if (actual.length != expected.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const vectorCount = actual.length
@@ -438,7 +438,7 @@ export function averageMeanSquaredError(actual: number[][], expected: number[][]
 
 export function meanSquaredError(actual: number[], expected: number[]) {
 	if (actual.length != expected.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const featureCount = actual.length
@@ -456,13 +456,13 @@ export function meanSquaredError(actual: number[], expected: number[]) {
 	return sum / featureCount
 }
 
-export function eucledianDistance(vector1: number[], vector2: number[]) {
-	return Math.sqrt(squaredEucledianDistance(vector1, vector2))
+export function euclidianDistance(vector1: number[], vector2: number[]) {
+	return Math.sqrt(squaredEuclidianDistance(vector1, vector2))
 }
 
-export function squaredEucledianDistance(vector1: number[], vector2: number[]) {
+export function squaredEuclidianDistance(vector1: number[], vector2: number[]) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const elementCount = vector1.length
@@ -486,7 +486,7 @@ export function cosineDistance(vector1: number[], vector2: number[]) {
 
 export function cosineSimilarity(vector1: number[], vector2: number[]) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	if (vector1.length == 0) {
@@ -514,7 +514,7 @@ export function cosineSimilarity(vector1: number[], vector2: number[]) {
 
 export function minkowskiDistance(vector1: number[], vector2: number[], power: number) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const elementCount = vector1.length
@@ -538,7 +538,7 @@ export function cosineDistancePrecomputedMagnitudes(vector1: number[], vector2:
 
 export function cosineSimilarityPrecomputedMagnitudes(vector1: number[], vector2: number[], magnitude1: number, magnitude2: number) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	if (vector1.length == 0) {
@@ -561,7 +561,7 @@ export function cosineSimilarityPrecomputedMagnitudes(vector1: number[], vector2
 
 export function subtractVectors(vector1: number[], vector2: number[]) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const result = createVector(vector1.length)
@@ -585,7 +585,7 @@ export function sumVector(vector: number[]) {
 
 export function dotProduct(vector1: number[], vector2: number[]) {
 	if (vector1.length != vector2.length) {
-		throw new Error("Vectors are not the same length")
+		throw new Error('Vectors are not the same length')
 	}
 
 	const elementCount = vector1.length
@@ -616,10 +616,14 @@ export function maxValue(vector: number[]) {
 }
 
 export function indexOfMax(vector: number[]) {
-	let maxValue = -Infinity
-	let result = -1
+	if (vector.length == 0) {
+		return -1
+	}
 
-	for (let i = 0; i < vector.length; i++) {
+	let maxValue = vector[0]
+	let result = 0
+
+	for (let i = 1; i < vector.length; i++) {
 		if (vector[i] > maxValue) {
 			maxValue = vector[i]
 			result = i
@@ -676,7 +680,7 @@ export function sigmoid(x: number) {
 }
 
 export function softmax(logits: number[], temperature = 1.0) {
-	if (logits.length == 0) {
+	if (logits.length === 0) {
 		return []
 	}
 
@@ -789,7 +793,7 @@ export function sumExp(values: number[]) {
 
 export function logSoftmax(values: number[], minVal = 1e-40) {
 	const softMaxOfValues = softmax(values)
-	
+
 	return logOfVector(softMaxOfValues, minVal)
 }
 
@@ -811,3 +815,8 @@ export class IncrementalMean {
 }
 
 export type DistanceFunction = (a: number[], b: number[]) => number
+
+export interface ComplexNumber {
+	real: number
+	imaginary: number
+}

package/src/nlp/ChineseSegmentation.ts

@@ -4,7 +4,7 @@ export async function splitChineseTextToWords_Jieba(text: string, fineGrained =
 	if (!fineGrained) {
 		return jieba.cut(text, useHMM)
 	} else {
-		const results = jieba.tokenize(text, "search", useHMM)
+		const results = jieba.tokenize(text, 'search', useHMM)
 
 		const startOffsetsSet = new Set<number>()
 		const endOffsetsSet = new Set<number>()
@@ -57,10 +57,10 @@ export async function splitChineseTextToWords_Jieba(text: string, fineGrained =
 	}
 }
 
-let JiebaWasmInstance: typeof import("jieba-wasm")
+let JiebaWasmInstance: typeof import('jieba-wasm')
 async function getWasmInstance() {
 	if (!JiebaWasmInstance) {
-		const { default: JibeaWasm } = await import("jieba-wasm")
+		const { default: JibeaWasm } = await import('jieba-wasm')
 		JiebaWasmInstance = JibeaWasm
 	}
 

package/src/nlp/CompromiseNLP.ts

@@ -32,12 +32,12 @@ export async function parse(text: string): Promise<CompromiseParsedDocument> {
 				endOffset: term.offset.start + term.offset.length
 			}
 
-			if (parsedTerm.text == "") {
+			if (parsedTerm.text == '') {
 				if (parsedSentence.length > 0) {
 					parsedSentence[parsedSentence.length - 1].postText += parsedTerm.preText + parsedTerm.postText
 				}
-			} else if (parsedTerm.tags.includes("Abbreviation") && parsedTerm.postText.startsWith(".")) {
-				parsedTerm.text += "."
+			} else if (parsedTerm.tags.includes('Abbreviation') && parsedTerm.postText.startsWith('.')) {
+				parsedTerm.text += '.'
 				parsedTerm.endOffset += 1
 				parsedSentence.push(parsedTerm)
 			} else {

package/src/nlp/EspeakPhonemizer.ts

@@ -1,13 +1,13 @@
-import * as EspeakTTS from "../synthesis/EspeakTTS.js"
-import { logToStderr } from "../utilities/Utilities.js"
-import * as Segmentation from "./Segmentation.js"
+import * as EspeakTTS from '../synthesis/EspeakTTS.js'
+import { logToStderr } from '../utilities/Utilities.js'
+import * as Segmentation from './Segmentation.js'
 
 const log = logToStderr
 
 export async function phonemizeSentence(sentence: string, espeakVoice: string, substitutionMap?: Map<string, string[]>, useIpa = true) {
 	const ipaString = await EspeakTTS.textToPhonemes(sentence, espeakVoice, useIpa)
 
-	const clauseStrings = ipaString.split(" | ")
+	const clauseStrings = ipaString.split(' | ')
 
 	const clauses: string[][][] = []
 
@@ -20,14 +20,14 @@ export async function phonemizeSentence(sentence: string, espeakVoice: string, s
 		for (let wordIndex = 0; wordIndex < wordStrings.length; wordIndex++) {
 			const word = wordStrings[wordIndex]
 
-			let wordPhonemes = word.split("_")
+			let wordPhonemes = word.split('_')
 
 			wordPhonemes = wordPhonemes.flatMap(phoneme => {
-				if (!phoneme || phoneme.startsWith("(")) {
+				if (!phoneme || phoneme.startsWith('(')) {
 					return []
-				} else if (phoneme.startsWith("ˈ") || phoneme.startsWith("ˌ")) {
+				} else if (phoneme.startsWith(`ˈ`) || phoneme.startsWith(`ˌ`)) {
 					return [phoneme[0], phoneme.substring(1)]
-				} else if (phoneme.endsWith("ˈ") || phoneme.endsWith("ˌ")) {
+				} else if (phoneme.endsWith(`ˈ`) || phoneme.endsWith(`ˌ`)) {
 					return [phoneme.substring(0, phoneme.length - 1), phoneme[phoneme.length - 1]]
 				} else {
 					return substitutionMap?.get(phoneme) || [phoneme]
@@ -49,13 +49,13 @@ export async function phonemizeSentence(sentence: string, espeakVoice: string, s
 
 export async function phonemizeText(text: string, voice: string, substitutionMap?: Map<string, string[]>) {
 	text = text
-			.replaceAll("，", ",")
-			.replaceAll("、", ",")
-			.replaceAll("。", ".")
-			.replaceAll("(", ", ")
-			.replaceAll(")", ", ")
-			.replaceAll("«", ", ")
-			.replaceAll("»", ", ")
+			.replaceAll('，', ',')
+			.replaceAll('、', ',')
+			.replaceAll('。', '.')
+			.replaceAll('(', ', ')
+			.replaceAll(')', ', ')
+			.replaceAll('«', ', ')
+			.replaceAll('»', ', ')
 
 	const segmentedText = await Segmentation.parse(text, voice)
 	const preparedClauses: string[] = []
@@ -64,7 +64,7 @@ export async function phonemizeText(text: string, voice: string, substitutionMap
 	for (const sentence of segmentedText) {
 		for (const clause of sentence.phrases) {
 			const words = clause.words.filter(wordObject => Segmentation.isWordOrSymbolWord(wordObject.text))
-			const preparedClauseText = words.map(word => word.text.replace(/\./g, " ")).join(" ")
+			const preparedClauseText = words.map(word => word.text.replace(/\./g, ' ')).join(' ')
 
 			preparedClauses.push(preparedClauseText)
 
@@ -72,18 +72,18 @@ export async function phonemizeText(text: string, voice: string, substitutionMap
 			const lastChar = trimmedClauseText[trimmedClauseText.length - 1]
 
 			if (clause.isSentenceFinalizer) {
-				if (trimmedClauseText.endsWith('?') || trimmedClauseText.endsWith('?"')) {
+				if (trimmedClauseText.endsWith('?') || trimmedClauseText.endsWith(`?"`)) {
 					clauseBreakers.push('?')
-				} else if (trimmedClauseText.endsWith('!') || trimmedClauseText.endsWith('!"')) {
+				} else if (trimmedClauseText.endsWith('!') || trimmedClauseText.endsWith(`!"`)) {
 					clauseBreakers.push('!')
 				} else {
-					clauseBreakers.push(".")
+					clauseBreakers.push('.')
 				}
 			} else {
 				if (lastChar == ':' || lastChar == ';') {
 					clauseBreakers.push(lastChar)
 				} else {
-					clauseBreakers.push(",")
+					clauseBreakers.push(',')
 				}
 			}
 		}
@@ -97,25 +97,25 @@ export async function phonemizeClauses(clauses: string[], voice: string, clauseB
 		return []
 	}
 
-	const preparedText = clauses.join("\n\n") // filter(clause => clause.trim().length > 0)
+	const preparedText = clauses.join('\n\n') // filter(clause => clause.trim().length > 0)
 
 	const ipaString = await EspeakTTS.textToIPA(preparedText, voice)
 
-	const ipaLines = ipaString.split("\n")
+	const ipaLines = ipaString.split('\n')
 
 	const phonemeLines = ipaLines.map(line => {
-		line = line.replace(/_+/g, "_").replace(/ +/g, " ")
+		line = line.replace(/_+/g, '_').replace(/ +/g, ' ')
 
-		return line.split(" ").map(word => {
-			word = word.replaceAll("_", " ").trim()
-			let wordPhonemes = word.split(" ")
+		return line.split(' ').map(word => {
+			word = word.replaceAll('_', ' ').trim()
+			let wordPhonemes = word.split(' ')
 
 			wordPhonemes = wordPhonemes.flatMap(phoneme => {
-				if (!phoneme || phoneme.startsWith("(")) {
+				if (!phoneme || phoneme.startsWith('(')) {
 					return []
-				} else if (phoneme.startsWith("ˈ") || phoneme.startsWith("ˌ")) {
+				} else if (phoneme.startsWith('ˈ') || phoneme.startsWith('ˌ')) {
 					return [phoneme[0], phoneme.substring(1)]
-				} else if (phoneme.endsWith("ˈ") || phoneme.endsWith("ˌ")) {
+				} else if (phoneme.endsWith('ˈ') || phoneme.endsWith('ˌ')) {
 					return [phoneme.substring(0, phoneme.length - 1), phoneme[phoneme.length - 1]]
 				} else {
 					return [phoneme]
@@ -157,7 +157,7 @@ export function phonemizedClausesToSentences(phonemizedClauses: string[][][]) {
 		const lastWord = phonemizedClause[phonemizedClause.length - 1]
 		const lastPhoneme = lastWord[lastWord.length - 1]
 
-		if ([".", "?", "!"].includes(lastPhoneme)) {
+		if (['.', '?', '!'].includes(lastPhoneme)) {
 			phonemizedSentences.push([])
 		}
 	}

package/src/nlp/IPA.ts

@@ -1,32 +1,32 @@
-import { logToStderr } from "../utilities/Utilities.js"
+import { logToStderr } from '../utilities/Utilities.js'
 
 const log = logToStderr
 
 const consonant = {
-	plosive: ["p", "b", "t", "d", "ʈ", "ɖ", "c", "ɟ", "k", "g", "q", "ɢ", "ʔ", /* extensions */ "ɡ"],
-	nasal: ["m", "ɱ", "n", "ɳ", "ɲ", "ŋ", "ɴ", "n̩"],
-	trill: ["ʙ", "r", "ʀ"],
-	tapOrFlap: ["ⱱ", "ɾ", "ɽ"],
-	fricative: ["ɸ", "β", "f", "v", "θ", "ð", "s", "z", "ʃ", "ʒ", "ʂ", "ʐ", "ç", "ʝ", "x", "ɣ", "χ", "ʁ", "ħ", "ʕ", "h", "ɦ"],
-	lateralFricative: ["ɬ", "ɮ"],
-	affricate: ["tʃ", "ʈʃ", "dʒ"], // very incomplete, there are many others
-	approximant: ["ʋ", "ɹ", "ɻ", "j", "ɰ", /* extensions */ "w"],
-	lateralApproximant: ["l", "ɭ", "ʎ", "ʟ"]
+	plosive: ['p', 'b', 't', 'd', 'ʈ', 'ɖ', 'c', 'ɟ', 'k', 'g', 'q', 'ɢ', 'ʔ', /* extensions */ 'ɡ'],
+	nasal: ['m', 'ɱ', 'n', 'ɳ', 'ɲ', 'ŋ', 'ɴ', 'n̩'],
+	trill: ['ʙ', 'r', 'ʀ'],
+	tapOrFlap: ['ⱱ', 'ɾ', 'ɽ'],
+	fricative: ['ɸ', 'β', 'f', 'v', 'θ', 'ð', 's', 'z', 'ʃ', 'ʒ', 'ʂ', 'ʐ', 'ç', 'ʝ', 'x', 'ɣ', 'χ', 'ʁ', 'ħ', 'ʕ', 'h', 'ɦ'],
+	lateralFricative: ['ɬ', 'ɮ'],
+	affricate: ['tʃ', 'ʈʃ', 'dʒ'], // very incomplete, there are many others
+	approximant: ['ʋ', 'ɹ', 'ɻ', 'j', 'ɰ', /* extensions */ 'w'],
+	lateralApproximant: ['l', 'ɭ', 'ʎ', 'ʟ']
 }
 
 const vowel = {
-	close: ["i", "yɨ", "ʉɯ", "u", "iː"],
-	closeOther: ["ɪ", "ʏ", "ʊ", "ɨ", "ᵻ"],
-	closeMid: ["e", "ø", "ɘ", "ɵ", "ɤ", "o", "ə", "oː"],
-	openMid: ["ɛ", "œ", "ɜ", "ɞ", "ʌ", "ɔ", "ɜː", "uː", "ɔː", "ɛː"],
-	open: ["æ", "a", "ɶ", "ɐ", "ɑ", "ɒ", "ɑː"],
+	close: ['i', 'yɨ', 'ʉɯ', 'u', 'iː'],
+	closeOther: ['ɪ', 'ʏ', 'ʊ', 'ɨ', 'ᵻ'],
+	closeMid: ['e', 'ø', 'ɘ', 'ɵ', 'ɤ', 'o', 'ə', 'oː'],
+	openMid: ['ɛ', 'œ', 'ɜ', 'ɞ', 'ʌ', 'ɔ', 'ɜː', 'uː', 'ɔː', 'ɛː'],
+	open: ['æ', 'a', 'ɶ', 'ɐ', 'ɑ', 'ɒ', 'ɑː'],
 
-	rhotic: ["◌˞", "ɚ", "ɝ", "ɹ̩"],
+	rhotic: ['◌˞', 'ɚ', 'ɝ', 'ɹ̩'],
 
 	diphtongs: [
-		"eɪ", "əʊ", "oʊ", "aɪ", "ɔɪ", "aʊ", "iə",
-		"ɜr", "ɑr", "ɔr", "oʊr", "oːɹ", "ir", "ɪɹ", "ɔːɹ", "ɑːɹ", "ʊɹ", "ʊr", "ɛr", "ɛɹ",
-		"əl", "aɪɚ", "aɪə"
+		'eɪ', 'əʊ', 'oʊ', 'aɪ', 'ɔɪ', 'aʊ', 'iə',
+		'ɜr', 'ɑr', 'ɔr', 'oʊr', 'oːɹ', 'ir', 'ɪɹ', 'ɔːɹ', 'ɑːɹ', 'ʊɹ', 'ʊr', 'ɛr', 'ɛɹ',
+		'əl', 'aɪɚ', 'aɪə'
 	],
 }
 
@@ -42,7 +42,7 @@ for (const p in vowel) {
 	vowels = [...vowels, ...(vowel as any)[p]]
 }
 
-const all = [" ", ...consonants, ...vowels]
+const all = [' ', ...consonants, ...vowels]
 
 export function getPhoneSubstitutionCost1(ipa1: string, ipa2: string) {
 	if (ipa1 == ipa2) {

package/src/nlp/JapaneseSegmentation.ts

@@ -1,6 +1,6 @@
-import path from "path"
-import { OpenPromise } from "../utilities/OpenPromise.js"
-import { resolveModuleScriptPath } from "../utilities/Utilities.js"
+import path from 'path'
+import { OpenPromise } from '../utilities/OpenPromise.js'
+import { resolveModuleScriptPath } from '../utilities/Utilities.js'
 
 export async function splitJapaneseTextToWords_Kuromoji(text: string) {
 	const tokenizer = await getKuromojiTokenizer()
@@ -18,12 +18,12 @@ async function getKuromojiTokenizer() {
 		return kuromojiTokenizer
 	}
 
-	const { default: kuromoji } = await import("kuromoji")
+	const { default: kuromoji } = await import('kuromoji')
 
 	const resultOpenPromise = new OpenPromise<any>()
 
 	const kuromojiScriptPath = await resolveModuleScriptPath('kuromoji')
-	const dictionaryPath = path.join(path.dirname(kuromojiScriptPath), "..", '/dict')
+	const dictionaryPath = path.join(path.dirname(kuromojiScriptPath), '..', '/dict')
 
 	kuromoji.builder({ dicPath: dictionaryPath }).build(function (error: any, tokenizer: any) {
 		if (error) {
@@ -41,7 +41,7 @@ async function getKuromojiTokenizer() {
 
 /*
 export async function splitJapaneseTextToWords_Sudachi(text: string, mode: 0 | 1 | 2) {
-	const { TokenizeMode, tokenize } = await import("sudachi")
+	const { TokenizeMode, tokenize } = await import('sudachi')
 
 	const resultString = tokenize(text, mode)
 

package/src/nlp/Lexicon.ts

@@ -1,6 +1,6 @@
-import { readAndParseJsonFile } from "../utilities/FileSystem.js"
-import { getShortLanguageCode } from "../utilities/Locale.js"
-import { resolveToModuleRootDir } from "../utilities/PathUtilities.js"
+import { readAndParseJsonFile } from '../utilities/FileSystem.js'
+import { getShortLanguageCode } from '../utilities/Locale.js'
+import { resolveToModuleRootDir } from '../utilities/PathUtilities.js'
 
 export function tryGetFirstLexiconSubstitution(sentenceWords: string[], wordIndex: number, lexicons: Lexicon[], languageCode: string) {
 	const reversedLexicons = [...lexicons].reverse() // Give precedence to later lexicons
@@ -45,8 +45,8 @@ export function tryGetLexiconSubstitution(sentenceWords: string[], wordIndex: nu
 			continue
 		}
 
-		const precedingWord = sentenceWords[wordIndex - 1] || ""
-		const succeedingWord = sentenceWords[wordIndex + 1] || ""
+		const precedingWord = sentenceWords[wordIndex - 1] || ''
+		const succeedingWord = sentenceWords[wordIndex + 1] || ''
 
 		const precededBy = substitutionEntry?.precededBy || []
 		const notPrecededBy = substitutionEntry?.notPrecededBy || []
@@ -76,8 +76,8 @@ export async function loadLexiconFile(jsonFilePath: string): Promise<Lexicon> {
 export async function loadLexiconsForLanguage(language: string, customLexiconPaths?: string[]) {
 	const lexicons: Lexicon[] = []
 
-	if (getShortLanguageCode(language) == "en") {
-		const heteronymsLexicon = await loadLexiconFile(resolveToModuleRootDir("data/lexicons/heteronyms.en.json"))
+	if (getShortLanguageCode(language) == 'en') {
+		const heteronymsLexicon = await loadLexiconFile(resolveToModuleRootDir('data/lexicons/heteronyms.en.json'))
 		lexicons.push(heteronymsLexicon)
 	}
 
@@ -118,5 +118,5 @@ export type LexiconEntry = {
 	example?: string
 }
 
-export type LexiconWordCase = "any" | "capitalized" | "uppercase" | "lowercase" | "titlecase" | "camelcase" | "pascalcase"
+export type LexiconWordCase = 'any' | 'capitalized' | 'uppercase' | 'lowercase' | 'titlecase' | 'camelcase' | 'pascalcase'
 export type LexiconPronunciationForLanguageCodes = { [languageCode: string]: string }