echogarden 2.6.0 → 2.8.0

package/src/dsp/SpeexResampler.ts

@@ -1,6 +1,6 @@
 import { RawAudio, cloneRawAudio } from '../audio/AudioUtilities.js'
 import { concatFloat32Arrays, isWasmSimdSupported } from '../utilities/Utilities.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+import { wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
 
 let speexResamplerInstance: any
 
@@ -23,17 +23,17 @@ export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: numb
 	}
 
 	const m = await getSpeexResamplerInstance()
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	function speexResultCodeToString(resultCode: number) {
 		const errorStrPtr = m._speex_resampler_strerror(resultCode)
-		const errorStrRef = wasmMemory.wrapUint8Array(errorStrPtr, 1024)
-		const message = errorStrRef.readAsNullTerminatedUtf8String()
+		const messageRef = wasmHeap.wrapNullTerminatedUtf8String(errorStrPtr)
+		const message = messageRef.value
 
 		return message
 	}
 
-	const initErrRef = wasmMemory.allocInt32()
+	const initErrRef = wasmHeap.allocInt32()
 	const resamplerStateAddress = m._speex_resampler_init(channelCount, inSampleRate, outSampleRate, quality, initErrRef.address)
 	let resultCode = initErrRef.value
 
@@ -46,11 +46,11 @@ export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: numb
 
 	const maxChunkSize = 2 ** 20
 
-	const inputChunkSampleCountRef = wasmMemory.allocInt32()
-	const outputChunkSampleCountRef = wasmMemory.allocInt32()
+	const inputChunkSampleCountRef = wasmHeap.allocInt32()
+	const outputChunkSampleCountRef = wasmHeap.allocInt32()
 
-	const inputChunkSamplesRef = wasmMemory.allocFloat32Array(maxChunkSize * 2)
-	const outputChunkSamplesRef = wasmMemory.allocFloat32Array(Math.floor(maxChunkSize * sampleRateRatio) * 2)
+	const inputChunkSamplesRef = wasmHeap.allocFloat32Array(maxChunkSize * 2)
+	const outputChunkSamplesRef = wasmHeap.allocFloat32Array(Math.floor(maxChunkSize * sampleRateRatio) * 2)
 
 	const resampledAudioChunksForChannels: Float32Array[][] = []
 
@@ -65,7 +65,7 @@ export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: numb
 			const inputPaddingSize = isLastChunk ? inputLatency : 0
 			const maxSamplesToRead = Math.min(maxChunkSize, totalSampleCount - readOffset) + inputPaddingSize
 
-			const maxSamplesToWrite = outputChunkSamplesRef.length
+			const maxSamplesToWrite = outputChunkSamplesRef.elementCount
 
 			const inputChunkSamplesForChannel = rawAudio.audioChannels[channelIndex].slice(readOffset, readOffset + maxSamplesToRead)
 
@@ -91,7 +91,7 @@ export async function resampleAudioSpeex(rawAudio: RawAudio, outSampleRate: numb
 	}
 
 	m._speex_resampler_destroy(resamplerStateAddress)
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	const resampledAudio: RawAudio = {
 		audioChannels: [],

package/src/encodings/Ascii.ts

@@ -49,7 +49,7 @@ export class ChunkedAsciiDecoder {
 	private readonly textDecoder = new TextDecoder('windows-1252')
 
 	writeChunk(chunk: Uint8Array) {
-		const decodedChunk = this.textDecoder.decode(chunk)
+		const decodedChunk = this.textDecoder.decode(chunk, { stream: true })
 
 		this.str += decodedChunk
 	}

package/src/encodings/Utf16.ts

@@ -41,7 +41,7 @@ export class ChunkedUtf16Decoder {
 	private readonly textDecoder = new TextDecoder('utf-16le')
 
 	writeChunk(chunk: Uint16Array) {
-		const decodedChunk = this.textDecoder.decode(chunk)
+		const decodedChunk = this.textDecoder.decode(chunk, { stream: true })
 
 		this.str += decodedChunk
 	}

package/src/encodings/Utf8.ts

@@ -33,7 +33,7 @@ export class ChunkedUtf8Decoder {
 	private readonly textDecoder = new TextDecoder('utf-8')
 
 	writeChunk(chunk: Uint8Array) {
-		const decodedChunk = this.textDecoder.decode(chunk)
+		const decodedChunk = this.textDecoder.decode(chunk, { stream: true })
 
 		this.str += decodedChunk
 	}

package/src/nlp/EspeakPhonemizer.ts

@@ -57,7 +57,7 @@ export async function phonemizeText(text: string, voice: string, substitutionMap
 			.replaceAll('«', ', ')
 			.replaceAll('»', ', ')
 
-	const segmentedText = await Segmentation.parse(text, voice)
+	const segmentedText = await Segmentation.parseTextAndConvertToFragmentObjects(text, voice)
 	const preparedPhrases: string[] = []
 	const phraseBreakers: string[] = []
 

package/src/nlp/Segmentation.ts

@@ -1,22 +1,26 @@
-import * as CldrSegmentation from 'cldr-segmentation'
-import { splitChineseTextToWords_Jieba } from './ChineseSegmentation.js'
-
 import { sumArray, logToStderr } from '../utilities/Utilities.js'
 import { getShortLanguageCode } from '../utilities/Locale.js'
-import { splitJapaneseTextToWords_Kuromoji } from './JapaneseSegmentation.js'
 import { ParagraphBreakType, WhitespaceProcessing } from '../api/Common.js'
-import { includesAnyOf, indexOfAnyOf } from '../utilities/StringUtilities.js'
+import { includesAnyOf, splitAndPreserveSeparators } from '../utilities/StringUtilities.js'
+
+import * as TextSegmentation from '@echogarden/text-segmentation'
+import { splitChineseTextToWords_Jieba } from './ChineseSegmentation.js'
+import { splitJapaneseTextToWords_Kuromoji } from './JapaneseSegmentation.js'
 
 const log = logToStderr
 
-export const wordCharacterPattern = /[\p{Letter}\p{Number}]/u
-export const punctuationPattern = /[\p{Punctuation}]/u
+export const wordCharacterRegExp = /[\p{Letter}\p{Number}]/u
+export const emojiCharacterRegExp = /[\p{Emoji}]/u
+export const punctuationRegExp = /[\p{Punctuation}]/u
 
-export const phraseSeparators = [',', ';', ':', '，', '、']
+export const phraseSeparators = [',', '、', '，', '،', ';', '；', ':', '：', '—']
 export const symbolWords = ['$', '€', '¢', '£', '¥', '©', '®', '™', '%', '&', '#', '~', '@', '+', '±', '÷', '/', '*', '=', '¼', '½', '¾']
 
+///////////////////////////////////////////////////////////////////////////////////////////////
+// Predicates
+///////////////////////////////////////////////////////////////////////////////////////////////
 export function isWordOrSymbolWord(str: string) {
-	return isWord(str) || symbolWords.includes(str)
+	return isWord(str) || includesEmoji(str) || symbolWords.includes(str)
 }
 
 export function isSymbolWord(str: string) {
@@ -24,87 +28,106 @@ export function isSymbolWord(str: string) {
 }
 
 export function isWord(str: string) {
-	return wordCharacterPattern.test(str.trim())
+	return wordCharacterRegExp.test(str.trim())
+}
+
+export function includesPunctuation(str: string) {
+	return punctuationRegExp.test(str.trim())
 }
 
-export function isPunctuation(str: string) {
-	return punctuationPattern.test(str.trim())
+export function includesEmoji(str: string) {
+	return emojiCharacterRegExp.test(str.trim())
 }
 
 export function isWhitespace(str: string) {
 	return str.trim().length === 0
 }
 
-export class Sentence {
-	phrases: Phrase[] = []
+///////////////////////////////////////////////////////////////////////////////////////////////
+// Paragraph, line, sentence, phrase, and word segmentation
+///////////////////////////////////////////////////////////////////////////////////////////////
+export function splitToParagraphs(text: string, paragraphBreakType: ParagraphBreakType, whitespaceProcessingMethod: WhitespaceProcessing) {
+	let paragraphs: string[] = []
 
-	readonly isSentenceFinalizer = true
+	if (paragraphBreakType === 'single') {
+		paragraphs = splitAndPreserveSeparators(text, /(\r?\n)+/g)
+	} else if (paragraphBreakType === 'double') {
+		paragraphs = splitAndPreserveSeparators(text, /(\r?\n)(\r?\n)+/g)
+	} else {
+		throw new Error(`Invalid paragraph break type: '${paragraphBreakType}'`)
+	}
 
-	get length() { return sumArray(this.phrases, (phrase) => phrase.length) }
+	paragraphs = paragraphs.map(p => applyWhitespaceProcessing(p, whitespaceProcessingMethod))
+	paragraphs = paragraphs.filter(p => p.length > 0)
 
-	get text() { return this.phrases.reduce<string>((result, phrase) => result + phrase.text, '') }
+	return paragraphs
 }
 
-export class Phrase {
-	words: Word[] = []
-
-	get length() { return sumArray(this.words, (word) => word.length) }
-
-	get text() { return this.words.reduce<string>((result, word) => result + word.text, '') }
-
-	get lastWord() {
-		if (this.words.length == 0) {
-			return undefined
-		}
-
-		return this.words[this.words.length - 1]
-	}
-
-	get isSentenceFinalizer() { return this.lastWord != null ? this.lastWord.isSentenceFinalizer : false }
+export function splitToLines(text: string) {
+	return splitAndPreserveSeparators(text, /\r?\n/g)
 }
 
-export class Word {
-	readonly text: string
-	isSentenceFinalizer: boolean
-
-	constructor(text: string, isSentenceFinalizer: boolean) {
-		this.text = text
-		this.isSentenceFinalizer = isSentenceFinalizer
-	}
-
-	get containsOnlyPunctuation() { return !wordCharacterPattern.test(this.text) && !this.isSymbolWord }
+export async function parseText(text: string, langCode: string) {
+	const shortLangCode = getShortLanguageCode(langCode || '')
 
-	get isSymbolWord() { return symbolWords.includes(this.text) }
+	const wordSequence = await splitToWords(text, shortLangCode)
 
-	get isPhraseSeperator() { return this.containsOnlyPunctuation && includesAnyOf(this.text, phraseSeparators) }
+	const parsedText = await TextSegmentation.segmentWordSequence(wordSequence)
 
-	get length() { return this.text.length }
+	return parsedText
 }
 
-export type Segment = Sentence | Phrase | Word
+export async function splitToWords(text: string, langCode: string): Promise<TextSegmentation.WordSequence> {
+	const shortLangCode = getShortLanguageCode(langCode || '')
 
-export class Fragment {
-	segments: Segment[] = []
+	if (shortLangCode === 'zh' || shortLangCode === 'cmn' || shortLangCode === 'ja') {
+		let wordArray: string[] = []
 
-	get length() { return sumArray(this.segments, (phrase) => phrase.length) }
+		if (shortLangCode === 'zh' || shortLangCode === 'cmn') {
+			wordArray = await splitChineseTextToWords_Jieba(text)
+		} else {
+			wordArray = await splitJapaneseTextToWords_Kuromoji(text)
+		}
 
-	get text() { return this.segments.reduce<string>((result, segment) => result + segment.text, '') }
+		const wordSequence = new TextSegmentation.WordSequence()
 
-	get isEmpty() { return this.length == 0 }
+		let offset = 0
 
-	get isNonempty() { return !this.isEmpty }
+		for (const wordText of wordArray) {
+			const startOffset = offset
+			const endOffset = startOffset + wordText.length
+			const isNonPunctuation = isWordOrSymbolWord(wordText)
 
-	get lastSegment() {
-		if (this.isEmpty) {
-			return undefined
+			wordSequence.addWord(wordText, startOffset, isNonPunctuation)
+
+			offset = endOffset
 		}
 
-		return this.segments[this.segments.length - 1]
+		return wordSequence
+	} else {
+		return TextSegmentation.splitToWords(text, { language: langCode })
+	}
+}
+
+export function applyWhitespaceProcessing(text: string, whitespaceProcessingMethod: WhitespaceProcessing) {
+	if (whitespaceProcessingMethod === 'removeLineBreaks') {
+		return text.trim().replaceAll(/(\r?\n)+/g, ' ')
+	} else if (whitespaceProcessingMethod === 'collapse') {
+		return text.trim().replaceAll(/\s+/g, ' ')
+	} else if (whitespaceProcessingMethod === 'preserve') {
+		return text
+	} else {
+		throw new Error(`Invalid whitespace processing method: '${whitespaceProcessingMethod}'`)
 	}
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////
+// Fragment segmentation
+//
+// Used to split text to fragments, to fit particular size constraints.
+///////////////////////////////////////////////////////////////////////////////////////////////
 export async function splitToFragments(text: string, maxFragmentLength: number, langCode: string, preserveSentences = true, preservePhrases = true) {
-	const parsedText = await parse(text, langCode)
+	const parsedText = await parseTextAndConvertToFragmentObjects(text, langCode)
 
 	const fragments: Fragment[] = []
 	let currentFragment = new Fragment()
@@ -173,33 +196,28 @@ export async function splitToFragments(text: string, maxFragmentLength: number,
 	return fragments
 }
 
-export async function parse(text: string, langCode: string) {
-	const sentencesText = splitToSentences(text, langCode)
+export async function parseTextAndConvertToFragmentObjects(text: string, langCode: string) {
+	const segmentedText = await parseText(text, langCode)
+
 	const sentences: Sentence[] = []
 
-	for (const sentenceText of sentencesText) {
+	for (const sentenceEntry of segmentedText.sentences) {
 		const sentence = new Sentence()
 
-		let currentPhrase = new Phrase()
-		const wordTexts = await splitToWords(sentenceText, langCode)
+		for (const phraseEntry of sentenceEntry.phrases) {
+			const phrase = new Phrase()
 
-		for (let wordIndex = 0; wordIndex < wordTexts.length; wordIndex++) {
-			const word = new Word(wordTexts[wordIndex], wordIndex == wordTexts.length - 1)
+			for (const wordEntry of phraseEntry.words.entries) {
+				const isSentenceFinalizer = wordEntry === sentenceEntry.words.lastEntry
 
-			if (word.isPhraseSeperator) {
-				const separatorIndex = indexOfAnyOf(word.text, phraseSeparators)
-				currentPhrase.words.push(new Word(word.text.substring(0, separatorIndex + 1), word.isSentenceFinalizer))
-				sentence.phrases.push(currentPhrase)
+				const word = new Word(wordEntry.text, isSentenceFinalizer)
 
-				currentPhrase = new Phrase()
-				currentPhrase.words.push(new Word(word.text.substring(separatorIndex + 1), false))
-			} else {
-				currentPhrase.words.push(word)
+				phrase.words.push(word)
 			}
-		}
 
-		if (currentPhrase.words.length > 0) {
-			sentence.phrases.push(currentPhrase)
+			if (phrase.words.length > 0) {
+				sentence.phrases.push(phrase)
+			}
 		}
 
 		sentences.push(sentence)
@@ -208,53 +226,70 @@ export async function parse(text: string, langCode: string) {
 	return sentences
 }
 
-export function splitToSentences(text: string, langCode: string): string[] {
-	const shortLangCode = getShortLanguageCode(langCode || '')
+export class Sentence {
+	phrases: Phrase[] = []
+
+	readonly isSentenceFinalizer = true
 
-	return CldrSegmentation.sentenceSplit(text, CldrSegmentation.suppressions[shortLangCode])
+	get length() { return sumArray(this.phrases, (phrase) => phrase.length) }
+
+	get text() { return this.phrases.reduce<string>((result, phrase) => result + phrase.text, '') }
 }
 
-export async function splitToWords(text: string, langCode: string): Promise<string[]> {
-	const shortLangCode = getShortLanguageCode(langCode || '')
+export class Phrase {
+	words: Word[] = []
 
-	if (shortLangCode == 'zh' || shortLangCode == 'cmn') {
-		return splitChineseTextToWords_Jieba(text, undefined, true)
-	} else if (shortLangCode == 'ja') {
-		return splitJapaneseTextToWords_Kuromoji(text)
-	} else {
-		return CldrSegmentation.wordSplit(text, CldrSegmentation.suppressions[shortLangCode])
+	get length() { return sumArray(this.words, (word) => word.length) }
+
+	get text() { return this.words.reduce<string>((result, word) => result + word.text, '') }
+
+	get lastWord() {
+		if (this.words.length == 0) {
+			return undefined
+		}
+
+		return this.words[this.words.length - 1]
 	}
+
+	get isSentenceFinalizer() { return this.lastWord != null ? this.lastWord.isSentenceFinalizer : false }
 }
 
-export function splitToParagraphs(text: string, paragraphBreaks: ParagraphBreakType, whitespaceProcessingMethod: WhitespaceProcessing) {
-	let paragraphs: string[] = []
+export class Word {
+	readonly text: string
+	isSentenceFinalizer: boolean
 
-	if (paragraphBreaks === 'single') {
-		paragraphs = text.split(/(\r?\n)+/g)
-	} else if (paragraphBreaks === 'double') {
-		paragraphs = text.split(/(\r?\n)(\r?\n)+/g)
-	} else {
-		throw new Error(`Invalid paragraph break type: '${paragraphBreaks}'`)
+	constructor(text: string, isSentenceFinalizer: boolean) {
+		this.text = text
+		this.isSentenceFinalizer = isSentenceFinalizer
 	}
 
-	paragraphs = paragraphs.map(p => applyWhitespaceProcessing(p.trim(), whitespaceProcessingMethod))
-	paragraphs = paragraphs.filter(p => p.length > 0)
+	get containsOnlyPunctuation() { return !wordCharacterRegExp.test(this.text) && !this.isSymbolWord }
 
-	return paragraphs
-}
+	get isSymbolWord() { return symbolWords.includes(this.text) }
 
-export function applyWhitespaceProcessing(text: string, whitespaceProcessingMethod: WhitespaceProcessing) {
-	if (whitespaceProcessingMethod === 'removeLineBreaks') {
-		return text.replaceAll(/(\r?\n)+/g, ' ')
-	} else if (whitespaceProcessingMethod === 'collapse') {
-		return text.replaceAll(/\s+/g, ' ')
-	} else if (whitespaceProcessingMethod === 'preserve') {
-		return text
-	} else {
-		throw new Error(`Invalid whitespace processing method: '${whitespaceProcessingMethod}'`)
-	}
+	get isPhraseSeperator() { return this.containsOnlyPunctuation && includesAnyOf(this.text, phraseSeparators) }
+
+	get length() { return this.text.length }
 }
 
-export function splitToLines(text: string) {
-	return text.split(/\r?\n/g)
+export type Segment = Sentence | Phrase | Word
+
+export class Fragment {
+	segments: Segment[] = []
+
+	get length() { return sumArray(this.segments, (phrase) => phrase.length) }
+
+	get text() { return this.segments.reduce<string>((result, segment) => result + segment.text, '') }
+
+	get isEmpty() { return this.length == 0 }
+
+	get isNonempty() { return !this.isEmpty }
+
+	get lastSegment() {
+		if (this.isEmpty) {
+			return undefined
+		}
+
+		return this.segments[this.segments.length - 1]
+	}
 }