@powersync/web 1.28.0 → 1.28.1

package/dist/worker/node_modules_bson_lib_bson_mjs.umd.js

@@ -5,9 +5,8 @@
 /*!********************************************!*\
   !*** ../../node_modules/bson/lib/bson.mjs ***!
   \********************************************/
-/***/ ((__webpack_module__, __webpack_exports__, __webpack_require__) => {
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
 
-__webpack_require__.a(__webpack_module__, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
 __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   BSON: () => (/* binding */ bson),
@@ -258,14 +257,7 @@ function tryWriteBasicLatin(destination, source, offset) {
 function nodejsMathRandomBytes(byteLength) {
     return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
 }
-const nodejsRandomBytes = await (async () => {
-    try {
-        return (await __webpack_require__.e(/*! import() */ "node_modules_crypto-browserify_index_js").then(__webpack_require__.t.bind(__webpack_require__, /*! crypto */ "../../node_modules/crypto-browserify/index.js", 19))).randomBytes;
-    }
-    catch {
-        return nodejsMathRandomBytes;
-    }
-})();
+const nodejsRandomBytes = nodejsMathRandomBytes;
 const nodeJsByteUtils = {
     toLocalBufferType(potentialBuffer) {
         if (Buffer.isBuffer(potentialBuffer)) {
@@ -790,6 +782,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.Int8) {
             throw new BSONError('Binary datatype field is not Int8');
         }
+        validateBinaryVector(this);
         return new Int8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
     }
     toFloat32Array() {
@@ -799,6 +792,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.Float32) {
             throw new BSONError('Binary datatype field is not Float32');
         }
+        validateBinaryVector(this);
         const floatBytes = new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
         if (NumberUtils.isBigEndian)
             ByteUtils.swap32(floatBytes);
@@ -811,6 +805,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
             throw new BSONError('Binary datatype field is not packed bit');
         }
+        validateBinaryVector(this);
         return new Uint8Array(this.buffer.buffer.slice(this.buffer.byteOffset + 2, this.buffer.byteOffset + this.position));
     }
     toBits() {
@@ -820,6 +815,7 @@ class Binary extends BSONValue {
         if (this.buffer[0] !== Binary.VECTOR_TYPE.PackedBit) {
             throw new BSONError('Binary datatype field is not packed bit');
         }
+        validateBinaryVector(this);
         const byteCount = this.length() - 2;
         const bitCount = byteCount * 8 - this.buffer[1];
         const bits = new Int8Array(bitCount);
@@ -838,7 +834,9 @@ class Binary extends BSONValue {
         buffer[1] = 0;
         const intBytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
         buffer.set(intBytes, 2);
-        return new this(buffer, this.SUBTYPE_VECTOR);
+        const bin = new this(buffer, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     static fromFloat32Array(array) {
         const binaryBytes = ByteUtils.allocate(array.byteLength + 2);
@@ -848,14 +846,18 @@ class Binary extends BSONValue {
         binaryBytes.set(floatBytes, 2);
         if (NumberUtils.isBigEndian)
             ByteUtils.swap32(new Uint8Array(binaryBytes.buffer, 2));
-        return new this(binaryBytes, this.SUBTYPE_VECTOR);
+        const bin = new this(binaryBytes, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     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);
+        const bin = new this(buffer, this.SUBTYPE_VECTOR);
+        validateBinaryVector(bin);
+        return bin;
     }
     static fromBits(bits) {
         const byteLength = (bits.length + 7) >>> 3;
@@ -905,6 +907,11 @@ function validateBinaryVector(vector) {
         padding !== 0) {
         throw new BSONError('Invalid Vector: padding must be zero for int8 and float32 vectors');
     }
+    if (datatype === Binary.VECTOR_TYPE.Float32) {
+        if (size !== 0 && size - 2 !== 0 && (size - 2) % 4 !== 0) {
+            throw new BSONError('Invalid Vector: Float32 vector must contain a multiple of 4 bytes');
+        }
+    }
     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');
     }
@@ -4416,6 +4423,29 @@ EJSON.serialize = EJSONserialize;
 EJSON.deserialize = EJSONdeserialize;
 Object.freeze(EJSON);
 
+const BSONElementType = {
+    double: 1,
+    string: 2,
+    object: 3,
+    array: 4,
+    binData: 5,
+    undefined: 6,
+    objectId: 7,
+    bool: 8,
+    date: 9,
+    null: 10,
+    regex: 11,
+    dbPointer: 12,
+    javascript: 13,
+    symbol: 14,
+    javascriptWithScope: 15,
+    int: 16,
+    timestamp: 17,
+    long: 18,
+    decimal: 19,
+    minKey: 255,
+    maxKey: 127
+};
 function getSize(source, offset) {
     try {
         return NumberUtils.getNonnegativeInt32LE(source, offset);
@@ -4460,48 +4490,48 @@ function parseToElements(bytes, startOffset = 0) {
         const nameLength = findNull(bytes, offset) - nameOffset;
         offset += nameLength + 1;
         let length;
-        if (type === 1 ||
-            type === 18 ||
-            type === 9 ||
-            type === 17) {
+        if (type === BSONElementType.double ||
+            type === BSONElementType.long ||
+            type === BSONElementType.date ||
+            type === BSONElementType.timestamp) {
             length = 8;
         }
-        else if (type === 16) {
+        else if (type === BSONElementType.int) {
             length = 4;
         }
-        else if (type === 7) {
+        else if (type === BSONElementType.objectId) {
             length = 12;
         }
-        else if (type === 19) {
+        else if (type === BSONElementType.decimal) {
             length = 16;
         }
-        else if (type === 8) {
+        else if (type === BSONElementType.bool) {
             length = 1;
         }
-        else if (type === 10 ||
-            type === 6 ||
-            type === 127 ||
-            type === 255) {
+        else if (type === BSONElementType.null ||
+            type === BSONElementType.undefined ||
+            type === BSONElementType.maxKey ||
+            type === BSONElementType.minKey) {
             length = 0;
         }
-        else if (type === 11) {
+        else if (type === BSONElementType.regex) {
             length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
         }
-        else if (type === 3 ||
-            type === 4 ||
-            type === 15) {
+        else if (type === BSONElementType.object ||
+            type === BSONElementType.array ||
+            type === BSONElementType.javascriptWithScope) {
             length = getSize(bytes, offset);
         }
-        else if (type === 2 ||
-            type === 5 ||
-            type === 12 ||
-            type === 13 ||
-            type === 14) {
+        else if (type === BSONElementType.string ||
+            type === BSONElementType.binData ||
+            type === BSONElementType.dbPointer ||
+            type === BSONElementType.javascript ||
+            type === BSONElementType.symbol) {
             length = getSize(bytes, offset) + 4;
-            if (type === 5) {
+            if (type === BSONElementType.binData) {
                 length += 1;
             }
-            if (type === 12) {
+            if (type === BSONElementType.dbPointer) {
                 length += 12;
             }
         }
@@ -4609,8 +4639,6 @@ var bson = /*#__PURE__*/Object.freeze({
 
 //# sourceMappingURL=bson.mjs.map
 
-__webpack_async_result__();
-} catch(e) { __webpack_async_result__(e); } }, 1);
 
 /***/ })