@browserless.io/browserless 2.31.1 → 2.32.0-beta-1

package/extensions/ublocklite/js/dnr-editor.js

@@ -0,0 +1,180 @@
+/*******************************************************************************
+
+    uBlock Origin Lite - a comprehensive, MV3-compliant content blocker
+    Copyright (C) 2014-present Raymond Hill
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see {http://www.gnu.org/licenses/}.
+
+    Home: https://github.com/gorhill/uBlock
+*/
+
+import { dnr } from './ext-compat.js';
+import { rulesFromText } from './dnr-parser.js';
+
+/******************************************************************************/
+
+export class DNREditor {
+    constructor() {
+        this.validatedRegexes = [];
+        this.validatedRegexResults = [];
+    }
+
+    updateView(editor, firstLine, lastLine) {
+        const { doc } = editor.view.state;
+        const text = doc.sliceString(firstLine.from, lastLine.to);
+        const { bad } = rulesFromText(text);
+        if ( Array.isArray(bad) && bad.length !== 0 ) {
+            self.cm6.lineErrorAdd(editor.view, bad.map(i => i + firstLine.number));
+        }
+        const entries = self.cm6.findAll(
+            editor.view,
+            '\\bregexFilter: (\\S+)',
+            firstLine.from,
+            lastLine.to
+        );
+        const regexes = [];
+        for ( const entry of entries ) {
+            const regex = entry.match[1];
+            const i = this.validatedRegexes.indexOf(regex);
+            if ( i !== -1 ) {
+                const reason = this.validatedRegexResults[i];
+                if ( reason === true ) { continue; }
+                self.cm6.spanErrorAdd(editor.view, entry.from+13, entry.to, reason);
+            } else { 
+                regexes.push(regex);
+            }
+        }
+        this.validateRegexes(editor, regexes);
+    }
+
+    exportToFile(text, fname) {
+        const { rules } = rulesFromText(text);
+        if ( Array.isArray(rules) === false ) { return; }
+        let ruleId = 1;
+        for ( const rule of rules ) {
+            rule.id = ruleId++;
+        }
+        return {
+            fname,
+            data: JSON.stringify(rules, null, 2),
+            mime: 'application/json',
+        };
+    }
+
+    async validateRegexes(editor, regexes) {
+        if ( regexes.length === 0 ) { return; }
+        const promises = regexes.map(regex => this.validateRegex(regex));
+        await Promise.all(promises);
+        for ( const regex of regexes ) {
+            const i = this.validatedRegexes.indexOf(regex);
+            if ( i === -1 ) { continue; }
+            const reason = this.validatedRegexResults[i];
+            if ( reason === true ) { continue; }
+            const entries = self.cm6.findAll(editor.view,
+                `(?<=\\bregexFilter: )${RegExp.escape(regex)}`
+            );
+            for ( const entry of entries ) {
+                self.cm6.spanErrorAdd(editor.view, entry.from, entry.to, reason);
+            }
+        }
+    }
+
+    async validateRegex(regex) {
+        const details = await dnr.isRegexSupported({ regex });
+        const result = details.isSupported || details.reason;
+        if ( this.validatedRegexes.length > 32 ) {
+            this.validatedRegexes.pop();
+            this.validatedRegexResults.pop();
+        }
+        this.validatedRegexes.unshift(regex);
+        this.validatedRegexResults.unshift(result);
+    }
+
+    createTooltipWidget(text) {
+        const template = document.querySelector('.badmark-tooltip');
+        const fragment = template.content.cloneNode(true);
+        const dom = fragment.querySelector('.badmark-tooltip');
+        dom.textContent = text;
+        return dom;
+    }
+
+    foldService(state, from) {
+        const { doc } = state;
+        const lineFrom = doc.lineAt(from);
+        if ( this.reFoldable.test(lineFrom.text) === false ) { return null; }
+        if ( lineFrom.number <= 5 ) { return null ; }
+        const lineBlockStart = doc.line(lineFrom.number - 5);
+        if ( this.reFoldCandidates.test(lineBlockStart.text) === false ) { return null; }
+        for ( let i = lineFrom.number-4; i < lineFrom.number; i++ ) {
+            const line = doc.line(i);
+            if ( this.reFoldable.test(line.text) === false ) { return null; }
+        }
+        let i = lineFrom.number + 1;
+        for ( ; i <= doc.lines; i++ ) {
+            const lineNext = doc.line(i);
+            if ( this.reFoldable.test(lineNext.text) === false ) { break; }
+        }
+        i -= 1;
+        if ( i === lineFrom.number ) { return null; }
+        const lineFoldEnd = doc.line(i);
+        return { from: lineFrom.from+6, to: lineFoldEnd.to };
+    }
+    reFoldable = /^ {4}- \S/;
+    reFoldCandidates = new RegExp(`^(?: {2})+${[
+        'initiatorDomains',
+        'excludedInitiatorDomains',
+        'requestDomains',
+        'excludedRequestDomains',
+    ].join('|')}:$`);
+
+    streamParserKeywords = new RegExp(`\\b(${[
+        'block',
+        'redirect',
+        'allow',
+        'modifyHeaders',
+        'upgradeScheme',
+        'allowAllRequest',
+        'append',
+        'set',
+        'remove',
+        'firstParty',
+        'thirdParty',
+        'true',
+        'false',
+        'connect',
+        'delete',
+        'get',
+        'head',
+        'options',
+        'patch',
+        'post',
+        'put',
+        'other',
+        'main_frame',
+        'sub_frame',
+        'stylesheet',
+        'script',
+        'image',
+        'font',
+        'object',
+        'xmlhttprequest',
+        'ping',
+        'csp_report',
+        'media',
+        'websocket',
+        'webtransport',
+        'webbundle',
+        'other',
+    ].join('|')})\\b`);
+};

package/extensions/ublocklite/js/dnr-parser.js

@@ -94,9 +94,15 @@ const perScopeParsers = {
             rule[key] = {};
             scope.push(key);
             break;
+        case 'id': {
+            const n = parseInt(val, 10);
+            if ( isNaN(n) || n < 1) { return false; }
+            rule.id = n;
+            break;
+        }
         case 'priority': {
             const n = parseInt(val, 10);
-            if ( isNaN(n) || n <= 1 ) { return false; }
+            if ( isNaN(n) || n < 1 ) { return false; }
             rule.priority = n;
             break;
         }
@@ -283,6 +289,10 @@ const perScopeParsers = {
             rule.condition[key] = [];
             scope.push(key);
             break;
+        case 'tabIds':
+            rule.condition.tabIds = [];
+            scope.push('tabIds');
+            break;
         default:
             return false;
         }
@@ -412,6 +422,12 @@ const perScopeParsers = {
         item.excludedValues.push(node.val);
         return true;
     },
+    'condition.tabIds': function(scope, rule, node) {
+        if ( node.list !== true ) { return false; }
+        const n = parseInt(node.val, 10);
+        if ( isNaN(n) || n === 0 ) { return false; }
+        rule.condition.tabIds.push(n);
+    },
 };
 
 /******************************************************************************/
@@ -479,16 +495,17 @@ export function rulesFromText(text) {
     const indices = [];
     for ( let i = 0; i < lines.length; i++ ) {
         const line = lines[i].trimEnd();
-        const trimmed = line.trimStart();
-        if ( trimmed.startsWith('#') ) { continue; }
-        // Discard leading empty lines
-        if ( trimmed === '' ) {
-            if ( indices.length === 0 ) { continue; }
-        }
+        if ( line.trim().startsWith('#') ) { continue; }
         if ( line !== '---' && line !== '...' ) {
             indices.push(i);
             continue;
         }
+        // Discard leading empty lines
+        while ( indices.length !== 0 ) {
+            const s = lines[indices[0]].trim();
+            if ( s.length !== 0 ) { break; }
+            indices.shift();
+        }
         // Discard trailing empty lines
         while ( indices.length !== 0 ) {
             const s = lines[indices.at(-1)].trim();
@@ -544,18 +561,21 @@ function textFromValue(val, depth) {
 
 /******************************************************************************/
 
-export function textFromRules(rules) {
+export function textFromRules(rules, option = {}) {
     if ( Array.isArray(rules) === false ) {
         if ( rules instanceof Object === false ) { return; }
         rules = [ rules ];
     }
     const out = [];
     for ( const rule of rules ) {
-        if ( rule.id ) { rule.id = undefined };
+        if ( option.keepId !== true && rule.id ) { rule.id = undefined };
         const text = textFromValue(rule, 0);
         if ( text === undefined ) { continue; }
         out.push(text, '---' );
     }
-    out.push('');
+    if ( out.length !== 0 ) {
+        out.unshift('---');
+        out.push('');
+    }
     return out.join('\n');
 }

package/extensions/ublocklite/js/i18n.js

@@ -263,6 +263,11 @@ if ( isBackgroundProcess !== true ) {
                 elem.setAttribute('aria-label', text);
             }
         }
+
+        for ( const elem of root.querySelectorAll('[data-i18n-label]') ) {
+            const text = i18n$(elem.getAttribute('data-i18n-label'));
+            elem.setAttribute('label', text);
+        }
     };
 
     i18n.renderElapsedTimeToString = function(tstamp) {

package/extensions/ublocklite/js/mode-editor.js

@@ -0,0 +1,87 @@
+/*******************************************************************************
+
+    uBlock Origin Lite - a comprehensive, MV3-compliant content blocker
+    Copyright (C) 2014-present Raymond Hill
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see {http://www.gnu.org/licenses/}.
+
+    Home: https://github.com/gorhill/uBlock
+*/
+
+import {
+    modesFromText,
+    textFromModes,
+} from './mode-parser.js';
+import { i18n$ } from './i18n.js';
+import { sendMessage } from './ext.js';
+
+/******************************************************************************/
+
+export class ModeEditor {
+    constructor(editor) {
+        this.editor = editor;
+        this.bc = null;
+    }
+
+    on() {
+        if ( this.bc !== null ) { return; }
+        this.bc = new self.BroadcastChannel('uBOL');
+        this.bc.onmessage = ev => {
+            const message = ev.data;
+            if ( message instanceof Object === false ) { return; }
+            if ( message.filteringModeDetails === undefined ) { return; }
+            // TODO: merge with ongoing edits?
+            const text = textFromModes(message.filteringModeDetails);
+            this.editor.setEditorText(text, true);
+        };
+    }
+
+    off() {
+        if ( this.bc === null ) { return; }
+        this.bc.onmessage = null;
+        this.bc = null;
+    }
+
+    async getText() {
+        const modes = await sendMessage({ what: 'getFilteringModeDetails' });
+        return textFromModes(modes);
+    }
+
+    async saveEditorText(editor) {
+        const { modes } = modesFromText(editor.getEditorText());
+        if ( modes instanceof Object === false ) { return; }
+        const modesAfter = await sendMessage({ what: 'setFilteringModeDetails', modes });
+        const text = textFromModes(modesAfter);
+        editor.setEditorText(text);
+        return true;
+    }
+
+    updateView(editor, firstLine, lastLine) {
+        const { doc } = editor.view.state;
+        const text = doc.sliceString(firstLine.from, lastLine.to);
+        const { bad } = modesFromText(text, true);
+        if ( Array.isArray(bad) && bad.length !== 0 ) {
+            self.cm6.lineErrorAdd(editor.view, bad.map(i => i + firstLine.number));
+        }
+    }
+
+    sequenceScopes = [
+        `${i18n$('filteringMode0Name')}:`, 'none:',
+        `${i18n$('filteringMode1Name')}:`, 'basic:',
+        `${i18n$('filteringMode2Name')}:`, 'optimal:',
+        `${i18n$('filteringMode3Name')}:`, 'complete:',
+    ];
+
+    ioAccept = '.json,application/json';
+};

package/extensions/ublocklite/js/mode-manager.js

@@ -225,7 +225,7 @@ export async function readFilteringModeDetails(bypassCache = false) {
         }
     }
     let [
-        userModes,
+        userModes = { optimal: [ 'all-urls' ] },
         adminDefaultFiltering,
         adminNoFiltering,
     ] = await Promise.all([
@@ -233,9 +233,6 @@ export async function readFilteringModeDetails(bypassCache = false) {
         adminReadEx('defaultFiltering'),
         adminReadEx('noFiltering'),
     ]);
-    if ( userModes === undefined ) {
-        userModes = { optimal: [ 'all-urls' ] };
-    }
     userModes = unserializeModeDetails(userModes);
     if ( adminDefaultFiltering !== undefined ) {
         const modefromName = {
@@ -277,29 +274,34 @@ async function writeFilteringModeDetails(afterDetails) {
     readFilteringModeDetails.cache = unserializeModeDetails(data);
     return Promise.all([
         getDefaultFilteringMode(),
-        getTrustedSites(),
         hasBroadHostPermissions(),
         localWrite('filteringModeDetails', data),
         sessionWrite('filteringModeDetails', data),
     ]).then(results => {
         broadcastMessage({
             defaultFilteringMode: results[0],
-            trustedSites: Array.from(results[1]),
-            hasOmnipotence: results[2],
+            hasOmnipotence: results[1],
+            filteringModeDetails: readFilteringModeDetails.cache,
         });
     });
 }
 
 /******************************************************************************/
 
-export async function getFilteringModeDetails() {
+export async function getFilteringModeDetails(serializable = false) {
     const actualDetails = await readFilteringModeDetails();
-    return {
+    const out = {
         none: new Set(actualDetails.none),
         basic: new Set(actualDetails.basic),
         optimal: new Set(actualDetails.optimal),
         complete: new Set(actualDetails.complete),
     };
+    return serializable ? serializeModeDetails(out) : out;
+}
+
+export async function setFilteringModeDetails(details) {
+    await localWrite('filteringModeDetails', serializeModeDetails(details));
+    await readFilteringModeDetails(true);
 }
 
 /******************************************************************************/
@@ -328,45 +330,6 @@ export function setDefaultFilteringMode(afterLevel) {
 
 /******************************************************************************/
 
-export async function getTrustedSites() {
-    const filteringModes = await getFilteringModeDetails();
-    return filteringModes.none;
-}
-
-export async function setTrustedSites(hostnames) {
-    const [
-        filteringModes,
-        hasOmnipotence,
-    ] = await Promise.all([
-        getFilteringModeDetails(),
-        hasBroadHostPermissions(),
-    ]);
-    const { none } = filteringModes;
-    const hnSet = new Set(hostnames);
-    let modified = false;
-    if ( none.has('all-urls') && hnSet.has('all-urls') === false ) {
-        applyFilteringMode(filteringModes, 'all-urls', hasOmnipotence ? MODE_OPTIMAL : MODE_BASIC);
-        modified = true;
-    }
-    for ( const hn of none ) {
-        if ( hnSet.has(hn) ) {
-            hnSet.delete(hn);
-        } else {
-            none.delete(hn);
-            modified = true;
-        }
-    }
-    for ( const hn of hnSet ) {
-        const level = applyFilteringMode(filteringModes, hn, MODE_NONE);
-        if ( level !== MODE_NONE ) { continue; }
-        modified = true;
-    }
-    if ( modified === false ) { return; }
-    return writeFilteringModeDetails(filteringModes);
-}
-
-/******************************************************************************/
-
 export async function syncWithBrowserPermissions() {
     const [
         permissions,

package/extensions/ublocklite/js/mode-parser.js

@@ -0,0 +1,211 @@
+/*******************************************************************************
+
+    uBlock Origin Lite - a comprehensive, MV3-compliant content blocker
+    Copyright (C) 2014-present Raymond Hill
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see {http://www.gnu.org/licenses/}.
+
+    Home: https://github.com/gorhill/uBlock
+*/
+
+import { i18n$ } from './i18n.js';
+import punycode from './punycode.js';
+
+/******************************************************************************/
+
+function selectParser(scope, modes, node) {
+    const parser = perScopeParsers[scope.join('.')];
+    if ( parser === undefined ) { return false; }
+    return parser(scope, modes, node);
+}
+
+const validModes = [
+    'none',
+    'basic',
+    'optimal',
+    'complete',
+];
+
+const uglyModeNames = {
+    [i18n$('filteringMode0Name')]: 'none',
+    [i18n$('filteringMode1Name')]: 'basic',
+    [i18n$('filteringMode2Name')]: 'optimal',
+    [i18n$('filteringMode3Name')]: 'complete',
+};
+
+const prettyModeNames = {
+    none: i18n$('filteringMode0Name'),
+    basic: i18n$('filteringMode1Name'),
+    optimal: i18n$('filteringMode2Name'),
+    complete: i18n$('filteringMode3Name'),
+};
+
+const perScopeParsers = {
+    '': function(scope, modes, node) {
+        const { key, val } = node;
+        switch ( key ) {
+        case 'none':
+        case 'basic':
+        case 'optimal':
+        case 'complete':
+        case prettyModeNames.none:
+        case prettyModeNames.basic:
+        case prettyModeNames.optimal:
+        case prettyModeNames.complete: {
+            const mode = uglyModeNames[key] || key;
+            if ( val !== undefined ) { return false; }
+            modes[mode] ||= [];
+            scope.push(mode);
+            break;
+        }
+        default:
+            return false;
+        }
+        return true;
+    },
+    none: function(scope, modes, node) {
+        return addHostnameToMode(modes, 'none', node)
+    },
+    basic: function(scope, modes, node) {
+        return addHostnameToMode(modes, 'basic', node)
+    },
+    optimal: function(scope, modes, node) {
+        return addHostnameToMode(modes, 'optimal', node)
+    },
+    complete: function(scope, modes, node) {
+        return addHostnameToMode(modes, 'complete', node)
+    },
+};
+
+const addHostnameToMode = (modes, mode, node) => {
+    if ( node.list !== true ) { return false; }
+    modes[mode].push(punycode.toASCII(node.val));
+};
+
+/******************************************************************************/
+
+function depthFromIndent(line) {
+    const match = /^\s*/.exec(line);
+    const count = match[0].length;
+    if ( (count & 1) !== 0 ) { return -1; }
+    return count / 2;
+}
+
+/******************************************************************************/
+
+function nodeFromLine(line) {
+    const match = reNodeParser.exec(line);
+    const out = {};
+    if ( match === null ) { return out; }
+    if ( match[1] ) {
+        out.list = true;
+    }
+    if ( match[4] ) {
+        out.val = match[4].trim();
+    } else if ( match[3] ) {
+        out.key = match[2];
+        out.val = match[3].trim();
+        if ( out.val === "''" ) { out.val = '' };
+    } else {
+        out.key = match[2];
+    }
+    return out;
+}
+
+const reNodeParser = /^\s*(- )?(?:([^:]+):( \S.*)?|(\S.*))$/;
+
+/******************************************************************************/
+
+export function modesFromText(text, justbad = false) {
+    const lines = [ ...text.split(/\n\r|\r\n|\n|\r/) ];
+    const indices = [];
+    for ( let i = 0; i < lines.length; i++ ) {
+        const line = lines[i].trimEnd();
+        if ( line.trim().startsWith('#') ) { continue; }
+        indices.push(i);
+    }
+    // Discard leading empty lines
+    while ( indices.length !== 0 ) {
+        const s = lines[indices[0]].trim();
+        if ( s.length !== 0 ) { break; }
+        indices.shift();
+    }
+    // Discard trailing empty lines
+    while ( indices.length !== 0 ) {
+        const s = lines[indices.at(-1)].trim();
+        if ( s.length !== 0 ) { break; }
+        indices.pop();
+    }
+    // Parse
+    const modes = {};
+    const bad = [];
+    const scope = [];
+    for ( const i of indices ) {
+        const line = lines[i];
+        const depth = depthFromIndent(line);
+        if ( depth < 0 ) {
+            bad.push(i);
+            continue;
+        }
+        scope.length = depth;
+        const node = nodeFromLine(line);
+        const result = selectParser(scope, modes, node);
+        if ( result === false ) {
+            bad.push(i);
+        }
+    }
+    if ( justbad ) {
+        return bad.length !== 0 ? { bad } : { };
+    }
+    // Ensure all modes are present, and that one mode is the default one
+    const seen = new Map();
+    let defaultMode = '';
+    for ( const mode of validModes ) {
+        modes[mode] = new Set(modes[mode]);
+        if ( modes[mode].has('all-urls') ) {
+            defaultMode = mode;
+        }
+        for ( const hn of modes[mode] ) {
+            if ( seen.has(hn) ) {
+                modes[seen.get(hn)].delete(hn);
+            }
+            seen.set(hn, mode);
+        }
+    }
+    if ( defaultMode === '' ) {
+        defaultMode = 'optimal';
+    }
+    modes[defaultMode].clear();
+    modes[defaultMode].add('all-urls');
+    for ( const mode of validModes ) {
+        modes[mode] = Array.from(modes[mode]);
+    }
+    return { modes };
+}
+
+/******************************************************************************/
+
+export function textFromModes(modes) {
+    const out = [];
+    for ( const mode of validModes ) {
+        const hostnames = modes[mode];
+        if ( hostnames === undefined ) { continue; }
+        out.push(`${prettyModeNames[mode]}:`);
+        for ( const hn of hostnames ) {
+            out.push(`  - ${punycode.toUnicode(hn)}`);
+        }
+    }
+    out.push('');
+    return out.join('\n');
+}