@browserless.io/browserless 2.5.0 → 2.6.0

package/extensions/ublock/js/base64-custom.js

@@ -46,105 +46,6 @@ const digitToVal = new Uint8Array(128);
     }
 }
 
-// The sparse base64 codec is best for buffers which contains a lot of
-// small u32 integer values. Those small u32 integer values are better
-// represented with stringified integers, because small values can be
-// represented with fewer bits than the usual base64 codec. For example,
-// 0 become '0 ', i.e. 16 bits instead of 48 bits with official base64
-// codec.
-
-const sparseBase64 = {
-    magic: 'Base64_1',
-
-    encode: function(arrbuf, arrlen) {
-        const inputLength = (arrlen + 3) >>> 2;
-        const inbuf = new Uint32Array(arrbuf, 0, inputLength);
-        const outputLength = this.magic.length + 7 + inputLength * 7;
-        const outbuf = new Uint8Array(outputLength);
-        // magic bytes
-        let j = 0;
-        for ( let i = 0; i < this.magic.length; i++ ) {
-            outbuf[j++] = this.magic.charCodeAt(i);
-        }
-        // array size
-        let v = inputLength;
-        do {
-            outbuf[j++] = valToDigit[v & 0b111111];
-            v >>>= 6;
-        } while ( v !== 0 );
-        outbuf[j++] = 0x20 /* ' ' */;
-        // array content
-        for ( let i = 0; i < inputLength; i++ ) {
-            v = inbuf[i];
-            do {
-                outbuf[j++] = valToDigit[v & 0b111111];
-                v >>>= 6;
-            } while ( v !== 0 );
-            outbuf[j++] = 0x20 /* ' ' */;
-        }
-        if ( typeof TextDecoder === 'undefined' ) {
-            return JSON.stringify(
-                Array.from(new Uint32Array(outbuf.buffer, 0, j >>> 2))
-            );
-        }
-        const textDecoder = new TextDecoder();
-        return textDecoder.decode(new Uint8Array(outbuf.buffer, 0, j));
-    },
-
-    decode: function(instr, arrbuf) {
-        if ( instr.charCodeAt(0) === 0x5B /* '[' */ ) {
-            const inbuf = JSON.parse(instr);
-            if ( arrbuf instanceof ArrayBuffer === false ) {
-                return new Uint32Array(inbuf);
-            }
-            const outbuf = new Uint32Array(arrbuf);
-            outbuf.set(inbuf);
-            return outbuf;
-        }
-        if ( instr.startsWith(this.magic) === false ) {
-            throw new Error('Invalid µBlock.base64 encoding');
-        }
-        const inputLength = instr.length;
-        const outputLength = this.decodeSize(instr) >> 2;
-        const outbuf = arrbuf instanceof ArrayBuffer === false
-            ? new Uint32Array(outputLength)
-            : new Uint32Array(arrbuf);
-        let i = instr.indexOf(' ', this.magic.length) + 1;
-        if ( i === -1 ) {
-            throw new Error('Invalid µBlock.base64 encoding');
-        }
-        // array content
-        let j = 0;
-        for (;;) {
-            if ( j === outputLength || i >= inputLength ) { break; }
-            let v = 0, l = 0;
-            for (;;) {
-                const c = instr.charCodeAt(i++);
-                if ( c === 0x20 /* ' ' */ ) { break; }
-                v += digitToVal[c] << l;
-                l += 6;
-            }
-            outbuf[j++] = v;
-        }
-        if ( i < inputLength || j < outputLength ) {
-            throw new Error('Invalid µBlock.base64 encoding');
-        }
-        return outbuf;
-    },
-
-    decodeSize: function(instr) {
-        if ( instr.startsWith(this.magic) === false ) { return 0; }
-        let v = 0, l = 0, i = this.magic.length;
-        for (;;) {
-            const c = instr.charCodeAt(i++);
-            if ( c === 0x20 /* ' ' */ ) { break; }
-            v += digitToVal[c] << l;
-            l += 6;
-        }
-        return v << 2;
-    },
-};
-
 // The dense base64 codec is best for typed buffers which values are
 // more random. For example, buffer contents as a result of compression
 // contain less repetitive values and thus the content is more
@@ -154,7 +55,7 @@ const sparseBase64 = {
 //       ArrayBuffer fails, the content of the resulting Uint8Array is
 //       non-sensical. WASM-related?
 
-const denseBase64 = {
+export const denseBase64 = {
     magic: 'DenseBase64_1',
 
     encode: function(input) {
@@ -242,5 +143,3 @@ const denseBase64 = {
 };
 
 /******************************************************************************/
-
-export { denseBase64, sparseBase64 };

package/extensions/ublock/js/benchmarks.js

@@ -74,8 +74,8 @@ const loadBenchmarkDataset = (( ) => {
         datasetPromise = undefined;
     });
 
-    return function() {
-        ttlTimer.offon({ min: 5 });
+    return async function() {
+        ttlTimer.offon({ min: 2 });
 
         if ( datasetPromise !== undefined ) {
             return datasetPromise;
@@ -84,7 +84,7 @@ const loadBenchmarkDataset = (( ) => {
         const datasetURL = µb.hiddenSettings.benchmarkDatasetURL;
         if ( datasetURL === 'unset' ) {
             console.info(`No benchmark dataset available.`);
-            return Promise.resolve();
+            return;
         }
         console.info(`Loading benchmark dataset...`);
         datasetPromise = io.fetchText(datasetURL).then(details => {
@@ -136,7 +136,7 @@ const loadBenchmarkDataset = (( ) => {
 
 // action: 1=test
 
-µb.benchmarkStaticNetFiltering = async function(options = {}) {
+export async function benchmarkStaticNetFiltering(options = {}) {
     const { target, redirectEngine } = options;
 
     const requests = await loadBenchmarkDataset();
@@ -231,11 +231,11 @@ const loadBenchmarkDataset = (( ) => {
     const s = output.join('\n');
     console.info(s);
     return s;
-};
+}
 
 /******************************************************************************/
 
-µb.tokenHistograms = async function() {
+export async function tokenHistogramsfunction() {
     const requests = await loadBenchmarkDataset();
     if ( Array.isArray(requests) === false || requests.length === 0 ) {
         console.info('No requests found to benchmark');
@@ -272,11 +272,11 @@ const loadBenchmarkDataset = (( ) => {
     const tophits = Array.from(hitTokenMap).sort(customSort).slice(0, 100);
     console.info('Misses:', JSON.stringify(topmisses));
     console.info('Hits:', JSON.stringify(tophits));
-};
+}
 
 /******************************************************************************/
 
-µb.benchmarkDynamicNetFiltering = async function() {
+export async function benchmarkDynamicNetFiltering() {
     const requests = await loadBenchmarkDataset();
     if ( Array.isArray(requests) === false || requests.length === 0 ) {
         console.info('No requests found to benchmark');
@@ -299,17 +299,19 @@ const loadBenchmarkDataset = (( ) => {
     const dur = t1 - t0;
     console.info(`Evaluated ${requests.length} requests in ${dur.toFixed(0)} ms`);
     console.info(`\tAverage: ${(dur / requests.length).toFixed(3)} ms per request`);
-};
+}
 
 /******************************************************************************/
 
-µb.benchmarkCosmeticFiltering = async function() {
+export async function benchmarkCosmeticFiltering() {
     const requests = await loadBenchmarkDataset();
     if ( Array.isArray(requests) === false || requests.length === 0 ) {
         console.info('No requests found to benchmark');
         return;
     }
-    console.info('Benchmarking cosmeticFilteringEngine.retrieveSpecificSelectors()...');
+    const output = [
+        'Benchmarking cosmeticFilteringEngine.retrieveSpecificSelectors()...',
+    ];
     const details = {
         tabId: undefined,
         frameId: undefined,
@@ -320,6 +322,7 @@ const loadBenchmarkDataset = (( ) => {
     const options = {
         noSpecificCosmeticFiltering: false,
         noGenericCosmeticFiltering: false,
+        dontInject: true,
     };
     let count = 0;
     const t0 = performance.now();
@@ -334,19 +337,26 @@ const loadBenchmarkDataset = (( ) => {
     }
     const t1 = performance.now();
     const dur = t1 - t0;
-    console.info(`Evaluated ${count} requests in ${dur.toFixed(0)} ms`);
-    console.info(`\tAverage: ${(dur / count).toFixed(3)} ms per request`);
-};
+    output.push(
+        `Evaluated ${count} retrieval in ${dur.toFixed(0)} ms`,
+        `\tAverage: ${(dur / count).toFixed(3)} ms per document`
+    );
+    const s = output.join('\n');
+    console.info(s);
+    return s;
+}
 
 /******************************************************************************/
 
-µb.benchmarkScriptletFiltering = async function() {
+export async function benchmarkScriptletFiltering() {
     const requests = await loadBenchmarkDataset();
     if ( Array.isArray(requests) === false || requests.length === 0 ) {
         console.info('No requests found to benchmark');
         return;
     }
-    console.info('Benchmarking scriptletFilteringEngine.retrieve()...');
+    const output = [
+        'Benchmarking scriptletFilteringEngine.retrieve()...',
+    ];
     const details = {
         domain: '',
         entity: '',
@@ -369,13 +379,18 @@ const loadBenchmarkDataset = (( ) => {
     }
     const t1 = performance.now();
     const dur = t1 - t0;
-    console.info(`Evaluated ${count} requests in ${dur.toFixed(0)} ms`);
-    console.info(`\tAverage: ${(dur / count).toFixed(3)} ms per request`);
-};
+    output.push(
+        `Evaluated ${count} retrieval in ${dur.toFixed(0)} ms`,
+        `\tAverage: ${(dur / count).toFixed(3)} ms per document`
+    );
+    const s = output.join('\n');
+    console.info(s);
+    return s;
+}
 
 /******************************************************************************/
 
-µb.benchmarkOnBeforeRequest = async function() {
+export async function benchmarkOnBeforeRequest() {
     const requests = await loadBenchmarkDataset();
     if ( Array.isArray(requests) === false || requests.length === 0 ) {
         console.info('No requests found to benchmark');
@@ -417,6 +432,6 @@ const loadBenchmarkDataset = (( ) => {
         console.info(`\tBlocked ${blockCount} requests`);
         console.info(`\tAverage: ${(dur / requests.length).toFixed(3)} ms per request`);
     });
-};
+}
 
 /******************************************************************************/

package/extensions/ublock/js/biditrie.js

@@ -576,34 +576,19 @@ class BidiTrieContainer {
         };
     }
 
-    serialize(encoder) {
-        if ( encoder instanceof Object ) {
-            return encoder.encode(
-                this.buf32.buffer,
-                this.buf32[CHAR1_SLOT]
-            );
-        }
-        return Array.from(
-            new Uint32Array(
-                this.buf32.buffer,
-                0,
-                this.buf32[CHAR1_SLOT] + 3 >>> 2
-            )
+    toSelfie() {
+        return this.buf32.subarray(
+            0,
+            this.buf32[CHAR1_SLOT] + 3 >>> 2
         );
     }
 
-    unserialize(selfie, decoder) {
-        const shouldDecode = typeof selfie === 'string';
-        let byteLength = shouldDecode
-            ? decoder.decodeSize(selfie)
-            : selfie.length << 2;
+    fromSelfie(selfie) {
+        if ( selfie instanceof Uint32Array === false ) { return false; }
+        let byteLength = selfie.length << 2;
         if ( byteLength === 0 ) { return false; }
         this.reallocateBuf(byteLength);
-        if ( shouldDecode ) {
-            decoder.decode(selfie, this.buf8.buffer);
-        } else {
-            this.buf32.set(selfie);
-        }
+        this.buf32.set(selfie);
         return true;
     }
 

package/extensions/ublock/js/broadcast.js

@@ -19,9 +19,7 @@
     Home: https://github.com/gorhill/uBlock
 */
 
-/* globals browser */
-
-'use strict';
+import webext from './webext.js';
 
 /******************************************************************************/
 
@@ -47,7 +45,7 @@ export async function broadcastToAll(message) {
     });
     const bcmessage = Object.assign({ broadcast: true }, message);
     for ( const tab of tabs ) {
-        browser.tabs.sendMessage(tab.id, bcmessage);
+        webext.tabs.sendMessage(tab.id, bcmessage).catch(( ) => { });
     }
 }