echogarden 1.8.7 → 2.0.0

package/src/denoising/NSNet2.ts

@@ -0,0 +1,182 @@
+import { decibelsToGainFactor, RawAudio } from '../audio/AudioUtilities.js'
+
+import type * as Onnx from 'onnxruntime-node'
+import { getOnnxSessionOptions, OnnxExecutionProvider } from '../utilities/OnnxUtilities.js'
+import { readdir } from '../utilities/FileSystem.js'
+import { joinPath } from '../utilities/PathUtilities.js'
+import { stftr, stiftr } from '../dsp/FFT.js'
+import { clip, concatFloat32Arrays } from '../utilities/Utilities.js'
+import { Logger } from '../utilities/Logger.js'
+
+export async function denoiseAudio(rawAudio: RawAudio, options: NSNet2Options) {
+	const onnxExecutionProviders: OnnxExecutionProvider[] = options.provider ? [options.provider] : []//['dml', 'cpu']
+
+	const denoiser = new NSNet2(options.model!, options.modelDirectoryPath!, onnxExecutionProviders, options.maxAttenuation!)
+
+	const result = await denoiser.denoiseAudio(rawAudio)
+
+	return result
+}
+
+export class NSNet2 {
+	session?: Onnx.InferenceSession
+
+	constructor(
+		public readonly modelName: NSNet2ModelName,
+		public readonly modelDirectoryPath: string,
+		public readonly executionProviders: OnnxExecutionProvider[],
+		public readonly maxAttenuation: number) {
+	}
+
+	async denoiseAudio(rawAudio: RawAudio) {
+		const logger = new Logger()
+
+		logger.start(`Initialize ONNX model ${this.modelName}`)
+		await this.initializeIfNeeded()
+
+		let fftSize: number
+
+		if (this.modelName === 'baseline-48khz') {
+			fftSize = 1024
+
+			if (rawAudio.sampleRate !== 48000) {
+				throw new Error(`Denoising model baseline-48khz requires a 48000 Hz signal`)
+			}
+		} else if (this.modelName === 'baseline-16khz') {
+			fftSize = 320
+
+			if (rawAudio.sampleRate !== 16000) {
+				throw new Error(`Denoising model baseline-16khz requires a 16000 Hz signal`)
+			}
+		} else {
+			throw new Error(`Unsupported model name: ${this.modelName}`)
+		}
+
+		const fftHopSize = fftSize / 2
+		const fftRealBinCount = (fftSize / 2) + 1
+
+		logger.start('Compute STFT frames')
+		const stftrFrames = await stftr(rawAudio.audioChannels[0], fftSize, fftSize, fftHopSize, 'hann')
+
+		logger.start('Compute log-power spectogram')
+		let logPowerSpectogram: Float32Array[] = []
+
+		{
+			for (const frame of stftrFrames) {
+				const logPowerSpectrum = new Float32Array(frame.length / 2)
+
+				let readOffset = 0
+				let writeOffset = 0
+
+				while (readOffset < frame.length) {
+					const real = frame[readOffset++]
+					const imaginary = frame[readOffset++]
+
+					const powerValue = (real ** 2) + (imaginary ** 2)
+					const clampedPowerValue = Math.max(powerValue, 1e-12)
+					const logPowerValue = Math.log10(clampedPowerValue)
+
+					logPowerSpectrum[writeOffset++] = logPowerValue
+				}
+
+				logPowerSpectogram.push(logPowerSpectrum)
+			}
+		}
+
+		logger.start('Process log-power spectogram using ONNX model')
+
+		const frameCount = logPowerSpectogram.length
+		let flattenedOutputTensor: Float32Array
+
+		{
+			const Onnx = await import('onnxruntime-node')
+
+			const flattenedFeatures = concatFloat32Arrays(logPowerSpectogram)
+
+			const inputTensor = new Onnx.Tensor('float32', flattenedFeatures, [1, frameCount, fftRealBinCount])
+			const inputs = { input: inputTensor }
+
+			const result = await this.session!.run(inputs)
+
+			flattenedOutputTensor = result.output.data as Float32Array
+		}
+
+		{
+			logger.start('Apply model output as a filter to original STFT frames')
+
+			const fftSizeReciprocal = 1 / fftSize
+
+			const minGainRatio = decibelsToGainFactor(-this.maxAttenuation)
+			const maxGainRatio = 1.0
+
+			let flattenenedOutputTensorReadIndex = 0
+
+			for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+				const frame = stftrFrames[frameIndex]
+
+				let frameReadIndex = 0
+
+				for (let binIndex = 0; binIndex < fftRealBinCount; binIndex++) {
+					let gainRatio = flattenedOutputTensor[flattenenedOutputTensorReadIndex++]
+					gainRatio = clip(gainRatio, minGainRatio, maxGainRatio)
+
+					frame[frameReadIndex++] *= gainRatio * fftSizeReciprocal
+					frame[frameReadIndex++] *= gainRatio * fftSizeReciprocal
+				}
+			}
+		}
+
+		// Allow logPowerSpectogram to be garbage collected
+		logPowerSpectogram = undefined as any
+
+		logger.start('Reconstruct filtered signal using inverse STFT')
+		const filteredSignal = await stiftr(stftrFrames, fftSize, fftSize, fftHopSize, 'hann')
+
+		const denoisedAudio: RawAudio = {
+			audioChannels: [filteredSignal],
+			sampleRate: rawAudio.sampleRate
+		}
+
+		logger.end()
+
+		return { denoisedAudio }
+	}
+
+	private async initializeIfNeeded() {
+		if (this.session) {
+			return
+		}
+
+		const filesInModelPath = await readdir(this.modelDirectoryPath)
+		const onnxModelFilename = filesInModelPath.find(filename => filename.endsWith('.onnx'))
+
+		if (!onnxModelFilename) {
+			throw new Error(`Couldn't file any ONNX model file in ${this.modelDirectoryPath}`)
+		}
+
+		const onnxModelPath = joinPath(this.modelDirectoryPath, onnxModelFilename)
+
+		const Onnx = await import('onnxruntime-node')
+
+		const onnxSessionOptions = getOnnxSessionOptions({ executionProviders: this.executionProviders })
+
+		this.session = await Onnx.InferenceSession.create(onnxModelPath, onnxSessionOptions)
+	}
+}
+
+//export type NSNet2ModelName = 'nsnet2-20ms-baseline' | 'nsnet2-20ms-48k-baseline'
+export type NSNet2ModelName = 'baseline-16khz' | 'baseline-48khz'
+
+export const defaultNSNet2Options: NSNet2Options = {
+	model: 'baseline-48khz',
+	modelDirectoryPath: undefined,
+	provider: undefined,
+	maxAttenuation: 30,
+}
+
+export interface NSNet2Options {
+	model?: NSNet2ModelName
+	modelDirectoryPath?: string
+	provider?: OnnxExecutionProvider
+	maxAttenuation?: number
+}

package/src/denoising/RNNoise.ts

@@ -9,11 +9,11 @@ let rnnoiseInstance: any
 export async function denoiseAudio(rawAudio: RawAudio) {
 	const logger = new Logger()
 	if (rawAudio.sampleRate != 48000) {
-		throw new Error('Sample rate must be 48000')
+		throw new Error(`RNNoise requires a 48000 Hz sample rate (${rawAudio.sampleRate} Hz given)`)
 	}
 
-	if (rawAudio.audioChannels.length != 1) {
-		throw new Error('Channel count must be 1')
+	if (rawAudio.audioChannels.length !== 1) {
+		throw new Error('RNNoise requires a channel count of 1')
 	}
 
 	if (rawAudio.audioChannels[0].length == 0) {

package/src/dsp/FFT.ts

@@ -226,6 +226,22 @@ export function complexToBinBuffer(complexBins: ComplexNumber[]) {
 	return binBuffer
 }
 
+// Convert complex bin to magnitude and phase
+export function complexToMagnitudeAndPhase(real: number, imaginary: number) {
+	const magnitude = Math.sqrt((real ** 2) + (imaginary ** 2))
+	const phase = Math.atan2(imaginary, real)
+
+	return { magnitude, phase }
+}
+
+// Convert magnitude and phase to complex bin
+export function magnitudeAndPhaseToComplex(magnitude: number, phase: number) {
+	const real = magnitude * Math.cos(phase)
+	const imaginary = magnitude * Math.sin(phase)
+
+	return { real, imaginary } as ComplexNumber
+}
+
 // Get window weights for a particular window function
 export function getWindowWeights(windowType: WindowType, windowSize: number) {
 	const weights = new Float32Array(windowSize)
@@ -237,6 +253,10 @@ export function getWindowWeights(windowType: WindowType, windowSize: number) {
 			//weights[i] = 0.5 * (1 - Math.cos(2 * Math.PI * (i / (windowSize - 1))))
 			weights[i] = 0.5 * (1 - Math.cos(innerFactor * i))
 		}
+	} else if (windowType == 'hann-sqrt') {
+		for (let i = 0; i < windowSize; i++) {
+			weights[i] = Math.sqrt(0.5 * (1 - Math.cos(innerFactor * i)))
+		}
 	} else if (windowType == 'hamming') {
 		for (let i = 0; i < windowSize; i++) {
 			//weights[i] = 0.54 - (0.46 * Math.cos(2 * Math.PI * (i / (windowSize - 1))))
@@ -284,4 +304,4 @@ async function getSimdPFFFTInstance() {
 	return pffftSimdInstance
 }
 
-export type WindowType = 'hann' | 'hamming' | 'povey'
+export type WindowType = 'hann' | 'hann-sqrt' | 'hamming' | 'povey'

package/src/encodings/Ascii.ts

@@ -0,0 +1,60 @@
+import { EncodeIntoResult } from "./TextEncodingsCommon.js"
+
+export function encodeAscii(asciiString: string) {
+	const charCount = asciiString.length
+
+	const resultArray = new Uint8Array(charCount)
+
+	const { written } = encodeAsciiInto(asciiString, resultArray)
+
+	return resultArray.subarray(0, written)
+}
+
+export function encodeAsciiInto(asciiString: string, resultBuffer: Uint8Array): EncodeIntoResult {
+	const len = asciiString.length
+
+	if (resultBuffer.length < len) {
+		throw new Error(`Result Uint8Array is not large enough to hold the string`)
+	}
+
+	for (let readOffset = 0; readOffset < len; readOffset++) {
+		const charCode = asciiString.charCodeAt(readOffset)
+
+		if (charCode >= 128) {
+			throw new Error(`Character '${asciiString[readOffset]}' (code: ${charCode}) can't be encoded as a standard ASCII character`)
+		}
+
+		resultBuffer[readOffset] = charCode
+	}
+
+	return { read: len, written: len }
+}
+
+export function decodeAscii(encodedString: Uint8Array) {
+	const maxChunkLength = 2 ** 24
+
+	const decoder = new ChunkedAsciiDecoder()
+
+	for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+		const chunk = encodedString.subarray(offset, offset + maxChunkLength)
+
+		decoder.writeChunk(chunk)
+	}
+
+	return decoder.toString()
+}
+
+export class ChunkedAsciiDecoder {
+	private str = ''
+	private readonly textDecoder = new TextDecoder('windows-1252')
+
+	writeChunk(chunk: Uint8Array) {
+		const decodedChunk = this.textDecoder.decode(chunk)
+
+		this.str += decodedChunk
+	}
+
+	toString() {
+		return this.str
+	}
+}

package/src/encodings/Base64.ts

@@ -0,0 +1,157 @@
+import { decodeAscii } from './Ascii.js';
+
+export function encodeBase64(inputBytes: Uint8Array,
+	paddingCharacter: string | undefined = '=',
+	charCodeMap?: Uint8Array): string {
+
+	const asciiBuffer = encodeBase64AsAsciiBuffer(inputBytes, undefined, paddingCharacter, charCodeMap)
+
+	return decodeAscii(asciiBuffer)
+}
+
+export function encodeBase64AsAsciiBuffer(
+	inputBytes: Uint8Array,
+	asciiBuffer?: Uint8Array,
+	paddingCharacter: string | undefined = '=',
+	charCodeMap?: Uint8Array): Uint8Array {
+
+	if (!inputBytes || inputBytes.length == 0) {
+		return new Uint8Array(0)
+	}
+
+	let paddingCharCode: number
+
+	if (paddingCharacter == null) {
+		paddingCharCode = -1
+	} else if (paddingCharacter.length !== 1) {
+		throw new Error(`A padding character can only be a single character`)
+	} else {
+		paddingCharCode = paddingCharacter.charCodeAt(0)
+	}
+
+	if (!charCodeMap) {
+		charCodeMap = defaultBase64CharCodeMap
+	}
+
+	let charCodes: Uint8Array
+
+	if (asciiBuffer) {
+		charCodes = asciiBuffer
+	} else {
+		charCodes = new Uint8Array(Math.floor((inputBytes.length * 4 / 3) + 4))
+	}
+
+	const inputBytesLength = inputBytes.length
+
+	let writeOffset = 0
+	let readOffset = 0
+
+	while (readOffset <= inputBytesLength - 3) {
+		const uint24 =
+			inputBytes[readOffset++] << 16 |
+			inputBytes[readOffset++] << 8 |
+			inputBytes[readOffset++]
+
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 18) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 12) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 6) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24) & 63]
+	}
+
+	if (readOffset === inputBytesLength - 2) {
+		// If two bytes are left, output 3 encoded characters and one padding character
+		const uint24 =
+			inputBytes[readOffset++] << 16 |
+			inputBytes[readOffset++] << 8
+
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 18) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 12) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 6) & 63]
+
+		if (paddingCharCode >= 0) {
+			charCodes[writeOffset++] = paddingCharCode
+		}
+	} else if (readOffset === inputBytesLength - 1) {
+		// Arrived at last byte at a position that did not complete a full 3 byte set
+		const uint24 =
+			inputBytes[readOffset++] << 16
+
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 18) & 63]
+		charCodes[writeOffset++] = charCodeMap[(uint24 >>> 12) & 63]
+
+		if (paddingCharCode >= 0) {
+			charCodes[writeOffset++] = paddingCharCode
+			charCodes[writeOffset++] = paddingCharCode
+		}
+	}
+
+	return charCodes.subarray(0, writeOffset)
+}
+
+export function decodeBase64(
+	base64String: string,
+	outputBuffer?: Uint8Array,
+	paddingCharacter = '=',
+	reverseCharCodeMap?: Uint8Array): Uint8Array {
+
+	if (!base64String || base64String.length === 0) {
+		return new Uint8Array(0)
+	}
+
+	if (!paddingCharacter || paddingCharacter.length !== 1) {
+		throw new Error(`A valid padding character must be provided for Base 64 decoding`)
+	}
+
+	// Add padding if omitted
+	const lengthModulo4 = base64String.length % 4
+
+	if (lengthModulo4 === 1) {
+		throw new Error(`Invalid Base64 string: length % 4 == 1`)
+	} else if (lengthModulo4 === 2) {
+		base64String += paddingCharacter
+		base64String += paddingCharacter
+	} else if (lengthModulo4 === 3) {
+		base64String += paddingCharacter
+	}
+
+	if (!reverseCharCodeMap) {
+		reverseCharCodeMap = defaultBase64ReverseCharCodeMap
+	}
+
+	if (!outputBuffer) {
+		const capacity = (base64String.length / 4) * 3
+
+		outputBuffer = new Uint8Array(capacity)
+	}
+
+	const stringLength = base64String.length
+
+	let readOffset = 0
+	let writeOffset = 0
+
+	while (readOffset < stringLength) {
+		const uint24 =
+			(reverseCharCodeMap[base64String.charCodeAt(readOffset++)] << 18) |
+			(reverseCharCodeMap[base64String.charCodeAt(readOffset++)] << 12) |
+			(reverseCharCodeMap[base64String.charCodeAt(readOffset++)] << 6) |
+			(reverseCharCodeMap[base64String.charCodeAt(readOffset++)])
+
+		outputBuffer[writeOffset++] = (uint24 >>> 16) & 255
+		outputBuffer[writeOffset++] = (uint24 >>> 8) & 255
+		outputBuffer[writeOffset++] = (uint24) & 255
+	}
+
+	// Remove 1 or 2 last bytes if padding characters were added to the string
+	if (base64String[stringLength - 1] === paddingCharacter) {
+		writeOffset--
+	}
+
+	if (base64String[stringLength - 2] === paddingCharacter) {
+		writeOffset--
+	}
+
+	return outputBuffer.subarray(0, writeOffset)
+}
+
+export const defaultBase64CharCodeMap: Uint8Array = new Uint8Array([65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47])
+export const defaultBase64ReverseCharCodeMap: Uint8Array = new Uint8Array([255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 255, 255, 255, 255])

package/src/encodings/Hex.ts

@@ -0,0 +1,67 @@
+import { decodeAscii } from "./Ascii.js"
+
+export function encodeHex(buffer: Uint8Array) {
+	const asciiBuffer = encodeHexAsAsciiBuffer(buffer)
+
+	return decodeAscii(asciiBuffer)
+}
+
+export function encodeHexAsAsciiBuffer(buffer: Uint8Array) {
+	const bufferLen = buffer.length
+
+	const charCodes = new Uint8Array(bufferLen * 2)
+
+	let readOffset = 0
+	let writeOffset = 0
+
+	while (readOffset < bufferLen) {
+		const value = buffer[readOffset++]
+
+		const valueHigh4Bits = (value >>> 4) & 0xf
+		const valueLow4Bits = value & 0xf
+
+		charCodes[writeOffset++] = hexCharCodeLookup[valueHigh4Bits]
+		charCodes[writeOffset++] = hexCharCodeLookup[valueLow4Bits]
+	}
+
+	return charCodes
+}
+
+export function decodeHex(hexString: string) {
+	const hexLength = hexString.length
+
+	if (hexLength % 2 !== 0) {
+		throw new Error(`Hexadecimal string doesn't have an even number of characters`)
+	}
+
+	const buffer = new Uint8Array(hexLength / 2)
+
+	let readOffset = 0
+	let writeOffset = 0
+
+	while (readOffset < hexLength) {
+		const valueHigh4Bits = hexCharCodeToValue(hexString.charCodeAt(readOffset++))
+		const valueLow4Bits = hexCharCodeToValue(hexString.charCodeAt(readOffset++))
+
+		const value = (valueHigh4Bits << 4) | valueLow4Bits
+
+		buffer[writeOffset++] = value
+	}
+
+	return buffer
+}
+
+function hexCharCodeToValue(hexCharCode: number) {
+	if (hexCharCode >= 48 && hexCharCode <= 57) { // '0'..'9'
+		return hexCharCode - 48
+	} else if (hexCharCode >= 97 && hexCharCode <= 102) { // 'a'..'f'
+		return 10 + hexCharCode - 97
+	} else if (hexCharCode >= 65 && hexCharCode <= 70) { // 'A'..'F'
+		return 10 + hexCharCode - 65
+	} else {
+		throw new Error(`Can't decode character '${String.fromCharCode(hexCharCode)}' (code: ${hexCharCode}) as hexadecimal`)
+	}
+}
+
+const hexCharLookup: string[] = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
+const hexCharCodeLookup = new Uint8Array([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102])

package/src/{utilities → encodings}/LEB128.ts

@@ -1,5 +1,5 @@
-import { DynamicUint8Array } from "./DynamicUint8Array.js"
-import { logToStderr } from "./Utilities.js"
+import { DynamicUint8Array, createDynamicUint8Array } from "../data-structures/DynamicTypedArray.js"
+import { logToStderr } from "../utilities/Utilities.js"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Encode unsigned integer
@@ -337,13 +337,13 @@ export interface DecodedValueAndReadOffset {
 // Tests
 ////////////////////////////////////////////////////////////////////////////////////
 export function testLeb128Signed() {
-	const encodedBytes = new DynamicUint8Array()
+	const encodedBytes = createDynamicUint8Array()
 
 	function runTest(testValue: number) {
 		encodedBytes.clear()
 
 		encodeSignedInt32Fast(testValue, encodedBytes)
-		const { decodedValue } = decodeSignedInt32Fast(encodedBytes.data, 0)
+		const { decodedValue } = decodeSignedInt32Fast(encodedBytes.elements, 0)
 
 		if (decodedValue !== testValue) {
 			throw new Error(`Expected ${testValue} but got ${decodedValue}`)

package/src/{utilities → encodings}/LPVarInt.ts

@@ -1,5 +1,5 @@
-import { DynamicUint8Array } from "./DynamicUint8Array.js"
-import { logToStderr } from "./Utilities.js"
+import { createDynamicUint8Array, DynamicUint8Array } from "../data-structures/DynamicTypedArray.js"
+import { logToStderr } from "../utilities/Utilities.js"
 
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -242,13 +242,13 @@ export interface DecodedValueAndReadOffset {
 // Tests
 ////////////////////////////////////////////////////////////////////////////////////
 export function testLPVarintSigned() {
-	const encodedBytes = new DynamicUint8Array()
+	const encodedBytes = createDynamicUint8Array()
 
 	function runTest(testValue: number) {
 		encodedBytes.clear()
 
 		encodeSignedInt32(testValue, encodedBytes)
-		const { decodedValue } = decodeSignedInt32(encodedBytes.data, 0)
+		const { decodedValue } = decodeSignedInt32(encodedBytes.elements, 0)
 
 		if (decodedValue !== testValue) {
 			throw new Error(`Expected ${testValue} but got ${decodedValue}`)
@@ -267,13 +267,13 @@ export function testLPVarintSigned() {
 }
 
 export function testLPVarintUnsigned() {
-	const encodedBytes = new DynamicUint8Array()
+	const encodedBytes = createDynamicUint8Array()
 
 	function runTest(testValue: number) {
 		encodedBytes.clear()
 
 		encodeUnsignedInt31(testValue, encodedBytes)
-		const { decodedValue } = decodeUnsignedInt31(encodedBytes.data, 0)
+		const { decodedValue } = decodeUnsignedInt31(encodedBytes.elements, 0)
 
 		if (decodedValue !== testValue) {
 			throw new Error(`Expected ${testValue} but got ${decodedValue}`)

package/src/encodings/TextEncodingsCommon.ts

@@ -0,0 +1,4 @@
+export interface EncodeIntoResult {
+	read: number
+	written: number
+}

package/src/encodings/Utf16.ts

@@ -0,0 +1,52 @@
+import { EncodeIntoResult } from "./TextEncodingsCommon.js"
+
+export function encodeUtf16(text: string) {
+	const resultArray = new Uint16Array(text.length)
+
+	const { written } = encodeUtf16Into(text, resultArray)
+
+	return resultArray.subarray(0, written)
+}
+
+export function encodeUtf16Into(text: string, resultBuffer: Uint16Array): EncodeIntoResult {
+	const len = text.length
+
+	if (resultBuffer.length < len) {
+		throw new Error(`Result Uint16Array is not large enough to hold the string`)
+	}
+
+	for (let readOffset = 0; readOffset < len; readOffset++) {
+		resultBuffer[readOffset] = text.charCodeAt(readOffset)
+	}
+
+	return { read: len, written: len }
+}
+
+export function decodeUtf16(encodedString: Uint16Array) {
+	const maxChunkLength = 2 ** 24
+
+	const decoder = new ChunkedUtf16Decoder()
+
+	for (let offset = 0; offset < encodedString.length; offset += maxChunkLength) {
+		const chunk = encodedString.subarray(offset, offset + maxChunkLength)
+
+		decoder.writeChunk(chunk)
+	}
+
+	return decoder.toString()
+}
+
+export class ChunkedUtf16Decoder {
+	private str = ''
+	private readonly textDecoder = new TextDecoder('utf-16le')
+
+	writeChunk(chunk: Uint16Array) {
+		const decodedChunk = this.textDecoder.decode(chunk)
+
+		this.str += decodedChunk
+	}
+
+	toString() {
+		return this.str
+	}
+}