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

package/build/routes/management/tests/management.spec.js

@@ -67,6 +67,20 @@ describe('Management APIs', function () {
             expect(r.status).to.equal(204);
             expect(r.headers.get('access-control-allow-origin')).to.equal('https://abc.example.com');
         });
+        it('allows glob-matched OPTIONS requests with OR patterns across two domains', async () => {
+            const config = new Config();
+            config.enableCORS(true);
+            config.setCORSOrigin('(https://(abc|xyz).example.com|https://deploy-preview-*.netlify.app)');
+            await start({ config });
+            const r = await fetch('http://localhost:3000/config?token=6R0W53R135510', {
+                method: 'OPTIONS',
+                headers: {
+                    Origin: 'https://deploy-preview-123--funky-monkey-12345.netlify.app',
+                },
+            });
+            expect(r.status).to.equal(204);
+            expect(r.headers.get('access-control-allow-origin')).to.equal('https://deploy-preview-123--funky-monkey-12345.netlify.app');
+        });
         it('should 404 when the origin does not match the CORS origin pattern', async () => {
             const config = new Config();
             config.enableCORS(true);

package/build/server.js

@@ -1,8 +1,7 @@
 import * as http from 'http';
 import { BadRequest, Logger as BlessLogger, NotFound, Timeout, TooManyRequests, Unauthorized, contentTypes, convertPathToURL, isMatch, queryParamsToObject, readBody, shimLegacyRequests, writeResponse, } from '@browserless.io/browserless';
 import { EventEmitter } from 'events';
-// @ts-ignore
-import Enjoi from 'enjoi';
+import EnjoiResolver from './shared/utils/enjoi-resolver.js';
 export class HTTPServer extends EventEmitter {
     config;
     metrics;
@@ -136,7 +135,7 @@ export class HTTPServer extends EventEmitter {
         if (route.querySchema) {
             this.logger.trace(`Validating route query-params with QUERY schema`);
             try {
-                const schema = Enjoi.schema(route.querySchema);
+                const schema = EnjoiResolver.schema(route.querySchema);
                 const valid = schema.validate(req.queryParams, {
                     abortEarly: false,
                 });
@@ -158,7 +157,7 @@ export class HTTPServer extends EventEmitter {
         if (route.bodySchema) {
             this.logger.trace(`Validating route payload with BODY schema`);
             try {
-                const schema = Enjoi.schema(route.bodySchema);
+                const schema = EnjoiResolver.schema(route.bodySchema);
                 const valid = schema.validate(body, { abortEarly: false });
                 if (valid.error) {
                     const errorDetails = valid.error.details
@@ -204,7 +203,7 @@ export class HTTPServer extends EventEmitter {
             if (route.querySchema) {
                 this.logger.trace(`Validating route query-params with QUERY schema`);
                 try {
-                    const schema = Enjoi.schema(route.querySchema);
+                    const schema = EnjoiResolver.schema(route.querySchema);
                     const valid = schema.validate(req.queryParams, {
                         abortEarly: false,
                     });

package/build/shared/utils/enjoi-resolver.d.ts

@@ -0,0 +1,77 @@
+interface SchemaResolverOptions {
+    subSchemas?: Record<string, any>;
+    refineType?: (type: string, format?: string) => string;
+    refineSchema?: (joiSchema: any, jsonSchema: any) => any;
+    strictMode?: boolean;
+    useDefaults?: boolean;
+    extensions?: any[];
+}
+interface JSONSchema {
+    type?: string | string[];
+    $ref?: string;
+    properties?: Record<string, any>;
+    format?: string;
+    enum?: any[];
+    anyOf?: any[];
+    allOf?: any[];
+    oneOf?: any[];
+    not?: any;
+    default?: any;
+    required?: string[];
+    additionalProperties?: boolean | any;
+    minProperties?: number;
+    maxProperties?: number;
+    items?: any;
+    ordered?: any;
+    additionalItems?: boolean;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    multipleOf?: number;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    [key: string]: any;
+}
+declare class SchemaResolver {
+    private root;
+    private subSchemas?;
+    private refineType?;
+    private refineSchema?;
+    private strictMode?;
+    private walkedSchemas;
+    private useDefaults?;
+    private joi;
+    constructor(root: any, { subSchemas, refineType, refineSchema, strictMode, useDefaults, extensions, }?: SchemaResolverOptions);
+    resolve(schema?: any, ancestors?: string[]): any;
+    resolveReference(value: string): any;
+    resolveType(schema: JSONSchema, ancestors: string[]): any;
+    resolveOneOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveAnyOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveAllOf(schema: JSONSchema, ancestors: string[]): any;
+    resolveNot(schema: JSONSchema, ancestors: string[]): any;
+    resolveLink(schema: any): any;
+    object(schema: JSONSchema, ancestors: string[]): any;
+    array(schema: JSONSchema, ancestors: string[]): any;
+    number(schema: JSONSchema): any;
+    string(schema: JSONSchema): any;
+    regularString(schema: JSONSchema, joischema: any): any;
+    binary(schema: JSONSchema): any;
+}
+/**
+ * Enjoi-compatible API
+ * Creates a Joi schema from a JSON Schema
+ * @param jsonSchema - The JSON schema to convert
+ * @param options - Optional configuration for schema resolution
+ * @returns Joi schema with validate method
+ */
+declare function schema(jsonSchema: any, options?: SchemaResolverOptions): any;
+export { SchemaResolver, schema };
+declare const _default: {
+    schema: typeof schema;
+};
+export default _default;

package/build/shared/utils/enjoi-resolver.js

@@ -0,0 +1,399 @@
+/* global WeakMap */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import * as Bourne from '@hapi/bourne';
+import * as Hoek from '@hapi/hoek';
+import Joi from 'joi';
+// Modern replacements for deprecated Node.js util functions
+const isArray = Array.isArray;
+const isObject = (value) => value && typeof value === 'object' && value.constructor === Object;
+const isNumber = (value) => typeof value === 'number';
+const isUndefined = (value) => value === undefined;
+function randomString(length) {
+    return Math.round(Math.pow(36, length + 1) - Math.random() * Math.pow(36, length))
+        .toString(36)
+        .slice(1);
+}
+class SchemaResolver {
+    root;
+    subSchemas;
+    refineType;
+    refineSchema;
+    strictMode;
+    walkedSchemas;
+    useDefaults;
+    joi;
+    constructor(root, { subSchemas, refineType, refineSchema, strictMode, useDefaults, extensions = [], } = {}) {
+        this.root = root;
+        this.subSchemas = subSchemas;
+        this.refineType = refineType;
+        this.refineSchema = refineSchema;
+        this.strictMode = strictMode;
+        this.walkedSchemas = new WeakMap(); // map of schemas iterated thus far to the generated id they were given
+        this.useDefaults = useDefaults;
+        this.joi = Joi.extend({
+            type: 'object',
+            base: Joi.object(),
+            coerce: {
+                from: 'string',
+                // @ts-ignore - Type compatibility issue with Joi coerce method
+                method(value) {
+                    if (typeof value !== 'string' ||
+                        (value[0] !== '{' && !/^\s*\{/.test(value))) {
+                        return;
+                    }
+                    try {
+                        return { value: Bourne.parse(value) };
+                    }
+                    catch (_) {
+                        return;
+                    } // eslint-disable-line no-empty
+                },
+            },
+        }, {
+            type: 'array',
+            base: Joi.array(),
+            coerce: {
+                from: 'string',
+                method(value) {
+                    if (typeof value !== 'string' ||
+                        (value[0] !== '[' && !/^\s*\[/.test(value))) {
+                        return;
+                    }
+                    try {
+                        return { value: Bourne.parse(value) };
+                    }
+                    catch (_) {
+                        return;
+                    } // eslint-disable-line no-empty
+                },
+            },
+        }, ...extensions);
+    }
+    resolve(schema = this.root, ancestors = []) {
+        let resolvedSchema;
+        let generatedId = this.walkedSchemas.get(schema);
+        if (generatedId && ancestors.lastIndexOf(generatedId) > -1) {
+            // resolve cyclic schema by using joi reference via generated unique ids
+            return this.resolveLink(schema);
+        }
+        else if (typeof schema === 'object') {
+            generatedId = randomString(10);
+            this.walkedSchemas.set(schema, generatedId);
+        }
+        if (typeof schema === 'string') {
+            // If schema is itself a string, interpret it as a type
+            resolvedSchema = this.resolveType({ type: schema }, ancestors);
+        }
+        else if (schema.$ref) {
+            resolvedSchema = this.resolve(this.resolveReference(schema.$ref), ancestors.concat(generatedId || ''));
+        }
+        else {
+            const partialSchemas = [];
+            if (schema.type) {
+                partialSchemas.push(this.resolveType(schema, ancestors.concat(generatedId || '')));
+            }
+            else if (schema.properties) {
+                // if no type is specified, just properties
+                partialSchemas.push(this.object(schema, ancestors.concat(generatedId || '')));
+            }
+            else if (schema.format) {
+                // if no type is specified, just format
+                partialSchemas.push(this.string(schema));
+            }
+            else if (schema.enum) {
+                // If no type is specified, just enum
+                partialSchemas.push(this.joi.any().valid(...schema.enum));
+            }
+            if (schema.anyOf) {
+                partialSchemas.push(this.resolveAnyOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.allOf) {
+                partialSchemas.push(this.resolveAllOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.oneOf) {
+                partialSchemas.push(this.resolveOneOf(schema, ancestors.concat(generatedId || '')));
+            }
+            if (schema.not) {
+                partialSchemas.push(this.resolveNot(schema, ancestors.concat(generatedId || '')));
+            }
+            if (partialSchemas.length === 0) {
+                //Fall through to whatever.
+                //eslint-disable-next-line no-console
+                console.warn("WARNING: schema missing a 'type' or '$ref' or 'enum': \n%s", JSON.stringify(schema, null, 2));
+                //TODO: Handle better
+                partialSchemas.push(this.joi.any());
+            }
+            resolvedSchema =
+                partialSchemas.length === 1
+                    ? partialSchemas[0]
+                    : this.joi.alternatives(partialSchemas).match('all');
+        }
+        if (generatedId) {
+            // we have finished resolving the schema, now attach the id generated earlier
+            resolvedSchema = resolvedSchema.id(this.walkedSchemas.get(schema));
+        }
+        if (this.refineSchema) {
+            resolvedSchema = this.refineSchema(resolvedSchema, schema);
+        }
+        if (this.useDefaults && schema.default !== undefined) {
+            resolvedSchema = resolvedSchema.default(schema.default);
+        }
+        return resolvedSchema;
+    }
+    resolveReference(value) {
+        let refschema;
+        const id = value.substr(0, value.indexOf('#') + 1);
+        const path = value.substr(value.indexOf('#') + 1);
+        if (id && this.subSchemas) {
+            refschema =
+                this.subSchemas[id] || this.subSchemas[id.substr(0, id.length - 1)];
+        }
+        if (!refschema) {
+            refschema = this.root;
+        }
+        Hoek.assert(refschema, 'Can not find schema reference: ' + value + '.');
+        let fragment = refschema;
+        const paths = path.split('/');
+        for (let i = 1; i < paths.length && fragment; i++) {
+            fragment = typeof fragment === 'object' && fragment[paths[i]];
+        }
+        return fragment;
+    }
+    resolveType(schema, ancestors) {
+        let joischema;
+        const typeDefinitionMap = {
+            description: 'description',
+            title: 'label',
+            default: 'default',
+        };
+        const joitype = (type, format) => {
+            let joischema;
+            if (this.refineType) {
+                type = this.refineType(type, format);
+            }
+            switch (type) {
+                case 'array':
+                    joischema = this.array(schema, ancestors);
+                    break;
+                case 'boolean':
+                    joischema = this.joi.boolean();
+                    break;
+                case 'integer':
+                case 'number':
+                    joischema = this.number(schema);
+                    break;
+                case 'object':
+                    joischema = this.object(schema, ancestors);
+                    break;
+                case 'string':
+                    joischema = this.string(schema);
+                    break;
+                case 'null':
+                    joischema = this.joi.any().valid(null);
+                    break;
+                default:
+                    joischema = this.joi.types()[type];
+            }
+            Hoek.assert(joischema, 'Could not resolve type: ' + schema.type + '.');
+            return this.strictMode === true ? joischema.strict(true) : joischema;
+        };
+        if (isArray(schema.type)) {
+            const schemas = [];
+            for (let i = 0; i < schema.type.length; i++) {
+                schemas.push(joitype(schema.type[i], schema.format));
+            }
+            joischema = this.joi.alternatives(schemas);
+        }
+        else {
+            joischema = joitype(schema.type, schema.format);
+        }
+        Object.keys(typeDefinitionMap).forEach((key) => {
+            if (schema[key] !== undefined) {
+                joischema = joischema[typeDefinitionMap[key]](schema[key]);
+            }
+        });
+        return joischema;
+    }
+    resolveOneOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.oneOf), 'Expected oneOf to be an array.');
+        return this.joi
+            .alternatives(schema.oneOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('one');
+    }
+    resolveAnyOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.anyOf), 'Expected anyOf to be an array.');
+        return this.joi
+            .alternatives(schema.anyOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('any');
+    }
+    resolveAllOf(schema, ancestors) {
+        Hoek.assert(isArray(schema.allOf), 'Expected allOf to be an array.');
+        return this.joi
+            .alternatives(schema.allOf.map((subSchema) => this.resolve(subSchema, ancestors)))
+            .match('all');
+    }
+    resolveNot(schema, ancestors) {
+        Hoek.assert(isObject(schema.not), 'Expected Not to be an object.');
+        return this.joi.alternatives().conditional('.', {
+            not: this.resolve(schema.not, ancestors),
+            then: this.joi.any(),
+            otherwise: this.joi.any().forbidden(),
+        });
+    }
+    resolveLink(schema) {
+        return this.joi.link().ref(`#${this.walkedSchemas.get(schema)}`);
+    }
+    object(schema, ancestors) {
+        const resolveproperties = () => {
+            const schemas = {};
+            if (!isObject(schema.properties)) {
+                return;
+            }
+            Object.keys(schema.properties).forEach((key) => {
+                const property = schema.properties[key];
+                let joischema = this.resolve(property, ancestors);
+                if (schema.required && schema.required.indexOf(key) !== -1) {
+                    joischema = joischema.required();
+                }
+                schemas[key] = joischema;
+            });
+            return schemas;
+        };
+        let joischema = this.joi.object(resolveproperties());
+        if (isObject(schema.additionalProperties)) {
+            joischema = joischema.pattern(/^/, this.resolve(schema.additionalProperties, ancestors));
+        }
+        else {
+            joischema = joischema.unknown(schema.additionalProperties !== false);
+        }
+        isNumber(schema.minProperties) &&
+            (joischema = joischema.min(schema.minProperties));
+        isNumber(schema.maxProperties) &&
+            (joischema = joischema.max(schema.maxProperties));
+        return joischema;
+    }
+    array(schema, ancestors) {
+        let joischema = this.joi.array();
+        let items;
+        const resolveAsArray = (value) => {
+            if (isArray(value)) {
+                // found an array, thus its _per type_
+                return value.map((v) => this.resolve(v, ancestors));
+            }
+            // it's a single entity, so just resolve it normally
+            return [this.resolve(value, ancestors)];
+        };
+        if (schema.items) {
+            items = resolveAsArray(schema.items);
+            joischema = joischema.items(...items);
+        }
+        else if (schema.ordered) {
+            items = resolveAsArray(schema.ordered);
+            joischema = joischema.ordered(...items);
+        }
+        if (items && schema.additionalItems === false) {
+            joischema = joischema.max(items.length);
+        }
+        isNumber(schema.minItems) && (joischema = joischema.min(schema.minItems));
+        isNumber(schema.maxItems) && (joischema = joischema.max(schema.maxItems));
+        if (schema.uniqueItems) {
+            joischema = joischema.unique();
+        }
+        return joischema;
+    }
+    number(schema) {
+        let joischema = this.joi.number();
+        if (schema.type === 'integer') {
+            joischema = joischema.integer();
+        }
+        isNumber(schema.minimum) && (joischema = joischema.min(schema.minimum));
+        isNumber(schema.maximum) && (joischema = joischema.max(schema.maximum));
+        isNumber(schema.exclusiveMinimum) &&
+            (joischema = joischema.greater(schema.exclusiveMinimum));
+        isNumber(schema.exclusiveMaximum) &&
+            (joischema = joischema.less(schema.exclusiveMaximum));
+        isNumber(schema.multipleOf) &&
+            schema.multipleOf !== 0 &&
+            (joischema = joischema.multiple(schema.multipleOf));
+        return joischema;
+    }
+    string(schema) {
+        let joischema = this.joi.string();
+        const dateRegex = '(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])';
+        const timeRegex = '([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60)(.[0-9]+)?(Z|(\\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))';
+        const dateTimeRegex = dateRegex + 'T' + timeRegex;
+        if (schema.enum) {
+            return this.joi.string().valid(...schema.enum);
+        }
+        switch (schema.format) {
+            case 'date':
+                return joischema.regex(new RegExp('^' + dateRegex + '$', 'i'), 'JsonSchema date format');
+            case 'time':
+                return joischema.regex(new RegExp('^' + timeRegex + '$', 'i'), 'JsonSchema time format');
+            case 'date-time':
+                return joischema.regex(new RegExp('^' + dateTimeRegex + '$', 'i'), 'JsonSchema date-time format');
+            case 'binary':
+                joischema = this.binary(schema);
+                break;
+            case 'email':
+                return joischema.email();
+            case 'hostname':
+                return joischema.hostname();
+            case 'ipv4':
+                return joischema.ip({
+                    version: ['ipv4'],
+                });
+            case 'ipv6':
+                return joischema.ip({
+                    version: ['ipv6'],
+                });
+            case 'uri':
+                return joischema.uri();
+            case 'byte':
+                joischema = joischema.base64();
+                break;
+            case 'uuid':
+                return joischema.guid({ version: ['uuidv4'] });
+            case 'guid':
+                return joischema.guid();
+        }
+        return this.regularString(schema, joischema);
+    }
+    regularString(schema, joischema) {
+        schema.pattern && (joischema = joischema.regex(new RegExp(schema.pattern)));
+        if (isUndefined(schema.minLength)) {
+            schema.minLength = 0;
+            if (!schema.pattern && !schema.format) {
+                joischema = joischema.allow('');
+            }
+        }
+        else if (schema.minLength === 0) {
+            joischema = joischema.allow('');
+        }
+        isNumber(schema.minLength) && (joischema = joischema.min(schema.minLength));
+        isNumber(schema.maxLength) && (joischema = joischema.max(schema.maxLength));
+        return joischema;
+    }
+    binary(schema) {
+        let joischema = this.joi.binary();
+        isNumber(schema.minLength) && (joischema = joischema.min(schema.minLength));
+        isNumber(schema.maxLength) && (joischema = joischema.max(schema.maxLength));
+        return joischema;
+    }
+}
+/**
+ * Enjoi-compatible API
+ * Creates a Joi schema from a JSON Schema
+ * @param jsonSchema - The JSON schema to convert
+ * @param options - Optional configuration for schema resolution
+ * @returns Joi schema with validate method
+ */
+function schema(jsonSchema, options) {
+    const resolver = new SchemaResolver(jsonSchema, options);
+    return resolver.resolve();
+}
+// Export both the class and the compatible API
+export { SchemaResolver, schema };
+export default { schema };

package/docker/base/Dockerfile

@@ -6,7 +6,7 @@ ARG DEBIAN_FRONTEND=noninteractive
 ARG TZ=America/Los_Angeles
 ARG BLESS_USER_ID=999
 ARG APP_DIR=/usr/src/app
-ARG NODE_VERSION=v22.11.0
+ARG NODE_VERSION=v24.2.0
 
 ENV NODE_VERSION=$NODE_VERSION
 ENV NVM_DIR /usr/src/.nvm
@@ -54,7 +54,7 @@ RUN apt-get update && apt-get install -y \
   wget \
   xvfb
 
-RUN curl -sL https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.3/install.sh | bash &&\
+RUN curl -sL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash &&\
   . $NVM_DIR/nvm.sh &&\
   nvm install $NODE_VERSION
 

package/extensions/ublocklite/README.md

@@ -7,8 +7,10 @@ The following assumes a linux environment.
 1. Open Bash console
 2. `git clone  https://github.com/gorhill/uBlock.git`
 3. `cd uBlock`
-4. `make mv3-[platform]`, where `[platform]` is either `chromium`, `edge`, `firefox`, or `safari`
-5. This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
+4. `git submodule init`
+5. `git submodule update`
+6. `make mv3-[platform]`, where `[platform]` is either `chromium`, `edge`, `firefox`, or `safari`
+7. This will fully build uBO Lite, and during the process filter lists will be downloaded from their respective remote servers
 
 Upon completion of the script, the resulting extension package will become present in:
 

package/extensions/ublocklite/_locales/ar/messages.json

@@ -20,7 +20,7 @@
     "description": "appears as tab name in dashboard"
   },
   "developPageName": {
-    "message": "Develop",
+    "message": "تطوير",
     "description": "appears as tab name in dashboard. Inspired from 'Develop' menu in Safari, see https://developer.apple.com/documentation/safari-developer-tools/develop-menu"
   },
   "aboutPageName": {
@@ -240,11 +240,11 @@
     "description": "Short description for a checkbox in the options page"
   },
   "developerModeLabel": {
-    "message": "Developer mode",
+    "message": "وضع المطور",
     "description": "Label for a checkbox in the options page"
   },
   "developerModeLegend": {
-    "message": "Enables access to features suitable for technical users.",
+    "message": "يمكن الوصول إلى الميزات المناسبة للمستخدمين التقنيين.",
     "description": "Short description for a checkbox in the options page"
   },
   "findListsPlaceholder": {
@@ -288,35 +288,59 @@
     "description": "A button to navigate to the blocked page"
   },
   "zapperTipEnter": {
-    "message": "Enter element zapper mode",
+    "message": "دخول وضع تحديد العناصر السريع",
     "description": "Tooltip for the button used to enter zapper mode"
   },
   "zapperTipQuit": {
-    "message": "Exit element zapper mode",
+    "message": "الخروج من وضع تحديد العناصر السريع",
     "description": "Tooltip for the button used to exit zapper mode"
   },
+  "developDropdownLabel": {
+    "message": "View:",
+    "description": "A label of a dropdown list"
+  },
+  "developOptionFilteringModeDetails": {
+    "message": "Filtering mode details",
+    "description": "An option in a dropdown list"
+  },
+  "developOptionCustomDnrRules": {
+    "message": "قواعد DNR مخصصة",
+    "description": "An option in a dropdown list"
+  },
+  "developOptionDnrRulesOf": {
+    "message": "قواعد DNR لـ …",
+    "description": "A section header in a dropdown list"
+  },
+  "developOptionDynamicRuleset": {
+    "message": "مجموعة قواعد متغيرة",
+    "description": "An option in a dropdown list"
+  },
+  "developOptionSessionRuleset": {
+    "message": "مجموعة قواعد جَلسة",
+    "description": "An option in a dropdown list"
+  },
   "saveButton": {
     "message": "حفظ",
     "description": "Text for buttons used to save changes"
   },
   "revertButton": {
-    "message": "Revert",
+    "message": "إرجاع",
     "description": "Text for buttons used to revert changes"
   },
   "importAndAppendButton": {
-    "message": "Import and append…",
+    "message": "استيراد واضافة…",
     "description": "Text for buttons used to import and append content"
   },
   "exportButton": {
     "message": "تصدير...",
     "description": "Text for buttons used to export content"
   },
-  "dnrRulesSummary": {
-    "message": "Enter your own DNR rules below. <b>Do not add content from untrusted sources.</b>",
+  "dnrRulesWarning": {
+    "message": "لا تضف محتوى من مصادر غير موثوقة",
     "description": "Short description of the DNR rules editor pane"
   },
   "dnrRulesCountInfo": {
-    "message": "Number of registered rules: {count}",
+    "message": "عدد القواعد المسجلة: {count}",
     "description": "Short sentence to report the number of currently registered DNR rules"
   }
 }