@powersync/web 1.21.1 → 1.22.0

package/dist/index.umd.js

@@ -2642,16 +2642,16 @@ function fromByteArray (uint8) {
         var w = this.words[i];
         var word = (((w << off) | carry) & 0xffffff).toString(16);
         carry = (w >>> (24 - off)) & 0xffffff;
-        if (carry !== 0 || i !== this.length - 1) {
-          out = zeros[6 - word.length] + word + out;
-        } else {
-          out = word + out;
-        }
         off += 2;
         if (off >= 26) {
           off -= 26;
           i--;
         }
+        if (carry !== 0 || i !== this.length - 1) {
+          out = zeros[6 - word.length] + word + out;
+        } else {
+          out = word + out;
+        }
       }
       if (carry !== 0) {
         out = carry.toString(16) + out;
@@ -4111,6 +4111,7 @@ function fromByteArray (uint8) {
       this.words[i] = carry;
       this.length++;
     }
+    this.length = num === 0 ? 1 : this.length;
 
     return this;
   };
@@ -9036,6 +9037,7 @@ module.exports = crt;
       this.words[i] = carry;
       this.length++;
     }
+    this.length = num === 0 ? 1 : this.length;
 
     return isNegNum ? this.ineg() : this;
   };
@@ -12991,6 +12993,7 @@ module.exports = verify;
       this.words[i] = carry;
       this.length++;
     }
+    this.length = num === 0 ? 1 : this.length;
 
     return isNegNum ? this.ineg() : this;
   };
@@ -17362,20 +17365,31 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 "use strict";
 
 
-function isAnyArrayBuffer(value) {
-    return ['[object ArrayBuffer]', '[object SharedArrayBuffer]'].includes(Object.prototype.toString.call(value));
-}
+const TypedArrayPrototypeGetSymbolToStringTag = (() => {
+    const g = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get;
+    return (value) => g.call(value);
+})();
 function isUint8Array(value) {
-    return Object.prototype.toString.call(value) === '[object Uint8Array]';
+    return TypedArrayPrototypeGetSymbolToStringTag(value) === 'Uint8Array';
 }
-function isRegExp(d) {
-    return Object.prototype.toString.call(d) === '[object RegExp]';
+function isAnyArrayBuffer(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        Symbol.toStringTag in value &&
+        (value[Symbol.toStringTag] === 'ArrayBuffer' ||
+            value[Symbol.toStringTag] === 'SharedArrayBuffer'));
 }
-function isMap(d) {
-    return Object.prototype.toString.call(d) === '[object Map]';
+function isRegExp(regexp) {
+    return regexp instanceof RegExp || Object.prototype.toString.call(regexp) === '[object RegExp]';
 }
-function isDate(d) {
-    return Object.prototype.toString.call(d) === '[object Date]';
+function isMap(value) {
+    return (typeof value === 'object' &&
+        value != null &&
+        Symbol.toStringTag in value &&
+        value[Symbol.toStringTag] === 'Map');
+}
+function isDate(date) {
+    return date instanceof Date || Object.prototype.toString.call(date) === '[object Date]';
 }
 function defaultInspect(x, _options) {
     return JSON.stringify(x, (k, v) => {
@@ -17399,8 +17413,9 @@ function getStylizeFunction(options) {
 }
 
 const BSON_MAJOR_VERSION = 6;
+const BSON_VERSION_SYMBOL = Symbol.for('@@mdb.bson.version');
 const BSON_INT32_MAX = 0x7fffffff;
-const BSON_INT32_MIN = -0x80000000;
+const BSON_INT32_MIN = -2147483648;
 const BSON_INT64_MAX = Math.pow(2, 63) - 1;
 const BSON_INT64_MIN = -Math.pow(2, 63);
 const JS_INT_MAX = Math.pow(2, 53);
@@ -17591,7 +17606,7 @@ const nodeJsByteUtils = {
             stringTag === '[object SharedArrayBuffer]') {
             return Buffer.from(potentialBuffer);
         }
-        throw new BSONError(`Cannot create Buffer from ${String(potentialBuffer)}`);
+        throw new BSONError(`Cannot create Buffer from the passed potentialBuffer.`);
     },
     allocate(size) {
         return Buffer.alloc(size);
@@ -17649,7 +17664,10 @@ const nodeJsByteUtils = {
         }
         return nodeJsByteUtils.toLocalBufferType(buffer).write(source, byteOffset, undefined, 'utf8');
     },
-    randomBytes: nodejsRandomBytes
+    randomBytes: nodejsRandomBytes,
+    swap32(buffer) {
+        return nodeJsByteUtils.toLocalBufferType(buffer).swap32();
+    }
 };
 
 function isReactNative() {
@@ -17694,7 +17712,7 @@ const webByteUtils = {
             stringTag === '[object SharedArrayBuffer]') {
             return new Uint8Array(potentialUint8array);
         }
-        throw new BSONError(`Cannot make a Uint8Array from ${String(potentialUint8array)}`);
+        throw new BSONError(`Cannot make a Uint8Array from passed potentialBuffer.`);
     },
     allocate(size) {
         if (typeof size !== 'number') {
@@ -17766,14 +17784,30 @@ const webByteUtils = {
         uint8array.set(bytes, byteOffset);
         return bytes.byteLength;
     },
-    randomBytes: webRandomBytes
+    randomBytes: webRandomBytes,
+    swap32(buffer) {
+        if (buffer.length % 4 !== 0) {
+            throw new RangeError('Buffer size must be a multiple of 32-bits');
+        }
+        for (let i = 0; i < buffer.length; i += 4) {
+            const byte0 = buffer[i];
+            const byte1 = buffer[i + 1];
+            const byte2 = buffer[i + 2];
+            const byte3 = buffer[i + 3];
+            buffer[i] = byte3;
+            buffer[i + 1] = byte2;
+            buffer[i + 2] = byte1;
+            buffer[i + 3] = byte0;
+        }
+        return buffer;
+    }
 };
 
 const hasGlobalBuffer = typeof Buffer === 'function' && Buffer.prototype?._isBuffer !== true;
 const ByteUtils = hasGlobalBuffer ? nodeJsByteUtils : webByteUtils;
 
 class BSONValue {
-    get [Symbol.for('@@mdb.bson.version')]() {
+    get [BSON_VERSION_SYMBOL]() {
         return BSON_MAJOR_VERSION;
     }
     [Symbol.for('nodejs.util.inspect.custom')](depth, options, inspect) {
@@ -17781,6 +17815,140 @@ class BSONValue {
     }
 }
 
+const FLOAT = new Float64Array(1);
+const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
+FLOAT[0] = -1;
+const isBigEndian = FLOAT_BYTES[7] === 0;
+const NumberUtils = {
+    isBigEndian,
+    getNonnegativeInt32LE(source, offset) {
+        if (source[offset + 3] > 127) {
+            throw new RangeError(`Size cannot be negative at offset: ${offset}`);
+        }
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
+    getInt32LE(source, offset) {
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
+    getUint32LE(source, offset) {
+        return (source[offset] +
+            source[offset + 1] * 256 +
+            source[offset + 2] * 65536 +
+            source[offset + 3] * 16777216);
+    },
+    getUint32BE(source, offset) {
+        return (source[offset + 3] +
+            source[offset + 2] * 256 +
+            source[offset + 1] * 65536 +
+            source[offset] * 16777216);
+    },
+    getBigInt64LE(source, offset) {
+        const hi = BigInt(source[offset + 4] +
+            source[offset + 5] * 256 +
+            source[offset + 6] * 65536 +
+            (source[offset + 7] << 24));
+        const lo = BigInt(source[offset] +
+            source[offset + 1] * 256 +
+            source[offset + 2] * 65536 +
+            source[offset + 3] * 16777216);
+        return (hi << BigInt(32)) + lo;
+    },
+    getFloat64LE: isBigEndian
+        ? (source, offset) => {
+            FLOAT_BYTES[7] = source[offset];
+            FLOAT_BYTES[6] = source[offset + 1];
+            FLOAT_BYTES[5] = source[offset + 2];
+            FLOAT_BYTES[4] = source[offset + 3];
+            FLOAT_BYTES[3] = source[offset + 4];
+            FLOAT_BYTES[2] = source[offset + 5];
+            FLOAT_BYTES[1] = source[offset + 6];
+            FLOAT_BYTES[0] = source[offset + 7];
+            return FLOAT[0];
+        }
+        : (source, offset) => {
+            FLOAT_BYTES[0] = source[offset];
+            FLOAT_BYTES[1] = source[offset + 1];
+            FLOAT_BYTES[2] = source[offset + 2];
+            FLOAT_BYTES[3] = source[offset + 3];
+            FLOAT_BYTES[4] = source[offset + 4];
+            FLOAT_BYTES[5] = source[offset + 5];
+            FLOAT_BYTES[6] = source[offset + 6];
+            FLOAT_BYTES[7] = source[offset + 7];
+            return FLOAT[0];
+        },
+    setInt32BE(destination, offset, value) {
+        destination[offset + 3] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset] = value;
+        return 4;
+    },
+    setInt32LE(destination, offset, value) {
+        destination[offset] = value;
+        value >>>= 8;
+        destination[offset + 1] = value;
+        value >>>= 8;
+        destination[offset + 2] = value;
+        value >>>= 8;
+        destination[offset + 3] = value;
+        return 4;
+    },
+    setBigInt64LE(destination, offset, value) {
+        const mask32bits = BigInt(0xffff_ffff);
+        let lo = Number(value & mask32bits);
+        destination[offset] = lo;
+        lo >>= 8;
+        destination[offset + 1] = lo;
+        lo >>= 8;
+        destination[offset + 2] = lo;
+        lo >>= 8;
+        destination[offset + 3] = lo;
+        let hi = Number((value >> BigInt(32)) & mask32bits);
+        destination[offset + 4] = hi;
+        hi >>= 8;
+        destination[offset + 5] = hi;
+        hi >>= 8;
+        destination[offset + 6] = hi;
+        hi >>= 8;
+        destination[offset + 7] = hi;
+        return 8;
+    },
+    setFloat64LE: isBigEndian
+        ? (destination, offset, value) => {
+            FLOAT[0] = value;
+            destination[offset] = FLOAT_BYTES[7];
+            destination[offset + 1] = FLOAT_BYTES[6];
+            destination[offset + 2] = FLOAT_BYTES[5];
+            destination[offset + 3] = FLOAT_BYTES[4];
+            destination[offset + 4] = FLOAT_BYTES[3];
+            destination[offset + 5] = FLOAT_BYTES[2];
+            destination[offset + 6] = FLOAT_BYTES[1];
+            destination[offset + 7] = FLOAT_BYTES[0];
+            return 8;
+        }
+        : (destination, offset, value) => {
+            FLOAT[0] = value;
+            destination[offset] = FLOAT_BYTES[0];
+            destination[offset + 1] = FLOAT_BYTES[1];
+            destination[offset + 2] = FLOAT_BYTES[2];
+            destination[offset + 3] = FLOAT_BYTES[3];
+            destination[offset + 4] = FLOAT_BYTES[4];
+            destination[offset + 5] = FLOAT_BYTES[5];
+            destination[offset + 6] = FLOAT_BYTES[6];
+            destination[offset + 7] = FLOAT_BYTES[7];
+            return 8;
+        }
+};
+
 class Binary extends BSONValue {
     get _bsontype() {
         return 'Binary';
@@ -17853,7 +18021,8 @@ class Binary extends BSONValue {
     }
     read(position, length) {
         length = length && length > 0 ? length : this.position;
-        return this.buffer.slice(position, position + length);
+        const end = position + length;
+        return this.buffer.subarray(position, end > this.position ? this.position : end);
     }
     value() {
         return this.buffer.length === this.position
@@ -17877,6 +18046,9 @@ class Binary extends BSONValue {
     }
     toExtendedJSON(options) {
         options = options || {};
+        if (this.sub_type === Binary.SUBTYPE_VECTOR) {
+            validateBinaryVector(this);
+        }
         const base64String = ByteUtils.toBase64(this.buffer);
         const subType = Number(this.sub_type).toString(16);
         if (options.legacy) {
@@ -17894,7 +18066,7 @@ class Binary extends BSONValue {
     }
     toUUID() {
         if (this.sub_type === Binary.SUBTYPE_UUID) {
-            return new UUID(this.buffer.slice(0, this.position));
+            return new UUID(this.buffer.subarray(0, this.position));
         }
         throw new BSONError(`Binary sub_type "${this.sub_type}" is not supported for converting to UUID. Only "${Binary.SUBTYPE_UUID}" is currently supported.`);
     }
@@ -17936,6 +18108,99 @@ class Binary extends BSONValue {
         const subTypeArg = inspect(this.sub_type, options);
         return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;
     }
+    toInt8Array() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.Int8) {
+            throw new BSONError('Binary datatype field is not Int8');
+        }
+        return new Int8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+    }
+    toFloat32Array() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.Float32) {
+            throw new BSONError('Binary datatype field is not Float32');
+        }
+        const floatBytes = new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+        if (NumberUtils.isBigEndian)
+            ByteUtils.swap32(floatBytes);
+        return new Float32Array(floatBytes.buffer);
+    }
+    toPackedBits() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
+            throw new BSONError('Binary datatype field is not packed bit');
+        }
+        return new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
+    }
+    toBits() {
+        if (this.sub_type !== Binary.SUBTYPE_VECTOR) {
+            throw new BSONError('Binary sub_type is not Vector');
+        }
+        if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
+            throw new BSONError('Binary datatype field is not packed bit');
+        }
+        const byteCount = this.length() - 2;
+        const bitCount = byteCount * 8 - this.buffer[1];
+        const bits = new Int8Array(bitCount);
+        for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+            const byteOffset = (bitOffset / 8) | 0;
+            const byte = this.buffer[byteOffset + 2];
+            const shift = 7 - (bitOffset % 8);
+            const bit = (byte >> shift) & 1;
+            bits[bitOffset] = bit;
+        }
+        return bits;
+    }
+    static fromInt8Array(array) {
+        const buffer = ByteUtils.allocate(array.byteLength + 2);
+        buffer[0] = Binary.VECTOR_TYPE.Int8;
+        buffer[1] = 0;
+        const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        buffer.set(intBytes, 2);
+        return new this(buffer, this.SUBTYPE_VECTOR);
+    }
+    static fromFloat32Array(array) {
+        const binaryBytes = ByteUtils.allocate(array.byteLength + 2);
+        binaryBytes[0] = Binary.VECTOR_TYPE.Float32;
+        binaryBytes[1] = 0;
+        const floatBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+        binaryBytes.set(floatBytes, 2);
+        if (NumberUtils.isBigEndian)
+            ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
+        return new this(binaryBytes, this.SUBTYPE_VECTOR);
+    }
+    static fromPackedBits(array, padding = 0) {
+        const buffer = ByteUtils.allocate(array.byteLength + 2);
+        buffer[0] = Binary.VECTOR_TYPE.PackedBit;
+        buffer[1] = padding;
+        buffer.set(array, 2);
+        return new this(buffer, this.SUBTYPE_VECTOR);
+    }
+    static fromBits(bits) {
+        const byteLength = (bits.length + 7) >>> 3;
+        const bytes = new Uint8Array(byteLength + 2);
+        bytes[0] = Binary.VECTOR_TYPE.PackedBit;
+        const remainder = bits.length % 8;
+        bytes[1] = remainder === 0 ? 0 : 8 - remainder;
+        for (let bitOffset = 0; bitOffset < bits.length; bitOffset++) {
+            const byteOffset = bitOffset >>> 3;
+            const bit = bits[bitOffset];
+            if (bit !== 0 && bit !== 1) {
+                throw new BSONError(`Invalid bit value at ${bitOffset}: must be 0 or 1, found ${bits[bitOffset]}`);
+            }
+            if (bit === 0)
+                continue;
+            const shift = 7 - (bitOffset % 8);
+            bytes[byteOffset + 2] |= bit << shift;
+        }
+        return new this(bytes, Binary.SUBTYPE_VECTOR);
+    }
 }
 Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
 Binary.BUFFER_SIZE = 256;
@@ -17948,7 +18213,30 @@ Binary.SUBTYPE_MD5 = 5;
 Binary.SUBTYPE_ENCRYPTED = 6;
 Binary.SUBTYPE_COLUMN = 7;
 Binary.SUBTYPE_SENSITIVE = 8;
+Binary.SUBTYPE_VECTOR = 9;
 Binary.SUBTYPE_USER_DEFINED = 128;
+Binary.VECTOR_TYPE = Object.freeze({
+    Int8: 0x03,
+    Float32: 0x27,
+    PackedBit: 0x10
+});
+function validateBinaryVector(vector) {
+    if (vector.sub_type !== Binary.SUBTYPE_VECTOR)
+        return;
+    const size = vector.position;
+    const datatype = vector.buffer[0];
+    const padding = vector.buffer[1];
+    if ((datatype === Binary.VECTOR_TYPE.Float32 || datatype === Binary.VECTOR_TYPE.Int8) &&
+        padding !== 0) {
+        throw new BSONError('Invalid Vector: padding must be zero for int8 and float32 vectors');
+    }
+    if (datatype === Binary.VECTOR_TYPE.PackedBit && padding !== 0 && size === 2) {
+        throw new BSONError('Invalid Vector: padding must be zero for packed bit vectors that are empty');
+    }
+    if (datatype === Binary.VECTOR_TYPE.PackedBit && padding > 7) {
+        throw new BSONError(`Invalid Vector: padding must be a value between 0 and 7. found: ${padding}`);
+    }
+}
 const UUID_BYTE_LENGTH = 16;
 const UUID_WITHOUT_DASHES = /^[0-9A-F]{32}$/i;
 const UUID_WITH_DASHES = /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i;
@@ -18270,7 +18558,7 @@ class Long extends BSONValue {
                 return Long.MAX_UNSIGNED_VALUE;
         }
         else {
-            if (value <= -TWO_PWR_63_DBL)
+            if (value <= -9223372036854776e3)
                 return Long.MIN_VALUE;
             if (value + 1 >= TWO_PWR_63_DBL)
                 return Long.MAX_VALUE;
@@ -18429,7 +18717,7 @@ class Long extends BSONValue {
             throw new BSONError('division by zero');
         if (wasm) {
             if (!this.unsigned &&
-                this.high === -0x80000000 &&
+                this.high === -2147483648 &&
                 divisor.low === -1 &&
                 divisor.high === -1) {
                 return this;
@@ -18950,7 +19238,7 @@ class Decimal128 extends BSONValue {
         if (typeof bytes === 'string') {
             this.bytes = Decimal128.fromString(bytes).bytes;
         }
-        else if (isUint8Array(bytes)) {
+        else if (bytes instanceof Uint8Array || isUint8Array(bytes)) {
             if (bytes.byteLength !== 16) {
                 throw new BSONError('Decimal128 must take a Buffer of 16 bytes');
             }
@@ -19560,135 +19848,8 @@ class MinKey extends BSONValue {
     }
 }
 
-const FLOAT = new Float64Array(1);
-const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
-FLOAT[0] = -1;
-const isBigEndian = FLOAT_BYTES[7] === 0;
-const NumberUtils = {
-    getNonnegativeInt32LE(source, offset) {
-        if (source[offset + 3] > 127) {
-            throw new RangeError(`Size cannot be negative at offset: ${offset}`);
-        }
-        return (source[offset] |
-            (source[offset + 1] << 8) |
-            (source[offset + 2] << 16) |
-            (source[offset + 3] << 24));
-    },
-    getInt32LE(source, offset) {
-        return (source[offset] |
-            (source[offset + 1] << 8) |
-            (source[offset + 2] << 16) |
-            (source[offset + 3] << 24));
-    },
-    getUint32LE(source, offset) {
-        return (source[offset] +
-            source[offset + 1] * 256 +
-            source[offset + 2] * 65536 +
-            source[offset + 3] * 16777216);
-    },
-    getUint32BE(source, offset) {
-        return (source[offset + 3] +
-            source[offset + 2] * 256 +
-            source[offset + 1] * 65536 +
-            source[offset] * 16777216);
-    },
-    getBigInt64LE(source, offset) {
-        const lo = NumberUtils.getUint32LE(source, offset);
-        const hi = NumberUtils.getUint32LE(source, offset + 4);
-        return (BigInt(hi) << BigInt(32)) + BigInt(lo);
-    },
-    getFloat64LE: isBigEndian
-        ? (source, offset) => {
-            FLOAT_BYTES[7] = source[offset];
-            FLOAT_BYTES[6] = source[offset + 1];
-            FLOAT_BYTES[5] = source[offset + 2];
-            FLOAT_BYTES[4] = source[offset + 3];
-            FLOAT_BYTES[3] = source[offset + 4];
-            FLOAT_BYTES[2] = source[offset + 5];
-            FLOAT_BYTES[1] = source[offset + 6];
-            FLOAT_BYTES[0] = source[offset + 7];
-            return FLOAT[0];
-        }
-        : (source, offset) => {
-            FLOAT_BYTES[0] = source[offset];
-            FLOAT_BYTES[1] = source[offset + 1];
-            FLOAT_BYTES[2] = source[offset + 2];
-            FLOAT_BYTES[3] = source[offset + 3];
-            FLOAT_BYTES[4] = source[offset + 4];
-            FLOAT_BYTES[5] = source[offset + 5];
-            FLOAT_BYTES[6] = source[offset + 6];
-            FLOAT_BYTES[7] = source[offset + 7];
-            return FLOAT[0];
-        },
-    setInt32BE(destination, offset, value) {
-        destination[offset + 3] = value;
-        value >>>= 8;
-        destination[offset + 2] = value;
-        value >>>= 8;
-        destination[offset + 1] = value;
-        value >>>= 8;
-        destination[offset] = value;
-        return 4;
-    },
-    setInt32LE(destination, offset, value) {
-        destination[offset] = value;
-        value >>>= 8;
-        destination[offset + 1] = value;
-        value >>>= 8;
-        destination[offset + 2] = value;
-        value >>>= 8;
-        destination[offset + 3] = value;
-        return 4;
-    },
-    setBigInt64LE(destination, offset, value) {
-        const mask32bits = BigInt(4294967295);
-        let lo = Number(value & mask32bits);
-        destination[offset] = lo;
-        lo >>= 8;
-        destination[offset + 1] = lo;
-        lo >>= 8;
-        destination[offset + 2] = lo;
-        lo >>= 8;
-        destination[offset + 3] = lo;
-        let hi = Number((value >> BigInt(32)) & mask32bits);
-        destination[offset + 4] = hi;
-        hi >>= 8;
-        destination[offset + 5] = hi;
-        hi >>= 8;
-        destination[offset + 6] = hi;
-        hi >>= 8;
-        destination[offset + 7] = hi;
-        return 8;
-    },
-    setFloat64LE: isBigEndian
-        ? (destination, offset, value) => {
-            FLOAT[0] = value;
-            destination[offset] = FLOAT_BYTES[7];
-            destination[offset + 1] = FLOAT_BYTES[6];
-            destination[offset + 2] = FLOAT_BYTES[5];
-            destination[offset + 3] = FLOAT_BYTES[4];
-            destination[offset + 4] = FLOAT_BYTES[3];
-            destination[offset + 5] = FLOAT_BYTES[2];
-            destination[offset + 6] = FLOAT_BYTES[1];
-            destination[offset + 7] = FLOAT_BYTES[0];
-            return 8;
-        }
-        : (destination, offset, value) => {
-            FLOAT[0] = value;
-            destination[offset] = FLOAT_BYTES[0];
-            destination[offset + 1] = FLOAT_BYTES[1];
-            destination[offset + 2] = FLOAT_BYTES[2];
-            destination[offset + 3] = FLOAT_BYTES[3];
-            destination[offset + 4] = FLOAT_BYTES[4];
-            destination[offset + 5] = FLOAT_BYTES[5];
-            destination[offset + 6] = FLOAT_BYTES[6];
-            destination[offset + 7] = FLOAT_BYTES[7];
-            return 8;
-        }
-};
-
-const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 let PROCESS_UNIQUE = null;
+const __idCache = new WeakMap();
 class ObjectId extends BSONValue {
     get _bsontype() {
         return 'ObjectId';
@@ -19717,8 +19878,11 @@ class ObjectId extends BSONValue {
             this.buffer = ByteUtils.toLocalBufferType(workingId);
         }
         else if (typeof workingId === 'string') {
-            if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+            if (ObjectId.validateHexString(workingId)) {
                 this.buffer = ByteUtils.fromHex(workingId);
+                if (ObjectId.cacheHexString) {
+                    __idCache.set(this, workingId);
+                }
             }
             else {
                 throw new BSONError('input must be a 24 character hex string, 12 byte Uint8Array, or an integer');
@@ -19727,9 +19891,6 @@ class ObjectId extends BSONValue {
         else {
             throw new BSONError('Argument passed in does not match the accepted types');
         }
-        if (ObjectId.cacheHexString) {
-            this.__id = ByteUtils.toHex(this.id);
-        }
     }
     get id() {
         return this.buffer;
@@ -19737,16 +19898,32 @@ class ObjectId extends BSONValue {
     set id(value) {
         this.buffer = value;
         if (ObjectId.cacheHexString) {
-            this.__id = ByteUtils.toHex(value);
+            __idCache.set(this, ByteUtils.toHex(value));
+        }
+    }
+    static validateHexString(string) {
+        if (string?.length !== 24)
+            return false;
+        for (let i = 0; i < 24; i++) {
+            const char = string.charCodeAt(i);
+            if ((char >= 48 && char <= 57) ||
+                (char >= 97 && char <= 102) ||
+                (char >= 65 && char <= 70)) {
+                continue;
+            }
+            return false;
         }
+        return true;
     }
     toHexString() {
-        if (ObjectId.cacheHexString && this.__id) {
-            return this.__id;
+        if (ObjectId.cacheHexString) {
+            const __id = __idCache.get(this);
+            if (__id)
+                return __id;
         }
         const hexString = ByteUtils.toHex(this.id);
-        if (ObjectId.cacheHexString && !this.__id) {
-            this.__id = hexString;
+        if (ObjectId.cacheHexString) {
+            __idCache.set(this, hexString);
         }
         return hexString;
     }
@@ -19852,6 +20029,8 @@ class ObjectId extends BSONValue {
     static isValid(id) {
         if (id == null)
             return false;
+        if (typeof id === 'string')
+            return ObjectId.validateHexString(id);
         try {
             new ObjectId(id);
             return true;
@@ -19868,6 +20047,9 @@ class ObjectId extends BSONValue {
     static fromExtendedJSON(doc) {
         return new ObjectId(doc.$oid);
     }
+    isCached() {
+        return ObjectId.cacheHexString && __idCache.has(this);
+    }
     inspect(depth, options, inspect) {
         inspect ??= defaultInspect;
         return `new ObjectId(${inspect(this.toHexString(), options)})`;
@@ -19922,7 +20104,7 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
         case 'object':
             if (value != null &&
                 typeof value._bsontype === 'string' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+                value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
                 throw new BSONVersionError();
             }
             else if (value == null || value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
@@ -20025,8 +20207,14 @@ function calculateElement(name, value, serializeFunctions = false, isArray = fal
                     ByteUtils.utf8ByteLength(value.toString()) +
                     1);
             }
+            return 0;
+        case 'bigint':
+            return (name != null ? ByteUtils.utf8ByteLength(name) + 1 : 0) + (8 + 1);
+        case 'symbol':
+            return 0;
+        default:
+            throw new BSONError(`Unrecognized JS type: ${typeof value}`);
     }
-    return 0;
 }
 
 function alphabetize(str) {
@@ -20126,6 +20314,12 @@ class Timestamp extends LongWithoutOverridesClass {
     get _bsontype() {
         return 'Timestamp';
     }
+    get i() {
+        return this.low >>> 0;
+    }
+    get t() {
+        return this.high >>> 0;
+    }
     constructor(low) {
         if (low == null) {
             super(0, 0, true);
@@ -20151,10 +20345,10 @@ class Timestamp extends LongWithoutOverridesClass {
             if (i < 0 || Number.isNaN(i)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
             }
-            if (t > 4294967295) {
+            if (t > 0xffff_ffff) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide t equal or less than uint32 max');
             }
-            if (i > 4294967295) {
+            if (i > 0xffff_ffff) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i equal or less than uint32 max');
             }
             super(i, t, true);
@@ -20181,7 +20375,7 @@ class Timestamp extends LongWithoutOverridesClass {
         return new Timestamp(Long.fromString(str, true, optRadix));
     }
     toExtendedJSON() {
-        return { $timestamp: { t: this.high >>> 0, i: this.low >>> 0 } };
+        return { $timestamp: { t: this.t, i: this.i } };
     }
     static fromExtendedJSON(doc) {
         const i = Long.isLong(doc.$timestamp.i)
@@ -20194,8 +20388,8 @@ class Timestamp extends LongWithoutOverridesClass {
     }
     inspect(depth, options, inspect) {
         inspect ??= defaultInspect;
-        const t = inspect(this.high >>> 0, options);
-        const i = inspect(this.low >>> 0, options);
+        const t = inspect(this.t, options);
+        const i = inspect(this.i, options);
         return `new Timestamp({ t: ${t}, i: ${i} })`;
     }
 }
@@ -20278,9 +20472,8 @@ function deserializeObject(buffer, index, options, isArray = false) {
         throw new BSONError('corrupt bson message');
     const object = isArray ? [] : {};
     let arrayIndex = 0;
-    const done = false;
     let isPossibleDBRef = isArray ? false : null;
-    while (!done) {
+    while (true) {
         const elementType = buffer[index++];
         if (elementType === 0)
             break;
@@ -20352,7 +20545,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (objectSize <= 0 || objectSize > buffer.length - index)
                 throw new BSONError('bad embedded document length in bson');
             if (raw) {
-                value = buffer.slice(index, index + objectSize);
+                value = buffer.subarray(index, index + objectSize);
             }
             else {
                 let objectOptions = options;
@@ -20424,49 +20617,23 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new BSONError('Negative binary type element size found');
             if (binarySize > buffer.byteLength)
                 throw new BSONError('Binary type size larger than document size');
-            if (buffer['slice'] != null) {
-                if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize = NumberUtils.getInt32LE(buffer, index);
-                    index += 4;
-                    if (binarySize < 0)
-                        throw new BSONError('Negative binary type element size found for subtype 0x02');
-                    if (binarySize > totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
-                    if (binarySize < totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
-                }
-                if (promoteBuffers && promoteValues) {
-                    value = ByteUtils.toLocalBufferType(buffer.slice(index, index + binarySize));
-                }
-                else {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
-                        value = value.toUUID();
-                    }
-                }
+            if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
+                binarySize = NumberUtils.getInt32LE(buffer, index);
+                index += 4;
+                if (binarySize < 0)
+                    throw new BSONError('Negative binary type element size found for subtype 0x02');
+                if (binarySize > totalBinarySize - 4)
+                    throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
+                if (binarySize < totalBinarySize - 4)
+                    throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
+            }
+            if (promoteBuffers && promoteValues) {
+                value = ByteUtils.toLocalBufferType(buffer.subarray(index, index + binarySize));
             }
             else {
-                if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
-                    binarySize = NumberUtils.getInt32LE(buffer, index);
-                    index += 4;
-                    if (binarySize < 0)
-                        throw new BSONError('Negative binary type element size found for subtype 0x02');
-                    if (binarySize > totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too long binary size');
-                    if (binarySize < totalBinarySize - 4)
-                        throw new BSONError('Binary type with subtype 0x02 contains too short binary size');
-                }
-                if (promoteBuffers && promoteValues) {
-                    value = ByteUtils.allocateUnsafe(binarySize);
-                    for (i = 0; i < binarySize; i++) {
-                        value[i] = buffer[index + i];
-                    }
-                }
-                else {
-                    value = new Binary(buffer.slice(index, index + binarySize), subType);
-                    if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
-                        value = value.toUUID();
-                    }
+                value = new Binary(buffer.subarray(index, index + binarySize), subType);
+                if (subType === BSON_BINARY_SUBTYPE_UUID_NEW && UUID.isValid(value)) {
+                    value = value.toUUID();
                 }
             }
             index = index + binarySize;
@@ -20888,6 +21055,9 @@ function serializeBinary(buffer, key, value, index) {
         size = size - 4;
         index += NumberUtils.setInt32LE(buffer, index, size);
     }
+    if (value.sub_type === Binary.SUBTYPE_VECTOR) {
+        validateBinaryVector(value);
+    }
     if (size <= 16) {
         for (let i = 0; i < size; i++)
             buffer[index + i] = data[i];
@@ -20964,79 +21134,83 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             if (typeof value?.toBSON === 'function') {
                 value = value.toBSON();
             }
-            if (typeof value === 'string') {
-                index = serializeString(buffer, key, value, index);
-            }
-            else if (typeof value === 'number') {
-                index = serializeNumber(buffer, key, value, index);
-            }
-            else if (typeof value === 'bigint') {
-                index = serializeBigInt(buffer, key, value, index);
-            }
-            else if (typeof value === 'boolean') {
-                index = serializeBoolean(buffer, key, value, index);
-            }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === undefined) {
+            const type = typeof value;
+            if (value === undefined) {
                 index = serializeNull(buffer, key, value, index);
             }
             else if (value === null) {
                 index = serializeNull(buffer, key, value, index);
             }
-            else if (isUint8Array(value)) {
-                index = serializeBuffer(buffer, key, value, index);
-            }
-            else if (value instanceof RegExp || isRegExp(value)) {
-                index = serializeRegExp(buffer, key, value, index);
-            }
-            else if (typeof value === 'object' && value._bsontype == null) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'string') {
+                index = serializeString(buffer, key, value, index);
             }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
+            else if (type === 'number') {
+                index = serializeNumber(buffer, key, value, index);
             }
-            else if (value._bsontype === 'ObjectId') {
-                index = serializeObjectId(buffer, key, value, index);
+            else if (type === 'bigint') {
+                index = serializeBigInt(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Decimal128') {
-                index = serializeDecimal128(buffer, key, value, index);
+            else if (type === 'boolean') {
+                index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-                index = serializeLong(buffer, key, value, index);
+            else if (type === 'object' && value._bsontype == null) {
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                else if (value._bsontype === 'ObjectId') {
+                    index = serializeObjectId(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Decimal128') {
+                    index = serializeDecimal128(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+                    index = serializeLong(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Double') {
+                    index = serializeDouble(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    index = serializeSymbol(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'DBRef') {
+                    index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+                }
+                else if (value._bsontype === 'BSONRegExp') {
+                    index = serializeBSONRegExp(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Int32') {
+                    index = serializeInt32(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+                    index = serializeMinMax(buffer, key, value, index);
+                }
+                else if (typeof value._bsontype !== 'undefined') {
+                    throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                index = serializeSymbol(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'DBRef') {
-                index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-            }
-            else if (value._bsontype === 'BSONRegExp') {
-                index = serializeBSONRegExp(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Int32') {
-                index = serializeInt32(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-                index = serializeMinMax(buffer, key, value, index);
-            }
-            else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     else if (object instanceof Map || isMap(object)) {
@@ -21047,8 +21221,8 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             done = !!entry.done;
             if (done)
                 continue;
-            const key = entry.value[0];
-            let value = entry.value[1];
+            const key = entry.value ? entry.value[0] : undefined;
+            let value = entry.value ? entry.value[1] : undefined;
             if (typeof value?.toBSON === 'function') {
                 value = value.toBSON();
             }
@@ -21066,7 +21240,14 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     }
                 }
             }
-            if (type === 'string') {
+            if (value === undefined) {
+                if (ignoreUndefined === false)
+                    index = serializeNull(buffer, key, value, index);
+            }
+            else if (value === null) {
+                index = serializeNull(buffer, key, value, index);
+            }
+            else if (type === 'string') {
                 index = serializeString(buffer, key, value, index);
             }
             else if (type === 'number') {
@@ -21078,64 +21259,64 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === null || (value === undefined && ignoreUndefined === false)) {
-                index = serializeNull(buffer, key, value, index);
-            }
-            else if (isUint8Array(value)) {
-                index = serializeBuffer(buffer, key, value, index);
-            }
-            else if (value instanceof RegExp || isRegExp(value)) {
-                index = serializeRegExp(buffer, key, value, index);
-            }
             else if (type === 'object' && value._bsontype == null) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
-            }
-            else if (value._bsontype === 'ObjectId') {
-                index = serializeObjectId(buffer, key, value, index);
-            }
-            else if (type === 'object' && value._bsontype === 'Decimal128') {
-                index = serializeDecimal128(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-                index = serializeLong(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                else if (value._bsontype === 'ObjectId') {
+                    index = serializeObjectId(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Decimal128') {
+                    index = serializeDecimal128(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+                    index = serializeLong(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Double') {
+                    index = serializeDouble(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    index = serializeSymbol(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'DBRef') {
+                    index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+                }
+                else if (value._bsontype === 'BSONRegExp') {
+                    index = serializeBSONRegExp(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Int32') {
+                    index = serializeInt32(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+                    index = serializeMinMax(buffer, key, value, index);
+                }
+                else if (typeof value._bsontype !== 'undefined') {
+                    throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                index = serializeSymbol(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'DBRef') {
-                index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-            }
-            else if (value._bsontype === 'BSONRegExp') {
-                index = serializeBSONRegExp(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Int32') {
-                index = serializeInt32(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-                index = serializeMinMax(buffer, key, value, index);
-            }
-            else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     else {
@@ -21164,7 +21345,14 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
                     }
                 }
             }
-            if (type === 'string') {
+            if (value === undefined) {
+                if (ignoreUndefined === false)
+                    index = serializeNull(buffer, key, value, index);
+            }
+            else if (value === null) {
+                index = serializeNull(buffer, key, value, index);
+            }
+            else if (type === 'string') {
                 index = serializeString(buffer, key, value, index);
             }
             else if (type === 'number') {
@@ -21176,68 +21364,64 @@ function serializeInto(buffer, object, checkKeys, startingIndex, depth, serializ
             else if (type === 'boolean') {
                 index = serializeBoolean(buffer, key, value, index);
             }
-            else if (value instanceof Date || isDate(value)) {
-                index = serializeDate(buffer, key, value, index);
-            }
-            else if (value === undefined) {
-                if (ignoreUndefined === false)
-                    index = serializeNull(buffer, key, value, index);
-            }
-            else if (value === null) {
-                index = serializeNull(buffer, key, value, index);
-            }
-            else if (isUint8Array(value)) {
-                index = serializeBuffer(buffer, key, value, index);
-            }
-            else if (value instanceof RegExp || isRegExp(value)) {
-                index = serializeRegExp(buffer, key, value, index);
-            }
             else if (type === 'object' && value._bsontype == null) {
-                index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
-            }
-            else if (typeof value === 'object' &&
-                value[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
-                throw new BSONVersionError();
-            }
-            else if (value._bsontype === 'ObjectId') {
-                index = serializeObjectId(buffer, key, value, index);
-            }
-            else if (type === 'object' && value._bsontype === 'Decimal128') {
-                index = serializeDecimal128(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
-                index = serializeLong(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Double') {
-                index = serializeDouble(buffer, key, value, index);
+                if (value instanceof Date || isDate(value)) {
+                    index = serializeDate(buffer, key, value, index);
+                }
+                else if (value instanceof Uint8Array || isUint8Array(value)) {
+                    index = serializeBuffer(buffer, key, value, index);
+                }
+                else if (value instanceof RegExp || isRegExp(value)) {
+                    index = serializeRegExp(buffer, key, value, index);
+                }
+                else {
+                    index = serializeObject(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
             }
-            else if (value._bsontype === 'Code') {
-                index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+            else if (type === 'object') {
+                if (value[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
+                    throw new BSONVersionError();
+                }
+                else if (value._bsontype === 'ObjectId') {
+                    index = serializeObjectId(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Decimal128') {
+                    index = serializeDecimal128(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Long' || value._bsontype === 'Timestamp') {
+                    index = serializeLong(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Double') {
+                    index = serializeDouble(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Code') {
+                    index = serializeCode(buffer, key, value, index, checkKeys, depth, serializeFunctions, ignoreUndefined, path);
+                }
+                else if (value._bsontype === 'Binary') {
+                    index = serializeBinary(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'BSONSymbol') {
+                    index = serializeSymbol(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'DBRef') {
+                    index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
+                }
+                else if (value._bsontype === 'BSONRegExp') {
+                    index = serializeBSONRegExp(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'Int32') {
+                    index = serializeInt32(buffer, key, value, index);
+                }
+                else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
+                    index = serializeMinMax(buffer, key, value, index);
+                }
+                else if (typeof value._bsontype !== 'undefined') {
+                    throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
+                }
             }
-            else if (typeof value === 'function' && serializeFunctions) {
+            else if (type === 'function' && serializeFunctions) {
                 index = serializeFunction(buffer, key, value, index);
             }
-            else if (value._bsontype === 'Binary') {
-                index = serializeBinary(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'BSONSymbol') {
-                index = serializeSymbol(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'DBRef') {
-                index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions, path);
-            }
-            else if (value._bsontype === 'BSONRegExp') {
-                index = serializeBSONRegExp(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'Int32') {
-                index = serializeInt32(buffer, key, value, index);
-            }
-            else if (value._bsontype === 'MinKey' || value._bsontype === 'MaxKey') {
-                index = serializeMinMax(buffer, key, value, index);
-            }
-            else if (typeof value._bsontype !== 'undefined') {
-                throw new BSONError(`Unrecognized or invalid _bsontype: ${String(value._bsontype)}`);
-            }
         }
     }
     path.delete(object);
@@ -21489,7 +21673,7 @@ function serializeDocument(doc, options) {
     else if (doc != null &&
         typeof doc === 'object' &&
         typeof doc._bsontype === 'string' &&
-        doc[Symbol.for('@@mdb.bson.version')] !== BSON_MAJOR_VERSION) {
+        doc[BSON_VERSION_SYMBOL] !== BSON_MAJOR_VERSION) {
         throw new BSONVersionError();
     }
     else if (isBSONType(doc)) {
@@ -23635,105 +23819,174 @@ var hexSliceLookupTable = (function () {
   \***********************************************/
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-var Buffer = (__webpack_require__(/*! safe-buffer */ "../../node_modules/safe-buffer/index.js").Buffer)
-var Transform = (__webpack_require__(/*! stream */ "../../node_modules/stream-browserify/index.js").Transform)
-var StringDecoder = (__webpack_require__(/*! string_decoder */ "../../node_modules/string_decoder/lib/string_decoder.js").StringDecoder)
-var inherits = __webpack_require__(/*! inherits */ "../../node_modules/inherits/inherits_browser.js")
+"use strict";
 
-function CipherBase (hashMode) {
-  Transform.call(this)
-  this.hashMode = typeof hashMode === 'string'
-  if (this.hashMode) {
-    this[hashMode] = this._finalOrDigest
-  } else {
-    this.final = this._finalOrDigest
-  }
-  if (this._final) {
-    this.__final = this._final
-    this._final = null
-  }
-  this._decoder = null
-  this._encoding = null
-}
-inherits(CipherBase, Transform)
 
-CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
-  if (typeof data === 'string') {
-    data = Buffer.from(data, inputEnc)
-  }
+var Buffer = (__webpack_require__(/*! safe-buffer */ "../../node_modules/safe-buffer/index.js").Buffer);
+var Transform = (__webpack_require__(/*! stream */ "../../node_modules/stream-browserify/index.js").Transform);
+var StringDecoder = (__webpack_require__(/*! string_decoder */ "../../node_modules/string_decoder/lib/string_decoder.js").StringDecoder);
+var inherits = __webpack_require__(/*! inherits */ "../../node_modules/inherits/inherits_browser.js");
+
+function CipherBase(hashMode) {
+	Transform.call(this);
+	this.hashMode = typeof hashMode === 'string';
+	if (this.hashMode) {
+		this[hashMode] = this._finalOrDigest;
+	} else {
+		this['final'] = this._finalOrDigest;
+	}
+	if (this._final) {
+		this.__final = this._final;
+		this._final = null;
+	}
+	this._decoder = null;
+	this._encoding = null;
+}
+inherits(CipherBase, Transform);
+
+var useUint8Array = typeof Uint8Array !== 'undefined';
+var useArrayBuffer = typeof ArrayBuffer !== 'undefined'
+	&& typeof Uint8Array !== 'undefined'
+	&& ArrayBuffer.isView
+	&& (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT);
+
+function toBuffer(data, encoding) {
+	/*
+	 * No need to do anything for exact instance
+	 * This is only valid when safe-buffer.Buffer === buffer.Buffer, i.e. when Buffer.from/Buffer.alloc existed
+	 */
+	if (data instanceof Buffer) {
+		return data;
+	}
 
-  var outData = this._update(data)
-  if (this.hashMode) return this
+	// Convert strings to Buffer
+	if (typeof data === 'string') {
+		return Buffer.from(data, encoding);
+	}
 
-  if (outputEnc) {
-    outData = this._toString(outData, outputEnc)
-  }
+	/*
+	 * Wrap any TypedArray instances and DataViews
+	 * Makes sense only on engines with full TypedArray support -- let Buffer detect that
+	 */
+	if (useArrayBuffer && ArrayBuffer.isView(data)) {
+		// Bug in Node.js <6.3.1, which treats this as out-of-bounds
+		if (data.byteLength === 0) {
+			return Buffer.alloc(0);
+		}
+
+		var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+		/*
+		 * Recheck result size, as offset/length doesn't work on Node.js <5.10
+		 * We just go to Uint8Array case if this fails
+		 */
+		if (res.byteLength === data.byteLength) {
+			return res;
+		}
+	}
+
+	/*
+	 * Uint8Array in engines where Buffer.from might not work with ArrayBuffer, just copy over
+	 * Doesn't make sense with other TypedArray instances
+	 */
+	if (useUint8Array && data instanceof Uint8Array) {
+		return Buffer.from(data);
+	}
 
-  return outData
+	/*
+	 * Old Buffer polyfill on an engine that doesn't have TypedArray support
+	 * Also, this is from a different Buffer polyfill implementation then we have, as instanceof check failed
+	 * Convert to our current Buffer implementation
+	 */
+	if (
+		Buffer.isBuffer(data)
+			&& data.constructor
+			&& typeof data.constructor.isBuffer === 'function'
+			&& data.constructor.isBuffer(data)
+	) {
+		return Buffer.from(data);
+	}
+
+	throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView.');
 }
 
-CipherBase.prototype.setAutoPadding = function () {}
+CipherBase.prototype.update = function (data, inputEnc, outputEnc) {
+	var bufferData = toBuffer(data, inputEnc); // asserts correct input type
+	var outData = this._update(bufferData);
+	if (this.hashMode) {
+		return this;
+	}
+
+	if (outputEnc) {
+		outData = this._toString(outData, outputEnc);
+	}
+
+	return outData;
+};
+
+CipherBase.prototype.setAutoPadding = function () {};
 CipherBase.prototype.getAuthTag = function () {
-  throw new Error('trying to get auth tag in unsupported state')
-}
+	throw new Error('trying to get auth tag in unsupported state');
+};
 
 CipherBase.prototype.setAuthTag = function () {
-  throw new Error('trying to set auth tag in unsupported state')
-}
+	throw new Error('trying to set auth tag in unsupported state');
+};
 
 CipherBase.prototype.setAAD = function () {
-  throw new Error('trying to set aad in unsupported state')
-}
+	throw new Error('trying to set aad in unsupported state');
+};
 
 CipherBase.prototype._transform = function (data, _, next) {
-  var err
-  try {
-    if (this.hashMode) {
-      this._update(data)
-    } else {
-      this.push(this._update(data))
-    }
-  } catch (e) {
-    err = e
-  } finally {
-    next(err)
-  }
-}
+	var err;
+	try {
+		if (this.hashMode) {
+			this._update(data);
+		} else {
+			this.push(this._update(data));
+		}
+	} catch (e) {
+		err = e;
+	} finally {
+		next(err);
+	}
+};
 CipherBase.prototype._flush = function (done) {
-  var err
-  try {
-    this.push(this.__final())
-  } catch (e) {
-    err = e
-  }
+	var err;
+	try {
+		this.push(this.__final());
+	} catch (e) {
+		err = e;
+	}
 
-  done(err)
-}
+	done(err);
+};
 CipherBase.prototype._finalOrDigest = function (outputEnc) {
-  var outData = this.__final() || Buffer.alloc(0)
-  if (outputEnc) {
-    outData = this._toString(outData, outputEnc, true)
-  }
-  return outData
-}
+	var outData = this.__final() || Buffer.alloc(0);
+	if (outputEnc) {
+		outData = this._toString(outData, outputEnc, true);
+	}
+	return outData;
+};
 
 CipherBase.prototype._toString = function (value, enc, fin) {
-  if (!this._decoder) {
-    this._decoder = new StringDecoder(enc)
-    this._encoding = enc
-  }
+	if (!this._decoder) {
+		this._decoder = new StringDecoder(enc);
+		this._encoding = enc;
+	}
 
-  if (this._encoding !== enc) throw new Error('can\'t switch encodings')
+	if (this._encoding !== enc) {
+		throw new Error('can’t switch encodings');
+	}
 
-  var out = this._decoder.write(value)
-  if (fin) {
-    out += this._decoder.end()
-  }
+	var out = this._decoder.write(value);
+	if (fin) {
+		out += this._decoder.end();
+	}
 
-  return out
-}
+	return out;
+};
 
-module.exports = CipherBase
+module.exports = CipherBase;
 
 
 /***/ }),
@@ -24184,101 +24437,107 @@ module.exports = Hmac
 "use strict";
 
 
-exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = __webpack_require__(/*! randombytes */ "../../node_modules/randombytes/browser.js")
-exports.createHash = exports.Hash = __webpack_require__(/*! create-hash */ "../../node_modules/create-hash/browser.js")
-exports.createHmac = exports.Hmac = __webpack_require__(/*! create-hmac */ "../../node_modules/create-hmac/browser.js")
+// eslint-disable-next-line no-multi-assign
+exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = __webpack_require__(/*! randombytes */ "../../node_modules/randombytes/browser.js");
+
+// eslint-disable-next-line no-multi-assign
+exports.createHash = exports.Hash = __webpack_require__(/*! create-hash */ "../../node_modules/create-hash/browser.js");
+
+// eslint-disable-next-line no-multi-assign
+exports.createHmac = exports.Hmac = __webpack_require__(/*! create-hmac */ "../../node_modules/create-hmac/browser.js");
+
+var algos = __webpack_require__(/*! browserify-sign/algos */ "../../node_modules/browserify-sign/algos.js");
+var algoKeys = Object.keys(algos);
+var hashes = [
+	'sha1',
+	'sha224',
+	'sha256',
+	'sha384',
+	'sha512',
+	'md5',
+	'rmd160'
+].concat(algoKeys);
 
-var algos = __webpack_require__(/*! browserify-sign/algos */ "../../node_modules/browserify-sign/algos.js")
-var algoKeys = Object.keys(algos)
-var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys)
 exports.getHashes = function () {
-  return hashes
-}
+	return hashes;
+};
 
-var p = __webpack_require__(/*! pbkdf2 */ "../../node_modules/pbkdf2/browser.js")
-exports.pbkdf2 = p.pbkdf2
-exports.pbkdf2Sync = p.pbkdf2Sync
+var p = __webpack_require__(/*! pbkdf2 */ "../../node_modules/pbkdf2/browser.js");
+exports.pbkdf2 = p.pbkdf2;
+exports.pbkdf2Sync = p.pbkdf2Sync;
 
-var aes = __webpack_require__(/*! browserify-cipher */ "../../node_modules/browserify-cipher/browser.js")
+var aes = __webpack_require__(/*! browserify-cipher */ "../../node_modules/browserify-cipher/browser.js");
 
-exports.Cipher = aes.Cipher
-exports.createCipher = aes.createCipher
-exports.Cipheriv = aes.Cipheriv
-exports.createCipheriv = aes.createCipheriv
-exports.Decipher = aes.Decipher
-exports.createDecipher = aes.createDecipher
-exports.Decipheriv = aes.Decipheriv
-exports.createDecipheriv = aes.createDecipheriv
-exports.getCiphers = aes.getCiphers
-exports.listCiphers = aes.listCiphers
+exports.Cipher = aes.Cipher;
+exports.createCipher = aes.createCipher;
+exports.Cipheriv = aes.Cipheriv;
+exports.createCipheriv = aes.createCipheriv;
+exports.Decipher = aes.Decipher;
+exports.createDecipher = aes.createDecipher;
+exports.Decipheriv = aes.Decipheriv;
+exports.createDecipheriv = aes.createDecipheriv;
+exports.getCiphers = aes.getCiphers;
+exports.listCiphers = aes.listCiphers;
 
-var dh = __webpack_require__(/*! diffie-hellman */ "../../node_modules/diffie-hellman/browser.js")
+var dh = __webpack_require__(/*! diffie-hellman */ "../../node_modules/diffie-hellman/browser.js");
 
-exports.DiffieHellmanGroup = dh.DiffieHellmanGroup
-exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup
-exports.getDiffieHellman = dh.getDiffieHellman
-exports.createDiffieHellman = dh.createDiffieHellman
-exports.DiffieHellman = dh.DiffieHellman
+exports.DiffieHellmanGroup = dh.DiffieHellmanGroup;
+exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;
+exports.getDiffieHellman = dh.getDiffieHellman;
+exports.createDiffieHellman = dh.createDiffieHellman;
+exports.DiffieHellman = dh.DiffieHellman;
 
-var sign = __webpack_require__(/*! browserify-sign */ "../../node_modules/browserify-sign/browser/index.js")
+var sign = __webpack_require__(/*! browserify-sign */ "../../node_modules/browserify-sign/browser/index.js");
 
-exports.createSign = sign.createSign
-exports.Sign = sign.Sign
-exports.createVerify = sign.createVerify
-exports.Verify = sign.Verify
+exports.createSign = sign.createSign;
+exports.Sign = sign.Sign;
+exports.createVerify = sign.createVerify;
+exports.Verify = sign.Verify;
 
-exports.createECDH = __webpack_require__(/*! create-ecdh */ "../../node_modules/create-ecdh/browser.js")
+exports.createECDH = __webpack_require__(/*! create-ecdh */ "../../node_modules/create-ecdh/browser.js");
 
-var publicEncrypt = __webpack_require__(/*! public-encrypt */ "../../node_modules/public-encrypt/browser.js")
+var publicEncrypt = __webpack_require__(/*! public-encrypt */ "../../node_modules/public-encrypt/browser.js");
 
-exports.publicEncrypt = publicEncrypt.publicEncrypt
-exports.privateEncrypt = publicEncrypt.privateEncrypt
-exports.publicDecrypt = publicEncrypt.publicDecrypt
-exports.privateDecrypt = publicEncrypt.privateDecrypt
+exports.publicEncrypt = publicEncrypt.publicEncrypt;
+exports.privateEncrypt = publicEncrypt.privateEncrypt;
+exports.publicDecrypt = publicEncrypt.publicDecrypt;
+exports.privateDecrypt = publicEncrypt.privateDecrypt;
 
 // the least I can do is make error messages for the rest of the node.js/crypto api.
-// ;[
+// [
 //   'createCredentials'
 // ].forEach(function (name) {
 //   exports[name] = function () {
-//     throw new Error([
-//       'sorry, ' + name + ' is not implemented yet',
-//       'we accept pull requests',
-//       'https://github.com/crypto-browserify/crypto-browserify'
-//     ].join('\n'))
-//   }
-// })
+//     throw new Error('sorry, ' + name + ' is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+//   };
+// });
 
-var rf = __webpack_require__(/*! randomfill */ "../../node_modules/randomfill/browser.js")
+var rf = __webpack_require__(/*! randomfill */ "../../node_modules/randomfill/browser.js");
 
-exports.randomFill = rf.randomFill
-exports.randomFillSync = rf.randomFillSync
+exports.randomFill = rf.randomFill;
+exports.randomFillSync = rf.randomFillSync;
 
 exports.createCredentials = function () {
-  throw new Error([
-    'sorry, createCredentials is not implemented yet',
-    'we accept pull requests',
-    'https://github.com/crypto-browserify/crypto-browserify'
-  ].join('\n'))
-}
+	throw new Error('sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
+};
 
 exports.constants = {
-  'DH_CHECK_P_NOT_SAFE_PRIME': 2,
-  'DH_CHECK_P_NOT_PRIME': 1,
-  'DH_UNABLE_TO_CHECK_GENERATOR': 4,
-  'DH_NOT_SUITABLE_GENERATOR': 8,
-  'NPN_ENABLED': 1,
-  'ALPN_ENABLED': 1,
-  'RSA_PKCS1_PADDING': 1,
-  'RSA_SSLV23_PADDING': 2,
-  'RSA_NO_PADDING': 3,
-  'RSA_PKCS1_OAEP_PADDING': 4,
-  'RSA_X931_PADDING': 5,
-  'RSA_PKCS1_PSS_PADDING': 6,
-  'POINT_CONVERSION_COMPRESSED': 2,
-  'POINT_CONVERSION_UNCOMPRESSED': 4,
-  'POINT_CONVERSION_HYBRID': 6
-}
+	DH_CHECK_P_NOT_SAFE_PRIME: 2,
+	DH_CHECK_P_NOT_PRIME: 1,
+	DH_UNABLE_TO_CHECK_GENERATOR: 4,
+	DH_NOT_SUITABLE_GENERATOR: 8,
+	NPN_ENABLED: 1,
+	ALPN_ENABLED: 1,
+	RSA_PKCS1_PADDING: 1,
+	RSA_SSLV23_PADDING: 2,
+	RSA_NO_PADDING: 3,
+	RSA_PKCS1_OAEP_PADDING: 4,
+	RSA_X931_PADDING: 5,
+	RSA_PKCS1_PSS_PADDING: 6,
+	POINT_CONVERSION_COMPRESSED: 2,
+	POINT_CONVERSION_UNCOMPRESSED: 4,
+	POINT_CONVERSION_HYBRID: 6
+};
 
 
 /***/ }),
@@ -27698,8 +27957,27 @@ EC.prototype.genKeyPair = function genKeyPair(options) {
   }
 };
 
-EC.prototype._truncateToN = function _truncateToN(msg, truncOnly) {
-  var delta = msg.byteLength() * 8 - this.n.bitLength();
+EC.prototype._truncateToN = function _truncateToN(msg, truncOnly, bitLength) {
+  var byteLength;
+  if (BN.isBN(msg) || typeof msg === 'number') {
+    msg = new BN(msg, 16);
+    byteLength = msg.byteLength();
+  } else if (typeof msg === 'object') {
+    // BN assumes an array-like input and asserts length
+    byteLength = msg.length;
+    msg = new BN(msg, 16);
+  } else {
+    // BN converts the value to string
+    var str = msg.toString();
+    // HEX encoding
+    byteLength = (str.length + 1) >>> 1;
+    msg = new BN(str, 16);
+  }
+  // Allow overriding
+  if (typeof bitLength !== 'number') {
+    bitLength = byteLength * 8;
+  }
+  var delta = bitLength - this.n.bitLength();
   if (delta > 0)
     msg = msg.ushrn(delta);
   if (!truncOnly && msg.cmp(this.n) >= 0)
@@ -27716,8 +27994,18 @@ EC.prototype.sign = function sign(msg, key, enc, options) {
   if (!options)
     options = {};
 
+  if (typeof msg !== 'string' && typeof msg !== 'number' && !BN.isBN(msg)) {
+    assert(typeof msg === 'object' && msg && typeof msg.length === 'number',
+      'Expected message to be an array-like, a hex string, or a BN instance');
+    assert((msg.length >>> 0) === msg.length); // non-negative 32-bit integer
+    for (var i = 0; i < msg.length; i++) assert((msg[i] & 255) === msg[i]);
+  }
+
   key = this.keyFromPrivate(key, enc);
-  msg = this._truncateToN(new BN(msg, 16));
+  msg = this._truncateToN(msg, false, options.msgBitLength);
+
+  // Would fail further checks, but let's make the error message clear
+  assert(!msg.isNeg(), 'Can not sign a negative message');
 
   // Zero-extend key to provide enough entropy
   var bytes = this.n.byteLength();
@@ -27726,6 +28014,9 @@ EC.prototype.sign = function sign(msg, key, enc, options) {
   // Zero-extend nonce to have the same byte size as N
   var nonce = msg.toArray('be', bytes);
 
+  // Recheck nonce to be bijective to msg
+  assert((new BN(nonce)).eq(msg), 'Can not sign message');
+
   // Instantiate Hmac_DRBG
   var drbg = new HmacDRBG({
     hash: this.hash,
@@ -27773,8 +28064,11 @@ EC.prototype.sign = function sign(msg, key, enc, options) {
   }
 };
 
-EC.prototype.verify = function verify(msg, signature, key, enc) {
-  msg = this._truncateToN(new BN(msg, 16));
+EC.prototype.verify = function verify(msg, signature, key, enc, options) {
+  if (!options)
+    options = {};
+
+  msg = this._truncateToN(msg, false, options.msgBitLength);
   key = this.keyFromPublic(key, enc);
   signature = new Signature(signature, 'hex');
 
@@ -27985,8 +28279,8 @@ KeyPair.prototype.sign = function sign(msg, enc, options) {
   return this.ec.sign(msg, this, enc, options);
 };
 
-KeyPair.prototype.verify = function verify(msg, signature) {
-  return this.ec.verify(msg, signature, this);
+KeyPair.prototype.verify = function verify(msg, signature, options) {
+  return this.ec.verify(msg, signature, this, undefined, options);
 };
 
 KeyPair.prototype.inspect = function inspect() {
@@ -29429,7 +29723,7 @@ utils.intFromLE = intFromLE;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"elliptic","version":"6.5.7","description":"EC cryptography","main":"lib/elliptic.js","files":["lib"],"scripts":{"lint":"eslint lib test","lint:fix":"npm run lint -- --fix","unit":"istanbul test _mocha --reporter=spec test/index.js","test":"npm run lint && npm run unit","version":"grunt dist && git add dist/"},"repository":{"type":"git","url":"git@github.com:indutny/elliptic"},"keywords":["EC","Elliptic","curve","Cryptography"],"author":"Fedor Indutny <fedor@indutny.com>","license":"MIT","bugs":{"url":"https://github.com/indutny/elliptic/issues"},"homepage":"https://github.com/indutny/elliptic","devDependencies":{"brfs":"^2.0.2","coveralls":"^3.1.0","eslint":"^7.6.0","grunt":"^1.2.1","grunt-browserify":"^5.3.0","grunt-cli":"^1.3.2","grunt-contrib-connect":"^3.0.0","grunt-contrib-copy":"^1.0.0","grunt-contrib-uglify":"^5.0.0","grunt-mocha-istanbul":"^5.0.2","grunt-saucelabs":"^9.0.1","istanbul":"^0.4.5","mocha":"^8.0.1"},"dependencies":{"bn.js":"^4.11.9","brorand":"^1.1.0","hash.js":"^1.0.0","hmac-drbg":"^1.0.1","inherits":"^2.0.4","minimalistic-assert":"^1.0.1","minimalistic-crypto-utils":"^1.0.1"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"elliptic","version":"6.6.1","description":"EC cryptography","main":"lib/elliptic.js","files":["lib"],"scripts":{"lint":"eslint lib test","lint:fix":"npm run lint -- --fix","unit":"istanbul test _mocha --reporter=spec test/index.js","test":"npm run lint && npm run unit","version":"grunt dist && git add dist/"},"repository":{"type":"git","url":"git@github.com:indutny/elliptic"},"keywords":["EC","Elliptic","curve","Cryptography"],"author":"Fedor Indutny <fedor@indutny.com>","license":"MIT","bugs":{"url":"https://github.com/indutny/elliptic/issues"},"homepage":"https://github.com/indutny/elliptic","devDependencies":{"brfs":"^2.0.2","coveralls":"^3.1.0","eslint":"^7.6.0","grunt":"^1.2.1","grunt-browserify":"^5.3.0","grunt-cli":"^1.3.2","grunt-contrib-connect":"^3.0.0","grunt-contrib-copy":"^1.0.0","grunt-contrib-uglify":"^5.0.0","grunt-mocha-istanbul":"^5.0.2","grunt-saucelabs":"^9.0.1","istanbul":"^0.4.5","mocha":"^8.0.1"},"dependencies":{"bn.js":"^4.11.9","brorand":"^1.1.0","hash.js":"^1.0.0","hmac-drbg":"^1.0.1","inherits":"^2.0.4","minimalistic-assert":"^1.0.1","minimalistic-crypto-utils":"^1.0.1"}}');
 
 /***/ }),
 
@@ -30005,15 +30299,9 @@ module.exports = EVP_BytesToKey
 "use strict";
 
 var Buffer = (__webpack_require__(/*! safe-buffer */ "../../node_modules/safe-buffer/index.js").Buffer)
-var Transform = (__webpack_require__(/*! readable-stream */ "../../node_modules/readable-stream/readable-browser.js").Transform)
+var Transform = (__webpack_require__(/*! stream */ "../../node_modules/stream-browserify/index.js").Transform)
 var inherits = __webpack_require__(/*! inherits */ "../../node_modules/inherits/inherits_browser.js")
 
-function throwIfNotStringOrBuffer (val, prefix) {
-  if (!Buffer.isBuffer(val) && typeof val !== 'string') {
-    throw new TypeError(prefix + ' must be a string or a buffer')
-  }
-}
-
 function HashBase (blockSize) {
   Transform.call(this)
 
@@ -30049,10 +30337,59 @@ HashBase.prototype._flush = function (callback) {
   callback(error)
 }
 
+var useUint8Array = typeof Uint8Array !== 'undefined'
+var useArrayBuffer = typeof ArrayBuffer !== 'undefined' &&
+  typeof Uint8Array !== 'undefined' &&
+  ArrayBuffer.isView &&
+  (Buffer.prototype instanceof Uint8Array || Buffer.TYPED_ARRAY_SUPPORT)
+
+function toBuffer (data, encoding) {
+  // No need to do anything for exact instance
+  // This is only valid when safe-buffer.Buffer === buffer.Buffer, i.e. when Buffer.from/Buffer.alloc existed
+  if (data instanceof Buffer) return data
+
+  // Convert strings to Buffer
+  if (typeof data === 'string') return Buffer.from(data, encoding)
+
+  /*
+   * Wrap any TypedArray instances and DataViews
+   * Makes sense only on engines with full TypedArray support -- let Buffer detect that
+   */
+  if (useArrayBuffer && ArrayBuffer.isView(data)) {
+    if (data.byteLength === 0) return Buffer.alloc(0) // Bug in Node.js <6.3.1, which treats this as out-of-bounds
+    var res = Buffer.from(data.buffer, data.byteOffset, data.byteLength)
+    // Recheck result size, as offset/length doesn't work on Node.js <5.10
+    // We just go to Uint8Array case if this fails
+    if (res.byteLength === data.byteLength) return res
+  }
+
+  /*
+   * Uint8Array in engines where Buffer.from might not work with ArrayBuffer, just copy over
+   * Doesn't make sense with other TypedArray instances
+   */
+  if (useUint8Array && data instanceof Uint8Array) return Buffer.from(data)
+
+  /*
+   * Old Buffer polyfill on an engine that doesn't have TypedArray support
+   * Also, this is from a different Buffer polyfill implementation then we have, as instanceof check failed
+   * Convert to our current Buffer implementation
+   */
+  if (
+    Buffer.isBuffer(data) &&
+    data.constructor &&
+    typeof data.constructor.isBuffer === 'function' &&
+    data.constructor.isBuffer(data)
+  ) {
+    return Buffer.from(data)
+  }
+
+  throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView.')
+}
+
 HashBase.prototype.update = function (data, encoding) {
-  throwIfNotStringOrBuffer(data, 'Data')
   if (this._finalized) throw new Error('Digest already called')
-  if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)
+
+  data = toBuffer(data, encoding) // asserts correct input type
 
   // consume data
   var block = this._block
@@ -36291,25 +36628,6 @@ module.exports = {
 module.exports = __webpack_require__(/*! events */ "../../node_modules/events/events.js").EventEmitter;
 
 
-/***/ }),
-
-/***/ "../../node_modules/readable-stream/readable-browser.js":
-/*!**************************************************************!*\
-  !*** ../../node_modules/readable-stream/readable-browser.js ***!
-  \**************************************************************/
-/***/ ((module, exports, __webpack_require__) => {
-
-exports = module.exports = __webpack_require__(/*! ./lib/_stream_readable.js */ "../../node_modules/readable-stream/lib/_stream_readable.js");
-exports.Stream = exports;
-exports.Readable = exports;
-exports.Writable = __webpack_require__(/*! ./lib/_stream_writable.js */ "../../node_modules/readable-stream/lib/_stream_writable.js");
-exports.Duplex = __webpack_require__(/*! ./lib/_stream_duplex.js */ "../../node_modules/readable-stream/lib/_stream_duplex.js");
-exports.Transform = __webpack_require__(/*! ./lib/_stream_transform.js */ "../../node_modules/readable-stream/lib/_stream_transform.js");
-exports.PassThrough = __webpack_require__(/*! ./lib/_stream_passthrough.js */ "../../node_modules/readable-stream/lib/_stream_passthrough.js");
-exports.finished = __webpack_require__(/*! ./lib/internal/streams/end-of-stream.js */ "../../node_modules/readable-stream/lib/internal/streams/end-of-stream.js");
-exports.pipeline = __webpack_require__(/*! ./lib/internal/streams/pipeline.js */ "../../node_modules/readable-stream/lib/internal/streams/pipeline.js");
-
-
 /***/ }),
 
 /***/ "../../node_modules/ripemd160/index.js":
@@ -38223,21 +38541,10 @@ class PowerSyncDatabase extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.A
             disconnect: options.disconnect ?? !this.resolvedFlags.enableMultiTabs
         });
     }
-    connect(connector, options) {
-        /**
-         * Using React strict mode might cause calls to connect to fire multiple times
-         * Connect is wrapped inside a lock in order to prevent race conditions internally between multiple
-         * connection attempts.
-         */
-        return this.runExclusive(() => {
-            this.options.logger?.debug('Attempting to connect to PowerSync instance');
-            return super.connect(connector, options);
-        });
-    }
     generateBucketStorageAdapter() {
         return new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SqliteBucketStorage(this.database, _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbstractPowerSyncDatabase.transactionMutex);
     }
-    runExclusive(cb) {
+    async runExclusive(cb) {
         if (this.resolvedFlags.ssrMode) {
             return PowerSyncDatabase.SHARED_MUTEX.runExclusive(cb);
         }
@@ -39757,9 +40064,6 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
      */
     async connect(options) {
         await this.waitForReady();
-        // This is needed since a new tab won't have any reference to the
-        // shared worker sync implementation since that is only created on the first call to `connect`.
-        await this.disconnect();
         return this.syncManager.connect(options);
     }
     async disconnect() {
@@ -39775,12 +40079,21 @@ class SharedWebStreamingSyncImplementation extends _WebStreamingSyncImplementati
     }
     async dispose() {
         await this.waitForReady();
-        // Signal the shared worker that this client is closing its connection to the worker
-        const closeMessagePayload = {
-            event: _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_CLIENT,
-            data: {}
-        };
-        this.messagePort.postMessage(closeMessagePayload);
+        await new Promise((resolve) => {
+            // Listen for the close acknowledgment from the worker
+            this.messagePort.addEventListener('message', (event) => {
+                const payload = event.data;
+                if (payload?.event === _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_ACK) {
+                    resolve();
+                }
+            });
+            // Signal the shared worker that this client is closing its connection to the worker
+            const closeMessagePayload = {
+                event: _worker_sync_SharedSyncImplementation__WEBPACK_IMPORTED_MODULE_2__.SharedSyncClientEvent.CLOSE_CLIENT,
+                data: {}
+            };
+            this.messagePort.postMessage(closeMessagePayload);
+        });
         // Release the proxy
         this.syncManager[comlink__WEBPACK_IMPORTED_MODULE_0__.releaseProxy]();
         this.messagePort.close();
@@ -40258,9 +40571,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _db_sync_WebStreamingSyncImplementation__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../db/sync/WebStreamingSyncImplementation */ "./lib/src/db/sync/WebStreamingSyncImplementation.js");
 /* harmony import */ var _db_adapters_LockedAsyncDatabaseAdapter__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../db/adapters/LockedAsyncDatabaseAdapter */ "./lib/src/db/adapters/LockedAsyncDatabaseAdapter.js");
 /* harmony import */ var _db_adapters_WorkerWrappedAsyncDatabaseConnection__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../../db/adapters/WorkerWrappedAsyncDatabaseConnection */ "./lib/src/db/adapters/WorkerWrappedAsyncDatabaseConnection.js");
-/* harmony import */ var _shared_navigator__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../../shared/navigator */ "./lib/src/shared/navigator.js");
-/* harmony import */ var _BroadcastLogger__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./BroadcastLogger */ "./lib/src/worker/sync/BroadcastLogger.js");
-
+/* harmony import */ var _BroadcastLogger__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./BroadcastLogger */ "./lib/src/worker/sync/BroadcastLogger.js");
 
 
 
@@ -40270,6 +40581,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 /**
+ * @internal
  * Manual message events for shared sync clients
  */
 var SharedSyncClientEvent;
@@ -40279,14 +40591,20 @@ var SharedSyncClientEvent;
      * close it's connection to the client.
      */
     SharedSyncClientEvent["CLOSE_CLIENT"] = "close-client";
+    SharedSyncClientEvent["CLOSE_ACK"] = "close-ack";
 })(SharedSyncClientEvent || (SharedSyncClientEvent = {}));
+/**
+ * HACK: The shared implementation wraps and provides its own
+ * PowerSyncBackendConnector when generating the streaming sync implementation.
+ * We provide this unused placeholder when connecting with the ConnectionManager.
+ */
+const CONNECTOR_PLACEHOLDER = {};
 /**
  * @internal
  * Shared sync implementation which runs inside a shared webworker
  */
 class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODULE_0__.BaseObserver {
     ports;
-    syncStreamClient;
     isInitialized;
     statusListener;
     fetchCredentialsController;
@@ -40295,6 +40613,8 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
     syncParams;
     logger;
     lastConnectOptions;
+    portMutex;
+    connectionManager;
     syncStatus;
     broadCastLogger;
     constructor() {
@@ -40302,9 +40622,9 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
         this.ports = [];
         this.dbAdapter = null;
         this.syncParams = null;
-        this.syncStreamClient = null;
         this.logger = (0,_powersync_common__WEBPACK_IMPORTED_MODULE_0__.createLogger)('shared-sync');
         this.lastConnectOptions = undefined;
+        this.portMutex = new async_mutex__WEBPACK_IMPORTED_MODULE_1__.Mutex();
         this.isInitialized = new Promise((resolve) => {
             const callback = this.registerListener({
                 initialized: () => {
@@ -40314,21 +40634,44 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
             });
         });
         this.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus({});
-        this.broadCastLogger = new _BroadcastLogger__WEBPACK_IMPORTED_MODULE_8__.BroadcastLogger(this.ports);
-    }
-    async waitForStatus(status) {
-        await this.waitForReady();
-        return this.syncStreamClient.waitForStatus(status);
-    }
-    async waitUntilStatusMatches(predicate) {
-        await this.waitForReady();
-        return this.syncStreamClient.waitUntilStatusMatches(predicate);
+        this.broadCastLogger = new _BroadcastLogger__WEBPACK_IMPORTED_MODULE_7__.BroadcastLogger(this.ports);
+        this.connectionManager = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.ConnectionManager({
+            createSyncImplementation: async () => {
+                return this.portMutex.runExclusive(async () => {
+                    await this.waitForReady();
+                    if (!this.dbAdapter) {
+                        await this.openInternalDB();
+                    }
+                    const sync = this.generateStreamingImplementation();
+                    const onDispose = sync.registerListener({
+                        statusChanged: (status) => {
+                            this.updateAllStatuses(status.toJSON());
+                        }
+                    });
+                    return {
+                        sync,
+                        onDispose
+                    };
+                });
+            },
+            logger: this.logger
+        });
     }
     get lastSyncedAt() {
-        return this.syncStreamClient?.lastSyncedAt;
+        return this.connectionManager.syncStreamImplementation?.lastSyncedAt;
     }
     get isConnected() {
-        return this.syncStreamClient?.isConnected ?? false;
+        return this.connectionManager.syncStreamImplementation?.isConnected ?? false;
+    }
+    async waitForStatus(status) {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.waitForStatus(status);
+        });
+    }
+    async waitUntilStatusMatches(predicate) {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.waitUntilStatusMatches(predicate);
+        });
     }
     async waitForReady() {
         return this.isInitialized;
@@ -40341,25 +40684,34 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * Configures the DBAdapter connection and a streaming sync client.
      */
     async setParams(params) {
-        if (this.syncParams) {
-            // Cannot modify already existing sync implementation
-            return;
-        }
-        this.syncParams = params;
-        if (params.streamOptions?.flags?.broadcastLogs) {
-            this.logger = this.broadCastLogger;
-        }
-        self.onerror = (event) => {
-            // Share any uncaught events on the broadcast logger
-            this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
-        };
-        await this.openInternalDB();
-        this.iterateListeners((l) => l.initialized?.());
+        await this.portMutex.runExclusive(async () => {
+            if (this.syncParams) {
+                // Cannot modify already existing sync implementation params
+                // But we can ask for a DB adapter, if required, at this point.
+                if (!this.dbAdapter) {
+                    await this.openInternalDB();
+                }
+                return;
+            }
+            // First time setting params
+            this.syncParams = params;
+            if (params.streamOptions?.flags?.broadcastLogs) {
+                this.logger = this.broadCastLogger;
+            }
+            self.onerror = (event) => {
+                // Share any uncaught events on the broadcast logger
+                this.logger.error('Uncaught exception in PowerSync shared sync worker', event);
+            };
+            if (!this.dbAdapter) {
+                await this.openInternalDB();
+            }
+            this.iterateListeners((l) => l.initialized?.());
+        });
     }
     async dispose() {
         await this.waitForReady();
         this.statusListener?.();
-        return this.syncStreamClient?.dispose();
+        return this.connectionManager.close();
     }
     /**
      * Connects to the PowerSync backend instance.
@@ -40368,99 +40720,110 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * connects.
      */
     async connect(options) {
-        await this.waitForReady();
-        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_7__.getNavigatorLocks)().request('shared-sync-connect', async () => {
-            if (!this.dbAdapter) {
-                await this.openInternalDB();
-            }
-            this.syncStreamClient = this.generateStreamingImplementation();
-            this.lastConnectOptions = options;
-            this.syncStreamClient.registerListener({
-                statusChanged: (status) => {
-                    this.updateAllStatuses(status.toJSON());
-                }
-            });
-            await this.syncStreamClient.connect(options);
-        });
+        this.lastConnectOptions = options;
+        return this.connectionManager.connect(CONNECTOR_PLACEHOLDER, options);
     }
     async disconnect() {
-        await this.waitForReady();
-        // This effectively queues connect and disconnect calls. Ensuring multiple tabs' requests are synchronized
-        return (0,_shared_navigator__WEBPACK_IMPORTED_MODULE_7__.getNavigatorLocks)().request('shared-sync-connect', async () => {
-            await this.syncStreamClient?.disconnect();
-            await this.syncStreamClient?.dispose();
-            this.syncStreamClient = null;
-        });
+        return this.connectionManager.disconnect();
     }
     /**
      * Adds a new client tab's message port to the list of connected ports
      */
-    addPort(port) {
-        const portProvider = {
-            port,
-            clientProvider: comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(port)
-        };
-        this.ports.push(portProvider);
-        // Give the newly connected client the latest status
-        const status = this.syncStreamClient?.syncStatus;
-        if (status) {
-            portProvider.clientProvider.statusChanged(status.toJSON());
-        }
+    async addPort(port) {
+        await this.portMutex.runExclusive(() => {
+            const portProvider = {
+                port,
+                clientProvider: comlink__WEBPACK_IMPORTED_MODULE_2__.wrap(port)
+            };
+            this.ports.push(portProvider);
+            // Give the newly connected client the latest status
+            const status = this.connectionManager.syncStreamImplementation?.syncStatus;
+            if (status) {
+                portProvider.clientProvider.statusChanged(status.toJSON());
+            }
+        });
     }
     /**
      * Removes a message port client from this manager's managed
      * clients.
      */
     async removePort(port) {
-        const index = this.ports.findIndex((p) => p.port == port);
-        if (index < 0) {
-            this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
-            return;
-        }
-        const trackedPort = this.ports[index];
-        // Remove from the list of active ports
-        this.ports.splice(index, 1);
-        /**
-         * The port might currently be in use. Any active functions might
-         * not resolve. Abort them here.
-         */
-        [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
-            if (abortController?.activePort.port == port) {
-                abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
+        // Remove the port within a mutex context.
+        // Warns if the port is not found. This should not happen in practice.
+        // We return early if the port is not found.
+        const { trackedPort, shouldReconnect } = await this.portMutex.runExclusive(async () => {
+            const index = this.ports.findIndex((p) => p.port == port);
+            if (index < 0) {
+                this.logger.warn(`Could not remove port ${port} since it is not present in active ports.`);
+                return {};
             }
+            const trackedPort = this.ports[index];
+            // Remove from the list of active ports
+            this.ports.splice(index, 1);
+            /**
+             * The port might currently be in use. Any active functions might
+             * not resolve. Abort them here.
+             */
+            [this.fetchCredentialsController, this.uploadDataController].forEach((abortController) => {
+                if (abortController?.activePort.port == port) {
+                    abortController.controller.abort(new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.AbortOperation('Closing pending requests after client port is removed'));
+                }
+            });
+            const shouldReconnect = !!this.connectionManager.syncStreamImplementation && this.ports.length > 0;
+            return {
+                shouldReconnect,
+                trackedPort
+            };
         });
-        const shouldReconnect = !!this.syncStreamClient;
+        if (!trackedPort) {
+            // We could not find the port to remove
+            return () => { };
+        }
         if (this.dbAdapter && this.dbAdapter == trackedPort.db) {
             if (shouldReconnect) {
-                await this.disconnect();
+                await this.connectionManager.disconnect();
             }
             // Clearing the adapter will result in a new one being opened in connect
             this.dbAdapter = null;
             if (shouldReconnect) {
-                await this.connect(this.lastConnectOptions);
+                await this.connectionManager.connect(CONNECTOR_PLACEHOLDER, this.lastConnectOptions);
             }
         }
         if (trackedPort.db) {
-            trackedPort.db.close();
+            await trackedPort.db.close();
         }
         // Release proxy
-        trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
+        return () => trackedPort.clientProvider[comlink__WEBPACK_IMPORTED_MODULE_2__.releaseProxy]();
     }
     triggerCrudUpload() {
-        this.waitForReady().then(() => this.syncStreamClient?.triggerCrudUpload());
-    }
-    async obtainLock(lockOptions) {
-        await this.waitForReady();
-        return this.syncStreamClient.obtainLock(lockOptions);
+        this.withSyncImplementation(async (sync) => {
+            sync.triggerCrudUpload();
+        });
     }
     async hasCompletedSync() {
-        await this.waitForReady();
-        return this.syncStreamClient.hasCompletedSync();
+        return this.withSyncImplementation(async (sync) => {
+            return sync.hasCompletedSync();
+        });
     }
     async getWriteCheckpoint() {
+        return this.withSyncImplementation(async (sync) => {
+            return sync.getWriteCheckpoint();
+        });
+    }
+    async withSyncImplementation(callback) {
         await this.waitForReady();
-        return this.syncStreamClient.getWriteCheckpoint();
+        if (this.connectionManager.syncStreamImplementation) {
+            return callback(this.connectionManager.syncStreamImplementation);
+        }
+        const sync = await new Promise((resolve) => {
+            const dispose = this.connectionManager.registerListener({
+                syncStreamCreated: (sync) => {
+                    resolve(sync);
+                    dispose?.();
+                }
+            });
+        });
+        return callback(sync);
     }
     generateStreamingImplementation() {
         // This should only be called after initialization has completed
@@ -40563,13 +40926,13 @@ class SharedSyncImplementation extends _powersync_common__WEBPACK_IMPORTED_MODUL
      * A function only used for unit tests which updates the internal
      * sync stream client and all tab client's sync status
      */
-    _testUpdateAllStatuses(status) {
-        if (!this.syncStreamClient) {
+    async _testUpdateAllStatuses(status) {
+        if (!this.connectionManager.syncStreamImplementation) {
             // This is just for testing purposes
-            this.syncStreamClient = this.generateStreamingImplementation();
+            this.connectionManager.syncStreamImplementation = this.generateStreamingImplementation();
         }
         // Only assigning, don't call listeners for this test
-        this.syncStreamClient.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
+        this.connectionManager.syncStreamImplementation.syncStatus = new _powersync_common__WEBPACK_IMPORTED_MODULE_0__.SyncStatus(status);
         this.updateAllStatuses(status);
     }
 }