echogarden 0.12.2 → 1.0.1

package/src/server/Client.ts

@@ -1,6 +1,6 @@
 import { WebSocket } from 'ws'
 import { encode as encodeMsgPack, decode as decodeMsgPack } from 'msgpack-lite'
-import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEvent, SynthesisResult, VoiceListRequestOptions } from "../api/Synthesis.js"
+import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEvent, SynthesisResult, VoiceListRequestOptions } from '../api/Synthesis.js'
 import { SynthesisResponseMessage, SynthesisSegmentEventMessage, SynthesisSentenceEventMessage, VoiceListRequestMessage, WorkerRequestMessage, VoiceListResponseMessage, AlignmentRequestMessage, AlignmentResponseMessage, RecognitionRequestMessage, RecognitionResponseMessage, SpeechTranslationRequestMessage, SpeechTranslationResponseMessage, SpeechLanguageDetectionRequestMessage, SpeechLanguageDetectionResponseMessage, TextLanguageDetectionResponseMessage, TextLanguageDetectionRequestMessage, SynthesisRequestMessage } from './Worker.js'
 import { getRandomHexString, logToStderr } from '../utilities/Utilities.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
@@ -20,9 +20,9 @@ export class Client {
 
 	constructor(sourceChannel: WebSocket | WorkerThread) {
 		if (sourceChannel instanceof WebSocket) {
-			sourceChannel.on("message", (messageData, isBinary) => {
+			sourceChannel.on('message', (messageData, isBinary) => {
 				if (!isBinary) {
-					log(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString("utf-8")}'`)
+					log(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString('utf-8')}'`)
 					return
 				}
 
@@ -44,11 +44,11 @@ export class Client {
 				sourceChannel.send(encodedMessage)
 			}
 		} else if (sourceChannel instanceof WorkerThread) {
-			sourceChannel.on("message", (message) => {
+			sourceChannel.on('message', (message) => {
 				this.onMessage(message)
 			})
 
-			sourceChannel.on("error", (e) => {
+			sourceChannel.on('error', (e) => {
 				throw e
 			})
 
@@ -64,17 +64,17 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<SynthesisResult>()
 
 		const requestMessage: SynthesisRequestMessage = {
-			messageType: "SynthesisRequest",
+			messageType: 'SynthesisRequest',
 			input,
 			options
 		}
 
 		function onResponse(responseMessage: SynthesisResponseMessage | SynthesisSegmentEventMessage | SynthesisSentenceEventMessage) {
-			if (responseMessage.messageType == "SynthesisResponse") {
+			if (responseMessage.messageType == 'SynthesisResponse') {
 				requestOpenPromise.resolve(responseMessage)
-			} else if (responseMessage.messageType == "SynthesisSegmentEvent" && onSegment) {
+			} else if (responseMessage.messageType == 'SynthesisSegmentEvent' && onSegment) {
 				onSegment(responseMessage)
-			} else if (responseMessage.messageType == "SynthesisSentenceEvent" && onSentence) {
+			} else if (responseMessage.messageType == 'SynthesisSentenceEvent' && onSentence) {
 				onSentence(responseMessage)
 			}
 		}
@@ -96,12 +96,12 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<RequestVoiceListResult>()
 
 		const requestMessage: VoiceListRequestMessage = {
-			messageType: "VoiceListRequest",
+			messageType: 'VoiceListRequest',
 			options
 		}
 
 		function onResponse(responseMessage: VoiceListResponseMessage) {
-			if (responseMessage.messageType == "VoiceListResponse") {
+			if (responseMessage.messageType == 'VoiceListResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -123,13 +123,13 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<RecognitionResult>()
 
 		const requestMessage: RecognitionRequestMessage = {
-			messageType: "RecognitionRequest",
+			messageType: 'RecognitionRequest',
 			input,
 			options
 		}
 
 		function onResponse(responseMessage: RecognitionResponseMessage) {
-			if (responseMessage.messageType == "RecognitionResponse") {
+			if (responseMessage.messageType == 'RecognitionResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -150,14 +150,14 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<AlignmentResult>()
 
 		const requestMessage: AlignmentRequestMessage = {
-			messageType: "AlignmentRequest",
+			messageType: 'AlignmentRequest',
 			input,
 			transcript,
 			options
 		}
 
 		function onResponse(responseMessage: AlignmentResponseMessage) {
-			if (responseMessage.messageType == "AlignmentResponse") {
+			if (responseMessage.messageType == 'AlignmentResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -179,13 +179,13 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<SpeechTranslationResult>()
 
 		const requestMessage: SpeechTranslationRequestMessage = {
-			messageType: "SpeechTranslationRequest",
+			messageType: 'SpeechTranslationRequest',
 			input,
 			options
 		}
 
 		function onResponse(responseMessage: SpeechTranslationResponseMessage) {
-			if (responseMessage.messageType == "SpeechTranslationResponse") {
+			if (responseMessage.messageType == 'SpeechTranslationResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -207,13 +207,13 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<SpeechLanguageDetectionResult>()
 
 		const requestMessage: SpeechLanguageDetectionRequestMessage = {
-			messageType: "SpeechLanguageDetectionRequest",
+			messageType: 'SpeechLanguageDetectionRequest',
 			input,
 			options
 		}
 
 		function onResponse(responseMessage: SpeechLanguageDetectionResponseMessage) {
-			if (responseMessage.messageType == "SpeechLanguageDetectionResponse") {
+			if (responseMessage.messageType == 'SpeechLanguageDetectionResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -235,13 +235,13 @@ export class Client {
 		const requestOpenPromise = new OpenPromise<TextLanguageDetectionResult>()
 
 		const requestMessage: TextLanguageDetectionRequestMessage = {
-			messageType: "TextLanguageDetectionRequest",
+			messageType: 'TextLanguageDetectionRequest',
 			input,
 			options
 		}
 
 		function onResponse(responseMessage: TextLanguageDetectionResponseMessage) {
-			if (responseMessage.messageType == "TextLanguageDetectionResponse") {
+			if (responseMessage.messageType == 'TextLanguageDetectionResponse') {
 				requestOpenPromise.resolve(responseMessage)
 			}
 		}
@@ -270,7 +270,7 @@ export class Client {
 		this.sendMessage(request)
 
 		function onResponseMessage(message: any) {
-			if (message.messageType == "Error") {
+			if (message.messageType == 'Error') {
 				onErrorResponse(message.error)
 			} else {
 				onResponse(message)
@@ -284,7 +284,7 @@ export class Client {
 		const requestId = incomingMessage.requestId
 
 		if (!requestId) {
-			log("Received a WebSocket message without a request ID")
+			log('Received a WebSocket message without a request ID')
 			return
 		}
 

package/src/server/Server.ts

@@ -22,7 +22,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 
 	function onHttpRequest(request: IncomingMessage, response: ServerResponse) {
 		response.writeHead(200, { 'Content-Type': 'text/plain' })
-		response.end("This is the Echogarden HTTP server!")
+		response.end('This is the Echogarden HTTP server!')
 	}
 
 	if (serverOptions.secure) {
@@ -59,7 +59,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 	const requestIdToWebSocket = new Map<string, WebSocket>()
 
 	function onWorkerMessage(message: any) {
-		if (message.name == "writeToStdErr") {
+		if (message.name == 'writeToStdErr') {
 			return
 		}
 
@@ -67,7 +67,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 		message['inputRawAudio'] = undefined
 
 		if (!message.requestId) {
-			throw new Error("Worker message doesn't have a request ID")
+			throw new Error(`Worker message doesn't have a request ID`)
 		}
 
 		const ws = requestIdToWebSocket.get(message.requestId)
@@ -93,12 +93,12 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 
 	const serverOpenPromise = new OpenPromise<void>
 
-	wss.on("listening", () => {
+	wss.on('listening', () => {
 		log(chalk.gray(`Started Echogarden WebSocket server on port ${serverOptions.port}`))
 		onStarted(serverOptions)
 	})
 
-	wss.on("close", () => {
+	wss.on('close', () => {
 		serverOpenPromise.resolve()
 	})
 
@@ -107,7 +107,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 
 		ws.on('message', (messageData, isBinary) => {
 			if (!isBinary) {
-				log(chalk.gray((`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString("utf-8")}'`)))
+				log(chalk.gray(`Received an unexpected string WebSocket message: '${(messageData as Buffer).toString('utf-8')}'`))
 				return
 			}
 
@@ -123,7 +123,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 			const requestId = incomingMessage.requestId
 
 			if (!requestId) {
-				log(chalk.gray(("Received a WebSocket message without a request ID")))
+				log(chalk.gray('Received a WebSocket message without a request ID'))
 				return
 			}
 
@@ -140,7 +140,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 			log(`${chalk.redBright('WebSocket error')}: ${e.message}`)
 		})
 
-		ws.on("close", () => {
+		ws.on('close', () => {
 			const keysToDelete: string[] = []
 
 			requestIdToWebSocket.forEach((value, key) => {
@@ -151,7 +151,7 @@ export async function startServer(serverOptions: ServerOptions, onStarted: (opti
 
 			keysToDelete.forEach(key => requestIdToWebSocket.delete(key))
 
-			log(chalk.gray((`Incoming connection from ${ req.socket.remoteAddress } was closed`)))
+			log(chalk.gray(`Incoming connection from ${ req.socket.remoteAddress } was closed`))
 		})
 	})
 

package/src/server/Worker.ts

@@ -1,16 +1,16 @@
-import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEventData, SynthesisResult, VoiceListRequestOptions, requestVoiceList, synthesize } from "../api/Synthesis.js"
-import { Queue } from "../utilities/Queue.js"
-import { logToStderr, yieldToEventLoop } from "../utilities/Utilities.js"
-import { AudioSourceParam } from "../audio/AudioUtilities.js"
-import { RecognitionOptions, RecognitionResult, recognize } from "../api/Recognition.js"
-import { AlignmentOptions, AlignmentResult, align } from "../api/Alignment.js"
-import { SpeechTranslationOptions, SpeechTranslationResult, translateSpeech } from "../api/Translation.js"
-import { resetActiveLogger } from "../utilities/Logger.js"
+import { RequestVoiceListResult, SynthesisOptions, SynthesisSegmentEventData, SynthesisResult, VoiceListRequestOptions, requestVoiceList, synthesize } from '../api/Synthesis.js'
+import { Queue } from '../utilities/Queue.js'
+import { logToStderr, yieldToEventLoop } from '../utilities/Utilities.js'
+import { AudioSourceParam } from '../audio/AudioUtilities.js'
+import { RecognitionOptions, RecognitionResult, recognize } from '../api/Recognition.js'
+import { AlignmentOptions, AlignmentResult, align } from '../api/Alignment.js'
+import { SpeechTranslationOptions, SpeechTranslationResult, translateSpeech } from '../api/Translation.js'
+import { resetActiveLogger } from '../utilities/Logger.js'
 import { writeToStderr } from '../utilities/Utilities.js'
 import { Worker, SHARE_ENV } from 'node:worker_threads'
-import { SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult, TextLanguageDetectionOptions, TextLanguageDetectionResult, detectSpeechLanguage, detectTextLanguage } from "../api/LanguageDetection.js"
-import chalk from "chalk"
-import { resolveToModuleRootDir } from "../utilities/PathUtilities.js"
+import { SpeechLanguageDetectionOptions, SpeechLanguageDetectionResult, TextLanguageDetectionOptions, TextLanguageDetectionResult, detectSpeechLanguage, detectTextLanguage } from '../api/LanguageDetection.js'
+import chalk from 'chalk'
+import { resolveToModuleRootDir } from '../utilities/PathUtilities.js'
 
 const log = logToStderr
 
@@ -33,7 +33,7 @@ export function startMessageChannel() {
 	messageChannel.port2.start()
 
 	addListenerToClientMessages((message) => {
-		if (message.messageType == "CancelationRequest") {
+		if (message.messageType == 'CancelationRequest' || message.messageType == 'CancellationRequest') {
 			//log(`CANCEL REQUESTED FOR ${message.requestId}`)
 			canceledRequests.add(message.requestId)
 			return
@@ -70,7 +70,7 @@ async function processQueueIfIdle() {
 			})
 		}
 
-		function setCancelationFlagIfNeeded() {
+		function setCancellationFlagIfNeeded() {
 			if (canceledRequests.has(requestId)) {
 				cancelCurrentTask = true
 				canceledRequests.delete(requestId)
@@ -79,28 +79,28 @@ async function processQueueIfIdle() {
 
 		await yieldToEventLoop()
 
-		setCancelationFlagIfNeeded()
-		const cancelationFlagSetterInterval = setInterval(setCancelationFlagIfNeeded, 20)
+		setCancellationFlagIfNeeded()
+		const cancellationFlagSetterInterval = setInterval(setCancellationFlagIfNeeded, 20)
 
 		try {
 			if (cancelCurrentTask) {
 				//log(`******* CANCELED BEFORE START: ${requestId} *******`)
-				throw new Error("Canceled")
+				throw new Error('Canceled')
 			}
 
 			await processMessage(incomingMessage, sendMessage)
 		} catch (e: any) {
-			log(`${chalk.redBright("Error")}: ${e.message}`)
+			log(`${chalk.redBright('Error')}: ${e.message}`)
 
 			sendMessageToClient({
 				requestId,
-				messageType: "Error",
+				messageType: 'Error',
 				error: e
 			})
 		} finally {
 			resetActiveLogger()
 
-			clearInterval(cancelationFlagSetterInterval)
+			clearInterval(cancellationFlagSetterInterval)
 			cancelCurrentTask = false
 		}
 	}
@@ -110,37 +110,37 @@ async function processQueueIfIdle() {
 
 export async function processMessage(message: WorkerRequestMessage, sendMessage: MessageFunc) {
 	switch (message.messageType) {
-		case "SynthesisRequest": {
+		case 'SynthesisRequest': {
 			await processSynthesisRequest(message, sendMessage)
 			break
 		}
 
-		case "VoiceListRequest": {
+		case 'VoiceListRequest': {
 			await processVoiceListRequest(message, sendMessage)
 			break
 		}
 
-		case "RecognitionRequest": {
+		case 'RecognitionRequest': {
 			await processRecognitionRequest(message, sendMessage)
 			break
 		}
 
-		case "AlignmentRequest": {
+		case 'AlignmentRequest': {
 			await processAlignmentRequest(message, sendMessage)
 			break
 		}
 
-		case "SpeechTranslationRequest": {
+		case 'SpeechTranslationRequest': {
 			await processSpeechTranslationRequest(message, sendMessage)
 			break
 		}
 
-		case "SpeechLanguageDetectionRequest": {
+		case 'SpeechLanguageDetectionRequest': {
 			await processSpeechLanguageDetectionRequest(message, sendMessage)
 			break
 		}
 
-		case "TextLanguageDetectionRequest": {
+		case 'TextLanguageDetectionRequest': {
 			await processTextLanguageDetectionRequest(message, sendMessage)
 			break
 		}
@@ -157,7 +157,7 @@ export async function processMessage(message: WorkerRequestMessage, sendMessage:
 async function processSynthesisRequest(message: SynthesisRequestMessage, sendMessage: MessageFunc) {
 	async function onSegment(eventData: SynthesisSegmentEventData) {
 		const responseMessage: SynthesisSegmentEventMessage = {
-			messageType: "SynthesisSegmentEvent",
+			messageType: 'SynthesisSegmentEvent',
 			...eventData
 		}
 
@@ -166,7 +166,7 @@ async function processSynthesisRequest(message: SynthesisRequestMessage, sendMes
 
 	async function onSentence(eventData: SynthesisSegmentEventData) {
 		const responseMessage: SynthesisSentenceEventMessage = {
-			messageType: "SynthesisSentenceEvent",
+			messageType: 'SynthesisSentenceEvent',
 			...eventData
 		}
 
@@ -176,7 +176,7 @@ async function processSynthesisRequest(message: SynthesisRequestMessage, sendMes
 	const result = await synthesize(message.input, message.options, onSegment, onSentence)
 
 	const responseMessage: SynthesisResponseMessage = {
-		messageType: "SynthesisResponse",
+		messageType: 'SynthesisResponse',
 		...result
 	}
 
@@ -185,28 +185,28 @@ async function processSynthesisRequest(message: SynthesisRequestMessage, sendMes
 
 // Synthesis message types
 export interface SynthesisRequestMessage extends WorkerMessageBase {
-	messageType: "SynthesisRequest"
+	messageType: 'SynthesisRequest'
 	input: string | string[]
 	options: SynthesisOptions
 }
 
 export interface SynthesisResponseMessage extends WorkerMessageBase, SynthesisResult {
-	messageType: "SynthesisResponse"
+	messageType: 'SynthesisResponse'
 }
 
 export interface SynthesisSegmentEventMessage extends WorkerMessageBase, SynthesisSegmentEventData {
-	messageType: "SynthesisSegmentEvent"
+	messageType: 'SynthesisSegmentEvent'
 }
 
 export interface SynthesisSentenceEventMessage extends WorkerMessageBase, SynthesisSegmentEventData {
-	messageType: "SynthesisSentenceEvent"
+	messageType: 'SynthesisSentenceEvent'
 }
 
 async function processVoiceListRequest(message: VoiceListRequestMessage, sendMessage: MessageFunc) {
 	const result = await requestVoiceList(message.options)
 
 	const responseMessage: VoiceListResponseMessage = {
-		messageType: "VoiceListResponse",
+		messageType: 'VoiceListResponse',
 		...result
 	}
 
@@ -215,12 +215,12 @@ async function processVoiceListRequest(message: VoiceListRequestMessage, sendMes
 
 // Voice list message types
 export interface VoiceListRequestMessage extends WorkerMessageBase {
-	messageType: "VoiceListRequest"
+	messageType: 'VoiceListRequest'
 	options: VoiceListRequestOptions
 }
 
 export interface VoiceListResponseMessage extends WorkerMessageBase, RequestVoiceListResult {
-	messageType: "VoiceListResponse"
+	messageType: 'VoiceListResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -230,7 +230,7 @@ async function processRecognitionRequest(message: RecognitionRequestMessage, sen
 	const result = await recognize(message.input, message.options)
 
 	const responseMessage: RecognitionResponseMessage = {
-		messageType: "RecognitionResponse",
+		messageType: 'RecognitionResponse',
 		...result
 	}
 
@@ -239,13 +239,13 @@ async function processRecognitionRequest(message: RecognitionRequestMessage, sen
 
 // Recognition message types
 export interface RecognitionRequestMessage extends WorkerMessageBase {
-	messageType: "RecognitionRequest"
+	messageType: 'RecognitionRequest'
 	input: AudioSourceParam
 	options: RecognitionOptions
 }
 
 export interface RecognitionResponseMessage extends WorkerMessageBase, RecognitionResult {
-	messageType: "RecognitionResponse"
+	messageType: 'RecognitionResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -255,7 +255,7 @@ async function processAlignmentRequest(message: AlignmentRequestMessage, sendMes
 	const result = await align(message.input, message.transcript, message.options)
 
 	const responseMessage: AlignmentResponseMessage = {
-		messageType: "AlignmentResponse",
+		messageType: 'AlignmentResponse',
 		...result
 	}
 
@@ -264,14 +264,14 @@ async function processAlignmentRequest(message: AlignmentRequestMessage, sendMes
 
 // Alignment message types
 export interface AlignmentRequestMessage extends WorkerMessageBase {
-	messageType: "AlignmentRequest"
+	messageType: 'AlignmentRequest'
 	input: AudioSourceParam
 	transcript: string
 	options: AlignmentOptions
 }
 
 export interface AlignmentResponseMessage extends WorkerMessageBase, AlignmentResult {
-	messageType: "AlignmentResponse"
+	messageType: 'AlignmentResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -281,7 +281,7 @@ async function processSpeechTranslationRequest(message: SpeechTranslationRequest
 	const result = await translateSpeech(message.input, message.options)
 
 	const responseMessage: SpeechTranslationResponseMessage = {
-		messageType: "SpeechTranslationResponse",
+		messageType: 'SpeechTranslationResponse',
 		...result
 	}
 
@@ -290,13 +290,13 @@ async function processSpeechTranslationRequest(message: SpeechTranslationRequest
 
 // Speech translation message types
 export interface SpeechTranslationRequestMessage extends WorkerMessageBase {
-	messageType: "SpeechTranslationRequest"
+	messageType: 'SpeechTranslationRequest'
 	input: AudioSourceParam
 	options: SpeechTranslationOptions
 }
 
 export interface SpeechTranslationResponseMessage extends WorkerMessageBase, SpeechTranslationResult {
-	messageType: "SpeechTranslationResponse"
+	messageType: 'SpeechTranslationResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -306,7 +306,7 @@ async function processSpeechLanguageDetectionRequest(message: SpeechLanguageDete
 	const result = await detectSpeechLanguage(message.input, message.options)
 
 	const responseMessage: SpeechLanguageDetectionResponseMessage = {
-		messageType: "SpeechLanguageDetectionResponse",
+		messageType: 'SpeechLanguageDetectionResponse',
 		...result
 	}
 
@@ -315,13 +315,13 @@ async function processSpeechLanguageDetectionRequest(message: SpeechLanguageDete
 
 // Speech language detection message types
 export interface SpeechLanguageDetectionRequestMessage extends WorkerMessageBase {
-	messageType: "SpeechLanguageDetectionRequest"
+	messageType: 'SpeechLanguageDetectionRequest'
 	input: AudioSourceParam
 	options: SpeechLanguageDetectionOptions
 }
 
 export interface SpeechLanguageDetectionResponseMessage extends WorkerMessageBase, SpeechLanguageDetectionResult {
-	messageType: "SpeechLanguageDetectionResponse"
+	messageType: 'SpeechLanguageDetectionResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -331,7 +331,7 @@ async function processTextLanguageDetectionRequest(message: TextLanguageDetectio
 	const result = await detectTextLanguage(message.input, message.options)
 
 	const responseMessage: TextLanguageDetectionResponseMessage = {
-		messageType: "TextLanguageDetectionResponse",
+		messageType: 'TextLanguageDetectionResponse',
 		...result
 	}
 
@@ -340,13 +340,13 @@ async function processTextLanguageDetectionRequest(message: TextLanguageDetectio
 
 // Text language detection message types
 export interface TextLanguageDetectionRequestMessage extends WorkerMessageBase {
-	messageType: "TextLanguageDetectionRequest"
+	messageType: 'TextLanguageDetectionRequest'
 	input: string
 	options: TextLanguageDetectionOptions
 }
 
 export interface TextLanguageDetectionResponseMessage extends WorkerMessageBase, TextLanguageDetectionResult {
-	messageType: "TextLanguageDetectionResponse"
+	messageType: 'TextLanguageDetectionResponse'
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
@@ -395,8 +395,8 @@ export async function startNewWorkerThread() {
 		env: SHARE_ENV
 	})
 
-	workerThread.on("message", (message) => {
-		if (message.name == "writeToStdErr") {
+	workerThread.on('message', (message) => {
+		if (message.name == 'writeToStdErr') {
 			writeToStderr(message.text)
 		}
 	})

package/src/server/WorkerStarter.ts

@@ -15,7 +15,7 @@ async function startIfInWorkerThread() {
 
 	const initOpenPromise = new OpenPromise<void>()
 
-	parentPort.once("message", (message) => {
+	parentPort.once('message', (message) => {
 		if (message.name == 'init') {
 			process.stderr.isTTY = message.stdErrIsTTY
 			process.stderr.hasColors = () => message.hasColors
@@ -31,7 +31,7 @@ async function startIfInWorkerThread() {
 
 	await initOpenPromise.promise
 
-	parentPort.on("message", (message: any) => {
+	parentPort.on('message', (message: any) => {
 		sendMessageToWorker(message)
 	})
 }