echogarden 1.8.6 → 2.0.0

package/src/synthesis/FliteTTS.ts

@@ -2,10 +2,9 @@ import { SynthesisVoice } from '../api/API.js'
 import { decodeWaveToRawAudio } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 import { getRandomHexString, logToStderr, resolveModuleMainPath } from '../utilities/Utilities.js'
-import { readFile, open, close, remove, ensureDir } from '../utilities/FileSystem.js'
-import path from 'node:path'
+import { open, close, remove, ensureDir, readFileAsBinary, readFileAsUtf8 } from '../utilities/FileSystem.js'
 import { escape } from 'html-escaper'
-import { getAppTempDir } from '../utilities/PathUtilities.js'
+import { getAppTempDir, joinPath } from '../utilities/PathUtilities.js'
 
 const log = logToStderr
 
@@ -25,8 +24,8 @@ export async function synthesize(text: string, voice: FliteVoiceName, voiceDir:
 	const tempDir = getAppTempDir('flite')
 	await ensureDir(tempDir)
 
-	const tempAudioFilePath = path.join(tempDir, outFileName)
-	const tempStdOutFilePath = path.join(tempDir, stdOutFileName)
+	const tempAudioFilePath = joinPath(tempDir, outFileName)
+	const tempStdOutFilePath = joinPath(tempDir, stdOutFileName)
 
 	const stdOutFileFd = await open(tempStdOutFilePath, 'w+')
 
@@ -100,8 +99,8 @@ export async function synthesize(text: string, voice: FliteVoiceName, voiceDir:
 		throw new Error(`Flite failed with exit code ${exitCode}`)
 	}
 
-	const waveData = await readFile(tempAudioFilePath)
-	const stdOutString = await readFile(tempStdOutFilePath, 'utf8')
+	const waveData = await readFileAsBinary(tempAudioFilePath)
+	const stdOutString = await readFileAsUtf8(tempStdOutFilePath)
 
 	await cleanup()
 
@@ -118,7 +117,7 @@ async function getModuleObject() {
 	if (!fliteModuleObject) {
 		const fliteWasiPath = await resolveModuleMainPath('@echogarden/flite-wasi')
 
-		fliteModuleObject = await WebAssembly.compile(await readFile(fliteWasiPath))
+		fliteModuleObject = await WebAssembly.compile(await readFileAsBinary(fliteWasiPath))
 	}
 
 	return fliteModuleObject

package/src/synthesis/GoogleCloudTTS.ts

@@ -1,6 +1,7 @@
 import { request } from 'gaxios'
 import { Logger } from '../utilities/Logger.js'
 import { logToStderr } from '../utilities/Utilities.js'
+import { decodeBase64 } from '../encodings/Base64.js'
 
 const log = logToStderr
 
@@ -15,7 +16,7 @@ export async function synthesize(
 	ssml = false,
 	audioEncoding: AudioEncoding = 'MP3_64_KBPS',
 	sampleRate = 24000) {
-		
+
 	const logger = new Logger()
 	logger.start('Request synthesis from Google Cloud')
 
@@ -75,7 +76,7 @@ export async function synthesize(
 }
 
 function parseResponseBody(responseBody: any) {
-	const audioData = Buffer.from(responseBody.audioContent, 'base64')
+	const audioData = decodeBase64(responseBody.audioContent)
 	const timepoints: timePoint[] = responseBody.timepoints
 
 	return { audioData, timepoints }

package/src/synthesis/GoogleTranslateTTS.ts

@@ -1,12 +1,13 @@
 import { request } from 'gaxios'
 import { Phrase, splitToFragments } from '../nlp/Segmentation.js'
-import { concatFloat32Arrays, logToStderr } from '../utilities/Utilities.js'
+import { concatFloat32Arrays, concatUint8Arrays, logToStderr } from '../utilities/Utilities.js'
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 import { trimAudioEnd } from '../audio/AudioUtilities.js'
 import { Logger } from '../utilities/Logger.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { getShortLanguageCode } from '../utilities/Locale.js'
 import { getChromeOnWindowsHeaders } from '../utilities/BrowserRequestHeaders.js'
+import { decodeBase64 } from '../encodings/Base64.js'
 
 const log = logToStderr
 
@@ -113,18 +114,18 @@ export async function synthesizeShortText(text: string, languageCode = 'en', tld
 
 	//log(response.data)
 
-	const audioChunks: Buffer[] = []
+	const audioChunks: Uint8Array[] = []
 
 	for (const line of response.data.split(/\r?\n/)) {
 		const match = line.match(/"jQ1olc","\[\\"(.*)\\"]/)
 
 		if (match != null) {
 			const base64AudioChunk = match[1]
-			audioChunks.push(Buffer.from(base64AudioChunk, 'base64'))
+			audioChunks.push(decodeBase64(base64AudioChunk))
 		}
 	}
 
-	const resultMp3Stream = Buffer.concat(audioChunks)
+	const resultMp3Stream = concatUint8Arrays(audioChunks)
 
 	return resultMp3Stream
 }

package/src/synthesis/MicrosoftEdgeTTS.ts

@@ -3,15 +3,14 @@ import WebSocket from 'ws'
 
 import { escape } from 'html-escaper'
 
-import splitBuffer from 'buffer-split'
-
 import * as AzureCognitiveServicesTTS from './AzureCognitiveServicesTTS.js'
 import * as FFMpegTranscoder from '../codecs/FFMpegTranscoder.js'
 import { Logger } from '../utilities/Logger.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
-import { getRandomHexString, logToStderr } from '../utilities/Utilities.js'
+import { concatUint8Arrays, getRandomHexString, logToStderr } from '../utilities/Utilities.js'
 import { RawAudio, getEmptyRawAudio, getRawAudioDuration } from '../audio/AudioUtilities.js'
 import { Timer } from '../utilities/Timer.js'
+import { decodeUtf8, encodeUtf8 } from '../encodings/Utf8.js'
 
 const traceEnabled = false
 
@@ -50,7 +49,7 @@ export async function synthesize(
 	return { rawAudio, timeline }
 }
 
-type SynthesisRequestResult = { audioData: Buffer, events: any[] }
+type SynthesisRequestResult = { audioData: Uint8Array, events: any[] }
 
 async function requestSynthesis(
 	text: string,
@@ -104,11 +103,11 @@ async function requestSynthesis(
 		throw e
 	}
 
-	const receivedBinaryMessages: Buffer[] = []
+	const receivedBinaryMessages: Uint8Array[] = []
 	const receivedEventMessages: any[] = []
-	const audioChunks: Buffer[] = []
+	const audioChunks: Uint8Array[] = []
 
-	const onMessage = (messageData: Buffer, isBinary: boolean) => {
+	const onMessage = (messageData: Uint8Array, isBinary: boolean) => {
 		lastReceievedMessageTime = Timer.currentTime
 
 		if (isBinary) {
@@ -124,11 +123,11 @@ async function requestSynthesis(
 			log(header)
 
 			receivedBinaryMessages.push(messageData)
-			receivedBinaryMessages.push(Buffer.from('\n\n'))
+			receivedBinaryMessages.push(encodeUtf8('\n\n'))
 
 			audioChunks.push(audioChunk)
 		} else {
-			const message = messageData.toString('utf8')
+			const message = decodeUtf8(messageData)
 			const [header, content] = parseTextMessage(message)
 
 			if (header['X-RequestId'] != requestId) {
@@ -147,7 +146,7 @@ async function requestSynthesis(
 				receivedEventMessages.push(content['Metadata'][0])
 			}
 			else if (header['Path'] == 'turn.end') {
-				const result: SynthesisRequestResult = { audioData: Buffer.concat(audioChunks), events: receivedEventMessages }
+				const result: SynthesisRequestResult = { audioData: concatUint8Arrays(audioChunks), events: receivedEventMessages }
 
 				removeWebSocketHandlers()
 
@@ -167,7 +166,7 @@ async function requestSynthesis(
 		}
 	}
 
-	const onClose = async (code: number, reason: Buffer) => {
+	const onClose = async (code: number, reason: Uint8Array) => {
 		log('WebSocket closed.')
 		log(code)
 		log(reason.toString())
@@ -282,7 +281,7 @@ export async function initializeWebsocketConnection(trustedClientToken: string)
 		requestOpenPromise.resolve(webSocket)
 	}
 
-	const onClose = (code: number, reason: Buffer) => {
+	const onClose = (code: number, reason: Uint8Array) => {
 		log('WebSocket closed.')
 		log(code)
 		log(reason.toString())
@@ -352,11 +351,44 @@ function parseTextMessage(message: string) {
 	return [parseHeaderString(headerString), JSON.parse(content)]
 }
 
-function parseBinaryMessage(message: Buffer) {
-	const audioChunk = splitBuffer(message, Buffer.from('Path:audio\r\n'))[1]
+function parseBinaryMessage(message: Uint8Array) {
+	const patternAsBytes = encodeUtf8('Path:audio\r\n')
+	const indexOfPattern = indexOfByteSubsequence(message, patternAsBytes)
+
+	if (indexOfPattern === -1) {
+		throw new Error(`Couldn't find separator pattern in Edge TTS binary message`)
+	}
+
+	const audioChunk = message.slice(indexOfPattern + patternAsBytes.length)
+
 	const headerBuffer = message.subarray(2, message.length - audioChunk.length)
-	const headerString = headerBuffer.toString('utf8').trim()
+	const headerString = decodeUtf8(headerBuffer).trim()
 
 	return [parseHeaderString(headerString), audioChunk]
 }
 
+function indexOfByteSubsequence(sequence: Uint8Array, subsequence: Uint8Array) {
+	function tryMatchAtOffset(offset: number) {
+		if (offset + subsequence.length > sequence.length) {
+			return false
+		}
+
+		for (let i = 0; i < subsequence.length; i++) {
+			if (sequence[offset + i] !== subsequence[i]) {
+				return false
+			}
+		}
+
+		return true
+	}
+
+	for (let offset = 0; offset < sequence.length; offset++) {
+		const matched = tryMatchAtOffset(offset)
+
+		if (matched) {
+			return offset
+		}
+	}
+
+	return -1
+}

package/src/synthesis/SapiTTS.ts

@@ -107,7 +107,7 @@ export function synthesize(text: string, voiceName: string, rate = 0, useSpeechP
 			EndStream: (streamId: number, streamPos: number) => {
 				clearInterval(dispatchMessagesInterval)
 
-				const audioData = Buffer.from(sapiOutputStream.GetData())
+				const audioData = new Uint8Array(sapiOutputStream.GetData())
 				const audioChannels = decodeToChannels(audioData, 1, 16, SampleFormat.PCM)
 
 				WinAX.release(sapiOutputStream)

package/src/synthesis/StreamlabsPollyTTS.ts

@@ -92,7 +92,7 @@ export async function synthesizeFragment(text: string, voice: string) {
 	const audioUrl = responseObject.speak_url
 	const audioUrlResponse = await request<ArrayBuffer>({ url: audioUrl, responseType: 'arraybuffer' })
 
-	return Buffer.from(audioUrlResponse.data)
+	return new Uint8Array(audioUrlResponse.data)
 }
 
 export const voiceList: SynthesisVoice[] = [

package/src/synthesis/SvoxPicoTTS.ts

@@ -5,7 +5,8 @@ import { bandwidthToQFactor } from '../dsp/BiquadFilter.js'
 import { Logger } from '../utilities/Logger.js'
 import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
-import { readFile } from '../utilities/FileSystem.js'
+import { readFileAsBinary } from '../utilities/FileSystem.js'
+import { concatUint8Arrays } from '../utilities/Utilities.js'
 
 let svoxPicoInstance: any
 
@@ -51,7 +52,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 	async function loadResource(localFilePath: string) {
 		const virtualFilePath = '.' + localFilePath.substring(localFilePath.lastIndexOf('/'))
 
-		const fileData = await readFile(localFilePath)
+		const fileData = await readFileAsBinary(localFilePath)
 		m.FS.writeFile(virtualFilePath, fileData)
 
 		const virtualFilePathRef = wasmMemory.allocNullTerminatedUtf8String(virtualFilePath)
@@ -108,7 +109,7 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 
 	const bytesWrittenRef = wasmMemory.allocInt32()
 
-	const audioParts: Buffer[] = []
+	const audioParts: Uint8Array[] = []
 
 	for (let textByteOffset = 0; textByteOffset < textRef.length;) {
 		bytesWrittenRef.value = 0
@@ -123,10 +124,10 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 		textByteOffset += bytesWritten
 	}
 
-	const audioData = Buffer.concat(audioParts)
+	const audioData = concatUint8Arrays(audioParts)
 
 	function readAudioDataFromEngine() {
-		const outBuffers: Buffer[] = []
+		const outBuffers: Uint8Array[] = []
 
 		const outBufferLength = 16384
 		const outBufferRef = wasmMemory.allocUint8Array(outBufferLength)
@@ -147,11 +148,11 @@ export async function synthesize(text: string, textAnalysisFilePath: string, sig
 			}
 
 			if (outByteCount > 0) {
-				outBuffers.push(Buffer.from(outBufferRef.slice(0, outByteCount)))
+				outBuffers.push(outBufferRef.slice(0, outByteCount) as Uint8Array)
 			}
 		}
 
-		return Buffer.concat(outBuffers)
+		return concatUint8Arrays(outBuffers)
 	}
 
 	dispose()

package/src/synthesis/VitsTTS.ts

@@ -5,9 +5,9 @@ import { RawAudio, getEmptyRawAudio, getRawAudioDuration } from '../audio/AudioU
 import { Lexicon } from '../nlp/Lexicon.js'
 import { Timeline } from '../utilities/Timeline.js'
 import { readAndParseJsonFile, readdir } from '../utilities/FileSystem.js'
-import path from 'node:path'
 import { EspeakOptions, defaultEspeakOptions } from '../synthesis/EspeakTTS.js'
 import { OnnxExecutionProvider, getOnnxSessionOptions } from '../utilities/OnnxUtilities.js'
+import { joinPath } from '../utilities/PathUtilities.js'
 
 const cachedInstanceLookup = new Map<string, VitsTTS>()
 
@@ -196,7 +196,7 @@ export class VitsTTS {
 			throw new Error(`Couldn't file any ONNX model file in ${this.modelPath}`)
 		}
 
-		const onnxModelFilepath = path.join(this.modelPath, onnxModelFilename)
+		const onnxModelFilepath = joinPath(this.modelPath, onnxModelFilename)
 
 		const onnxSessionOptions = getOnnxSessionOptions({ executionProviders: this.executionProviders })
 

package/src/tests/Test.ts

@@ -1,5 +1,3 @@
-import { createAlignmentReferenceUsingEspeakForFragments } from '../alignment/SpeechAlignment.js'
-import { setVoice } from '../synthesis/EspeakTTS.js'
 import { logToStderr, setupProgramTerminationListeners } from '../utilities/Utilities.js'
 
 const log = logToStderr
@@ -9,32 +7,4 @@ setupProgramTerminationListeners()
 //process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
 //process.env.http_proxy = 'http://localhost:8080'
 
-if (false) {
-	for (let i = 0; i < 1000000; i++) {
-		if (i % 1000 === 0) {
-			console.log(`Iteration ${i}`)
-		}
-
-		await setVoice('en')
-	}
-}
-
-if (true) {
-	const fragments: string[] = []
-
-	for (let i = 0; i < 30000; i++) {
-		fragments.push(`hello`, `${i}`)
-	}
-
-	await createAlignmentReferenceUsingEspeakForFragments(fragments, {
-		voice: "gmw/en-US",
-		ssml: false,
-		rate: 150,
-		pitch: 50,
-		pitchRange: 50,
-		useKlatt: false,
-		insertSeparators: true,
-	})
-}
-
 process.exit(0)

package/src/text-language-detection/FastTextLanguageDetection.ts

@@ -1,8 +1,8 @@
-import path from 'path'
 import { languageCodeToName } from '../utilities/Locale.js'
 import { OpenPromise } from '../utilities/OpenPromise.js'
 import { resolveModuleMainPath, roundToDigits } from '../utilities/Utilities.js'
 import { LanguageDetectionResults } from '../api/LanguageDetectionCommon.js'
+import { getDirName, joinPath } from '../utilities/PathUtilities.js'
 
 let fastTextLanguageDetectionModel: any
 
@@ -41,7 +41,7 @@ async function loadLanguageDetectionModel() {
 		const fastText = new FastText()
 
 		const moduleMainPath = await resolveModuleMainPath('@echogarden/fasttext-wasm')
-		const modelPath = path.join(path.dirname(moduleMainPath), 'lid.176.ftz')
+		const modelPath = joinPath(getDirName(moduleMainPath), 'lid.176.ftz')
 
 		const model = await fastText.loadModel(modelPath)
 

package/src/typings/Fillers.d.ts

@@ -92,9 +92,7 @@ declare module 'onnxruntime-node' {
 
 	type RunOptions = InferenceSession.RunOptions
 
-	/**
-	 * Binding exports a simple synchronized inference session object wrap.
-	 */
+	// Binding exports a simple synchronized inference session object wrap.
 	export namespace Binding {
 		interface InferenceSession {
 			loadModel(modelPath: string, options: SessionOptions): void
@@ -115,5 +113,5 @@ declare module 'onnxruntime-node' {
 	}
 
 	// From version.d.ts
-	export const version = '1.16.1'
+	export const version = '1.20.0'
 }

package/src/typings/TypedArray.ts

@@ -0,0 +1,5 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array
+
+export interface TypedArrayConstructor<T extends TypedArray> {
+	new(length: number): T
+}

package/src/utilities/BinaryArrayConversion.ts

@@ -1,186 +1,112 @@
-// Typed arrays to Buffer (little endian) conversions
+// Typed arrays to Uint8Array buffers (little endian) conversions
 //
-// The faster conversion methods (other than the methods for int8) would only work correctly
+// The conversion methods (other than the methods for int8 and int24) would only work correctly
 // on little-endian architectures, since they assume the byte order of the underlying architecture.
 //
 // Since Echogarden only supports little-endian architectures, this shouldn't matter.
 
 // int8 <-> bufferLE
 export function int8ToBuffer(int8s: Int8Array) {
-	return Buffer.copyBytesFrom(int8s)
+	return new Uint8Array(int8s.buffer, int8s.byteOffset, int8s.byteLength)
 }
 
-export function int8ToBuffer_Slow(int8s: Int8Array) {
-	const buffer = Buffer.alloc(int8s.length)
-
-	for (let i = 0; i < int8s.length; i++) {
-		buffer[i] = int8s[i] + 128
-	}
-
-	return buffer
-}
-
-export function bufferToInt8(buffer: Buffer) {
+export function bufferToInt8(buffer: Uint8Array) {
 	return new Int8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
 }
 
-export function bufferToInt8_Slow(buffer: Buffer) {
-	const result = new Int8Array(buffer.length)
-
-	for (let i = 0; i < result.length; i++) {
-		result[i] = buffer[i] - 128
-	}
-
-	return result
-}
-
 // int16 <-> bufferLE
 export function int16ToBufferLE(int16s: Int16Array) {
-	return Buffer.copyBytesFrom(int16s)
-}
-
-export function int16ToBufferLE_Slow(int16s: Int16Array) {
-	const buffer = Buffer.alloc(int16s.length * 2)
-
-	for (let i = 0; i < int16s.length; i++) {
-		buffer.writeInt16LE(int16s[i], i * 2)
-	}
-
-	return buffer
+	return new Uint8Array(int16s.buffer, int16s.byteOffset, int16s.byteLength)
 }
 
-export function bufferLEToInt16(buffer: Buffer) {
+export function bufferLEToInt16(buffer: Uint8Array) {
 	return new Int16Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 2)
 }
 
-export function bufferLEToInt16_Slow(buffer: Buffer) {
-	const result = new Int16Array(buffer.length / 2)
+// int24 <-> bufferLE (uses int32 for storage)
+export function int24ToBufferLE(int24s: Int32Array) {
+	const buffer = new Uint8Array(int24s.length * 3)
 
-	for (let i = 0; i < result.length; i++) {
-		result[i] = buffer.readInt16LE(i * 2)
-	}
+	let readOffset = 0
+	let writeOffset = 0
 
-	return result
-}
+	while (readOffset < int24s.length) {
+		const signedValue = int24s[readOffset++]
 
-// int24 <-> bufferLE (uses int32 for storage)
-export function int24ToBufferLE(int24s: Int32Array) {
-	const buffer = Buffer.alloc(int24s.length * 3)
+		let unsignedValue: number
 
-	for (let i = 0; i < int24s.length; i++) {
-		const val = int24s[i]
-		const encodedVal = val < 0 ? val + 0x1000000 : val
+		if (signedValue >= 0) {
+			unsignedValue = signedValue
+		} else {
+			unsignedValue = signedValue + (2 ** 24)
+		}
 
-		buffer[(i * 3) + 0] = (encodedVal >> 0) & 0xff
-		buffer[(i * 3) + 1] = (encodedVal >> 8) & 0xff
-		buffer[(i * 3) + 2] = (encodedVal >> 16) & 0xff
+		buffer[writeOffset++] = (unsignedValue) & 0xff
+		buffer[writeOffset++] = (unsignedValue >> 8) & 0xff
+		buffer[writeOffset++] = (unsignedValue >> 16) & 0xff
 	}
 
 	return buffer
 }
 
-export function bufferLEToInt24(buffer: Buffer) {
+export function bufferLEToInt24(buffer: Uint8Array) {
+	if (buffer.length % 3 !== 0) {
+		throw new Error(`Buffer has a length of ${buffer.length}, which is not a multiple of 3`)
+	}
+
 	const result = new Int32Array(buffer.length / 3)
 
-	for (let i = 0; i < result.length; i++) {
-		const b0 = buffer[(i * 3) + 0]
-		const b1 = buffer[(i * 3) + 1]
-		const b2 = buffer[(i * 3) + 2]
+	let readOffset = 0
+	let writeOffset = 0
 
-		const encodedVal = (b0 << 0) + (b1 << 8) + (b2 << 16)
-		result[i] = encodedVal > 0x800000 ? encodedVal - 0x1000000 : encodedVal
-	}
+	while (writeOffset < result.length) {
+		const b0 = buffer[readOffset++]
+		const b1 = buffer[readOffset++]
+		const b2 = buffer[readOffset++]
 
-	return result
-}
+		const unsignedValue = (b0) | (b1 << 8) | (b2 << 16)
 
-// int32 <-> bufferLE
-export function int32ToBufferLE(int32s: Int32Array) {
-	return Buffer.copyBytesFrom(int32s)
-}
+		let signedValue: number
 
-export function int32ToBufferLE_Slow(int32s: Int32Array) {
-	const buffer = Buffer.alloc(int32s.length * 4)
+		if (unsignedValue < 2 ** 23) {
+			signedValue = unsignedValue
+		} else {
+			signedValue = unsignedValue - (2 ** 24)
+		}
 
-	for (let i = 0; i < int32s.length; i++) {
-		buffer.writeInt32LE(int32s[i], i * 4)
+		result[writeOffset++] = signedValue
 	}
 
-	return buffer
+	return result
 }
 
-export function bufferLEToInt32(buffer: Buffer) {
-	return new Int32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4)
+// int32 <-> bufferLE
+export function int32ToBufferLE(int32s: Int32Array) {
+	return new Uint8Array(int32s.buffer, int32s.byteOffset, int32s.byteLength)
 }
 
-export function bufferLEToInt32_Slow(buffer: Buffer) {
-	const result = new Int32Array(buffer.length / 4)
-
-	for (let i = 0; i < result.length; i++) {
-		result[i] = buffer.readInt32LE(i * 4)
-	}
-
-	return result
+export function bufferLEToInt32(buffer: Uint8Array) {
+	return new Int32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4)
 }
 
 // float32 <-> bufferLE
 export function float32ToBufferLE(float32s: Float32Array) {
-	return Buffer.copyBytesFrom(float32s)
+	return new Uint8Array(float32s.buffer, float32s.byteOffset, float32s.byteLength)
 }
 
-export function float32ToBufferLE_Slow(float32s: Float32Array) {
-	const buffer = Buffer.alloc(float32s.length * 4)
-
-	for (let i = 0; i < float32s.length; i++) {
-		buffer.writeFloatLE(float32s[i], i * 4)
-	}
-
-	return buffer
-}
-
-export function bufferLEToFloat32(buffer: Buffer) {
+export function bufferLEToFloat32(buffer: Uint8Array) {
 	return new Float32Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 4)
 }
 
-export function bufferLEToFloat32_Slow(buffer: Buffer) {
-	const result = new Float32Array(buffer.length / 4)
-
-	for (let i = 0; i < result.length; i++) {
-		result[i] = buffer.readFloatLE(i * 4)
-	}
-
-	return result
-}
-
 // float64 <-> bufferLE
 export function float64ToBufferLE(float64s: Float64Array) {
-	return Buffer.copyBytesFrom(float64s)
-}
-
-export function float64ToBufferLE_Slow(float64s: Float64Array) {
-	const buffer = Buffer.alloc(float64s.length * 8)
-
-	for (let i = 0; i < float64s.length; i++) {
-		buffer.writeDoubleLE(float64s[i], i * 8)
-	}
-
-	return buffer
+	return new Uint8Array(float64s.buffer, float64s.byteOffset, float64s.byteLength)
 }
 
-export function bufferLEToFloat64(buffer: Buffer) {
+export function bufferLEToFloat64(buffer: Uint8Array) {
 	return new Float64Array(buffer.buffer, buffer.byteOffset, buffer.byteLength / 8)
 }
 
-export function bufferLEToFloat64_Slow(buffer: Buffer) {
-	const result = new Float64Array(buffer.length / 8)
-
-	for (let i = 0; i < result.length; i++) {
-		result[i] = buffer.readDoubleLE(i * 8)
-	}
-
-	return result
-}
-
 // float64 <-> float32
 export function float64Tofloat32(float64s: Float64Array) {
 	return Float32Array.from(float64s)