@livestore/wa-sqlite 0.4.0-dev.22 → 0.4.0-dev.24

package/src/FacadeVFS.js

@@ -1,7 +1,7 @@
 // Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
-import * as VFS from './VFS.js';
+import * as VFS from './VFS.js'
 
-const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor
 
 // Convenience base class for a JavaScript VFS.
 // The raw xOpen, xRead, etc. function signatures receive only C primitives
@@ -10,168 +10,165 @@ const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
 // such as string, Uint8Array, and DataView.
 export class FacadeVFS extends VFS.Base {
   /**
-   * @param {string} name 
-   * @param {object} module 
+   * @param {string} name
+   * @param {object} module
    */
-  constructor(name, module) {
-    super(name, module);
-  }
 
   /**
    * Override to indicate which methods are asynchronous.
-   * @param {string} methodName 
+   * @param {string} methodName
    * @returns {boolean}
    */
   hasAsyncMethod(methodName) {
     // The input argument is a string like "xOpen", so convert to "jOpen".
     // Then check if the method exists and is async.
-    const jMethodName = `j${methodName.slice(1)}`;
-    return this[jMethodName] instanceof AsyncFunction;
+    const jMethodName = `j${methodName.slice(1)}`
+    return this[jMethodName] instanceof AsyncFunction
   }
-  
+
   /**
    * Return the filename for a file id for use by mixins.
-   * @param {number} pFile 
+   * @param {number} pFile
    * @returns {string}
    */
   getFilename(pFile) {
-    throw new Error('unimplemented');
+    throw new Error('unimplemented')
   }
 
   /**
-   * @param {string?} filename 
-   * @param {number} pFile 
-   * @param {number} flags 
-   * @param {DataView} pOutFlags 
+   * @param {string?} filename
+   * @param {number} pFile
+   * @param {number} flags
+   * @param {DataView} pOutFlags
    * @returns {number|Promise<number>}
    */
   jOpen(filename, pFile, flags, pOutFlags) {
-    return VFS.SQLITE_CANTOPEN;
+    return VFS.SQLITE_CANTOPEN
   }
 
   /**
-   * @param {string} filename 
-   * @param {number} syncDir 
+   * @param {string} filename
+   * @param {number} syncDir
    * @returns {number|Promise<number>}
    */
   jDelete(filename, syncDir) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {string} filename 
-   * @param {number} flags 
-   * @param {DataView} pResOut 
+   * @param {string} filename
+   * @param {number} flags
+   * @param {DataView} pResOut
    * @returns {number|Promise<number>}
    */
   jAccess(filename, flags, pResOut) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {string} filename 
-   * @param {Uint8Array} zOut 
+   * @param {string} filename
+   * @param {Uint8Array} zOut
    * @returns {number|Promise<number>}
    */
   jFullPathname(filename, zOut) {
     // Copy the filename to the output buffer.
-    const { read, written } = new TextEncoder().encodeInto(filename, zOut);
-    if (read < filename.length) return VFS.SQLITE_IOERR;
-    if (written >= zOut.length) return VFS.SQLITE_IOERR;
-    zOut[written] = 0;
-    return VFS.SQLITE_OK;
+    const { read, written } = new TextEncoder().encodeInto(filename, zOut)
+    if (read < filename.length) return VFS.SQLITE_IOERR
+    if (written >= zOut.length) return VFS.SQLITE_IOERR
+    zOut[written] = 0
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {Uint8Array} zBuf 
+   * @param {Uint8Array} zBuf
    * @returns {number|Promise<number>}
    */
   jGetLastError(zBuf) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
+   * @param {number} pFile
    * @returns {number|Promise<number>}
    */
   jClose(pFile) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset 
+   * @param {number} pFile
+   * @param {Uint8Array} pData
+   * @param {number} iOffset
    * @returns {number|Promise<number>}
    */
   jRead(pFile, pData, iOffset) {
-    pData.fill(0);
-    return VFS.SQLITE_IOERR_SHORT_READ;
+    pData.fill(0)
+    return VFS.SQLITE_IOERR_SHORT_READ
   }
 
   /**
-   * @param {number} pFile 
-   * @param {Uint8Array} pData 
-   * @param {number} iOffset 
+   * @param {number} pFile
+   * @param {Uint8Array} pData
+   * @param {number} iOffset
    * @returns {number|Promise<number>}
    */
   jWrite(pFile, pData, iOffset) {
-    return VFS.SQLITE_IOERR_WRITE;
+    return VFS.SQLITE_IOERR_WRITE
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} size 
+   * @param {number} pFile
+   * @param {number} size
    * @returns {number|Promise<number>}
    */
   jTruncate(pFile, size) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} flags 
+   * @param {number} pFile
+   * @param {number} flags
    * @returns {number|Promise<number>}
    */
   jSync(pFile, flags) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
+   * @param {number} pFile
    * @param {DataView} pSize
    * @returns {number|Promise<number>}
    */
   jFileSize(pFile, pSize) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} lockType 
+   * @param {number} pFile
+   * @param {number} lockType
    * @returns {number|Promise<number>}
    */
   jLock(pFile, lockType) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} lockType 
+   * @param {number} pFile
+   * @param {number} lockType
    * @returns {number|Promise<number>}
    */
   jUnlock(pFile, lockType) {
-    return VFS.SQLITE_OK;
+    return VFS.SQLITE_OK
   }
 
   /**
-   * @param {number} pFile 
-   * @param {DataView} pResOut 
+   * @param {number} pFile
+   * @param {DataView} pResOut
    * @returns {number|Promise<number>}
    */
   jCheckReservedLock(pFile, pResOut) {
-    pResOut.setInt32(0, 0, true);
-    return VFS.SQLITE_OK;
+    pResOut.setInt32(0, 0, true)
+    return VFS.SQLITE_OK
   }
 
   /**
@@ -181,7 +178,7 @@ export class FacadeVFS extends VFS.Base {
    * @returns {number|Promise<number>}
    */
   jFileControl(pFile, op, pArg) {
-    return VFS.SQLITE_NOTFOUND;
+    return VFS.SQLITE_NOTFOUND
   }
 
   /**
@@ -189,7 +186,7 @@ export class FacadeVFS extends VFS.Base {
    * @returns {number|Promise<number>}
    */
   jSectorSize(pFile) {
-    return super.xSectorSize(pFile);
+    return super.xSectorSize(pFile)
   }
 
   /**
@@ -197,210 +194,208 @@ export class FacadeVFS extends VFS.Base {
    * @returns {number|Promise<number>}
    */
   jDeviceCharacteristics(pFile) {
-    return 0;
+    return 0
   }
 
   /**
-   * @param {number} pVfs 
-   * @param {number} zName 
-   * @param {number} pFile 
-   * @param {number} flags 
-   * @param {number} pOutFlags 
+   * @param {number} pVfs
+   * @param {number} zName
+   * @param {number} pFile
+   * @param {number} flags
+   * @param {number} pOutFlags
    * @returns {number|Promise<number>}
    */
   xOpen(pVfs, zName, pFile, flags, pOutFlags) {
-    const filename = this.#decodeFilename(zName, flags);
-    const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags);
-    this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16));
-    return this.jOpen(filename, pFile, flags, pOutFlagsView);
+    const filename = this.#decodeFilename(zName, flags)
+    const pOutFlagsView = this.#makeTypedDataView('Int32', pOutFlags)
+    this['log']?.('jOpen', filename, pFile, '0x' + flags.toString(16))
+    return this.jOpen(filename, pFile, flags, pOutFlagsView)
   }
 
   /**
-   * @param {number} pVfs 
-   * @param {number} zName 
-   * @param {number} syncDir 
+   * @param {number} pVfs
+   * @param {number} zName
+   * @param {number} syncDir
    * @returns {number|Promise<number>}
    */
   xDelete(pVfs, zName, syncDir) {
-    const filename = this._module.UTF8ToString(zName);
-    this['log']?.('jDelete', filename, syncDir);
-    return this.jDelete(filename, syncDir);
+    const filename = this._module.UTF8ToString(zName)
+    this['log']?.('jDelete', filename, syncDir)
+    return this.jDelete(filename, syncDir)
   }
 
   /**
-   * @param {number} pVfs 
-   * @param {number} zName 
-   * @param {number} flags 
-   * @param {number} pResOut 
+   * @param {number} pVfs
+   * @param {number} zName
+   * @param {number} flags
+   * @param {number} pResOut
    * @returns {number|Promise<number>}
    */
   xAccess(pVfs, zName, flags, pResOut) {
-    const filename = this._module.UTF8ToString(zName);
-    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
-    this['log']?.('jAccess', filename, flags);
-    return this.jAccess(filename, flags, pResOutView);
+    const filename = this._module.UTF8ToString(zName)
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut)
+    this['log']?.('jAccess', filename, flags)
+    return this.jAccess(filename, flags, pResOutView)
   }
 
   /**
-   * @param {number} pVfs 
-   * @param {number} zName 
-   * @param {number} nOut 
-   * @param {number} zOut 
+   * @param {number} pVfs
+   * @param {number} zName
+   * @param {number} nOut
+   * @param {number} zOut
    * @returns {number|Promise<number>}
    */
   xFullPathname(pVfs, zName, nOut, zOut) {
-    const filename = this._module.UTF8ToString(zName);
-    const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut);
-    this['log']?.('jFullPathname', filename, nOut);
-    return this.jFullPathname(filename, zOutArray);
+    const filename = this._module.UTF8ToString(zName)
+    const zOutArray = this._module.HEAPU8.subarray(zOut, zOut + nOut)
+    this['log']?.('jFullPathname', filename, nOut)
+    return this.jFullPathname(filename, zOutArray)
   }
 
   /**
-   * @param {number} pVfs 
-   * @param {number} nBuf 
-   * @param {number} zBuf 
+   * @param {number} pVfs
+   * @param {number} nBuf
+   * @param {number} zBuf
    * @returns {number|Promise<number>}
    */
   xGetLastError(pVfs, nBuf, zBuf) {
-    const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf);
-    this['log']?.('jGetLastError', nBuf);
-    return this.jGetLastError(zBufArray);
+    const zBufArray = this._module.HEAPU8.subarray(zBuf, zBuf + nBuf)
+    this['log']?.('jGetLastError', nBuf)
+    return this.jGetLastError(zBufArray)
   }
 
   /**
-   * @param {number} pFile 
+   * @param {number} pFile
    * @returns {number|Promise<number>}
    */
   xClose(pFile) {
-    this['log']?.('jClose', pFile);
-    return this.jClose(pFile);
+    this['log']?.('jClose', pFile)
+    return this.jClose(pFile)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} pData 
-   * @param {number} iAmt 
-   * @param {number} iOffsetLo 
-   * @param {number} iOffsetHi 
+   * @param {number} pFile
+   * @param {number} pData
+   * @param {number} iAmt
+   * @param {number} iOffsetLo
+   * @param {number} iOffsetHi
    * @returns {number|Promise<number>}
    */
   xRead(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
-    const pDataArray = this.#makeDataArray(pData, iAmt);
-    const iOffset = delegalize(iOffsetLo, iOffsetHi);
-    this['log']?.('jRead', pFile, iAmt, iOffset);
-    return this.jRead(pFile, pDataArray, iOffset);
+    const pDataArray = this.#makeDataArray(pData, iAmt)
+    const iOffset = delegalize(iOffsetLo, iOffsetHi)
+    this['log']?.('jRead', pFile, iAmt, iOffset)
+    return this.jRead(pFile, pDataArray, iOffset)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} pData 
-   * @param {number} iAmt 
-   * @param {number} iOffsetLo 
-   * @param {number} iOffsetHi 
+   * @param {number} pFile
+   * @param {number} pData
+   * @param {number} iAmt
+   * @param {number} iOffsetLo
+   * @param {number} iOffsetHi
    * @returns {number|Promise<number>}
    */
   xWrite(pFile, pData, iAmt, iOffsetLo, iOffsetHi) {
-    const pDataArray = this.#makeDataArray(pData, iAmt);
-    const iOffset = delegalize(iOffsetLo, iOffsetHi);
-    this['log']?.('jWrite', pFile, pDataArray, iOffset);
-    return this.jWrite(pFile, pDataArray, iOffset);
+    const pDataArray = this.#makeDataArray(pData, iAmt)
+    const iOffset = delegalize(iOffsetLo, iOffsetHi)
+    this['log']?.('jWrite', pFile, pDataArray, iOffset)
+    return this.jWrite(pFile, pDataArray, iOffset)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} sizeLo 
-   * @param {number} sizeHi 
+   * @param {number} pFile
+   * @param {number} sizeLo
+   * @param {number} sizeHi
    * @returns {number|Promise<number>}
    */
   xTruncate(pFile, sizeLo, sizeHi) {
-    const size = delegalize(sizeLo, sizeHi);
-    this['log']?.('jTruncate', pFile, size);
-    return this.jTruncate(pFile, size);
+    const size = delegalize(sizeLo, sizeHi)
+    this['log']?.('jTruncate', pFile, size)
+    return this.jTruncate(pFile, size)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} flags 
+   * @param {number} pFile
+   * @param {number} flags
    * @returns {number|Promise<number>}
    */
   xSync(pFile, flags) {
-    this['log']?.('jSync', pFile, flags);
-    return this.jSync(pFile, flags);
+    this['log']?.('jSync', pFile, flags)
+    return this.jSync(pFile, flags)
   }
 
   /**
-   * 
-   * @param {number} pFile 
-   * @param {number} pSize 
+   *
+   * @param {number} pFile
+   * @param {number} pSize
    * @returns {number|Promise<number>}
    */
   xFileSize(pFile, pSize) {
-    const pSizeView = this.#makeTypedDataView('BigInt64', pSize);
-    this['log']?.('jFileSize', pFile);
-    return this.jFileSize(pFile, pSizeView);
+    const pSizeView = this.#makeTypedDataView('BigInt64', pSize)
+    this['log']?.('jFileSize', pFile)
+    return this.jFileSize(pFile, pSizeView)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} lockType 
+   * @param {number} pFile
+   * @param {number} lockType
    * @returns {number|Promise<number>}
    */
   xLock(pFile, lockType) {
-    this['log']?.('jLock', pFile, lockType);
-    return this.jLock(pFile, lockType);
+    this['log']?.('jLock', pFile, lockType)
+    return this.jLock(pFile, lockType)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} lockType 
+   * @param {number} pFile
+   * @param {number} lockType
    * @returns {number|Promise<number>}
    */
   xUnlock(pFile, lockType) {
-    this['log']?.('jUnlock', pFile, lockType);
-    return this.jUnlock(pFile, lockType);
-  } 
+    this['log']?.('jUnlock', pFile, lockType)
+    return this.jUnlock(pFile, lockType)
+  }
 
   /**
-   * @param {number} pFile 
-   * @param {number} pResOut 
+   * @param {number} pFile
+   * @param {number} pResOut
    * @returns {number|Promise<number>}
    */
   xCheckReservedLock(pFile, pResOut) {
-    const pResOutView = this.#makeTypedDataView('Int32', pResOut);
-    this['log']?.('jCheckReservedLock', pFile);
-    return this.jCheckReservedLock(pFile, pResOutView);
+    const pResOutView = this.#makeTypedDataView('Int32', pResOut)
+    this['log']?.('jCheckReservedLock', pFile)
+    return this.jCheckReservedLock(pFile, pResOutView)
   }
 
   /**
-   * @param {number} pFile 
-   * @param {number} op 
-   * @param {number} pArg 
+   * @param {number} pFile
+   * @param {number} op
+   * @param {number} pArg
    * @returns {number|Promise<number>}
    */
   xFileControl(pFile, op, pArg) {
-    const pArgView = new DataView(
-      this._module.HEAPU8.buffer,
-      this._module.HEAPU8.byteOffset + pArg);
-    this['log']?.('jFileControl', pFile, op, pArgView);
-    return this.jFileControl(pFile, op, pArgView);
+    const pArgView = new DataView(this._module.HEAPU8.buffer, this._module.HEAPU8.byteOffset + pArg)
+    this['log']?.('jFileControl', pFile, op, pArgView)
+    return this.jFileControl(pFile, op, pArgView)
   }
 
   /**
-   * @param {number} pFile 
+   * @param {number} pFile
    * @returns {number|Promise<number>}
    */
   xSectorSize(pFile) {
-    this['log']?.('jSectorSize', pFile);
-    return this.jSectorSize(pFile);
+    this['log']?.('jSectorSize', pFile)
+    return this.jSectorSize(pFile)
   }
 
   /**
-   * @param {number} pFile 
+   * @param {number} pFile
    * @returns {number|Promise<number>}
    */
   xDeviceCharacteristics(pFile) {
-    this['log']?.('jDeviceCharacteristics', pFile);
-    return this.jDeviceCharacteristics(pFile);
+    this['log']?.('jDeviceCharacteristics', pFile)
+    return this.jDeviceCharacteristics(pFile)
   }
 
   /**
@@ -408,13 +403,13 @@ export class FacadeVFS extends VFS.Base {
    * Pointers to a single value are passed using a DataView-like class.
    * This wrapper class prevents use of incorrect type or endianness, and
    * reacquires the underlying buffer when the WebAssembly memory is resized.
-   * @param {'Int32'|'BigInt64'} type 
-   * @param {number} byteOffset 
+   * @param {'Int32'|'BigInt64'} type
+   * @param {number} byteOffset
    * @returns {DataView}
    */
   #makeTypedDataView(type, byteOffset) {
     // @ts-ignore
-    return new DataViewProxy(this._module, byteOffset, type);
+    return new DataViewProxy(this._module, byteOffset, type)
   }
 
   /**
@@ -422,13 +417,13 @@ export class FacadeVFS extends VFS.Base {
    * Memory blocks are passed as a Uint8Array-like class. This wrapper
    * class reacquires the underlying buffer when the WebAssembly memory
    * is resized.
-   * @param {number} byteOffset 
-   * @param {number} byteLength 
+   * @param {number} byteOffset
+   * @param {number} byteLength
    * @returns {Uint8Array}
    */
   #makeDataArray(byteOffset, byteLength) {
     // @ts-ignore
-    return new Uint8ArrayProxy(this._module, byteOffset, byteLength);
+    return new Uint8ArrayProxy(this._module, byteOffset, byteLength)
   }
 
   #decodeFilename(zName, flags) {
@@ -436,41 +431,41 @@ export class FacadeVFS extends VFS.Base {
       // The first null-terminated string is the URI path. Subsequent
       // strings are query parameter keys and values.
       // https://www.sqlite.org/c3ref/open.html#urifilenamesinsqlite3open
-      let pName = zName;
-      let state = 1;
-      const charCodes = [];
+      let pName = zName
+      let state = 1
+      const charCodes = []
       while (state) {
-        const charCode = this._module.HEAPU8[pName++];
+        const charCode = this._module.HEAPU8[pName++]
         if (charCode) {
-          charCodes.push(charCode);
+          charCodes.push(charCode)
         } else {
-          if (!this._module.HEAPU8[pName]) state = null;
+          if (!this._module.HEAPU8[pName]) state = null
           switch (state) {
             case 1: // path
-              charCodes.push('?'.charCodeAt(0));
-              state = 2;
-              break;
+              charCodes.push('?'.charCodeAt(0))
+              state = 2
+              break
             case 2: // key
-              charCodes.push('='.charCodeAt(0));
-              state = 3;
-              break;
+              charCodes.push('='.charCodeAt(0))
+              state = 3
+              break
             case 3: // value
-              charCodes.push('&'.charCodeAt(0));
-              state = 2;
-              break;
+              charCodes.push('&'.charCodeAt(0))
+              state = 2
+              break
           }
         }
       }
-      return  new TextDecoder().decode(new Uint8Array(charCodes));
+      return new TextDecoder().decode(new Uint8Array(charCodes))
     }
-    return zName ? this._module.UTF8ToString(zName) : null;
+    return zName ? this._module.UTF8ToString(zName) : null
   }
 }
 
 // Emscripten "legalizes" 64-bit integer arguments by passing them as
 // two 32-bit signed integers.
 function delegalize(lo32, hi32) {
-  return (hi32 * 0x100000000) + lo32 + (lo32 < 0 ? 2**32 : 0);
+  return hi32 * 0x100000000 + lo32 + (lo32 < 0 ? 2 ** 32 : 0)
 }
 
 // This class provides a Uint8Array-like interface for a WebAssembly memory
@@ -484,131 +479,129 @@ function delegalize(lo32, hi32) {
 // a Uint8Array may not work. Use subarray() to get a real Uint8Array
 // if needed.
 class Uint8ArrayProxy {
-  #module;
+  #module
 
   #_array = new Uint8Array()
   get #array() {
     if (this.#_array.buffer.byteLength === 0) {
       // WebAssembly memory resize detached the buffer so re-create the
       // array with the new buffer.
-      this.#_array = this.#module.HEAPU8.subarray(
-        this.byteOffset,
-        this.byteOffset + this.byteLength);
+      this.#_array = this.#module.HEAPU8.subarray(this.byteOffset, this.byteOffset + this.byteLength)
     }
-    return this.#_array;
+    return this.#_array
   }
 
   /**
    * @param {*} module
-   * @param {number} byteOffset 
-   * @param {number} byteLength 
+   * @param {number} byteOffset
+   * @param {number} byteLength
    */
   constructor(module, byteOffset, byteLength) {
-    this.#module = module;
-    this.byteOffset = byteOffset;
-    this.length = this.byteLength = byteLength;
+    this.#module = module
+    this.byteOffset = byteOffset
+    this.length = this.byteLength = byteLength
   }
 
   get buffer() {
-    return this.#array.buffer;
+    return this.#array.buffer
   }
 
   at(index) {
-    return this.#array.at(index);
+    return this.#array.at(index)
   }
   copyWithin(target, start, end) {
-    this.#array.copyWithin(target, start, end);
+    this.#array.copyWithin(target, start, end)
   }
   entries() {
-    return this.#array.entries();
+    return this.#array.entries()
   }
   every(predicate) {
-    return this.#array.every(predicate);
+    return this.#array.every(predicate)
   }
   fill(value, start, end) {
-    this.#array.fill(value, start, end);
+    this.#array.fill(value, start, end)
   }
   filter(predicate) {
-    return this.#array.filter(predicate);
+    return this.#array.filter(predicate)
   }
   find(predicate) {
-    return this.#array.find(predicate);
+    return this.#array.find(predicate)
   }
   findIndex(predicate) {
-    return this.#array.findIndex(predicate);
+    return this.#array.findIndex(predicate)
   }
   findLast(predicate) {
-    return this.#array.findLast(predicate);
+    return this.#array.findLast(predicate)
   }
   findLastIndex(predicate) {
-    return this.#array.findLastIndex(predicate);
+    return this.#array.findLastIndex(predicate)
   }
   forEach(callback) {
-    this.#array.forEach(callback);
+    this.#array.forEach(callback)
   }
   includes(value, start) {
-    return this.#array.includes(value, start);
+    return this.#array.includes(value, start)
   }
   indexOf(value, start) {
-    return this.#array.indexOf(value, start);
+    return this.#array.indexOf(value, start)
   }
   join(separator) {
-    return this.#array.join(separator);
+    return this.#array.join(separator)
   }
   keys() {
-    return this.#array.keys();
+    return this.#array.keys()
   }
   lastIndexOf(value, start) {
-    return this.#array.lastIndexOf(value, start);
+    return this.#array.lastIndexOf(value, start)
   }
   map(callback) {
-    return this.#array.map(callback);
+    return this.#array.map(callback)
   }
   reduce(callback, initialValue) {
-    return this.#array.reduce(callback, initialValue);
+    return this.#array.reduce(callback, initialValue)
   }
   reduceRight(callback, initialValue) {
-    return this.#array.reduceRight(callback, initialValue);
+    return this.#array.reduceRight(callback, initialValue)
   }
   reverse() {
-    this.#array.reverse();
+    this.#array.reverse()
   }
   set(array, offset) {
-    this.#array.set(array, offset);
+    this.#array.set(array, offset)
   }
   slice(start, end) {
-    return this.#array.slice(start, end);
+    return this.#array.slice(start, end)
   }
   some(predicate) {
-    return this.#array.some(predicate);
+    return this.#array.some(predicate)
   }
   sort(compareFn) {
-    this.#array.sort(compareFn);
+    this.#array.sort(compareFn)
   }
   subarray(begin, end) {
-    return this.#array.subarray(begin, end);
+    return this.#array.subarray(begin, end)
   }
   toLocaleString(locales, options) {
     // @ts-ignore
-    return this.#array.toLocaleString(locales, options);
+    return this.#array.toLocaleString(locales, options)
   }
   toReversed() {
-    return this.#array.toReversed();
+    return this.#array.toReversed()
   }
   toSorted(compareFn) {
-    return this.#array.toSorted(compareFn);
+    return this.#array.toSorted(compareFn)
   }
   toString() {
-    return this.#array.toString();
+    return this.#array.toString()
   }
   values() {
-    return this.#array.values();
+    return this.#array.values()
   }
   with(index, value) {
-    return this.#array.with(index, value);
+    return this.#array.with(index, value)
   }
   [Symbol.iterator]() {
-    return this.#array[Symbol.iterator]();
+    return this.#array[Symbol.iterator]()
   }
 }
 
@@ -617,65 +610,63 @@ class Uint8ArrayProxy {
 // the underlying buffer when the WebAssembly memory is resized, which can
 // happen when the memory is detached and resized by the WebAssembly module.
 class DataViewProxy {
-  #module;
-  #type;
+  #module
+  #type
 
-  #_view = new DataView(new ArrayBuffer(0));
+  #_view = new DataView(new ArrayBuffer(0))
   get #view() {
     if (this.#_view.buffer.byteLength === 0) {
       // WebAssembly memory resize detached the buffer so re-create the
       // view with the new buffer.
-      this.#_view = new DataView(
-        this.#module.HEAPU8.buffer,
-        this.#module.HEAPU8.byteOffset + this.byteOffset);
+      this.#_view = new DataView(this.#module.HEAPU8.buffer, this.#module.HEAPU8.byteOffset + this.byteOffset)
     }
-    return this.#_view;
+    return this.#_view
   }
 
   /**
    * @param {*} module
-   * @param {number} byteOffset 
+   * @param {number} byteOffset
    * @param {'Int32'|'BigInt64'} type
    */
   constructor(module, byteOffset, type) {
-    this.#module = module;
-    this.byteOffset = byteOffset;
-    this.#type = type;
+    this.#module = module
+    this.byteOffset = byteOffset
+    this.#type = type
   }
 
   get buffer() {
-    return this.#view.buffer;
+    return this.#view.buffer
   }
   get byteLength() {
-    return this.#type === 'Int32' ? 4 : 8;
+    return this.#type === 'Int32' ? 4 : 8
   }
 
   getInt32(byteOffset, littleEndian) {
     if (this.#type !== 'Int32') {
-      throw new Error('invalid type');
+      throw new Error('invalid type')
     }
-    if (!littleEndian) throw new Error('must be little endian');
-    return this.#view.getInt32(byteOffset, littleEndian);
+    if (!littleEndian) throw new Error('must be little endian')
+    return this.#view.getInt32(byteOffset, littleEndian)
   }
   setInt32(byteOffset, value, littleEndian) {
     if (this.#type !== 'Int32') {
-      throw new Error('invalid type');
+      throw new Error('invalid type')
     }
-    if (!littleEndian) throw new Error('must be little endian');
-    this.#view.setInt32(byteOffset, value, littleEndian);
+    if (!littleEndian) throw new Error('must be little endian')
+    this.#view.setInt32(byteOffset, value, littleEndian)
   }
   getBigInt64(byteOffset, littleEndian) {
     if (this.#type !== 'BigInt64') {
-      throw new Error('invalid type');
+      throw new Error('invalid type')
     }
-    if (!littleEndian) throw new Error('must be little endian');
-    return this.#view.getBigInt64(byteOffset, littleEndian);
+    if (!littleEndian) throw new Error('must be little endian')
+    return this.#view.getBigInt64(byteOffset, littleEndian)
   }
   setBigInt64(byteOffset, value, littleEndian) {
     if (this.#type !== 'BigInt64') {
-      throw new Error('invalid type');
+      throw new Error('invalid type')
     }
-    if (!littleEndian) throw new Error('must be little endian');
-    this.#view.setBigInt64(byteOffset, value, littleEndian);
+    if (!littleEndian) throw new Error('must be little endian')
+    this.#view.setBigInt64(byteOffset, value, littleEndian)
   }
-}
+}