brilliantsole 0.0.28 → 0.0.29

package/build/brilliantsole.js

@@ -60,7 +60,7 @@
 		isSafari: isSafari
 	});
 
-	var _a$7, _Console_consoles, _Console_levelFlags;
+	var _a$8, _Console_consoles, _Console_levelFlags;
 	var __console;
 	if (isInLensStudio) {
 	    const log = function (...args) {
@@ -134,27 +134,27 @@
 	            error: true,
 	            table: true,
 	        });
-	        if (__classPrivateFieldGet(_a$7, _a$7, "f", _Console_consoles)[type]) {
+	        if (__classPrivateFieldGet(_a$8, _a$8, "f", _Console_consoles)[type]) {
 	            throw new Error(`"${type}" console already exists`);
 	        }
-	        __classPrivateFieldGet(_a$7, _a$7, "f", _Console_consoles)[type] = this;
+	        __classPrivateFieldGet(_a$8, _a$8, "f", _Console_consoles)[type] = this;
 	    }
 	    setLevelFlags(levelFlags) {
 	        Object.assign(__classPrivateFieldGet(this, _Console_levelFlags, "f"), levelFlags);
 	    }
 	    static setLevelFlagsForType(type, levelFlags) {
-	        if (!__classPrivateFieldGet(this, _a$7, "f", _Console_consoles)[type]) {
+	        if (!__classPrivateFieldGet(this, _a$8, "f", _Console_consoles)[type]) {
 	            throw new Error(`no console found with type "${type}"`);
 	        }
-	        __classPrivateFieldGet(this, _a$7, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
+	        __classPrivateFieldGet(this, _a$8, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
 	    }
 	    static setAllLevelFlags(levelFlags) {
-	        for (const type in __classPrivateFieldGet(this, _a$7, "f", _Console_consoles)) {
-	            __classPrivateFieldGet(this, _a$7, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
+	        for (const type in __classPrivateFieldGet(this, _a$8, "f", _Console_consoles)) {
+	            __classPrivateFieldGet(this, _a$8, "f", _Console_consoles)[type].setLevelFlags(levelFlags);
 	        }
 	    }
 	    static create(type, levelFlags) {
-	        const console = __classPrivateFieldGet(this, _a$7, "f", _Console_consoles)[type] || new _a$7(type);
+	        const console = __classPrivateFieldGet(this, _a$8, "f", _Console_consoles)[type] || new _a$8(type);
 	        return console;
 	    }
 	    get log() {
@@ -187,7 +187,7 @@
 	        this.assertWithError(value >= min && value <= max, `${name} ${value} must be within ${min}-${max}`);
 	    }
 	}
-	_a$7 = Console, _Console_levelFlags = new WeakMap();
+	_a$8 = Console, _Console_levelFlags = new WeakMap();
 	_Console_consoles = { value: {} };
 	function createConsole(type, levelFlags) {
 	    return Console.create(type, levelFlags);
@@ -199,7 +199,7 @@
 	    Console.setAllLevelFlags(levelFlags);
 	}
 
-	const _console$y = createConsole("EventDispatcher", { log: false });
+	const _console$z = createConsole("EventDispatcher", { log: false });
 	class EventDispatcher {
 	    constructor(target, validEventTypes) {
 	        this.target = target;
@@ -220,7 +220,7 @@
 	            return;
 	        this.listeners[type] = this.listeners[type].filter((listenerObj) => {
 	            if (listenerObj.shouldRemove) {
-	                _console$y.log(`removing "${type}" eventListener`, listenerObj);
+	                _console$z.log(`removing "${type}" eventListener`, listenerObj);
 	            }
 	            return !listenerObj.shouldRemove;
 	        });
@@ -231,18 +231,18 @@
 	        }
 	        if (!this.listeners[type]) {
 	            this.listeners[type] = [];
-	            _console$y.log(`creating "${type}" listeners array`, this.listeners[type]);
+	            _console$z.log(`creating "${type}" listeners array`, this.listeners[type]);
 	        }
 	        const alreadyAdded = this.listeners[type].find((listenerObject) => {
 	            return listenerObject.listener == listener && listenerObject.once == options.once;
 	        });
 	        if (alreadyAdded) {
-	            _console$y.log("already added listener");
+	            _console$z.log("already added listener");
 	            return;
 	        }
-	        _console$y.log(`adding "${type}" listener`, listener, options);
+	        _console$z.log(`adding "${type}" listener`, listener, options);
 	        this.listeners[type].push({ listener, once: options.once });
-	        _console$y.log(`currently have ${this.listeners[type].length} "${type}" listeners`);
+	        _console$z.log(`currently have ${this.listeners[type].length} "${type}" listeners`);
 	    }
 	    removeEventListener(type, listener) {
 	        if (!this.isValidEventType(type)) {
@@ -250,11 +250,11 @@
 	        }
 	        if (!this.listeners[type])
 	            return;
-	        _console$y.log(`removing "${type}" listener...`, listener);
+	        _console$z.log(`removing "${type}" listener...`, listener);
 	        this.listeners[type].forEach((listenerObj) => {
 	            const isListenerToRemove = listenerObj.listener === listener;
 	            if (isListenerToRemove) {
-	                _console$y.log(`flagging "${type}" listener`, listener);
+	                _console$z.log(`flagging "${type}" listener`, listener);
 	                listenerObj.shouldRemove = true;
 	            }
 	        });
@@ -266,11 +266,11 @@
 	        }
 	        if (!this.listeners[type])
 	            return;
-	        _console$y.log(`removing "${type}" listeners...`);
+	        _console$z.log(`removing "${type}" listeners...`);
 	        this.listeners[type] = [];
 	    }
 	    removeAllEventListeners() {
-	        _console$y.log(`removing listeners...`);
+	        _console$z.log(`removing listeners...`);
 	        this.listeners = {};
 	    }
 	    dispatchEvent(type, message) {
@@ -283,10 +283,10 @@
 	            if (listenerObj.shouldRemove) {
 	                return;
 	            }
-	            _console$y.log(`dispatching "${type}" listener`, listenerObj);
+	            _console$z.log(`dispatching "${type}" listener`, listenerObj);
 	            listenerObj.listener({ type, target: this.target, message });
 	            if (listenerObj.once) {
-	                _console$y.log(`flagging "${type}" listener`, listenerObj);
+	                _console$z.log(`flagging "${type}" listener`, listenerObj);
 	                listenerObj.shouldRemove = true;
 	            }
 	        });
@@ -303,14 +303,14 @@
 	}
 
 	var _Timer_callback, _Timer_interval, _Timer_intervalId;
-	const _console$x = createConsole("Timer", { log: false });
+	const _console$y = createConsole("Timer", { log: false });
 	class Timer {
 	    get callback() {
 	        return __classPrivateFieldGet(this, _Timer_callback, "f");
 	    }
 	    set callback(newCallback) {
-	        _console$x.assertTypeWithError(newCallback, "function");
-	        _console$x.log({ newCallback });
+	        _console$y.assertTypeWithError(newCallback, "function");
+	        _console$y.log({ newCallback });
 	        __classPrivateFieldSet(this, _Timer_callback, newCallback, "f");
 	        if (this.isRunning) {
 	            this.restart();
@@ -320,9 +320,9 @@
 	        return __classPrivateFieldGet(this, _Timer_interval, "f");
 	    }
 	    set interval(newInterval) {
-	        _console$x.assertTypeWithError(newInterval, "number");
-	        _console$x.assertWithError(newInterval > 0, "interval must be above 0");
-	        _console$x.log({ newInterval });
+	        _console$y.assertTypeWithError(newInterval, "number");
+	        _console$y.assertWithError(newInterval > 0, "interval must be above 0");
+	        _console$y.log({ newInterval });
 	        __classPrivateFieldSet(this, _Timer_interval, newInterval, "f");
 	        if (this.isRunning) {
 	            this.restart();
@@ -340,10 +340,10 @@
 	    }
 	    start(immediately = false) {
 	        if (this.isRunning) {
-	            _console$x.log("interval already running");
+	            _console$y.log("interval already running");
 	            return;
 	        }
-	        _console$x.log(`starting interval every ${__classPrivateFieldGet(this, _Timer_interval, "f")}ms`);
+	        _console$y.log(`starting interval every ${__classPrivateFieldGet(this, _Timer_interval, "f")}ms`);
 	        __classPrivateFieldSet(this, _Timer_intervalId, setInterval(__classPrivateFieldGet(this, _Timer_callback, "f"), __classPrivateFieldGet(this, _Timer_interval, "f")), "f");
 	        if (immediately) {
 	            __classPrivateFieldGet(this, _Timer_callback, "f").call(this);
@@ -351,10 +351,10 @@
 	    }
 	    stop() {
 	        if (!this.isRunning) {
-	            _console$x.log("interval already not running");
+	            _console$y.log("interval already not running");
 	            return;
 	        }
-	        _console$x.log("stopping interval");
+	        _console$y.log("stopping interval");
 	        clearInterval(__classPrivateFieldGet(this, _Timer_intervalId, "f"));
 	        __classPrivateFieldSet(this, _Timer_intervalId, undefined, "f");
 	    }
@@ -420,7 +420,7 @@
 	const textEncoder = new _TextEncoder();
 	const textDecoder = new _TextDecoder();
 
-	const _console$w = createConsole("ArrayBufferUtils", { log: false });
+	const _console$x = createConsole("ArrayBufferUtils", { log: false });
 	function concatenateArrayBuffers(...arrayBuffers) {
 	    arrayBuffers = arrayBuffers.filter((arrayBuffer) => arrayBuffer != undefined || arrayBuffer != null);
 	    arrayBuffers = arrayBuffers.map((arrayBuffer) => {
@@ -481,7 +481,7 @@
 	    if (length != undefined) {
 	        end = dataView.byteOffset + begin + length;
 	    }
-	    _console$w.log({ dataView, begin, end, length });
+	    _console$x.log({ dataView, begin, end, length });
 	    return new DataView(dataView.buffer.slice(dataView.byteOffset + begin, end));
 	}
 	async function getFileBuffer(file) {
@@ -540,8 +540,8 @@
 		return self;
 	}
 
-	var _FileTransferManager_instances, _a$6, _FileTransferManager_dispatchEvent_get, _FileTransferManager_assertValidType, _FileTransferManager_assertValidTypeEnum, _FileTransferManager_assertValidStatusEnum, _FileTransferManager_assertValidCommand, _FileTransferManager_fileTypes, _FileTransferManager_parseFileTypes, _FileTransferManager_MaxLength, _FileTransferManager_maxLength, _FileTransferManager_parseMaxLength, _FileTransferManager_updateMaxLength, _FileTransferManager_assertValidLength, _FileTransferManager_type, _FileTransferManager_parseType, _FileTransferManager_updateType, _FileTransferManager_setType, _FileTransferManager_length, _FileTransferManager_parseLength, _FileTransferManager_updateLength, _FileTransferManager_setLength, _FileTransferManager_checksum, _FileTransferManager_parseChecksum, _FileTransferManager_updateChecksum, _FileTransferManager_setChecksum, _FileTransferManager_setCommand, _FileTransferManager_status, _FileTransferManager_parseStatus, _FileTransferManager_updateStatus, _FileTransferManager_assertIsIdle, _FileTransferManager_assertIsNotIdle, _FileTransferManager_receivedBlocks, _FileTransferManager_parseBlock, _FileTransferManager_buffer, _FileTransferManager_bytesTransferred, _FileTransferManager_send, _FileTransferManager_sendBlock, _FileTransferManager_parseBytesTransferred, _FileTransferManager_isCancelling, _FileTransferManager_isServerSide;
-	const _console$v = createConsole("FileTransferManager", { log: false });
+	var _FileTransferManager_instances, _a$7, _FileTransferManager_dispatchEvent_get, _FileTransferManager_assertValidType, _FileTransferManager_assertValidTypeEnum, _FileTransferManager_assertValidStatusEnum, _FileTransferManager_assertValidCommand, _FileTransferManager_fileTypes, _FileTransferManager_parseFileTypes, _FileTransferManager_MaxLength, _FileTransferManager_maxLength, _FileTransferManager_parseMaxLength, _FileTransferManager_updateMaxLength, _FileTransferManager_assertValidLength, _FileTransferManager_type, _FileTransferManager_parseType, _FileTransferManager_updateType, _FileTransferManager_setType, _FileTransferManager_length, _FileTransferManager_parseLength, _FileTransferManager_updateLength, _FileTransferManager_setLength, _FileTransferManager_checksum, _FileTransferManager_parseChecksum, _FileTransferManager_updateChecksum, _FileTransferManager_setChecksum, _FileTransferManager_setCommand, _FileTransferManager_status, _FileTransferManager_parseStatus, _FileTransferManager_updateStatus, _FileTransferManager_assertIsIdle, _FileTransferManager_assertIsNotIdle, _FileTransferManager_receivedBlocks, _FileTransferManager_parseBlock, _FileTransferManager_buffer, _FileTransferManager_bytesTransferred, _FileTransferManager_send, _FileTransferManager_sendBlock, _FileTransferManager_parseBytesTransferred, _FileTransferManager_isCancelling, _FileTransferManager_isServerSide;
+	const _console$w = createConsole("FileTransferManager", { log: false });
 	const FileTransferMessageTypes = [
 	    "getFileTypes",
 	    "maxFileLength",
@@ -582,7 +582,7 @@
 	    constructor() {
 	        _FileTransferManager_instances.add(this);
 	        _FileTransferManager_fileTypes.set(this, []);
-	        _FileTransferManager_maxLength.set(this, _a$6.MaxLength);
+	        _FileTransferManager_maxLength.set(this, _a$7.MaxLength);
 	        _FileTransferManager_type.set(this, void 0);
 	        _FileTransferManager_length.set(this, 0);
 	        _FileTransferManager_checksum.set(this, 0);
@@ -607,7 +607,7 @@
 	        return __classPrivateFieldGet(this, _FileTransferManager_fileTypes, "f");
 	    }
 	    static get MaxLength() {
-	        return __classPrivateFieldGet(this, _a$6, "f", _FileTransferManager_MaxLength);
+	        return __classPrivateFieldGet(this, _a$7, "f", _FileTransferManager_MaxLength);
 	    }
 	    get maxLength() {
 	        return __classPrivateFieldGet(this, _FileTransferManager_maxLength, "f");
@@ -625,7 +625,7 @@
 	        return __classPrivateFieldGet(this, _FileTransferManager_status, "f");
 	    }
 	    parseMessage(messageType, dataView) {
-	        _console$v.log({ messageType });
+	        _console$w.log({ messageType });
 	        switch (messageType) {
 	            case "getFileTypes":
 	                __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_parseFileTypes).call(this, dataView);
@@ -667,16 +667,16 @@
 	        const fileLength = fileBuffer.byteLength;
 	        const checksum = crc32(fileBuffer);
 	        if (type != this.type) {
-	            _console$v.log("different fileTypes - sending");
+	            _console$w.log("different fileTypes - sending");
 	        }
 	        else if (fileLength != this.length) {
-	            _console$v.log("different fileLengths - sending");
+	            _console$w.log("different fileLengths - sending");
 	        }
 	        else if (checksum != this.checksum) {
-	            _console$v.log("different fileChecksums - sending");
+	            _console$w.log("different fileChecksums - sending");
 	        }
 	        else {
-	            _console$v.log("already sent file");
+	            _console$w.log("already sent file");
 	            return false;
 	        }
 	        const promises = [];
@@ -697,7 +697,7 @@
 	    }
 	    async cancel() {
 	        __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertIsNotIdle).call(this);
-	        _console$v.log("cancelling file transfer...");
+	        _console$w.log("cancelling file transfer...");
 	        __classPrivateFieldSet(this, _FileTransferManager_isCancelling, true, "f");
 	        await __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_setCommand).call(this, "cancel");
 	    }
@@ -706,64 +706,64 @@
 	    }
 	    set isServerSide(newIsServerSide) {
 	        if (__classPrivateFieldGet(this, _FileTransferManager_isServerSide, "f") == newIsServerSide) {
-	            _console$v.log("redundant isServerSide assignment");
+	            _console$w.log("redundant isServerSide assignment");
 	            return;
 	        }
-	        _console$v.log({ newIsServerSide });
+	        _console$w.log({ newIsServerSide });
 	        __classPrivateFieldSet(this, _FileTransferManager_isServerSide, newIsServerSide, "f");
 	    }
 	    requestRequiredInformation() {
-	        _console$v.log("requesting required fileTransfer information");
+	        _console$w.log("requesting required fileTransfer information");
 	        const messages = RequiredFileTransferMessageTypes.map((messageType) => ({
 	            type: messageType,
 	        }));
 	        this.sendMessage(messages, false);
 	    }
 	}
-	_a$6 = FileTransferManager, _FileTransferManager_fileTypes = new WeakMap(), _FileTransferManager_maxLength = new WeakMap(), _FileTransferManager_type = new WeakMap(), _FileTransferManager_length = new WeakMap(), _FileTransferManager_checksum = new WeakMap(), _FileTransferManager_status = new WeakMap(), _FileTransferManager_receivedBlocks = new WeakMap(), _FileTransferManager_buffer = new WeakMap(), _FileTransferManager_bytesTransferred = new WeakMap(), _FileTransferManager_isCancelling = new WeakMap(), _FileTransferManager_isServerSide = new WeakMap(), _FileTransferManager_instances = new WeakSet(), _FileTransferManager_dispatchEvent_get = function _FileTransferManager_dispatchEvent_get() {
+	_a$7 = FileTransferManager, _FileTransferManager_fileTypes = new WeakMap(), _FileTransferManager_maxLength = new WeakMap(), _FileTransferManager_type = new WeakMap(), _FileTransferManager_length = new WeakMap(), _FileTransferManager_checksum = new WeakMap(), _FileTransferManager_status = new WeakMap(), _FileTransferManager_receivedBlocks = new WeakMap(), _FileTransferManager_buffer = new WeakMap(), _FileTransferManager_bytesTransferred = new WeakMap(), _FileTransferManager_isCancelling = new WeakMap(), _FileTransferManager_isServerSide = new WeakMap(), _FileTransferManager_instances = new WeakSet(), _FileTransferManager_dispatchEvent_get = function _FileTransferManager_dispatchEvent_get() {
 	    return this.eventDispatcher.dispatchEvent;
 	}, _FileTransferManager_assertValidType = function _FileTransferManager_assertValidType(type) {
-	    _console$v.assertEnumWithError(type, FileTypes);
+	    _console$w.assertEnumWithError(type, FileTypes);
 	}, _FileTransferManager_assertValidTypeEnum = function _FileTransferManager_assertValidTypeEnum(typeEnum) {
-	    _console$v.assertWithError(typeEnum in FileTypes, `invalid typeEnum ${typeEnum}`);
+	    _console$w.assertWithError(typeEnum in FileTypes, `invalid typeEnum ${typeEnum}`);
 	}, _FileTransferManager_assertValidStatusEnum = function _FileTransferManager_assertValidStatusEnum(statusEnum) {
-	    _console$v.assertWithError(statusEnum in FileTransferStatuses, `invalid statusEnum ${statusEnum}`);
+	    _console$w.assertWithError(statusEnum in FileTransferStatuses, `invalid statusEnum ${statusEnum}`);
 	}, _FileTransferManager_assertValidCommand = function _FileTransferManager_assertValidCommand(command) {
-	    _console$v.assertEnumWithError(command, FileTransferCommands);
+	    _console$w.assertEnumWithError(command, FileTransferCommands);
 	}, _FileTransferManager_parseFileTypes = function _FileTransferManager_parseFileTypes(dataView) {
 	    const fileTypes = Array.from(new Uint8Array(dataView.buffer))
 	        .map((index) => FileTypes[index])
 	        .filter(Boolean);
 	    __classPrivateFieldSet(this, _FileTransferManager_fileTypes, fileTypes, "f");
-	    _console$v.log("fileTypes", fileTypes);
+	    _console$w.log("fileTypes", fileTypes);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "getFileTypes", {
 	        fileTypes: __classPrivateFieldGet(this, _FileTransferManager_fileTypes, "f"),
 	    });
 	}, _FileTransferManager_parseMaxLength = function _FileTransferManager_parseMaxLength(dataView) {
-	    _console$v.log("parseFileMaxLength", dataView);
+	    _console$w.log("parseFileMaxLength", dataView);
 	    const maxLength = dataView.getUint32(0, true);
-	    _console$v.log(`maxLength: ${maxLength / 1024}kB`);
+	    _console$w.log(`maxLength: ${maxLength / 1024}kB`);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_updateMaxLength).call(this, maxLength);
 	}, _FileTransferManager_updateMaxLength = function _FileTransferManager_updateMaxLength(maxLength) {
-	    _console$v.log({ maxLength });
+	    _console$w.log({ maxLength });
 	    __classPrivateFieldSet(this, _FileTransferManager_maxLength, maxLength, "f");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "maxFileLength", { maxFileLength: maxLength });
 	}, _FileTransferManager_assertValidLength = function _FileTransferManager_assertValidLength(length) {
-	    _console$v.assertWithError(length <= this.maxLength, `file length ${length}kB too large - must be ${this.maxLength}kB or less`);
+	    _console$w.assertWithError(length <= this.maxLength, `file length ${length}kB too large - must be ${this.maxLength}kB or less`);
 	}, _FileTransferManager_parseType = function _FileTransferManager_parseType(dataView) {
-	    _console$v.log("parseFileType", dataView);
+	    _console$w.log("parseFileType", dataView);
 	    const typeEnum = dataView.getUint8(0);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertValidTypeEnum).call(this, typeEnum);
 	    const type = FileTypes[typeEnum];
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_updateType).call(this, type);
 	}, _FileTransferManager_updateType = function _FileTransferManager_updateType(type) {
-	    _console$v.log({ fileTransferType: type });
+	    _console$w.log({ fileTransferType: type });
 	    __classPrivateFieldSet(this, _FileTransferManager_type, type, "f");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "getFileType", { fileType: type });
 	}, _FileTransferManager_setType = async function _FileTransferManager_setType(newType, sendImmediately) {
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertValidType).call(this, newType);
 	    if (this.type == newType) {
-	        _console$v.log(`redundant type assignment ${newType}`);
+	        _console$w.log(`redundant type assignment ${newType}`);
 	        return;
 	    }
 	    const promise = this.waitForEvent("getFileType");
@@ -771,18 +771,18 @@
 	    this.sendMessage([{ type: "setFileType", data: Uint8Array.from([typeEnum]).buffer }], sendImmediately);
 	    await promise;
 	}, _FileTransferManager_parseLength = function _FileTransferManager_parseLength(dataView) {
-	    _console$v.log("parseFileLength", dataView);
+	    _console$w.log("parseFileLength", dataView);
 	    const length = dataView.getUint32(0, true);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_updateLength).call(this, length);
 	}, _FileTransferManager_updateLength = function _FileTransferManager_updateLength(length) {
-	    _console$v.log(`length: ${length / 1024}kB`);
+	    _console$w.log(`length: ${length / 1024}kB`);
 	    __classPrivateFieldSet(this, _FileTransferManager_length, length, "f");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "getFileLength", { fileLength: length });
 	}, _FileTransferManager_setLength = async function _FileTransferManager_setLength(newLength, sendImmediately) {
-	    _console$v.assertTypeWithError(newLength, "number");
+	    _console$w.assertTypeWithError(newLength, "number");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertValidLength).call(this, newLength);
 	    if (this.length == newLength) {
-	        _console$v.log(`redundant length assignment ${newLength}`);
+	        _console$w.log(`redundant length assignment ${newLength}`);
 	        return;
 	    }
 	    const promise = this.waitForEvent("getFileLength");
@@ -791,17 +791,17 @@
 	    this.sendMessage([{ type: "setFileLength", data: dataView.buffer }], sendImmediately);
 	    await promise;
 	}, _FileTransferManager_parseChecksum = function _FileTransferManager_parseChecksum(dataView) {
-	    _console$v.log("checksum", dataView);
+	    _console$w.log("checksum", dataView);
 	    const checksum = dataView.getUint32(0, true);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_updateChecksum).call(this, checksum);
 	}, _FileTransferManager_updateChecksum = function _FileTransferManager_updateChecksum(checksum) {
-	    _console$v.log({ checksum });
+	    _console$w.log({ checksum });
 	    __classPrivateFieldSet(this, _FileTransferManager_checksum, checksum, "f");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "getFileChecksum", { fileChecksum: checksum });
 	}, _FileTransferManager_setChecksum = async function _FileTransferManager_setChecksum(newChecksum, sendImmediately) {
-	    _console$v.assertTypeWithError(newChecksum, "number");
+	    _console$w.assertTypeWithError(newChecksum, "number");
 	    if (this.checksum == newChecksum) {
-	        _console$v.log(`redundant checksum assignment ${newChecksum}`);
+	        _console$w.log(`redundant checksum assignment ${newChecksum}`);
 	        return;
 	    }
 	    const promise = this.waitForEvent("getFileChecksum");
@@ -812,7 +812,7 @@
 	}, _FileTransferManager_setCommand = async function _FileTransferManager_setCommand(command, sendImmediately) {
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertValidCommand).call(this, command);
 	    const promise = this.waitForEvent("fileTransferStatus");
-	    _console$v.log(`setting command ${command}`);
+	    _console$w.log(`setting command ${command}`);
 	    const commandEnum = FileTransferCommands.indexOf(command);
 	    this.sendMessage([
 	        {
@@ -822,27 +822,27 @@
 	    ], sendImmediately);
 	    await promise;
 	}, _FileTransferManager_parseStatus = function _FileTransferManager_parseStatus(dataView) {
-	    _console$v.log("parseFileStatus", dataView);
+	    _console$w.log("parseFileStatus", dataView);
 	    const statusEnum = dataView.getUint8(0);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_assertValidStatusEnum).call(this, statusEnum);
 	    const status = FileTransferStatuses[statusEnum];
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "m", _FileTransferManager_updateStatus).call(this, status);
 	}, _FileTransferManager_updateStatus = function _FileTransferManager_updateStatus(status) {
-	    _console$v.log({ status });
+	    _console$w.log({ status });
 	    __classPrivateFieldSet(this, _FileTransferManager_status, status, "f");
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileTransferStatus", { fileTransferStatus: status });
 	    __classPrivateFieldGet(this, _FileTransferManager_receivedBlocks, "f").length = 0;
 	    __classPrivateFieldSet(this, _FileTransferManager_isCancelling, false, "f");
 	}, _FileTransferManager_assertIsIdle = function _FileTransferManager_assertIsIdle() {
-	    _console$v.assertWithError(__classPrivateFieldGet(this, _FileTransferManager_status, "f") == "idle", "status is not idle");
+	    _console$w.assertWithError(__classPrivateFieldGet(this, _FileTransferManager_status, "f") == "idle", "status is not idle");
 	}, _FileTransferManager_assertIsNotIdle = function _FileTransferManager_assertIsNotIdle() {
-	    _console$v.assertWithError(__classPrivateFieldGet(this, _FileTransferManager_status, "f") != "idle", "status is idle");
+	    _console$w.assertWithError(__classPrivateFieldGet(this, _FileTransferManager_status, "f") != "idle", "status is idle");
 	}, _FileTransferManager_parseBlock = async function _FileTransferManager_parseBlock(dataView) {
-	    _console$v.log("parseFileBlock", dataView);
+	    _console$w.log("parseFileBlock", dataView);
 	    __classPrivateFieldGet(this, _FileTransferManager_receivedBlocks, "f").push(dataView.buffer);
 	    const bytesReceived = __classPrivateFieldGet(this, _FileTransferManager_receivedBlocks, "f").reduce((sum, arrayBuffer) => (sum += arrayBuffer.byteLength), 0);
 	    const progress = bytesReceived / __classPrivateFieldGet(this, _FileTransferManager_length, "f");
-	    _console$v.log(`received ${bytesReceived} of ${__classPrivateFieldGet(this, _FileTransferManager_length, "f")} bytes (${progress * 100}%)`);
+	    _console$w.log(`received ${bytesReceived} of ${__classPrivateFieldGet(this, _FileTransferManager_length, "f")} bytes (${progress * 100}%)`);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileTransferProgress", { progress });
 	    if (bytesReceived != __classPrivateFieldGet(this, _FileTransferManager_length, "f")) {
 	        const dataView = new DataView(new ArrayBuffer(4));
@@ -855,7 +855,7 @@
 	        ]);
 	        return;
 	    }
-	    _console$v.log("file transfer complete");
+	    _console$w.log("file transfer complete");
 	    let fileName = new Date().toLocaleString();
 	    switch (this.type) {
 	        case "tflite":
@@ -877,12 +877,12 @@
 	    }
 	    const arrayBuffer = await file.arrayBuffer();
 	    const checksum = crc32(arrayBuffer);
-	    _console$v.log({ checksum });
+	    _console$w.log({ checksum });
 	    if (checksum != __classPrivateFieldGet(this, _FileTransferManager_checksum, "f")) {
-	        _console$v.error(`wrong checksum - expected ${__classPrivateFieldGet(this, _FileTransferManager_checksum, "f")}, got ${checksum}`);
+	        _console$w.error(`wrong checksum - expected ${__classPrivateFieldGet(this, _FileTransferManager_checksum, "f")}, got ${checksum}`);
 	        return;
 	    }
-	    _console$v.log("received file", file);
+	    _console$w.log("received file", file);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "getFileBlock", { fileTransferBlock: dataView });
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileTransferComplete", { direction: "receiving" });
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileReceived", { file });
@@ -895,25 +895,25 @@
 	        return;
 	    }
 	    if (__classPrivateFieldGet(this, _FileTransferManager_isCancelling, "f")) {
-	        _console$v.error("not sending block - busy cancelling");
+	        _console$w.error("not sending block - busy cancelling");
 	        return;
 	    }
 	    if (!__classPrivateFieldGet(this, _FileTransferManager_buffer, "f")) {
 	        if (!this.isServerSide) {
-	            _console$v.error("no buffer defined");
+	            _console$w.error("no buffer defined");
 	        }
 	        return;
 	    }
 	    const buffer = __classPrivateFieldGet(this, _FileTransferManager_buffer, "f");
 	    let offset = __classPrivateFieldGet(this, _FileTransferManager_bytesTransferred, "f");
 	    const slicedBuffer = buffer.slice(offset, offset + (this.mtu - 3 - 3));
-	    _console$v.log("slicedBuffer", slicedBuffer);
+	    _console$w.log("slicedBuffer", slicedBuffer);
 	    const bytesLeft = buffer.byteLength - offset;
 	    const progress = 1 - bytesLeft / buffer.byteLength;
-	    _console$v.log(`sending bytes ${offset}-${offset + slicedBuffer.byteLength} of ${buffer.byteLength} bytes (${progress * 100}%)`);
+	    _console$w.log(`sending bytes ${offset}-${offset + slicedBuffer.byteLength} of ${buffer.byteLength} bytes (${progress * 100}%)`);
 	    __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileTransferProgress", { progress });
 	    if (slicedBuffer.byteLength == 0) {
-	        _console$v.log("finished sending buffer");
+	        _console$w.log("finished sending buffer");
 	        __classPrivateFieldGet(this, _FileTransferManager_instances, "a", _FileTransferManager_dispatchEvent_get).call(this, "fileTransferComplete", { direction: "sending" });
 	    }
 	    else {
@@ -921,15 +921,15 @@
 	        __classPrivateFieldSet(this, _FileTransferManager_bytesTransferred, offset + slicedBuffer.byteLength, "f");
 	    }
 	}, _FileTransferManager_parseBytesTransferred = async function _FileTransferManager_parseBytesTransferred(dataView) {
-	    _console$v.log("parseBytesTransferred", dataView);
+	    _console$w.log("parseBytesTransferred", dataView);
 	    const bytesTransferred = dataView.getUint32(0, true);
-	    _console$v.log({ bytesTransferred });
+	    _console$w.log({ bytesTransferred });
 	    if (this.status != "sending") {
-	        _console$v.error(`not currently sending file`);
+	        _console$w.error(`not currently sending file`);
 	        return;
 	    }
 	    if (!this.isServerSide && __classPrivateFieldGet(this, _FileTransferManager_bytesTransferred, "f") != bytesTransferred) {
-	        _console$v.error(`bytesTransferred are not equal - got ${bytesTransferred}, expected ${__classPrivateFieldGet(this, _FileTransferManager_bytesTransferred, "f")}`);
+	        _console$w.error(`bytesTransferred are not equal - got ${bytesTransferred}, expected ${__classPrivateFieldGet(this, _FileTransferManager_bytesTransferred, "f")}`);
 	        this.cancel();
 	        return;
 	    }
@@ -937,7 +937,7 @@
 	};
 	_FileTransferManager_MaxLength = { value: 0 };
 
-	const _console$u = createConsole("MathUtils", { log: false });
+	const _console$v = createConsole("MathUtils", { log: false });
 	function getInterpolation(value, min, max, span) {
 	    if (span == undefined) {
 	        span = max - min;
@@ -956,7 +956,7 @@
 	    const lower2Bytes = dataView.getUint16(byteOffset, true);
 	    let timestamp = nowWithoutLower2Bytes + lower2Bytes;
 	    if (Math.abs(now - timestamp) > timestampThreshold) {
-	        _console$u.log("correcting timestamp delta");
+	        _console$v.log("correcting timestamp delta");
 	        timestamp += Uint16Max * Math.sign(now - timestamp);
 	    }
 	    return timestamp;
@@ -1055,7 +1055,7 @@
 	}
 
 	var _PressureSensorDataManager_positions, _PressureSensorDataManager_sensorRangeHelpers, _PressureSensorDataManager_normalizedSumRangeHelper, _PressureSensorDataManager_centerOfPressureHelper;
-	const _console$t = createConsole("PressureDataManager", { log: false });
+	const _console$u = createConsole("PressureDataManager", { log: false });
 	const PressureSensorTypes = ["pressure"];
 	const ContinuousPressureSensorTypes = PressureSensorTypes;
 	const DefaultNumberOfPressureSensors = 8;
@@ -1080,7 +1080,7 @@
 	                y: dataView.getUint8(byteOffset + 1) / 2 ** 8,
 	            });
 	        }
-	        _console$t.log({ positions });
+	        _console$u.log({ positions });
 	        __classPrivateFieldSet(this, _PressureSensorDataManager_positions, positions, "f");
 	        __classPrivateFieldSet(this, _PressureSensorDataManager_sensorRangeHelpers, createArray(this.numberOfSensors, () => new RangeHelper()), "f");
 	        this.resetRange();
@@ -1123,13 +1123,13 @@
 	            pressure.normalizedCenter =
 	                __classPrivateFieldGet(this, _PressureSensorDataManager_centerOfPressureHelper, "f").updateAndGetNormalization(pressure.center, false);
 	        }
-	        _console$t.log({ pressure });
+	        _console$u.log({ pressure });
 	        return pressure;
 	    }
 	}
 	_PressureSensorDataManager_positions = new WeakMap(), _PressureSensorDataManager_sensorRangeHelpers = new WeakMap(), _PressureSensorDataManager_normalizedSumRangeHelper = new WeakMap(), _PressureSensorDataManager_centerOfPressureHelper = new WeakMap();
 
-	const _console$s = createConsole("MotionSensorDataManager", { log: false });
+	const _console$t = createConsole("MotionSensorDataManager", { log: false });
 	const MotionSensorTypes = [
 	    "acceleration",
 	    "gravity",
@@ -1178,7 +1178,7 @@
 	            dataView.getInt16(4, true),
 	        ].map((value) => value * scalar);
 	        const vector = { x, y, z };
-	        _console$s.log({ vector });
+	        _console$t.log({ vector });
 	        return vector;
 	    }
 	    parseQuaternion(dataView, scalar) {
@@ -1189,7 +1189,7 @@
 	            dataView.getInt16(6, true),
 	        ].map((value) => value * scalar);
 	        const quaternion = { x, y, z, w };
-	        _console$s.log({ quaternion });
+	        _console$t.log({ quaternion });
 	        return quaternion;
 	    }
 	    parseEuler(dataView, scalar) {
@@ -1204,32 +1204,32 @@
 	            heading += 360;
 	        }
 	        const euler = { heading, pitch, roll };
-	        _console$s.log({ euler });
+	        _console$t.log({ euler });
 	        return euler;
 	    }
 	    parseStepCounter(dataView) {
-	        _console$s.log("parseStepCounter", dataView);
+	        _console$t.log("parseStepCounter", dataView);
 	        const stepCount = dataView.getUint32(0, true);
-	        _console$s.log({ stepCount });
+	        _console$t.log({ stepCount });
 	        return stepCount;
 	    }
 	    parseActivity(dataView) {
-	        _console$s.log("parseActivity", dataView);
+	        _console$t.log("parseActivity", dataView);
 	        const activity = {};
 	        const activityBitfield = dataView.getUint8(0);
-	        _console$s.log("activityBitfield", activityBitfield.toString(2));
+	        _console$t.log("activityBitfield", activityBitfield.toString(2));
 	        ActivityTypes.forEach((activityType, index) => {
 	            activity[activityType] = Boolean(activityBitfield & (1 << index));
 	        });
-	        _console$s.log("activity", activity);
+	        _console$t.log("activity", activity);
 	        return activity;
 	    }
 	    parseDeviceOrientation(dataView) {
-	        _console$s.log("parseDeviceOrientation", dataView);
+	        _console$t.log("parseDeviceOrientation", dataView);
 	        const index = dataView.getUint8(0);
 	        const deviceOrientation = DeviceOrientations[index];
-	        _console$s.assertWithError(deviceOrientation, "undefined deviceOrientation");
-	        _console$s.log({ deviceOrientation });
+	        _console$t.assertWithError(deviceOrientation, "undefined deviceOrientation");
+	        _console$t.log({ deviceOrientation });
 	        return deviceOrientation;
 	    }
 	}
@@ -1237,7 +1237,7 @@
 	var _BarometerSensorDataManager_instances, _BarometerSensorDataManager_calculcateAltitude;
 	const BarometerSensorTypes = ["barometer"];
 	const ContinuousBarometerSensorTypes = BarometerSensorTypes;
-	const _console$r = createConsole("BarometerSensorDataManager", { log: false });
+	const _console$s = createConsole("BarometerSensorDataManager", { log: false });
 	class BarometerSensorDataManager {
 	    constructor() {
 	        _BarometerSensorDataManager_instances.add(this);
@@ -1245,7 +1245,7 @@
 	    parseData(dataView, scalar) {
 	        const pressure = dataView.getUint32(0, true) * scalar;
 	        const altitude = __classPrivateFieldGet(this, _BarometerSensorDataManager_instances, "m", _BarometerSensorDataManager_calculcateAltitude).call(this, pressure);
-	        _console$r.log({ pressure, altitude });
+	        _console$s.log({ pressure, altitude });
 	        return { pressure };
 	    }
 	}
@@ -1261,7 +1261,7 @@
 	    return h;
 	};
 
-	const _console$q = createConsole("ParseUtils", { log: false });
+	const _console$r = createConsole("ParseUtils", { log: false });
 	function parseStringFromDataView(dataView, byteOffset = 0) {
 	    const stringLength = dataView.getUint8(byteOffset++);
 	    const string = textDecoder.decode(dataView.buffer.slice(dataView.byteOffset + byteOffset, dataView.byteOffset + byteOffset + stringLength));
@@ -1272,7 +1272,7 @@
 	    let byteOffset = 0;
 	    while (byteOffset < dataView.byteLength) {
 	        const messageTypeEnum = dataView.getUint8(byteOffset++);
-	        _console$q.assertWithError(messageTypeEnum in messageTypes, `invalid messageTypeEnum ${messageTypeEnum}`);
+	        _console$r.assertWithError(messageTypeEnum in messageTypes, `invalid messageTypeEnum ${messageTypeEnum}`);
 	        const messageType = messageTypes[messageTypeEnum];
 	        let messageLength;
 	        if (parseMessageLengthAsUint16) {
@@ -1282,7 +1282,7 @@
 	        else {
 	            messageLength = dataView.getUint8(byteOffset++);
 	        }
-	        _console$q.log({
+	        _console$r.log({
 	            messageTypeEnum,
 	            messageType,
 	            messageLength,
@@ -1290,14 +1290,14 @@
 	            byteOffset,
 	        });
 	        const _dataView = sliceDataView(dataView, byteOffset, messageLength);
-	        _console$q.log({ _dataView });
+	        _console$r.log({ _dataView });
 	        callback(messageType, _dataView, context);
 	        byteOffset += messageLength;
 	    }
 	}
 
-	var _CameraManager_instances, _a$5, _CameraManager_dispatchEvent_get, _CameraManager_cameraStatus, _CameraManager_parseCameraStatus, _CameraManager_updateCameraStatus, _CameraManager_sendCameraCommand, _CameraManager_assertIsAsleep, _CameraManager_assertIsAwake, _CameraManager_parseCameraData, _CameraManager_onCameraData, _CameraManager_headerSize, _CameraManager_headerData, _CameraManager_headerProgress, _CameraManager_imageSize, _CameraManager_imageData, _CameraManager_imageProgress, _CameraManager_footerSize, _CameraManager_footerData, _CameraManager_footerProgress, _CameraManager_didBuildImage, _CameraManager_buildImage, _CameraManager_cameraConfiguration, _CameraManager_availableCameraConfigurationTypes, _CameraManager_cameraConfigurationRanges, _CameraManager_parseCameraConfiguration, _CameraManager_isCameraConfigurationRedundant, _CameraManager_assertAvailableCameraConfigurationType, _CameraManager_createData;
-	const _console$p = createConsole("CameraManager", { log: false });
+	var _CameraManager_instances, _a$6, _CameraManager_dispatchEvent_get, _CameraManager_cameraStatus, _CameraManager_parseCameraStatus, _CameraManager_updateCameraStatus, _CameraManager_sendCameraCommand, _CameraManager_assertIsAsleep, _CameraManager_assertIsAwake, _CameraManager_parseCameraData, _CameraManager_onCameraData, _CameraManager_headerSize, _CameraManager_headerData, _CameraManager_headerProgress, _CameraManager_imageSize, _CameraManager_imageData, _CameraManager_imageProgress, _CameraManager_footerSize, _CameraManager_footerData, _CameraManager_footerProgress, _CameraManager_didBuildImage, _CameraManager_buildImage, _CameraManager_cameraConfiguration, _CameraManager_availableCameraConfigurationTypes, _CameraManager_cameraConfigurationRanges, _CameraManager_parseCameraConfiguration, _CameraManager_isCameraConfigurationRedundant, _CameraManager_assertAvailableCameraConfigurationType, _CameraManager_createData;
+	const _console$q = createConsole("CameraManager", { log: false });
 	const CameraSensorTypes = ["camera"];
 	const CameraCommands = [
 	    "focus",
@@ -1376,7 +1376,7 @@
 	        return this.eventDispatcher.waitForEvent;
 	    }
 	    requestRequiredInformation() {
-	        _console$p.log("requesting required camera information");
+	        _console$q.log("requesting required camera information");
 	        const messages = RequiredCameraMessageTypes.map((messageType) => ({
 	            type: messageType,
 	        }));
@@ -1415,13 +1415,13 @@
 	        return __classPrivateFieldGet(this, _CameraManager_cameraConfigurationRanges, "f");
 	    }
 	    async setCameraConfiguration(newCameraConfiguration) {
-	        _console$p.log({ newCameraConfiguration });
+	        _console$q.log({ newCameraConfiguration });
 	        if (__classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_isCameraConfigurationRedundant).call(this, newCameraConfiguration)) {
-	            _console$p.log("redundant camera configuration");
+	            _console$q.log("redundant camera configuration");
 	            return;
 	        }
 	        const setCameraConfigurationData = __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_createData).call(this, newCameraConfiguration);
-	        _console$p.log({ setCameraConfigurationData });
+	        _console$q.log({ setCameraConfigurationData });
 	        const promise = this.waitForEvent("getCameraConfiguration");
 	        this.sendMessage([
 	            {
@@ -1432,14 +1432,14 @@
 	        await promise;
 	    }
 	    static AssertValidCameraConfigurationType(cameraConfigurationType) {
-	        _console$p.assertEnumWithError(cameraConfigurationType, CameraConfigurationTypes);
+	        _console$q.assertEnumWithError(cameraConfigurationType, CameraConfigurationTypes);
 	    }
 	    static AssertValidCameraConfigurationTypeEnum(cameraConfigurationTypeEnum) {
-	        _console$p.assertTypeWithError(cameraConfigurationTypeEnum, "number");
-	        _console$p.assertWithError(cameraConfigurationTypeEnum in CameraConfigurationTypes, `invalid cameraConfigurationTypeEnum ${cameraConfigurationTypeEnum}`);
+	        _console$q.assertTypeWithError(cameraConfigurationTypeEnum, "number");
+	        _console$q.assertWithError(cameraConfigurationTypeEnum in CameraConfigurationTypes, `invalid cameraConfigurationTypeEnum ${cameraConfigurationTypeEnum}`);
 	    }
 	    parseMessage(messageType, dataView) {
-	        _console$p.log({ messageType, dataView });
+	        _console$q.log({ messageType, dataView });
 	        switch (messageType) {
 	            case "cameraStatus":
 	                __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_parseCameraStatus).call(this, dataView);
@@ -1462,21 +1462,21 @@
 	        __classPrivateFieldSet(this, _CameraManager_footerProgress, 0, "f");
 	    }
 	}
-	_a$5 = CameraManager, _CameraManager_cameraStatus = new WeakMap(), _CameraManager_headerSize = new WeakMap(), _CameraManager_headerData = new WeakMap(), _CameraManager_headerProgress = new WeakMap(), _CameraManager_imageSize = new WeakMap(), _CameraManager_imageData = new WeakMap(), _CameraManager_imageProgress = new WeakMap(), _CameraManager_footerSize = new WeakMap(), _CameraManager_footerData = new WeakMap(), _CameraManager_footerProgress = new WeakMap(), _CameraManager_didBuildImage = new WeakMap(), _CameraManager_cameraConfiguration = new WeakMap(), _CameraManager_availableCameraConfigurationTypes = new WeakMap(), _CameraManager_cameraConfigurationRanges = new WeakMap(), _CameraManager_instances = new WeakSet(), _CameraManager_dispatchEvent_get = function _CameraManager_dispatchEvent_get() {
+	_a$6 = CameraManager, _CameraManager_cameraStatus = new WeakMap(), _CameraManager_headerSize = new WeakMap(), _CameraManager_headerData = new WeakMap(), _CameraManager_headerProgress = new WeakMap(), _CameraManager_imageSize = new WeakMap(), _CameraManager_imageData = new WeakMap(), _CameraManager_imageProgress = new WeakMap(), _CameraManager_footerSize = new WeakMap(), _CameraManager_footerData = new WeakMap(), _CameraManager_footerProgress = new WeakMap(), _CameraManager_didBuildImage = new WeakMap(), _CameraManager_cameraConfiguration = new WeakMap(), _CameraManager_availableCameraConfigurationTypes = new WeakMap(), _CameraManager_cameraConfigurationRanges = new WeakMap(), _CameraManager_instances = new WeakSet(), _CameraManager_dispatchEvent_get = function _CameraManager_dispatchEvent_get() {
 	    return this.eventDispatcher.dispatchEvent;
 	}, _CameraManager_parseCameraStatus = function _CameraManager_parseCameraStatus(dataView) {
 	    const cameraStatusIndex = dataView.getUint8(0);
 	    const newCameraStatus = CameraStatuses[cameraStatusIndex];
 	    __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_updateCameraStatus).call(this, newCameraStatus);
 	}, _CameraManager_updateCameraStatus = function _CameraManager_updateCameraStatus(newCameraStatus) {
-	    _console$p.assertEnumWithError(newCameraStatus, CameraStatuses);
+	    _console$q.assertEnumWithError(newCameraStatus, CameraStatuses);
 	    if (newCameraStatus == __classPrivateFieldGet(this, _CameraManager_cameraStatus, "f")) {
-	        _console$p.log(`redundant cameraStatus ${newCameraStatus}`);
+	        _console$q.log(`redundant cameraStatus ${newCameraStatus}`);
 	        return;
 	    }
 	    const previousCameraStatus = __classPrivateFieldGet(this, _CameraManager_cameraStatus, "f");
 	    __classPrivateFieldSet(this, _CameraManager_cameraStatus, newCameraStatus, "f");
-	    _console$p.log(`updated cameraStatus to "${this.cameraStatus}"`);
+	    _console$q.log(`updated cameraStatus to "${this.cameraStatus}"`);
 	    __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraStatus", {
 	        cameraStatus: this.cameraStatus,
 	        previousCameraStatus,
@@ -1488,10 +1488,10 @@
 	    }
 	}, _CameraManager_sendCameraCommand =
 	async function _CameraManager_sendCameraCommand(command, sendImmediately) {
-	    _console$p.assertEnumWithError(command, CameraCommands);
-	    _console$p.log(`sending camera command "${command}"`);
+	    _console$q.assertEnumWithError(command, CameraCommands);
+	    _console$q.log(`sending camera command "${command}"`);
 	    const promise = this.waitForEvent("cameraStatus");
-	    _console$p.log(`setting command "${command}"`);
+	    _console$q.log(`setting command "${command}"`);
 	    const commandEnum = CameraCommands.indexOf(command);
 	    this.sendMessage([
 	        {
@@ -1501,74 +1501,74 @@
 	    ], sendImmediately);
 	    await promise;
 	}, _CameraManager_assertIsAsleep = function _CameraManager_assertIsAsleep() {
-	    _console$p.assertWithError(__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f") == "asleep", `camera is not asleep - currently ${__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f")}`);
+	    _console$q.assertWithError(__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f") == "asleep", `camera is not asleep - currently ${__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f")}`);
 	}, _CameraManager_assertIsAwake = function _CameraManager_assertIsAwake() {
-	    _console$p.assertWithError(__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f") != "asleep", `camera is not awake - currently ${__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f")}`);
+	    _console$q.assertWithError(__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f") != "asleep", `camera is not awake - currently ${__classPrivateFieldGet(this, _CameraManager_cameraStatus, "f")}`);
 	}, _CameraManager_parseCameraData = function _CameraManager_parseCameraData(dataView) {
-	    _console$p.log("parsing camera data", dataView);
+	    _console$q.log("parsing camera data", dataView);
 	    parseMessage(dataView, CameraDataTypes, __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_onCameraData).bind(this), null, true);
 	}, _CameraManager_onCameraData = function _CameraManager_onCameraData(cameraDataType, dataView) {
-	    _console$p.log({ cameraDataType, dataView });
+	    _console$q.log({ cameraDataType, dataView });
 	    switch (cameraDataType) {
 	        case "headerSize":
 	            __classPrivateFieldSet(this, _CameraManager_headerSize, dataView.getUint16(0, true), "f");
-	            _console$p.log({ headerSize: __classPrivateFieldGet(this, _CameraManager_headerSize, "f") });
+	            _console$q.log({ headerSize: __classPrivateFieldGet(this, _CameraManager_headerSize, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_headerData, undefined, "f");
 	            __classPrivateFieldGet(this, _CameraManager_headerProgress, "f") == 0;
 	            break;
 	        case "header":
 	            __classPrivateFieldSet(this, _CameraManager_headerData, concatenateArrayBuffers(__classPrivateFieldGet(this, _CameraManager_headerData, "f"), dataView), "f");
-	            _console$p.log({ headerData: __classPrivateFieldGet(this, _CameraManager_headerData, "f") });
+	            _console$q.log({ headerData: __classPrivateFieldGet(this, _CameraManager_headerData, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_headerProgress, __classPrivateFieldGet(this, _CameraManager_headerData, "f")?.byteLength / __classPrivateFieldGet(this, _CameraManager_headerSize, "f"), "f");
-	            _console$p.log({ headerProgress: __classPrivateFieldGet(this, _CameraManager_headerProgress, "f") });
+	            _console$q.log({ headerProgress: __classPrivateFieldGet(this, _CameraManager_headerProgress, "f") });
 	            __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraImageProgress", {
 	                progress: __classPrivateFieldGet(this, _CameraManager_headerProgress, "f"),
 	                type: "header",
 	            });
 	            if (__classPrivateFieldGet(this, _CameraManager_headerProgress, "f") == 1) {
-	                _console$p.log("finished getting header data");
+	                _console$q.log("finished getting header data");
 	            }
 	            break;
 	        case "imageSize":
 	            __classPrivateFieldSet(this, _CameraManager_imageSize, dataView.getUint16(0, true), "f");
-	            _console$p.log({ imageSize: __classPrivateFieldGet(this, _CameraManager_imageSize, "f") });
+	            _console$q.log({ imageSize: __classPrivateFieldGet(this, _CameraManager_imageSize, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_imageData, undefined, "f");
 	            __classPrivateFieldGet(this, _CameraManager_imageProgress, "f") == 0;
 	            __classPrivateFieldSet(this, _CameraManager_didBuildImage, false, "f");
 	            break;
 	        case "image":
 	            __classPrivateFieldSet(this, _CameraManager_imageData, concatenateArrayBuffers(__classPrivateFieldGet(this, _CameraManager_imageData, "f"), dataView), "f");
-	            _console$p.log({ imageData: __classPrivateFieldGet(this, _CameraManager_imageData, "f") });
+	            _console$q.log({ imageData: __classPrivateFieldGet(this, _CameraManager_imageData, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_imageProgress, __classPrivateFieldGet(this, _CameraManager_imageData, "f")?.byteLength / __classPrivateFieldGet(this, _CameraManager_imageSize, "f"), "f");
-	            _console$p.log({ imageProgress: __classPrivateFieldGet(this, _CameraManager_imageProgress, "f") });
+	            _console$q.log({ imageProgress: __classPrivateFieldGet(this, _CameraManager_imageProgress, "f") });
+	            __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraImageProgress", {
+	                progress: __classPrivateFieldGet(this, _CameraManager_imageProgress, "f"),
+	                type: "image",
+	            });
 	            if (__classPrivateFieldGet(this, _CameraManager_imageProgress, "f") == 1) {
-	                _console$p.log("finished getting image data");
+	                _console$q.log("finished getting image data");
 	                if (__classPrivateFieldGet(this, _CameraManager_headerProgress, "f") == 1) {
 	                    __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_buildImage).call(this);
 	                }
 	            }
-	            __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraImageProgress", {
-	                progress: __classPrivateFieldGet(this, _CameraManager_imageProgress, "f"),
-	                type: "image",
-	            });
 	            break;
 	        case "footerSize":
 	            __classPrivateFieldSet(this, _CameraManager_footerSize, dataView.getUint16(0, true), "f");
-	            _console$p.log({ footerSize: __classPrivateFieldGet(this, _CameraManager_footerSize, "f") });
+	            _console$q.log({ footerSize: __classPrivateFieldGet(this, _CameraManager_footerSize, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_footerData, undefined, "f");
 	            __classPrivateFieldGet(this, _CameraManager_footerProgress, "f") == 0;
 	            break;
 	        case "footer":
 	            __classPrivateFieldSet(this, _CameraManager_footerData, concatenateArrayBuffers(__classPrivateFieldGet(this, _CameraManager_footerData, "f"), dataView), "f");
-	            _console$p.log({ footerData: __classPrivateFieldGet(this, _CameraManager_footerData, "f") });
+	            _console$q.log({ footerData: __classPrivateFieldGet(this, _CameraManager_footerData, "f") });
 	            __classPrivateFieldSet(this, _CameraManager_footerProgress, __classPrivateFieldGet(this, _CameraManager_footerData, "f")?.byteLength / __classPrivateFieldGet(this, _CameraManager_footerSize, "f"), "f");
-	            _console$p.log({ footerProgress: __classPrivateFieldGet(this, _CameraManager_footerProgress, "f") });
+	            _console$q.log({ footerProgress: __classPrivateFieldGet(this, _CameraManager_footerProgress, "f") });
 	            __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraImageProgress", {
 	                progress: __classPrivateFieldGet(this, _CameraManager_footerProgress, "f"),
 	                type: "footer",
 	            });
 	            if (__classPrivateFieldGet(this, _CameraManager_footerProgress, "f") == 1) {
-	                _console$p.log("finished getting footer data");
+	                _console$q.log("finished getting footer data");
 	                if (__classPrivateFieldGet(this, _CameraManager_imageProgress, "f") == 1) {
 	                    __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_buildImage).call(this);
 	                }
@@ -1576,13 +1576,13 @@
 	            break;
 	    }
 	}, _CameraManager_buildImage = function _CameraManager_buildImage() {
-	    _console$p.log("building image...");
+	    _console$q.log("building image...");
 	    const imageData = concatenateArrayBuffers(__classPrivateFieldGet(this, _CameraManager_headerData, "f"), __classPrivateFieldGet(this, _CameraManager_imageData, "f"), __classPrivateFieldGet(this, _CameraManager_footerData, "f"));
-	    _console$p.log({ imageData });
+	    _console$q.log({ imageData });
 	    let blob = new Blob([imageData], { type: "image/jpeg" });
-	    _console$p.log("created blob", blob);
+	    _console$q.log("created blob", blob);
 	    const url = URL.createObjectURL(blob);
-	    _console$p.log("created url", url);
+	    _console$q.log("created url", url);
 	    __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "cameraImage", { url, blob });
 	    __classPrivateFieldSet(this, _CameraManager_didBuildImage, true, "f");
 	}, _CameraManager_parseCameraConfiguration = function _CameraManager_parseCameraConfiguration(dataView) {
@@ -1591,11 +1591,11 @@
 	    while (byteOffset < dataView.byteLength) {
 	        const cameraConfigurationTypeIndex = dataView.getUint8(byteOffset++);
 	        const cameraConfigurationType = CameraConfigurationTypes[cameraConfigurationTypeIndex];
-	        _console$p.assertWithError(cameraConfigurationType, `invalid cameraConfigurationTypeIndex ${cameraConfigurationTypeIndex}`);
+	        _console$q.assertWithError(cameraConfigurationType, `invalid cameraConfigurationTypeIndex ${cameraConfigurationTypeIndex}`);
 	        parsedCameraConfiguration[cameraConfigurationType] = dataView.getUint16(byteOffset, true);
 	        byteOffset += 2;
 	    }
-	    _console$p.log({ parsedCameraConfiguration });
+	    _console$q.log({ parsedCameraConfiguration });
 	    __classPrivateFieldSet(this, _CameraManager_availableCameraConfigurationTypes, Object.keys(parsedCameraConfiguration), "f");
 	    __classPrivateFieldSet(this, _CameraManager_cameraConfiguration, parsedCameraConfiguration, "f");
 	    __classPrivateFieldGet(this, _CameraManager_instances, "a", _CameraManager_dispatchEvent_get).call(this, "getCameraConfiguration", {
@@ -1608,21 +1608,427 @@
 	            cameraConfiguration[cameraConfigurationType]);
 	    });
 	}, _CameraManager_assertAvailableCameraConfigurationType = function _CameraManager_assertAvailableCameraConfigurationType(cameraConfigurationType) {
-	    _console$p.assertWithError(__classPrivateFieldGet(this, _CameraManager_availableCameraConfigurationTypes, "f"), "must get initial cameraConfiguration");
+	    _console$q.assertWithError(__classPrivateFieldGet(this, _CameraManager_availableCameraConfigurationTypes, "f"), "must get initial cameraConfiguration");
 	    const isCameraConfigurationTypeAvailable = __classPrivateFieldGet(this, _CameraManager_availableCameraConfigurationTypes, "f")?.includes(cameraConfigurationType);
-	    _console$p.assertWithError(isCameraConfigurationTypeAvailable, `unavailable camera configuration type "${cameraConfigurationType}"`);
+	    _console$q.assertWithError(isCameraConfigurationTypeAvailable, `unavailable camera configuration type "${cameraConfigurationType}"`);
 	    return isCameraConfigurationTypeAvailable;
 	}, _CameraManager_createData = function _CameraManager_createData(cameraConfiguration) {
 	    let cameraConfigurationTypes = Object.keys(cameraConfiguration);
 	    cameraConfigurationTypes = cameraConfigurationTypes.filter((cameraConfigurationType) => __classPrivateFieldGet(this, _CameraManager_instances, "m", _CameraManager_assertAvailableCameraConfigurationType).call(this, cameraConfigurationType));
 	    const dataView = new DataView(new ArrayBuffer(cameraConfigurationTypes.length * 3));
 	    cameraConfigurationTypes.forEach((cameraConfigurationType, index) => {
-	        _a$5.AssertValidCameraConfigurationType(cameraConfigurationType);
+	        _a$6.AssertValidCameraConfigurationType(cameraConfigurationType);
 	        const cameraConfigurationTypeEnum = CameraConfigurationTypes.indexOf(cameraConfigurationType);
 	        dataView.setUint8(index * 3, cameraConfigurationTypeEnum);
 	        const value = cameraConfiguration[cameraConfigurationType];
 	        dataView.setUint16(index * 3 + 1, value, true);
 	    });
+	    _console$q.log({ sensorConfigurationData: dataView });
+	    return dataView;
+	};
+
+	createConsole("AudioUtils", { log: true });
+	function float32ArrayToWav(audioData, sampleRate, numChannels) {
+	    const wavBuffer = encodeWAV(audioData, sampleRate, numChannels);
+	    return new Blob([wavBuffer], { type: "audio/wav" });
+	}
+	function encodeWAV(interleaved, sampleRate, numChannels) {
+	    const buffer = new ArrayBuffer(44 + interleaved.length * 2);
+	    const view = new DataView(buffer);
+	    writeString(view, 0, "RIFF");
+	    view.setUint32(4, 36 + interleaved.length * 2, true);
+	    writeString(view, 8, "WAVE");
+	    writeString(view, 12, "fmt ");
+	    view.setUint32(16, 16, true);
+	    view.setUint16(20, 1, true);
+	    view.setUint16(22, numChannels, true);
+	    view.setUint32(24, sampleRate, true);
+	    view.setUint32(28, sampleRate * numChannels * 2, true);
+	    view.setUint16(32, numChannels * 2, true);
+	    view.setUint16(34, 16, true);
+	    writeString(view, 36, "data");
+	    view.setUint32(40, interleaved.length * 2, true);
+	    for (let i = 0; i < interleaved.length; i++) {
+	        view.setInt16(44 + i * 2, interleaved[i] * 0x7fff, true);
+	    }
+	    return buffer;
+	}
+	function writeString(view, offset, string) {
+	    for (let i = 0; i < string.length; i++) {
+	        view.setUint8(offset + i, string.charCodeAt(i));
+	    }
+	}
+
+	var _MicrophoneManager_instances, _a$5, _MicrophoneManager_dispatchEvent_get, _MicrophoneManager_microphoneStatus, _MicrophoneManager_parseMicrophoneStatus, _MicrophoneManager_updateMicrophoneStatus, _MicrophoneManager_sendMicrophoneCommand, _MicrophoneManager_assertIsNotIdle, _MicrophoneManager_assertValidBitDepth, _MicrophoneManager_fadeDuration, _MicrophoneManager_playbackTime, _MicrophoneManager_parseMicrophoneData, _MicrophoneManager_bytesPerSample_get, _MicrophoneManager_microphoneConfiguration, _MicrophoneManager_availableMicrophoneConfigurationTypes, _MicrophoneManager_parseMicrophoneConfiguration, _MicrophoneManager_isMicrophoneConfigurationRedundant, _MicrophoneManager_assertAvailableMicrophoneConfigurationType, _MicrophoneManager_createData, _MicrophoneManager_audioContext, _MicrophoneManager_gainNode, _MicrophoneManager_mediaStreamDestination, _MicrophoneManager_isRecording, _MicrophoneManager_microphoneRecordingData;
+	const _console$p = createConsole("MicrophoneManager", { log: false });
+	const MicrophoneSensorTypes = ["microphone"];
+	const MicrophoneCommands = ["start", "stop", "vad"];
+	const MicrophoneStatuses = ["idle", "streaming", "vad"];
+	const MicrophoneConfigurationTypes = ["sampleRate", "bitDepth"];
+	const MicrophoneSampleRates = ["8000", "16000"];
+	const MicrophoneBitDepths = ["8", "16"];
+	const MicrophoneMessageTypes = [
+	    "microphoneStatus",
+	    "microphoneCommand",
+	    "getMicrophoneConfiguration",
+	    "setMicrophoneConfiguration",
+	    "microphoneData",
+	];
+	const MicrophoneConfigurationValues = {
+	    sampleRate: MicrophoneSampleRates,
+	    bitDepth: MicrophoneBitDepths,
+	};
+	const RequiredMicrophoneMessageTypes = [
+	    "getMicrophoneConfiguration",
+	    "microphoneStatus",
+	];
+	const MicrophoneEventTypes = [
+	    ...MicrophoneMessageTypes,
+	    "isRecordingMicrophone",
+	    "microphoneRecording",
+	];
+	class MicrophoneManager {
+	    constructor() {
+	        _MicrophoneManager_instances.add(this);
+	        _MicrophoneManager_microphoneStatus.set(this, void 0);
+	        _MicrophoneManager_fadeDuration.set(this, 0.001);
+	        _MicrophoneManager_playbackTime.set(this, 0);
+	        _MicrophoneManager_microphoneConfiguration.set(this, {});
+	        _MicrophoneManager_availableMicrophoneConfigurationTypes.set(this, void 0);
+	        _MicrophoneManager_audioContext.set(this, void 0);
+	        _MicrophoneManager_gainNode.set(this, void 0);
+	        _MicrophoneManager_mediaStreamDestination.set(this, void 0);
+	        _MicrophoneManager_isRecording.set(this, false);
+	        _MicrophoneManager_microphoneRecordingData.set(this, void 0);
+	        autoBind(this);
+	    }
+	    get waitForEvent() {
+	        return this.eventDispatcher.waitForEvent;
+	    }
+	    requestRequiredInformation() {
+	        _console$p.log("requesting required microphone information");
+	        const messages = RequiredMicrophoneMessageTypes.map((messageType) => ({
+	            type: messageType,
+	        }));
+	        this.sendMessage(messages, false);
+	    }
+	    get microphoneStatus() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_microphoneStatus, "f");
+	    }
+	    async start() {
+	        await __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_sendMicrophoneCommand).call(this, "start");
+	    }
+	    async stop() {
+	        __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_assertIsNotIdle).call(this);
+	        await __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_sendMicrophoneCommand).call(this, "stop");
+	    }
+	    async vad() {
+	        await __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_sendMicrophoneCommand).call(this, "vad");
+	    }
+	    async toggle() {
+	        switch (this.microphoneStatus) {
+	            case "idle":
+	                this.start();
+	                break;
+	            case "streaming":
+	                this.stop();
+	                break;
+	        }
+	    }
+	    get microphoneConfiguration() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_microphoneConfiguration, "f");
+	    }
+	    get availableMicrophoneConfigurationTypes() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_availableMicrophoneConfigurationTypes, "f");
+	    }
+	    get bitDepth() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_microphoneConfiguration, "f").bitDepth;
+	    }
+	    get sampleRate() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_microphoneConfiguration, "f").sampleRate;
+	    }
+	    async setMicrophoneConfiguration(newMicrophoneConfiguration) {
+	        _console$p.log({ newMicrophoneConfiguration });
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_isMicrophoneConfigurationRedundant).call(this, newMicrophoneConfiguration)) {
+	            _console$p.log("redundant microphone configuration");
+	            return;
+	        }
+	        const setMicrophoneConfigurationData = __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_createData).call(this, newMicrophoneConfiguration);
+	        _console$p.log({ setMicrophoneConfigurationData });
+	        const promise = this.waitForEvent("getMicrophoneConfiguration");
+	        this.sendMessage([
+	            {
+	                type: "setMicrophoneConfiguration",
+	                data: setMicrophoneConfigurationData.buffer,
+	            },
+	        ]);
+	        await promise;
+	    }
+	    static AssertValidMicrophoneConfigurationType(microphoneConfigurationType) {
+	        _console$p.assertEnumWithError(microphoneConfigurationType, MicrophoneConfigurationTypes);
+	    }
+	    static AssertValidMicrophoneConfigurationTypeEnum(microphoneConfigurationTypeEnum) {
+	        _console$p.assertTypeWithError(microphoneConfigurationTypeEnum, "number");
+	        _console$p.assertWithError(microphoneConfigurationTypeEnum in MicrophoneConfigurationTypes, `invalid microphoneConfigurationTypeEnum ${microphoneConfigurationTypeEnum}`);
+	    }
+	    parseMessage(messageType, dataView) {
+	        _console$p.log({ messageType, dataView });
+	        switch (messageType) {
+	            case "microphoneStatus":
+	                __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_parseMicrophoneStatus).call(this, dataView);
+	                break;
+	            case "getMicrophoneConfiguration":
+	            case "setMicrophoneConfiguration":
+	                __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_parseMicrophoneConfiguration).call(this, dataView);
+	                break;
+	            case "microphoneData":
+	                __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_parseMicrophoneData).call(this, dataView);
+	                break;
+	            default:
+	                throw Error(`uncaught messageType ${messageType}`);
+	        }
+	    }
+	    get audioContext() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f");
+	    }
+	    set audioContext(newAudioContext) {
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f") == newAudioContext) {
+	            _console$p.log("redundant audioContext assignment", __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f"));
+	            return;
+	        }
+	        __classPrivateFieldSet(this, _MicrophoneManager_audioContext, newAudioContext, "f");
+	        _console$p.log("assigned new audioContext", __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f"));
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f")) {
+	            __classPrivateFieldSet(this, _MicrophoneManager_playbackTime, __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").currentTime, "f");
+	        }
+	        else {
+	            if (__classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f")) {
+	                __classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f").disconnect();
+	                __classPrivateFieldSet(this, _MicrophoneManager_mediaStreamDestination, undefined, "f");
+	            }
+	            if (__classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f")) {
+	                __classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f").disconnect();
+	                __classPrivateFieldSet(this, _MicrophoneManager_gainNode, undefined, "f");
+	            }
+	        }
+	    }
+	    get gainNode() {
+	        _console$p.assertWithError(__classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f"), "audioContext assignment required for gainNode");
+	        if (!__classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f")) {
+	            _console$p.log("creating gainNode...");
+	            __classPrivateFieldSet(this, _MicrophoneManager_gainNode, __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").createGain(), "f");
+	            _console$p.log("created gainNode", __classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f"));
+	        }
+	        return __classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f");
+	    }
+	    get mediaStreamDestination() {
+	        _console$p.assertWithError(__classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f"), "audioContext assignment required for mediaStreamDestination");
+	        if (!__classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f")) {
+	            _console$p.log("creating mediaStreamDestination...");
+	            __classPrivateFieldSet(this, _MicrophoneManager_mediaStreamDestination, __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").createMediaStreamDestination(), "f");
+	            this.gainNode?.connect(__classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f"));
+	            _console$p.log("created mediaStreamDestination", __classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f"));
+	        }
+	        return __classPrivateFieldGet(this, _MicrophoneManager_mediaStreamDestination, "f");
+	    }
+	    get isRecording() {
+	        return __classPrivateFieldGet(this, _MicrophoneManager_isRecording, "f");
+	    }
+	    startRecording() {
+	        if (this.isRecording) {
+	            _console$p.log("already recording");
+	            return;
+	        }
+	        __classPrivateFieldSet(this, _MicrophoneManager_microphoneRecordingData, [], "f");
+	        __classPrivateFieldSet(this, _MicrophoneManager_isRecording, true, "f");
+	        __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "isRecordingMicrophone", {
+	            isRecordingMicrophone: this.isRecording,
+	        });
+	    }
+	    stopRecording() {
+	        if (!this.isRecording) {
+	            _console$p.log("already not recording");
+	            return;
+	        }
+	        __classPrivateFieldSet(this, _MicrophoneManager_isRecording, false, "f");
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f") &&
+	            __classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f").length > 0) {
+	            _console$p.log("parsing microphone data...", __classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f").length);
+	            const arrayBuffer = concatenateArrayBuffers(...__classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f"));
+	            const samples = new Float32Array(arrayBuffer);
+	            const blob = float32ArrayToWav(samples, Number(this.sampleRate), 1);
+	            const url = URL.createObjectURL(blob);
+	            __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "microphoneRecording", {
+	                samples,
+	                sampleRate: this.sampleRate,
+	                bitDepth: this.bitDepth,
+	                blob,
+	                url,
+	            });
+	        }
+	        __classPrivateFieldSet(this, _MicrophoneManager_microphoneRecordingData, undefined, "f");
+	        __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "isRecordingMicrophone", {
+	            isRecordingMicrophone: this.isRecording,
+	        });
+	    }
+	    toggleRecording() {
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_isRecording, "f")) {
+	            this.stopRecording();
+	        }
+	        else {
+	            this.startRecording();
+	        }
+	    }
+	    clear() {
+	        __classPrivateFieldSet(this, _MicrophoneManager_microphoneStatus, undefined, "f");
+	        __classPrivateFieldSet(this, _MicrophoneManager_microphoneConfiguration, {}, "f");
+	        if (this.isRecording) {
+	            this.stopRecording();
+	        }
+	    }
+	}
+	_a$5 = MicrophoneManager, _MicrophoneManager_microphoneStatus = new WeakMap(), _MicrophoneManager_fadeDuration = new WeakMap(), _MicrophoneManager_playbackTime = new WeakMap(), _MicrophoneManager_microphoneConfiguration = new WeakMap(), _MicrophoneManager_availableMicrophoneConfigurationTypes = new WeakMap(), _MicrophoneManager_audioContext = new WeakMap(), _MicrophoneManager_gainNode = new WeakMap(), _MicrophoneManager_mediaStreamDestination = new WeakMap(), _MicrophoneManager_isRecording = new WeakMap(), _MicrophoneManager_microphoneRecordingData = new WeakMap(), _MicrophoneManager_instances = new WeakSet(), _MicrophoneManager_dispatchEvent_get = function _MicrophoneManager_dispatchEvent_get() {
+	    return this.eventDispatcher.dispatchEvent;
+	}, _MicrophoneManager_parseMicrophoneStatus = function _MicrophoneManager_parseMicrophoneStatus(dataView) {
+	    const microphoneStatusIndex = dataView.getUint8(0);
+	    const newMicrophoneStatus = MicrophoneStatuses[microphoneStatusIndex];
+	    __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_updateMicrophoneStatus).call(this, newMicrophoneStatus);
+	}, _MicrophoneManager_updateMicrophoneStatus = function _MicrophoneManager_updateMicrophoneStatus(newMicrophoneStatus) {
+	    _console$p.assertEnumWithError(newMicrophoneStatus, MicrophoneStatuses);
+	    if (newMicrophoneStatus == __classPrivateFieldGet(this, _MicrophoneManager_microphoneStatus, "f")) {
+	        _console$p.log(`redundant microphoneStatus ${newMicrophoneStatus}`);
+	        return;
+	    }
+	    const previousMicrophoneStatus = __classPrivateFieldGet(this, _MicrophoneManager_microphoneStatus, "f");
+	    __classPrivateFieldSet(this, _MicrophoneManager_microphoneStatus, newMicrophoneStatus, "f");
+	    _console$p.log(`updated microphoneStatus to "${this.microphoneStatus}"`);
+	    __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "microphoneStatus", {
+	        microphoneStatus: this.microphoneStatus,
+	        previousMicrophoneStatus,
+	    });
+	}, _MicrophoneManager_sendMicrophoneCommand =
+	async function _MicrophoneManager_sendMicrophoneCommand(command, sendImmediately) {
+	    _console$p.assertEnumWithError(command, MicrophoneCommands);
+	    _console$p.log(`sending microphone command "${command}"`);
+	    const promise = this.waitForEvent("microphoneStatus");
+	    _console$p.log(`setting command "${command}"`);
+	    const commandEnum = MicrophoneCommands.indexOf(command);
+	    this.sendMessage([
+	        {
+	            type: "microphoneCommand",
+	            data: Uint8Array.from([commandEnum]).buffer,
+	        },
+	    ], sendImmediately);
+	    await promise;
+	}, _MicrophoneManager_assertIsNotIdle = function _MicrophoneManager_assertIsNotIdle() {
+	    _console$p.assertWithError(__classPrivateFieldGet(this, _MicrophoneManager_microphoneStatus, "f") != "idle", `microphone is idle`);
+	}, _MicrophoneManager_assertValidBitDepth = function _MicrophoneManager_assertValidBitDepth() {
+	    _console$p.assertEnumWithError(this.bitDepth, MicrophoneBitDepths);
+	}, _MicrophoneManager_parseMicrophoneData = function _MicrophoneManager_parseMicrophoneData(dataView) {
+	    __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_assertValidBitDepth).call(this);
+	    _console$p.log("parsing microphone data", dataView);
+	    const numberOfSamples = dataView.byteLength / __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_bytesPerSample_get);
+	    const samples = new Float32Array(numberOfSamples);
+	    for (let i = 0; i < numberOfSamples; i++) {
+	        let sample;
+	        switch (this.bitDepth) {
+	            case "16":
+	                sample = dataView.getInt16(i * 2, true);
+	                samples[i] = sample / 2 ** 15;
+	                break;
+	            case "8":
+	                sample = dataView.getInt8(i);
+	                samples[i] = sample / 2 ** 7;
+	                break;
+	        }
+	    }
+	    _console$p.log("samples", samples);
+	    if (__classPrivateFieldGet(this, _MicrophoneManager_isRecording, "f") && __classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f")) {
+	        __classPrivateFieldGet(this, _MicrophoneManager_microphoneRecordingData, "f").push(samples);
+	    }
+	    if (__classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f")) {
+	        if (__classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f")) {
+	            const audioBuffer = __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").createBuffer(1, samples.length, Number(this.sampleRate));
+	            audioBuffer.getChannelData(0).set(samples);
+	            const bufferSource = __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").createBufferSource();
+	            bufferSource.buffer = audioBuffer;
+	            const channelData = audioBuffer.getChannelData(0);
+	            const sampleRate = Number(this.sampleRate);
+	            for (let i = 0; i < __classPrivateFieldGet(this, _MicrophoneManager_fadeDuration, "f") * sampleRate; i++) {
+	                channelData[i] *= i / (__classPrivateFieldGet(this, _MicrophoneManager_fadeDuration, "f") * sampleRate);
+	            }
+	            for (let i = channelData.length - 1; i >= channelData.length - __classPrivateFieldGet(this, _MicrophoneManager_fadeDuration, "f") * sampleRate; i--) {
+	                channelData[i] *=
+	                    (channelData.length - i) / (__classPrivateFieldGet(this, _MicrophoneManager_fadeDuration, "f") * sampleRate);
+	            }
+	            bufferSource.connect(__classPrivateFieldGet(this, _MicrophoneManager_gainNode, "f"));
+	            if (__classPrivateFieldGet(this, _MicrophoneManager_playbackTime, "f") < __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").currentTime) {
+	                __classPrivateFieldSet(this, _MicrophoneManager_playbackTime, __classPrivateFieldGet(this, _MicrophoneManager_audioContext, "f").currentTime, "f");
+	            }
+	            bufferSource.start(__classPrivateFieldGet(this, _MicrophoneManager_playbackTime, "f"));
+	            __classPrivateFieldSet(this, _MicrophoneManager_playbackTime, __classPrivateFieldGet(this, _MicrophoneManager_playbackTime, "f") + audioBuffer.duration, "f");
+	        }
+	    }
+	    __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "microphoneData", {
+	        samples,
+	        sampleRate: this.sampleRate,
+	        bitDepth: this.bitDepth,
+	    });
+	}, _MicrophoneManager_bytesPerSample_get = function _MicrophoneManager_bytesPerSample_get() {
+	    switch (this.bitDepth) {
+	        case "8":
+	            return 1;
+	        case "16":
+	            return 2;
+	    }
+	}, _MicrophoneManager_parseMicrophoneConfiguration = function _MicrophoneManager_parseMicrophoneConfiguration(dataView) {
+	    const parsedMicrophoneConfiguration = {};
+	    let byteOffset = 0;
+	    while (byteOffset < dataView.byteLength) {
+	        const microphoneConfigurationTypeIndex = dataView.getUint8(byteOffset++);
+	        const microphoneConfigurationType = MicrophoneConfigurationTypes[microphoneConfigurationTypeIndex];
+	        _console$p.assertWithError(microphoneConfigurationType, `invalid microphoneConfigurationTypeIndex ${microphoneConfigurationTypeIndex}`);
+	        let rawValue = dataView.getUint8(byteOffset++);
+	        const values = MicrophoneConfigurationValues[microphoneConfigurationType];
+	        const value = values[rawValue];
+	        _console$p.assertEnumWithError(value, values);
+	        _console$p.log({ microphoneConfigurationType, value });
+	        parsedMicrophoneConfiguration[microphoneConfigurationType] = value;
+	    }
+	    _console$p.log({ parsedMicrophoneConfiguration });
+	    __classPrivateFieldSet(this, _MicrophoneManager_availableMicrophoneConfigurationTypes, Object.keys(parsedMicrophoneConfiguration), "f");
+	    __classPrivateFieldSet(this, _MicrophoneManager_microphoneConfiguration, parsedMicrophoneConfiguration, "f");
+	    __classPrivateFieldGet(this, _MicrophoneManager_instances, "a", _MicrophoneManager_dispatchEvent_get).call(this, "getMicrophoneConfiguration", {
+	        microphoneConfiguration: __classPrivateFieldGet(this, _MicrophoneManager_microphoneConfiguration, "f"),
+	    });
+	}, _MicrophoneManager_isMicrophoneConfigurationRedundant = function _MicrophoneManager_isMicrophoneConfigurationRedundant(microphoneConfiguration) {
+	    let microphoneConfigurationTypes = Object.keys(microphoneConfiguration);
+	    return microphoneConfigurationTypes.every((microphoneConfigurationType) => {
+	        return (this.microphoneConfiguration[microphoneConfigurationType] ==
+	            microphoneConfiguration[microphoneConfigurationType]);
+	    });
+	}, _MicrophoneManager_assertAvailableMicrophoneConfigurationType = function _MicrophoneManager_assertAvailableMicrophoneConfigurationType(microphoneConfigurationType) {
+	    _console$p.assertWithError(__classPrivateFieldGet(this, _MicrophoneManager_availableMicrophoneConfigurationTypes, "f"), "must get initial microphoneConfiguration");
+	    const isMicrophoneConfigurationTypeAvailable = __classPrivateFieldGet(this, _MicrophoneManager_availableMicrophoneConfigurationTypes, "f")?.includes(microphoneConfigurationType);
+	    _console$p.assertWithError(isMicrophoneConfigurationTypeAvailable, `unavailable microphone configuration type "${microphoneConfigurationType}"`);
+	    return isMicrophoneConfigurationTypeAvailable;
+	}, _MicrophoneManager_createData = function _MicrophoneManager_createData(microphoneConfiguration) {
+	    let microphoneConfigurationTypes = Object.keys(microphoneConfiguration);
+	    microphoneConfigurationTypes = microphoneConfigurationTypes.filter((microphoneConfigurationType) => __classPrivateFieldGet(this, _MicrophoneManager_instances, "m", _MicrophoneManager_assertAvailableMicrophoneConfigurationType).call(this, microphoneConfigurationType));
+	    const dataView = new DataView(new ArrayBuffer(microphoneConfigurationTypes.length * 2));
+	    microphoneConfigurationTypes.forEach((microphoneConfigurationType, index) => {
+	        _a$5.AssertValidMicrophoneConfigurationType(microphoneConfigurationType);
+	        const microphoneConfigurationTypeEnum = MicrophoneConfigurationTypes.indexOf(microphoneConfigurationType);
+	        dataView.setUint8(index * 2, microphoneConfigurationTypeEnum);
+	        let value = microphoneConfiguration[microphoneConfigurationType];
+	        if (typeof value == "number") {
+	            value = value.toString();
+	        }
+	        const values = MicrophoneConfigurationValues[microphoneConfigurationType];
+	        _console$p.assertEnumWithError(value, values);
+	        const rawValue = values.indexOf(value);
+	        dataView.setUint8(index * 2 + 1, rawValue);
+	    });
 	    _console$p.log({ sensorConfigurationData: dataView });
 	    return dataView;
 	};
@@ -1634,6 +2040,7 @@
 	    ...MotionSensorTypes,
 	    ...BarometerSensorTypes,
 	    ...CameraSensorTypes,
+	    ...MicrophoneSensorTypes,
 	];
 	const ContinuousSensorTypes = [
 	    ...ContinuousPressureSensorTypes,
@@ -1750,6 +2157,8 @@
 	                break;
 	            case "camera":
 	                return;
+	            case "microphone":
+	                return;
 	            default:
 	                _console$o.error(`uncaught sensorType "${sensorType}"`);
 	        }
@@ -3270,6 +3679,7 @@
 	    ...TfliteMessageTypes,
 	    ...WifiMessageTypes,
 	    ...CameraMessageTypes,
+	    ...MicrophoneMessageTypes,
 	];
 	const SMPMessageTypes = ["smp"];
 	const BatteryLevelMessageTypes = ["batteryLevel"];
@@ -5389,7 +5799,7 @@
 	    __classPrivateFieldGet(this, _WebSocketConnectionManager_instances, "m", _WebSocketConnectionManager_sendWebSocketMessage).call(this, ...WebSocketDeviceInformationMessageTypes);
 	};
 
-	var _Device_instances, _a$2, _Device_DefaultConnectionManager, _Device_eventDispatcher, _Device_dispatchEvent_get, _Device_connectionManager, _Device_sendTxMessages, _Device_isConnected, _Device_assertIsConnected, _Device_didReceiveMessageTypes, _Device_hasRequiredInformation_get, _Device_requestRequiredInformation, _Device_assertCanReconnect, _Device_ReconnectOnDisconnection, _Device_reconnectOnDisconnection, _Device_reconnectIntervalId, _Device_onConnectionStatusUpdated, _Device_dispatchConnectionEvents, _Device_checkConnection, _Device_clear, _Device_clearConnection, _Device_onConnectionMessageReceived, _Device_onConnectionMessagesReceived, _Device_deviceInformationManager, _Device_batteryLevel, _Device_updateBatteryLevel, _Device_sensorConfigurationManager, _Device_ClearSensorConfigurationOnLeave, _Device_clearSensorConfigurationOnLeave, _Device_sensorDataManager, _Device_vibrationManager, _Device_fileTransferManager, _Device_tfliteManager, _Device_firmwareManager, _Device_assertCanUpdateFirmware, _Device_sendSmpMessage, _Device_isServerSide, _Device_wifiManager, _Device_cameraManager, _Device_assertHasCamera;
+	var _Device_instances, _a$2, _Device_DefaultConnectionManager, _Device_eventDispatcher, _Device_dispatchEvent_get, _Device_connectionManager, _Device_sendTxMessages, _Device_isConnected, _Device_assertIsConnected, _Device_didReceiveMessageTypes, _Device_hasRequiredInformation_get, _Device_requestRequiredInformation, _Device_assertCanReconnect, _Device_ReconnectOnDisconnection, _Device_reconnectOnDisconnection, _Device_reconnectIntervalId, _Device_onConnectionStatusUpdated, _Device_dispatchConnectionEvents, _Device_checkConnection, _Device_clear, _Device_clearConnection, _Device_onConnectionMessageReceived, _Device_onConnectionMessagesReceived, _Device_deviceInformationManager, _Device_batteryLevel, _Device_updateBatteryLevel, _Device_sensorConfigurationManager, _Device_ClearSensorConfigurationOnLeave, _Device_clearSensorConfigurationOnLeave, _Device_sensorDataManager, _Device_vibrationManager, _Device_fileTransferManager, _Device_tfliteManager, _Device_firmwareManager, _Device_assertCanUpdateFirmware, _Device_sendSmpMessage, _Device_isServerSide, _Device_wifiManager, _Device_cameraManager, _Device_assertHasCamera, _Device_microphoneManager, _Device_assertHasMicrophone, _Device_assertWebAudioSupport;
 	const _console$6 = createConsole("Device", { log: false });
 	const DeviceEventTypes = [
 	    "connectionMessage",
@@ -5405,6 +5815,7 @@
 	    ...TfliteEventTypes,
 	    ...WifiEventTypes,
 	    ...CameraEventTypes,
+	    ...MicrophoneEventTypes,
 	    ...FirmwareEventTypes,
 	];
 	const RequiredInformationConnectionMessages = [
@@ -5451,6 +5862,7 @@
 	        _Device_isServerSide.set(this, false);
 	        _Device_wifiManager.set(this, new WifiManager());
 	        _Device_cameraManager.set(this, new CameraManager());
+	        _Device_microphoneManager.set(this, new MicrophoneManager());
 	        __classPrivateFieldGet(this, _Device_deviceInformationManager, "f").eventDispatcher = __classPrivateFieldGet(this, _Device_eventDispatcher, "f");
 	        this._informationManager.sendMessage = this
 	            .sendTxMessages;
@@ -5474,6 +5886,9 @@
 	        __classPrivateFieldGet(this, _Device_cameraManager, "f").sendMessage = this
 	            .sendTxMessages;
 	        __classPrivateFieldGet(this, _Device_cameraManager, "f").eventDispatcher = __classPrivateFieldGet(this, _Device_eventDispatcher, "f");
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").sendMessage = this
+	            .sendTxMessages;
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").eventDispatcher = __classPrivateFieldGet(this, _Device_eventDispatcher, "f");
 	        __classPrivateFieldGet(this, _Device_firmwareManager, "f").sendMessage = this
 	            .sendSmpMessage;
 	        __classPrivateFieldGet(this, _Device_firmwareManager, "f").eventDispatcher = __classPrivateFieldGet(this, _Device_eventDispatcher, "f");
@@ -5506,6 +5921,16 @@
 	            else {
 	                _console$6.log("don't need to request camera infomration");
 	            }
+	            if (this.sensorTypes.includes("microphone")) {
+	                _console$6.log("requesting required microphone information");
+	                const messages = RequiredMicrophoneMessageTypes.map((messageType) => ({
+	                    type: messageType,
+	                }));
+	                this.sendTxMessages(messages, false);
+	            }
+	            else {
+	                _console$6.log("don't need to request microphone infomration");
+	            }
 	        });
 	        this.addEventListener("getFileTypes", () => {
 	            if (this.connectionStatus != "connecting") {
@@ -6056,8 +6481,70 @@
 	    get setCameraConfiguration() {
 	        return __classPrivateFieldGet(this, _Device_cameraManager, "f").setCameraConfiguration;
 	    }
+	    get hasMicrophone() {
+	        return this.sensorTypes.includes("microphone");
+	    }
+	    get microphoneStatus() {
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").microphoneStatus;
+	    }
+	    async startMicrophone() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertHasMicrophone).call(this);
+	        await __classPrivateFieldGet(this, _Device_microphoneManager, "f").start();
+	    }
+	    async stopMicrophone() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertHasMicrophone).call(this);
+	        await __classPrivateFieldGet(this, _Device_microphoneManager, "f").stop();
+	    }
+	    async enableMicrophoneVad() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertHasMicrophone).call(this);
+	        await __classPrivateFieldGet(this, _Device_microphoneManager, "f").vad();
+	    }
+	    async toggleMicrophone() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertHasMicrophone).call(this);
+	        await __classPrivateFieldGet(this, _Device_microphoneManager, "f").toggle();
+	    }
+	    get microphoneConfiguration() {
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").microphoneConfiguration;
+	    }
+	    get availableMicrophoneConfigurationTypes() {
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").availableMicrophoneConfigurationTypes;
+	    }
+	    get setMicrophoneConfiguration() {
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").setMicrophoneConfiguration;
+	    }
+	    get audioContext() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").audioContext;
+	    }
+	    set audioContext(newAudioContext) {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").audioContext = newAudioContext;
+	    }
+	    get microphoneMediaStreamDestination() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").mediaStreamDestination;
+	    }
+	    get microphoneGainNode() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").gainNode;
+	    }
+	    get isRecordingMicrophone() {
+	        return __classPrivateFieldGet(this, _Device_microphoneManager, "f").isRecording;
+	    }
+	    startRecordingMicrophone() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").startRecording();
+	    }
+	    stopRecordingMicrophone() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").stopRecording();
+	    }
+	    toggleMicrophoneRecording() {
+	        __classPrivateFieldGet(this, _Device_instances, "m", _Device_assertWebAudioSupport).call(this);
+	        __classPrivateFieldGet(this, _Device_microphoneManager, "f").toggleRecording();
+	    }
 	}
-	_a$2 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManager = new WeakMap(), _Device_isConnected = new WeakMap(), _Device_reconnectOnDisconnection = new WeakMap(), _Device_reconnectIntervalId = new WeakMap(), _Device_deviceInformationManager = new WeakMap(), _Device_batteryLevel = new WeakMap(), _Device_sensorConfigurationManager = new WeakMap(), _Device_clearSensorConfigurationOnLeave = new WeakMap(), _Device_sensorDataManager = new WeakMap(), _Device_vibrationManager = new WeakMap(), _Device_fileTransferManager = new WeakMap(), _Device_tfliteManager = new WeakMap(), _Device_firmwareManager = new WeakMap(), _Device_isServerSide = new WeakMap(), _Device_wifiManager = new WeakMap(), _Device_cameraManager = new WeakMap(), _Device_instances = new WeakSet(), _Device_DefaultConnectionManager = function _Device_DefaultConnectionManager() {
+	_a$2 = Device, _Device_eventDispatcher = new WeakMap(), _Device_connectionManager = new WeakMap(), _Device_isConnected = new WeakMap(), _Device_reconnectOnDisconnection = new WeakMap(), _Device_reconnectIntervalId = new WeakMap(), _Device_deviceInformationManager = new WeakMap(), _Device_batteryLevel = new WeakMap(), _Device_sensorConfigurationManager = new WeakMap(), _Device_clearSensorConfigurationOnLeave = new WeakMap(), _Device_sensorDataManager = new WeakMap(), _Device_vibrationManager = new WeakMap(), _Device_fileTransferManager = new WeakMap(), _Device_tfliteManager = new WeakMap(), _Device_firmwareManager = new WeakMap(), _Device_isServerSide = new WeakMap(), _Device_wifiManager = new WeakMap(), _Device_cameraManager = new WeakMap(), _Device_microphoneManager = new WeakMap(), _Device_instances = new WeakSet(), _Device_DefaultConnectionManager = function _Device_DefaultConnectionManager() {
 	    return new WebBluetoothConnectionManager();
 	}, _Device_dispatchEvent_get = function _Device_dispatchEvent_get() {
 	    return __classPrivateFieldGet(this, _Device_eventDispatcher, "f").dispatchEvent;
@@ -6157,6 +6644,7 @@
 	    __classPrivateFieldGet(this, _Device_tfliteManager, "f").clear();
 	    __classPrivateFieldGet(this, _Device_wifiManager, "f").clear();
 	    __classPrivateFieldGet(this, _Device_cameraManager, "f").clear();
+	    __classPrivateFieldGet(this, _Device_microphoneManager, "f").clear();
 	}, _Device_clearConnection = function _Device_clearConnection() {
 	    this.connectionManager?.clear();
 	    this.latestConnectionMessages.clear();
@@ -6199,6 +6687,9 @@
 	            else if (CameraMessageTypes.includes(messageType)) {
 	                __classPrivateFieldGet(this, _Device_cameraManager, "f").parseMessage(messageType, dataView);
 	            }
+	            else if (MicrophoneMessageTypes.includes(messageType)) {
+	                __classPrivateFieldGet(this, _Device_microphoneManager, "f").parseMessage(messageType, dataView);
+	            }
 	            else {
 	                throw Error(`uncaught messageType ${messageType}`);
 	            }
@@ -6233,6 +6724,10 @@
 	    return __classPrivateFieldGet(this, _Device_connectionManager, "f").sendSmpMessage(data);
 	}, _Device_assertHasCamera = function _Device_assertHasCamera() {
 	    _console$6.assertWithError(this.hasCamera, "camera not available");
+	}, _Device_assertHasMicrophone = function _Device_assertHasMicrophone() {
+	    _console$6.assertWithError(this.hasMicrophone, "microphone not available");
+	}, _Device_assertWebAudioSupport = function _Device_assertWebAudioSupport() {
+	    _console$6.assertWithError(AudioContext, "WebAudio is not supported");
 	};
 	_Device_ReconnectOnDisconnection = { value: false };
 	_Device_ClearSensorConfigurationOnLeave = { value: true };
@@ -7229,6 +7724,9 @@
 	exports.MaxVibrationWaveformSegmentDuration = MaxVibrationWaveformSegmentDuration;
 	exports.MaxWifiPasswordLength = MaxWifiPasswordLength;
 	exports.MaxWifiSSIDLength = MaxWifiSSIDLength;
+	exports.MicrophoneCommands = MicrophoneCommands;
+	exports.MicrophoneConfigurationTypes = MicrophoneConfigurationTypes;
+	exports.MicrophoneConfigurationValues = MicrophoneConfigurationValues;
 	exports.MinNameLength = MinNameLength;
 	exports.MinWifiPasswordLength = MinWifiPasswordLength;
 	exports.MinWifiSSIDLength = MinWifiSSIDLength;