echogarden 2.7.0 → 2.8.0

package/src/utilities/Timeline.ts

@@ -1,7 +1,8 @@
+import { addMissingPunctuationWordsToWordSequence, segmentWordSequence, WordSequence } from '@echogarden/text-segmentation'
 import { ParagraphBreakType, WhitespaceProcessing } from '../api/Common.js'
-import { applyWhitespaceProcessing, isWord, isWordOrSymbolWord, splitToParagraphs, splitToSentences, splitToWords } from '../nlp/Segmentation.js'
+import { isWord, isWordOrSymbolWord, splitToParagraphs, splitToWords } from '../nlp/Segmentation.js'
 import { deepClone } from './ObjectUtilities.js'
-import { getUTF32Chars, splitAndPreserveSeparators } from './StringUtilities.js'
+import { getUTF32Chars } from './StringUtilities.js'
 import { roundToDigits } from './Utilities.js'
 
 export function addTimeOffsetToTimeline(targetTimeline: Timeline, timeOffset: number) {
@@ -62,199 +63,155 @@ export function roundTimelineProperties(targetTimeline: Timeline, decimalDigits
 	return roundedTimeline
 }
 
-export async function wordTimelineToSegmentSentenceTimeline(wordTimeline: Timeline, transcript: string, language: string, paragraphBreaks: ParagraphBreakType = 'double', whitespace: WhitespaceProcessing = 'collapse') {
-	let segments: string[][] = []
+export async function wordTimelineToSegmentSentenceTimeline(wordTimelineWithOffsets: Timeline, transcript: string, language: string, paragraphBreaks: ParagraphBreakType = 'double', whitespace: WhitespaceProcessing = 'collapse') {
+	const wordSequence = new WordSequence()
 
-	{
-		// Ensure word entries with words that include potential sentence ending characters,
-		// like '.', '?' or '!', aren't causing the sentence segmentation
-		// to identify them as sentence breaks.
-		const maskedTranscript = replaceSentenceEndersWithinWordsWithMaskingCharacter(transcript, wordTimeline, '_')
-
-		// Split to segments and sentences, based on the masked transcript,
-		// don't apply any whitespace processing yet.
-		let paragraphs: string[]
-
-		if (paragraphBreaks === 'single') {
-			paragraphs = splitAndPreserveSeparators(maskedTranscript, /(\r?\n)+/g)
-		} else if (paragraphBreaks === 'double') {
-			paragraphs = splitAndPreserveSeparators(maskedTranscript, /(\r?\n)(\r?\n)+/g)
-		} else {
-			throw new Error(`Invalid paragraph break type: '${paragraphBreaks}'`)
-		}
-
-		const maskedSegments = paragraphs.map(paragraph => splitToSentences(paragraph, language))
-
-		// Restore the sentence text the original text, using the original transcript,
-		// and apply whitespace processing to each sentence.
-		let offset = 0
+	for (const wordEntry of wordTimelineWithOffsets) {
+		const wordStartOffset = wordEntry.startOffsetUtf16!
+		const wordEndOffset = wordEntry.endOffsetUtf16!
 
-		for (const segment of maskedSegments) {
-			const newSegment: string[] = []
+		const isPunctuation = !isWordOrSymbolWord(wordEntry.text)
 
-			for (let sentenceIndex = 0; sentenceIndex < segment.length; sentenceIndex++) {
-				const sentence = segment[sentenceIndex]
-				const sentenceLength = sentence.length
-
-				const restoredSentence = transcript.substring(offset, offset + sentenceLength)
-				const restoredAndProcessedSentence = applyWhitespaceProcessing(restoredSentence, whitespace).trim()
+		wordSequence.addWord(wordEntry.text, wordStartOffset, isPunctuation)
+	}
 
-				if (restoredAndProcessedSentence.length > 0) {
-					newSegment.push(restoredAndProcessedSentence)
-				}
+	const { wordSequenceWithPunctuation, originalWordsReverseMapping } = addMissingPunctuationWordsToWordSequence(wordSequence, transcript)
 
-				offset += sentenceLength
-			}
+	const segmentedWordSequence = await segmentWordSequence(wordSequenceWithPunctuation)
 
-			segments.push(newSegment)
-		}
+	const paragraphs = splitToParagraphs(transcript, paragraphBreaks, whitespace)
+	const sentenceIndexesForParagraph = paragraphs.map(_ => [] as number[])
 
-		segments = segments.filter(segment => segment.length > 0)
-	}
+	{
+		let sentenceIndex = 0
+		let charOffset = 0
 
-	// Create a new text based on the processed sentences, new segment and sentence timeline,
-	// and store mapping between character indexes and the corresponding sentence they belong to.
-	let text = ''
-	const charIndexToSentenceEntryMapping: TimelineEntry[] = []
+		for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex++) {
+			const paragraph = paragraphs[paragraphIndex]
 
-	const segmentTimeline: Timeline = []
+			const paragraphStartOffset = charOffset
+			const paragraphEndOffset = paragraphStartOffset + paragraph.length
 
-	for (const segment of segments) {
-		const sentencesInSegment: Timeline = []
+			while (sentenceIndex < segmentedWordSequence.sentences.length) {
+				const sentenceEntry = segmentedWordSequence.sentences[sentenceIndex]
+				const sentenceStartOffset = sentenceEntry.charRange.start
+				const sentenceEndOffset = sentenceEntry.charRange.end
 
-		const segmentEntry: TimelineEntry = {
-			type: 'segment',
-			text: '',
-			startTime: -1,
-			endTime: -1,
-			timeline: sentencesInSegment
-		}
-
-		for (const sentence of segment) {
-			const sentenceEntry: TimelineEntry = {
-				type: 'sentence',
-				text: sentence,
-				startTime: -1,
-				endTime: -1,
-				timeline: []
+				if (sentenceStartOffset < paragraphEndOffset) {
+					sentenceIndexesForParagraph[paragraphIndex].push(sentenceIndex)
+					sentenceIndex++
+				} else {
+					break
+				}
 			}
 
-			for (const char of sentence + ' ') {
-				text += char
-				charIndexToSentenceEntryMapping.push(sentenceEntry)
+			if (sentenceIndex === segmentedWordSequence.sentences.length) {
+				break
 			}
 
-			sentencesInSegment.push(sentenceEntry)
+			charOffset += paragraph.length
 		}
-
-		segmentTimeline.push(segmentEntry)
 	}
 
-	// Add the word entries to their corresponding sentence timelines
-	{
-		let wordSearchStartOffset = 0
-
-		for (let wordIndex = 0; wordIndex < wordTimeline.length; wordIndex++) {
-			const wordEntry = wordTimeline[wordIndex]
-			const wordText = wordEntry.text
-
-			if (!isWordOrSymbolWord(wordText)) {
-				continue
-			}
-
-			const indexOfWordInText = text.indexOf(wordText, wordSearchStartOffset)
-
-			if (indexOfWordInText == -1) {
-				throw new Error(`Couldn't find the word '${wordText}' in the text at start position ${wordSearchStartOffset}`)
-			}
+	const segmentTimeline: Timeline = []
+	let wordIndex = 0
 
-			const targetSentenceEntry = charIndexToSentenceEntryMapping[indexOfWordInText]
-			targetSentenceEntry.timeline!.push(deepClone(wordEntry))
+	for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex++) {
+		const paragraph = paragraphs[paragraphIndex]
+		const sentencesIndexes = sentenceIndexesForParagraph[paragraphIndex]
+		const sentenceEntries = sentencesIndexes.map(index => segmentedWordSequence.sentences[index])
 
-			wordSearchStartOffset = indexOfWordInText + wordText.length
-		}
-	}
+		const sentenceTimeline: Timeline = []
 
-	// Produce a new segment/sentence timeline with rewritten entries,
-	// that match the assigned words.
-	const newSegmentTimeline: Timeline = []
+		for (const sentenceEntry of sentenceEntries) {
+			const wordTimeline: Timeline = []
 
-	for (const segmentEntry of segmentTimeline) {
-		const oldSentenceTimeline = segmentEntry.timeline!
+			for (const _ of sentenceEntry.words.entries) {
+				const originalWordIndex = originalWordsReverseMapping.get(wordIndex)
 
-		const newSentenceTimeline: Timeline = []
+				if (originalWordIndex !== undefined) {
+					const wordTimelineEntry = wordTimelineWithOffsets[originalWordIndex]
 
-		for (const sentenceEntry of oldSentenceTimeline) {
-			const wordTimeline = sentenceEntry.timeline
+					wordTimeline.push(wordTimelineEntry)
+				}
 
-			if (!wordTimeline || wordTimeline.length === 0) {
-				continue
+				wordIndex += 1
 			}
 
-			sentenceEntry.startTime = wordTimeline[0].startTime
-			sentenceEntry.endTime = wordTimeline[wordTimeline.length - 1].endTime
+			const sentenceTimelineEntry: TimelineEntry = {
+				type: 'sentence',
+				text: sentenceEntry.text,
+				startTime: wordTimeline[0].startTime,
+				endTime: wordTimeline[wordTimeline.length - 1].endTime,
 
-			newSentenceTimeline.push(sentenceEntry)
-		}
+				timeline: wordTimeline,
+			}
 
-		if (newSentenceTimeline.length === 0) {
-			continue
+			sentenceTimeline.push(sentenceTimelineEntry)
 		}
 
-		segmentEntry.text = newSentenceTimeline.map(sentenceEntry => sentenceEntry.text).join(' ')
+		const segmentTimelineEntry: TimelineEntry = {
+			type: 'segment',
+			text: paragraph,
+			startTime: sentenceTimeline[0].startTime,
+			endTime: sentenceTimeline[sentenceTimeline.length - 1].endTime,
 
-		segmentEntry.startTime = newSentenceTimeline[0].startTime
-		segmentEntry.endTime = newSentenceTimeline[newSentenceTimeline.length - 1].endTime
+			timeline: sentenceTimeline,
+		}
 
-		newSegmentTimeline.push(segmentEntry)
+		segmentTimeline.push(segmentTimelineEntry)
 	}
 
-	return { segmentTimeline: newSegmentTimeline }
+	return { segmentTimeline }
 }
 
-export function addWordTextOffsetsToTimeline(timeline: Timeline, text: string, currentOffset = 0) {
-	const { mapping } = getUTF32Chars(text)
+export function addWordTextOffsetsToTimelineInPlace(timeline: Timeline, text: string) {
+	const { utf16To32Mapping } = getUTF32Chars(text)
 
-	for (const entry of timeline) {
-		if (entry.type == 'word') {
-			let word = entry.text
+	let currentOffset = 0
 
-			word = word.trim().replaceAll(/\s+/g, ' ')
+	function processTimeline(timeline: Timeline) {
+		for (const entry of timeline) {
+			if (entry.type === 'word') {
+				let word = entry.text
 
-			const wordParts = word.split(' ')
+				word = word.trim().replaceAll(/\s+/g, ' ')
 
-			let startOffset: number | undefined
-			let endOffset: number | undefined
+				const wordParts = word.split(' ')
 
-			for (let i = 0; i < wordParts.length; i++) {
-				let wordPart = wordParts[i]
+				let startOffset: number | undefined
+				let endOffset: number | undefined
 
-				let wordPartOffset = text.indexOf(wordPart, currentOffset)
+				for (let i = 0; i < wordParts.length; i++) {
+					const wordPart = wordParts[i]
 
-				if (wordPartOffset == -1) {
-					continue
-				}
+					const wordPartOffset = text.indexOf(wordPart, currentOffset)
 
-				currentOffset = wordPartOffset + wordParts[i].length
+					if (wordPartOffset === -1) {
+						continue
+					}
 
-				if (i == 0) {
-					startOffset = wordPartOffset
-				}
+					currentOffset = wordPartOffset + wordParts[i].length
 
-				endOffset = currentOffset
-			}
+					if (i === 0) {
+						startOffset = wordPartOffset
+					}
 
-			entry.startOffsetUtf16 = startOffset
-			entry.endOffsetUtf16 = endOffset
+					endOffset = currentOffset
+				}
 
-			entry.startOffsetUtf32 = startOffset != undefined ? mapping[startOffset] : undefined
-			entry.endOffsetUtf32 = endOffset != undefined ? mapping[endOffset] : undefined
-		} else if (entry.timeline) {
-			currentOffset = addWordTextOffsetsToTimeline(entry.timeline, text, currentOffset)
+				entry.startOffsetUtf16 = startOffset
+				entry.endOffsetUtf16 = endOffset
+
+				entry.startOffsetUtf32 = startOffset !== undefined ? utf16To32Mapping[startOffset] : undefined
+				entry.endOffsetUtf32 = endOffset !== undefined ? utf16To32Mapping[endOffset] : undefined
+			} else if (entry.timeline) {
+				processTimeline(entry.timeline)
+			}
 		}
 	}
 
-	return currentOffset
+	return processTimeline(timeline)
 }
 
 function replaceSentenceEndersWithinWordsWithMaskingCharacter(transcript: string, wordTimeline: Timeline, maskingCharacter: string) {
@@ -344,30 +301,3 @@ export type TimelineEntry = {
 }
 
 export type Timeline = TimelineEntry[]
-
-////
-
-export async function testTimelineFix() {
-	let transcript = 'Hello world how are you? Do you want to play chess?'
-	const words = (await splitToWords(transcript, 'en')).filter(word => word.trim() !== '')
-
-	let wordTimeline: Timeline = words.map(wordText => ({
-		type: 'word',
-
-		text: wordText,
-
-		startTime: 0,
-		endTime: 0,
-	}))
-
-	addWordTextOffsetsToTimeline(wordTimeline, transcript)
-
-	wordTimeline[1].text = 'wor.d'
-	wordTimeline[8].text = 'wa.t'
-
-	transcript = transcript.replace('world', 'wor.d').replace('want', 'wa.t')
-
-	const result = await wordTimelineToSegmentSentenceTimeline(wordTimeline, transcript, 'en')
-
-	const x = 1
-}

package/src/utilities/WikipediaReader.ts

@@ -1,4 +1,4 @@
-import { splitToParagraphs, wordCharacterPattern } from '../nlp/Segmentation.js'
+import { splitToParagraphs, wordCharacterRegExp } from '../nlp/Segmentation.js'
 import { Logger } from './Logger.js'
 
 export async function parseWikipediaArticle(articleName: string, language: string) {
@@ -20,7 +20,7 @@ export async function parseWikipediaArticle(articleName: string, language: strin
 	for (const section of sections) {
 		const sectionTitle = section.title()
 
-		if (wordCharacterPattern.test(sectionTitle)) {
+		if (wordCharacterRegExp.test(sectionTitle)) {
 			sectionsText.push(sectionTitle)
 		}
 
@@ -29,7 +29,7 @@ export async function parseWikipediaArticle(articleName: string, language: strin
 		for (const paragraph of sectionParagraphs) {
 			const paragraphText = paragraph
 
-			if (wordCharacterPattern.test(paragraphText)) {
+			if (wordCharacterRegExp.test(paragraphText)) {
 				sectionsText.push(paragraphText)
 			}
 		}

package/src/voice-activity-detection/WebRtcVAD.ts

@@ -1,6 +1,7 @@
 import * as AudioBufferConversion from '../audio/AudioBufferConversion.js'
 import { RawAudio } from '../audio/AudioUtilities.js'
-import { WasmMemoryManager } from '../utilities/WasmMemoryManager.js'
+
+import { wrapEmscriptenModuleHeap } from 'wasm-heap-manager'
 
 export async function detectVoiceActivity(rawAudio: RawAudio, frameDuration: 10 | 20 | 30 = 10, mode: 0 | 1 | 2 | 3 = 0) {
 	if (rawAudio.sampleRate != 16000) {
@@ -15,7 +16,7 @@ export async function detectVoiceActivity(rawAudio: RawAudio, frameDuration: 10
 export async function fvad(samples: Int16Array, sampleRate: number, frameDuration: 10 | 20 | 30, mode: 0 | 1 | 2 | 3) {
 	const m = await getFvadInstance()
 
-	const wasmMemory = new WasmMemoryManager(m)
+	const wasmHeap = wrapEmscriptenModuleHeap(m)
 
 	const fvad_new = m._fvad_new
 	const fvad_free = m._fvad_free
@@ -39,7 +40,7 @@ export async function fvad(samples: Int16Array, sampleRate: number, frameDuratio
 	}
 
 	const frameSampleCount = Math.floor(sampleRate * (frameDuration / 1000))
-	const frameSamplesRef = wasmMemory.allocInt16Array(frameSampleCount)
+	const frameSamplesRef = wasmHeap.allocInt16Array(frameSampleCount)
 
 	const result = []
 
@@ -59,7 +60,7 @@ export async function fvad(samples: Int16Array, sampleRate: number, frameDuratio
 	}
 
 	fvad_free(instancePtr)
-	wasmMemory.freeAll()
+	wasmHeap.freeAll()
 
 	return result
 }

package/dist/nlp/CompromiseNLP.d.ts

@@ -1,15 +0,0 @@
-import { Lexicon } from './Lexicon.js';
-export declare function parse(text: string): Promise<CompromiseParsedDocument>;
-export declare function tryMatchInLexicons(term: CompromiseParsedTerm, lexicons: Lexicon[], espeakVoice: string): string[] | undefined;
-export declare function tryMatchInLexicon(term: CompromiseParsedTerm, lexicon: Lexicon, espeakVoice: string): string[] | undefined;
-export type CompromiseParsedDocument = CompromiseParsedSentence[];
-export type CompromiseParsedSentence = CompromiseParsedTerm[];
-export type CompromiseParsedTerm = {
-    text: string;
-    pos: string;
-    tags: string[];
-    preText: string;
-    postText: string;
-    startOffset: number;
-    endOffset: number;
-};

package/dist/nlp/CompromiseNLP.js

@@ -1,79 +0,0 @@
-import { getShortLanguageCode } from '../utilities/Locale.js';
-import { logToStderr } from '../utilities/Utilities.js';
-const log = logToStderr;
-export async function parse(text) {
-    const { default: nlp } = await import('compromise');
-    const doc = nlp(text);
-    doc.compute('penn');
-    const jsonDoc = doc.json({ offset: true });
-    //log(jsonDoc)
-    const result = jsonDoc.map(sentence => {
-        const terms = sentence.terms;
-        const parsedSentence = [];
-        for (let termIndex = 0; termIndex < terms.length; termIndex++) {
-            const term = terms[termIndex];
-            const parsedTerm = {
-                text: term.text,
-                pos: term.penn,
-                tags: term.tags,
-                preText: term.pre,
-                postText: term.post,
-                startOffset: term.offset.start,
-                endOffset: term.offset.start + term.offset.length
-            };
-            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 += '.';
-                parsedTerm.endOffset += 1;
-                parsedSentence.push(parsedTerm);
-            }
-            else {
-                parsedSentence.push(parsedTerm);
-            }
-        }
-        return parsedSentence;
-    });
-    //log(result)
-    return result;
-}
-export function tryMatchInLexicons(term, lexicons, espeakVoice) {
-    const reversedLexicons = [...lexicons].reverse(); // Give precedence to later lexicons
-    for (const lexicon of reversedLexicons) {
-        const match = tryMatchInLexicon(term, lexicon, espeakVoice);
-        if (match) {
-            return match;
-        }
-    }
-    return undefined;
-}
-export function tryMatchInLexicon(term, lexicon, espeakVoice) {
-    const shortLanguageCode = getShortLanguageCode(espeakVoice);
-    const lexiconForLanguage = lexicon[shortLanguageCode];
-    if (!lexiconForLanguage) {
-        return undefined;
-    }
-    const termText = term.text;
-    const lowerCaseTermText = termText.toLocaleLowerCase();
-    let entry = lexiconForLanguage[lowerCaseTermText];
-    if (!entry) {
-        return undefined;
-    }
-    if (!Array.isArray(entry)) {
-        entry = [entry];
-    }
-    for (const substitutionEntry of entry) {
-        if (!substitutionEntry.pos || substitutionEntry.pos.includes(term.pos)) {
-            const substitutionPhonemesText = substitutionEntry?.pronunciation?.espeak?.[espeakVoice];
-            if (substitutionPhonemesText) {
-                const substitutionPhonemes = substitutionPhonemesText.split(/ +/g);
-                return substitutionPhonemes;
-            }
-        }
-    }
-    return undefined;
-}
-//# sourceMappingURL=CompromiseNLP.js.map

package/dist/nlp/CompromiseNLP.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CompromiseNLP.js","sourceRoot":"","sources":["../../src/nlp/CompromiseNLP.ts"],"names":[],"mappings":"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"}

package/dist/utilities/WasmMemoryManager.d.ts

@@ -1,153 +0,0 @@
-import { TypedArray } from "../typings/TypedArray.js";
-export declare class WasmMemoryManager {
-    wasmModule: any;
-    private wasmAlloc;
-    private wasmFree;
-    private allocatedReferences;
-    constructor(wasmModule: any, options?: WasmMemoryManagerOptions);
-    allocInt8(): Int8Ref;
-    wrapInt8(address: number): Int8Ref;
-    allocUint8(): Uint8Ref;
-    wrapUint8(address: number): Uint8Ref;
-    allocInt16(): Int16Ref;
-    wrapInt16(address: number): Int16Ref;
-    allocUint16(): Uint16Ref;
-    wrapUint16(address: number): Uint16Ref;
-    allocInt32(): Int32Ref;
-    wrapInt32(address: number): Int32Ref;
-    allocUint32(): Uint32Ref;
-    wrapUint32(address: number): Uint32Ref;
-    allocPointer(): PointerRef;
-    wrapPointer(address: number): PointerRef;
-    allocFloat32(): Float64Ref;
-    wrapFloat32(address: number): Float32Ref;
-    allocFloat64(): Float64Ref;
-    wrapFloat64(address: number): Float64Ref;
-    allocInt8Array(length: number): Int8ArrayRef;
-    wrapInt8Array(address: number, length: number): Int8ArrayRef;
-    allocUint8Array(length: number): Uint8ArrayRef;
-    wrapUint8Array(address: number, length: number): Uint8ArrayRef;
-    allocInt16Array(length: number): Int16ArrayRef;
-    wrapInt16Array(address: number, length: number): Int16ArrayRef;
-    allocUint16Array(length: number): Uint16ArrayRef;
-    wrapUint16Array(address: number, length: number): Uint16ArrayRef;
-    allocInt32Array(length: number): Int32ArrayRef;
-    wrapInt32Array(address: number, length: number): Int32ArrayRef;
-    allocUint32Array(length: number): Uint32ArrayRef;
-    wrapUint32Array(address: number, length: number): Uint32ArrayRef;
-    allocFloat32Array(length: number): Float32ArrayRef;
-    wrapFloat32Array(address: number, length: number): Float32ArrayRef;
-    allocFloat64Array(length: number): Float64ArrayRef;
-    wrapFloat64Array(address: number, length: number): Float64ArrayRef;
-    allocNullTerminatedUtf8String(str: string): Uint8ArrayRef;
-    wrapNullTerminatedUtf8String(address: number): NullTerminatedUtf8StringRef;
-    private alloc;
-    free(wasmReference: WasmRef): void;
-    freeAll(): void;
-    detach<T extends WasmRef>(wasmReference: T): T;
-}
-declare abstract class ValueRef<T extends number | string> {
-    protected ptr: number;
-    private readonly manager;
-    protected get module(): any;
-    constructor(ptr: number, manager: WasmMemoryManager);
-    get value(): T;
-    set value(newValue: T);
-    abstract getValue(): T;
-    abstract setValue(newValue: T): void;
-    get address(): number;
-    clear(): this;
-    free(): void;
-    detach(): this;
-    clearAddress(): void;
-    get isFreed(): boolean;
-    protected assertNotFreed(): void;
-}
-export declare class Int8Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Uint8Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Int16Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Uint16Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Int32Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Uint32Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class PointerRef extends Uint32Ref {
-}
-export declare class Float32Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class Float64Ref extends ValueRef<number> {
-    getValue(): number;
-    setValue(newValue: number): void;
-}
-export declare class NullTerminatedUtf8StringRef extends ValueRef<string> {
-    getValue(): string;
-    setValue(newValue: string): void;
-}
-declare abstract class TypedArrayRef<T extends TypedArray> {
-    protected ptr: number;
-    readonly length: number;
-    private readonly manager;
-    get module(): any;
-    constructor(ptr: number, length: number, manager: WasmMemoryManager);
-    get view(): T;
-    protected abstract getView(): T;
-    slice(start?: number, end?: number): Int32Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Uint8ClampedArray<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Float64Array<ArrayBuffer>;
-    get address(): number;
-    clear(): this;
-    free(): void;
-    clearAddress(): void;
-    detach(): this;
-    get isFreed(): boolean;
-    protected assertNotFreed(): void;
-}
-export declare class Int8ArrayRef extends TypedArrayRef<Int8Array> {
-    getView(): Int8Array;
-}
-export declare class Uint8ArrayRef extends TypedArrayRef<Uint8Array> {
-    getView(): Uint8Array;
-    readAsNullTerminatedUtf8String(): string;
-}
-export declare class Int16ArrayRef extends TypedArrayRef<Int16Array> {
-    getView(): Int16Array;
-}
-export declare class Uint16ArrayRef extends TypedArrayRef<Uint16Array> {
-    getView(): Uint16Array;
-}
-export declare class Int32ArrayRef extends TypedArrayRef<Int32Array> {
-    getView(): Int32Array;
-}
-export declare class Uint32ArrayRef extends TypedArrayRef<Uint32Array> {
-    getView(): Uint32Array;
-}
-export declare class Float32ArrayRef extends TypedArrayRef<Float32Array> {
-    getView(): Float32Array;
-}
-export declare class Float64ArrayRef extends TypedArrayRef<Float64Array> {
-    getView(): Float64Array;
-}
-export type WasmRef = ValueRef<number> | ValueRef<string> | TypedArrayRef<TypedArray>;
-export interface WasmMemoryManagerOptions {
-    wasmAlloc?: WasmAllocMethod;
-    wasmFree?: WasmFreeMethod;
-}
-export type WasmAllocMethod = (size: number) => number;
-export type WasmFreeMethod = (address: number) => void;
-export {};