@adguard/filters-compiler 3.0.2 → 3.1.1

package/dist/index.js

@@ -1,9 +1,12 @@
-import path from 'path';
+import path$1 from 'path';
 import { RuleFactory, CosmeticRule, NetworkRule, setConfiguration, CompatibilityTypes } from '@adguard/tsurlfilter';
-import fs from 'fs';
+import fs$1 from 'fs';
 import md5 from 'md5';
 import { FiltersDownloader } from '@adguard/filters-downloader';
 import { RuleParser, RuleConverter, RuleGenerator, CosmeticRuleType, CommentParser, RuleCategory, RegExpUtils, ADG_SCRIPTLET_MASK } from '@adguard/agtree';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { Logger } from '@adguard/logger';
 import { defaultParserOptions } from '@adguard/agtree/parser';
 import { parse } from '@adguard/ecss-tree';
@@ -69,24 +72,103 @@ const version = {
 };
 
 /**
- * Export logger implementation.
+ * Extend logger implementation
  */
-const logger = new Logger(console);
+class CompilerLogger extends Logger {
+    /**
+     * File descriptor
+     *
+     * @type {number | null}
+     *
+     * @private
+     */
+    #fd = null;
 
-/**
- * Initializes logger
- *
- * @param path log file
- * @param level log lvl
- */
-logger.initialize = (path) => {
-    if (!path) {
-        /* eslint-disable-next-line no-console */
-        console.warn('Log file is not specified');
-        return;
+    /**
+     * Helper to append message to log file
+     *
+     * @param {string} message
+     * @param {'INFO'|'WARN'|'ERROR'} level
+     *
+     * @private
+     */
+    #append(message, level) {
+        if (this.#fd == null) {
+            return;
+        }
+
+        const line = `[${new Date().toLocaleTimeString()}] [${level}]: ${message}${os.EOL}`;
+
+        // Using appendFileSync with an fd ensures atomic append semantics.
+        fs.appendFileSync(this.#fd, line, 'utf8');
     }
-    fs.openSync(path, 'w');
-};
+
+    /** @inheritdoc */
+    info(message) {
+        super.info(message);
+        this.#append(message, 'INFO');
+    }
+
+    /** @inheritdoc */
+    error(message) {
+        super.error(message);
+        this.#append(message, 'ERROR');
+    }
+
+    /** @inheritdoc */
+    warn(message) {
+        super.warn(message);
+        this.#append(message, 'WARN');
+    }
+
+    /**
+     * Initializes logger
+     *
+     * @param {string} logFilePath - log file path
+     *
+     * The log file is opened with 'w' (truncate/create). Subsequent writes are appended.
+     */
+    initialize(logFilePath) {
+        if (!logFilePath) {
+            /* eslint-disable no-console */
+            console.warn('Log file is not specified');
+            return;
+        }
+
+        // Ensure the directory exists before creating the log file
+        const dir = path.dirname(logFilePath);
+        fs.mkdirSync(dir, { recursive: true });
+
+        // Close any previous descriptor to avoid leaks
+        if (this.#fd != null) {
+            try {
+                fs.closeSync(this.#fd);
+            } catch {
+                /* noop */
+            }
+            this.#fd = null;
+        }
+
+        // Open (truncate) now; we’ll append to the same fd later.
+        this.#fd = fs.openSync(logFilePath, 'w');
+        this.logFile = logFilePath;
+    }
+
+    /**
+     * Optional: call to close the file descriptor when done (e.g., on shutdown)
+     */
+    close() {
+        if (this.#fd != null) {
+            try {
+                fs.closeSync(this.#fd);
+            } finally {
+                this.#fd = null;
+            }
+        }
+    }
+}
+
+const logger = new CompilerLogger();
 
 // TODO: a lot of these masks can be imported from @adguard/agtree
 /**
@@ -154,7 +236,7 @@ const convertRulesToAdgSyntax = (rulesList, excluded) => {
             }
         } catch (e) {
             const message = `Unable to convert rule to AdGuard syntax: "${rule}" due to error: ${e.message}`;
-            logger.info(message);
+            logger.error(message);
             excludeRule$1(rule, excluded, message);
         }
     }
@@ -218,7 +300,7 @@ const convertToUbo = (rules) => {
                         // https://github.com/AdguardTeam/Scriptlets#trusted-scriptlets-restriction
                         // does not work in other blockers
                         const message = `Trusted scriptlets should not be converted to uBO syntax. Rule: "${rule}"`;
-                        logger.info(message);
+                        logger.warn(message);
                         modified.push('');
                         return;
                     }
@@ -228,7 +310,7 @@ const convertToUbo = (rules) => {
                 modified.push(...convertedRules);
             } catch (e) {
                 const message = `Unable to convert rule to Ubo syntax: "${rule}" due to error: ${e.message}`;
-                logger.info(message);
+                logger.error(message);
             }
         } else {
             modified.push('');
@@ -1254,7 +1336,7 @@ const cleanupAndOptimizeRules = function (rules, config, optimizationConfig, fil
 
 /* eslint-disable global-require */
 
-const __dirname$3 = path.dirname(new URL(import.meta.url).pathname);
+const __dirname$3 = path$1.dirname(new URL(import.meta.url).pathname);
 
 const RULES_SEPARATOR = '\r\n';
 let filterIdsPool = [];
@@ -1323,7 +1405,7 @@ let adguardFiltersServerUrl = null;
  */
 const readFile$2 = function (path) {
     try {
-        return fs.readFileSync(path, { encoding: 'utf-8' });
+        return fs$1.readFileSync(path, { encoding: 'utf-8' });
     } catch (e) {
         return null;
     }
@@ -1428,15 +1510,15 @@ const calculateChecksum = function (header, rules) {
  * @throws {Error} Throws an error if there is a permission issue or if the directory cannot be created.
  */
 const createDir = (dir) => {
-    const { sep } = path;
-    const initDir = path.isAbsolute(dir) ? sep : '';
+    const { sep } = path$1;
+    const initDir = path$1.isAbsolute(dir) ? sep : '';
     // eslint-disable-next-line no-undef
     const baseDir = __dirname$3;
 
     return dir.split(sep).reduce((parentDir, childDir) => {
-        const curDir = path.resolve(baseDir, parentDir, childDir);
+        const curDir = path$1.resolve(baseDir, parentDir, childDir);
         try {
-            fs.mkdirSync(curDir);
+            fs$1.mkdirSync(curDir);
         } catch (err) {
             if (err.code === 'EEXIST') { // curDir already exists!
                 return curDir;
@@ -1448,7 +1530,7 @@ const createDir = (dir) => {
             }
 
             const caughtErr = ['EACCES', 'EPERM', 'EISDIR'].indexOf(err.code) > -1;
-            if ((!caughtErr || caughtErr) && (curDir === path.resolve(dir))) {
+            if ((!caughtErr || caughtErr) && (curDir === path$1.resolve(dir))) {
                 throw err; // Throw if it's just the last created dir.
             }
         }
@@ -1707,12 +1789,12 @@ const loadLocales = function (dir) {
         filters: {},
     };
 
-    const locales = fs.readdirSync(dir);
+    const locales = fs$1.readdirSync(dir);
     // eslint-disable-next-line no-restricted-syntax
     for (const directory of locales) {
-        const localeDir = path.join(dir, directory);
-        if (fs.lstatSync(localeDir).isDirectory()) {
-            const groups = JSON.parse(readFile$2(path.join(localeDir, 'groups.json')));
+        const localeDir = path$1.join(dir, directory);
+        if (fs$1.lstatSync(localeDir).isDirectory()) {
+            const groups = JSON.parse(readFile$2(path$1.join(localeDir, 'groups.json')));
             if (groups) {
                 // eslint-disable-next-line no-restricted-syntax
                 for (const group of groups) {
@@ -1731,7 +1813,7 @@ const loadLocales = function (dir) {
                 }
             }
 
-            const tags = JSON.parse(readFile$2(path.join(localeDir, 'tags.json')));
+            const tags = JSON.parse(readFile$2(path$1.join(localeDir, 'tags.json')));
             if (tags) {
                 // eslint-disable-next-line no-restricted-syntax
                 for (const tag of tags) {
@@ -1750,7 +1832,7 @@ const loadLocales = function (dir) {
                 }
             }
 
-            const filters = JSON.parse(readFile$2(path.join(localeDir, 'filters.json')));
+            const filters = JSON.parse(readFile$2(path$1.join(localeDir, 'filters.json')));
             if (filters) {
                 // eslint-disable-next-line no-restricted-syntax
                 for (const filter of filters) {
@@ -1886,13 +1968,13 @@ const removeGroupDescriptions = (inputGroups) => {
 const writeFiltersMetadata = function (platformsPath, filtersDir, filtersMetadata, obsoleteFilters) {
     logger.info('Writing filters metadata');
 
-    const groups = JSON.parse(readFile$2(path.join(filtersDir, '../groups', 'metadata.json')));
+    const groups = JSON.parse(readFile$2(path$1.join(filtersDir, '../groups', 'metadata.json')));
     if (!groups) {
         logger.error('Error reading groups metadata');
         return;
     }
 
-    const tags = JSON.parse(readFile$2(path.join(filtersDir, '../tags', 'metadata.json')));
+    const tags = JSON.parse(readFile$2(path$1.join(filtersDir, '../tags', 'metadata.json')));
     if (!tags) {
         logger.error('Error reading tags metadata');
         return;
@@ -1902,17 +1984,17 @@ const writeFiltersMetadata = function (platformsPath, filtersDir, filtersMetadat
     const parsedLangTagsFiltersMetadata = processFiltersFromMetadata(filtersMetadata);
     const replacedTagKeywordsFiltersMetadata = replaceTagKeywords(parsedLangTagsFiltersMetadata, tags);
 
-    const localizations = loadLocales(path.join(filtersDir, '../locales'));
+    const localizations = loadLocales(path$1.join(filtersDir, '../locales'));
 
     // eslint-disable-next-line guard-for-in,no-restricted-syntax
     for (const platform in platformPathsConfig) {
         const config = platformPathsConfig[platform];
-        const platformDir = path.join(platformsPath, config.path);
+        const platformDir = path$1.join(platformsPath, config.path);
         createDir(platformDir);
 
         logger.info(`Writing filters metadata: ${config.path}`);
-        const filtersFileJson = path.join(platformDir, FILTERS_METADATA_FILE_JSON);
-        const filtersFileJs = path.join(platformDir, FILTERS_METADATA_FILE_JS);
+        const filtersFileJson = path$1.join(platformDir, FILTERS_METADATA_FILE_JSON);
+        const filtersFileJs = path$1.join(platformDir, FILTERS_METADATA_FILE_JS);
 
         const replacedExpiresFiltersMetadata = replaceExpires(replacedTagKeywordsFiltersMetadata, config.expires);
 
@@ -1936,12 +2018,12 @@ const writeFiltersMetadata = function (platformsPath, filtersDir, filtersMetadat
 
         const filtersContent = JSON.stringify(sortMetadataFilters(metadata), null, '\t');
 
-        fs.writeFileSync(filtersFileJson, filtersContent, 'utf8');
-        fs.writeFileSync(filtersFileJs, filtersContent, 'utf8');
+        fs$1.writeFileSync(filtersFileJson, filtersContent, 'utf8');
+        fs$1.writeFileSync(filtersFileJs, filtersContent, 'utf8');
 
         logger.info(`Writing filters localizations: ${config.path}`);
-        const filtersI18nFileJson = path.join(platformDir, FILTERS_I18N_METADATA_FILE_JSON);
-        const filtersI18nFileJs = path.join(platformDir, FILTERS_I18N_METADATA_FILE_JS);
+        const filtersI18nFileJson = path$1.join(platformDir, FILTERS_I18N_METADATA_FILE_JSON);
+        const filtersI18nFileJs = path$1.join(platformDir, FILTERS_I18N_METADATA_FILE_JS);
 
         let localizedFilters = { ...localizations.filters };
 
@@ -1978,8 +2060,8 @@ const writeFiltersMetadata = function (platformsPath, filtersDir, filtersMetadat
 
         const i18nContent = JSON.stringify(i18nMetadata, null, '\t');
 
-        fs.writeFileSync(filtersI18nFileJson, i18nContent, 'utf8');
-        fs.writeFileSync(filtersI18nFileJs, i18nContent, 'utf8');
+        fs$1.writeFileSync(filtersI18nFileJson, i18nContent, 'utf8');
+        fs$1.writeFileSync(filtersI18nFileJs, i18nContent, 'utf8');
     }
 
     logger.info('Writing filters metadata done');
@@ -1996,7 +2078,7 @@ const writeLocalScriptRules = function (platformsPath) {
     // eslint-disable-next-line guard-for-in,no-restricted-syntax
     for (const platform in platformPathsConfig) {
         const config = platformPathsConfig[platform];
-        const platformDir = path.join(platformsPath, config.path);
+        const platformDir = path$1.join(platformsPath, config.path);
 
         const rulesTxt = [];
         const rulesJson = {
@@ -2008,7 +2090,7 @@ const writeLocalScriptRules = function (platformsPath) {
         // because AdGuard Chinese filter has id 224
         // https://github.com/AdguardTeam/FiltersRegistry/blob/master/filters/filter_224_Chinese/metadata.json
         for (let i = 1; i <= LAST_ADGUARD_FILTER_ID; i += 1) {
-            const filterRules = readFile$2(path.join(platformDir, PLATFORM_FILTERS_DIR, `${i}.txt`));
+            const filterRules = readFile$2(path$1.join(platformDir, PLATFORM_FILTERS_DIR, `${i}.txt`));
             if (!filterRules) {
                 continue;
             }
@@ -2039,13 +2121,13 @@ const writeLocalScriptRules = function (platformsPath) {
         // remove scriptlet rules in local_script_rules.json
         rulesJson.rules = removeScriptletRules(rulesJson.rules);
 
-        fs.writeFileSync(
-            path.join(platformDir, LOCAL_SCRIPT_RULES_FILE),
+        fs$1.writeFileSync(
+            path$1.join(platformDir, LOCAL_SCRIPT_RULES_FILE),
             rulesTxt.join(RULES_SEPARATOR),
             'utf8',
         );
-        fs.writeFileSync(
-            path.join(platformDir, LOCAL_SCRIPT_RULES_FILE_JSON),
+        fs$1.writeFileSync(
+            path$1.join(platformDir, LOCAL_SCRIPT_RULES_FILE_JSON),
             JSON.stringify(rulesJson, null, 4),
             'utf8',
         );
@@ -2064,13 +2146,13 @@ const writeLocalScriptRules = function (platformsPath) {
  * @throws {Error} If the metadata or revision file cannot be read.
  */
 const loadFilterMetadata = function (filterDir, whitelist, blacklist) {
-    const metadataFilePath = path.join(filterDir, metadataFile);
+    const metadataFilePath = path$1.join(filterDir, metadataFile);
     const metadataString = readFile$2(metadataFilePath);
     if (!metadataString) {
         throw new Error(`Error reading filter metadata:${filterDir}`);
     }
 
-    const revisionFilePath = path.join(filterDir, revisionFile);
+    const revisionFilePath = path$1.join(filterDir, revisionFile);
     const revisionString = readFile$2(revisionFilePath);
     if (!revisionString) {
         throw new Error(`Error reading filter revision:${filterDir}`);
@@ -2131,7 +2213,7 @@ const writeFilterFile = function (filterFile, adbHeader, rulesHeader, rules) {
         data = [adbHeader].concat(data);
     }
 
-    fs.writeFileSync(filterFile, data.join(RULES_SEPARATOR), 'utf8');
+    fs$1.writeFileSync(filterFile, data.join(RULES_SEPARATOR), 'utf8');
 };
 
 /**
@@ -2140,7 +2222,7 @@ const writeFilterFile = function (filterFile, adbHeader, rulesHeader, rules) {
 const writeFilterRules = function (filterId, dir, config, rulesHeader, rules, optimized) {
     createDir(dir);
 
-    const filterFile = path.join(dir, `${filterId}${optimized ? '_optimized' : ''}.txt`);
+    const filterFile = path$1.join(dir, `${filterId}${optimized ? '_optimized' : ''}.txt`);
     let rulesList = rules;
 
     // Convert Adguard scriptlets and redirect rules to UBlock syntax.
@@ -2162,7 +2244,7 @@ const writeFilterRules = function (filterId, dir, config, rulesHeader, rules, op
         const correctedHeader = rewriteHeader(rulesHeader);
         const correctedRules = rewriteRules(rulesList);
 
-        const correctedFile = path.join(dir, `${filterId}_without_easylist.txt`);
+        const correctedFile = path$1.join(dir, `${filterId}_without_easylist.txt`);
         writeFilterFile(correctedFile, config.configuration.adbHeader, correctedHeader, correctedRules);
     }
 };
@@ -2215,10 +2297,10 @@ const removeRuleDuplicates = function (list) {
  * @param blacklist - Array of filter ids to blacklist
  */
 const buildFilter$1 = async (filterDir, platformsPath, whitelist, blacklist) => {
-    const originalRules = readFile$2(path.join(filterDir, filterFile)).split('\r\n');
+    const originalRules = readFile$2(path$1.join(filterDir, filterFile)).split('\r\n');
 
-    const metadataFilePath = path.join(filterDir, metadataFile);
-    const revisionFilePath = path.join(filterDir, revisionFile);
+    const metadataFilePath = path$1.join(filterDir, metadataFile);
+    const revisionFilePath = path$1.join(filterDir, revisionFile);
 
     const metadata = JSON.parse(readFile$2(metadataFilePath));
     const { filterId } = metadata;
@@ -2274,7 +2356,7 @@ const buildFilter$1 = async (filterDir, platformsPath, whitelist, blacklist) =>
 
         const header = makeHeader(metadataFilePath, revisionFilePath, config.expires);
 
-        const platformDir = path.join(platformsPath, config.path, PLATFORM_FILTERS_DIR);
+        const platformDir = path$1.join(platformsPath, config.path, PLATFORM_FILTERS_DIR);
         writeFilterRules(filterId, platformDir, config, header, rules, false);
 
         // add '(Optimized)' to the '! Title:' for optimized filters
@@ -2340,13 +2422,13 @@ const parseDirectory$1 = async (
     blacklist,
     obsoleteFiltersMetadata,
 ) => {
-    const items = fs.readdirSync(filtersDir);
+    const items = fs$1.readdirSync(filtersDir);
     // eslint-disable-next-line no-restricted-syntax
     for (const directory of items) {
-        const filterDir = path.join(filtersDir, directory);
-        if (fs.lstatSync(filterDir).isDirectory()) {
-            const metadataFilePath = path.join(filterDir, metadataFile);
-            if (fs.existsSync(metadataFilePath)) {
+        const filterDir = path$1.join(filtersDir, directory);
+        if (fs$1.lstatSync(filterDir).isDirectory()) {
+            const metadataFilePath = path$1.join(filterDir, metadataFile);
+            if (fs$1.existsSync(metadataFilePath)) {
                 logger.info(`Building filter platforms: ${directory}`);
                 // eslint-disable-next-line no-await-in-loop
                 await buildFilter$1(filterDir, platformsPath, whitelist, blacklist);
@@ -2464,7 +2546,7 @@ const skipFilter = (metadata) => {
  */
 const create = (reportPath) => {
     if (reportPath) {
-        fs.writeFileSync(reportPath, reportData, 'utf8');
+        fs$1.writeFileSync(reportPath, reportData, 'utf8');
         return;
     }
     log(reportData);
@@ -2626,7 +2708,7 @@ const optimizeDomainBlockingRules = async (lines) => {
 /* eslint-disable global-require */
 
 
-const __dirname$2 = path.dirname(new URL(import.meta.url).pathname);
+const __dirname$2 = path$1.dirname(new URL(import.meta.url).pathname);
 
 const TEMPLATE_FILE = 'template.txt';
 const FILTER_FILE = 'filter.txt';
@@ -2667,11 +2749,11 @@ const DIFF_PATH_TAG = 'Diff-Path:';
  * @returns {*}
  */
 const readFile$1 = function (path) {
-    if (!fs.existsSync(path)) {
+    if (!fs$1.existsSync(path)) {
         return null;
     }
 
-    return fs.readFileSync(path, { encoding: 'utf-8' });
+    return fs$1.readFileSync(path, { encoding: 'utf-8' });
 };
 
 /**
@@ -2681,7 +2763,7 @@ const readFile$1 = function (path) {
  * @param data
  */
 const writeFile = function (path, data) {
-    fs.writeFileSync(path, data, 'utf8');
+    fs$1.writeFileSync(path, data, 'utf8');
 };
 
 /**
@@ -2836,7 +2918,7 @@ const exclude = function (lines, exclusionsFile, excluded) {
 
     exclusions = splitLines(exclusions);
 
-    const exclusionsFileName = path.parse(exclusionsFile).base;
+    const exclusionsFileName = path$1.parse(exclusionsFile).base;
     const result = [];
 
     lines.forEach((line, pos) => {
@@ -2979,7 +3061,7 @@ const include = async (filterDir, directiveLine, excluded) => {
 
     const included = externalInclude
         ? downloadFile(url)
-        : readFile$1(path.join(filterDir, url));
+        : readFile$1(path$1.join(filterDir, url));
 
     if (included) {
         includedLines = splitLines(included);
@@ -3000,7 +3082,7 @@ const include = async (filterDir, directiveLine, excluded) => {
             let optionsExcludePath;
             switch (name) {
                 case EXCLUDE_OPTION:
-                    optionsExcludePath = path.join(filterDir, value);
+                    optionsExcludePath = path$1.join(filterDir, value);
                     includedLines = exclude(includedLines, optionsExcludePath, excluded);
                     break;
                 case STRIP_COMMENTS_OPTION:
@@ -3059,7 +3141,7 @@ const getResolvedPreprocessorIncludes = async function (filterDir, filterName, l
     try {
         rules = await FiltersDownloader.resolveIncludes(lines, filterDir);
     } catch (e) {
-        logger.warn(`Error resolving includes in ${filterName}: ${e.message}`);
+        logger.error(`Error resolving includes in ${filterName}: ${e.message}`);
     }
     return rules;
 };
@@ -3175,7 +3257,7 @@ const compile$1 = async function (filterDir, filterName, templateContent, trustL
 
     result = result.filter((line) => !isDiffPathHeaderTag(line));
 
-    const excludeFilePath = path.join(filterDir, EXCLUDE_FILE);
+    const excludeFilePath = path$1.join(filterDir, EXCLUDE_FILE);
     result = exclude(result, excludeFilePath, excluded);
 
     result = validateAndFilterRules(result, excluded, invalid, filterName);
@@ -3231,15 +3313,22 @@ const makeRevision = function (path, hash) {
  * @returns {Promise<void>} A promise that resolves when all filters and its subdirectories have been processed.
  */
 const buildFilter = async function (filterDir, whitelist, blacklist) {
-    const templateContent = readFile$1(path.join(filterDir, TEMPLATE_FILE));
+    const templateContent = readFile$1(path$1.join(filterDir, TEMPLATE_FILE));
     if (!templateContent) {
         throw new Error('Invalid template');
     }
 
-    const metadata = JSON.parse(readFile$1(path.join(filterDir, METADATA_FILE)));
+    const metadata = JSON.parse(readFile$1(path$1.join(filterDir, METADATA_FILE)));
 
     const { filterId } = metadata;
 
+    // check whether the filter is disabled after other checks to avoid unnecessary logging
+    if (metadata.disabled) {
+        logger.warn(`Filter ${filterId} skipped as disabled`);
+        skipFilter(metadata);
+        return;
+    }
+
     if (whitelist && whitelist.length > 0 && whitelist.indexOf(filterId) < 0) {
         logger.info(`Filter ${filterId} skipped due to '--include' option`);
         return;
@@ -3250,16 +3339,9 @@ const buildFilter = async function (filterDir, whitelist, blacklist) {
         return;
     }
 
-    // check whether the filter is disabled after other checks to avoid unnecessary logging
-    if (metadata.disabled) {
-        logger.warn(`Filter ${filterId} skipped as disabled`);
-        skipFilter(metadata);
-        return;
-    }
-
     const trustLevel = metadata.trustLevel ? metadata.trustLevel : DEFAULT_TRUST_LEVEL;
     // eslint-disable-next-line no-undef
-    const trustLevelSettings = path.resolve(__dirname$2, TRUST_LEVEL_DIR, `exclusions-${trustLevel}.txt`);
+    const trustLevelSettings = path$1.resolve(__dirname$2, TRUST_LEVEL_DIR, `exclusions-${trustLevel}.txt`);
 
     const { name: filterName } = metadata;
     logger.info(`Compiling ${filterName}`);
@@ -3279,14 +3361,14 @@ const buildFilter = async function (filterDir, whitelist, blacklist) {
     const compiledData = compiled.join('\r\n');
 
     logger.info(`Writing filter file, lines:${compiled.length}`);
-    writeFile(path.join(filterDir, FILTER_FILE), compiledData);
+    writeFile(path$1.join(filterDir, FILTER_FILE), compiledData);
     logger.info(`Writing excluded file, lines:${excluded.length}`);
-    writeFile(path.join(filterDir, EXCLUDED_LINES_FILE), excluded.join('\r\n'));
+    writeFile(path$1.join(filterDir, EXCLUDED_LINES_FILE), excluded.join('\r\n'));
     logger.info('Writing revision file..');
 
     // eslint-disable-next-line no-buffer-constructor
     const hash = Buffer.from(md5(compiledData, { asString: true })).toString('base64').trim();
-    const revisionFile = path.join(filterDir, REVISION_FILE);
+    const revisionFile = path$1.join(filterDir, REVISION_FILE);
     const revision = makeRevision(revisionFile, hash);
     writeFile(revisionFile, JSON.stringify(revision, null, '\t'));
 };
@@ -3300,15 +3382,15 @@ const buildFilter = async function (filterDir, whitelist, blacklist) {
  * @returns {Promise<void>} A promise that resolves when all filters and its subdirectories have been processed.
  */
 const parseDirectory = async function (filtersDir, whitelist, blacklist) {
-    const items = fs.readdirSync(filtersDir)
+    const items = fs$1.readdirSync(filtersDir)
         .sort((a, b) => getFilterIdFromDirName(a) - getFilterIdFromDirName(b));
 
     // eslint-disable-next-line no-restricted-syntax
     for (const directory of items) {
-        const filterDir = path.join(filtersDir, directory);
-        if (fs.lstatSync(filterDir).isDirectory()) {
-            const template = path.join(filterDir, TEMPLATE_FILE);
-            if (fs.existsSync(template)) {
+        const filterDir = path$1.join(filtersDir, directory);
+        if (fs$1.lstatSync(filterDir).isDirectory()) {
+            const template = path$1.join(filterDir, TEMPLATE_FILE);
+            if (fs$1.existsSync(template)) {
                 logger.info(`Building filter ${directory}...`);
                 // eslint-disable-next-line no-await-in-loop
                 await buildFilter(filterDir, whitelist, blacklist);
@@ -3371,14 +3453,14 @@ const OLD_MAC_V2_PLATFORM = 'mac_v2';
 const loadSchemas = (dir) => {
     const schemas = {};
 
-    const items = fs.readdirSync(dir);
+    const items = fs$1.readdirSync(dir);
     // eslint-disable-next-line no-restricted-syntax
     for (const f of items) {
         if (f.endsWith(SCHEMA_EXTENSION)) {
             const validationFileName = f.substr(0, f.indexOf(SCHEMA_EXTENSION));
 
             logger.info(`Loading schema for ${validationFileName}`);
-            schemas[validationFileName] = JSON.parse(fs.readFileSync(path.join(dir, f)));
+            schemas[validationFileName] = JSON.parse(fs$1.readFileSync(path$1.join(dir, f)));
         }
     }
 
@@ -3398,30 +3480,30 @@ const loadSchemas = (dir) => {
 const validateDir = (dir, validator, schemas, oldSchemas, filtersRequiredAmount) => {
     let items;
     try {
-        items = fs.readdirSync(dir);
+        items = fs$1.readdirSync(dir);
     } catch (e) {
         logger.info(e.message);
         return false;
     }
     // eslint-disable-next-line no-restricted-syntax
     for (const f of items) {
-        const item = path.join(dir, f);
-        if (fs.lstatSync(item).isDirectory()) {
+        const item = path$1.join(dir, f);
+        if (fs$1.lstatSync(item).isDirectory()) {
             if (!validateDir(item, validator, schemas, oldSchemas)) {
                 return false;
             }
         } else {
-            const fileName = path.basename(item, '.json');
+            const fileName = path$1.basename(item, '.json');
             let schema = schemas[fileName];
 
             // Validate `mac` (mac v1) dir with old schemas
-            if (path.basename(path.dirname(item)) === OLD_MAC_V1_PLATFORM) {
+            if (path$1.basename(path$1.dirname(item)) === OLD_MAC_V1_PLATFORM) {
                 logger.info('Look up old schemas for mac directory');
                 schema = oldSchemas[OLD_MAC_V1_PLATFORM][fileName];
             }
 
             // Validate `mac_v2` dir with old schemas
-            if (path.basename(path.dirname(item)) === OLD_MAC_V2_PLATFORM) {
+            if (path$1.basename(path$1.dirname(item)) === OLD_MAC_V2_PLATFORM) {
                 logger.info('Look up old schemas for mac_v2 directory');
                 schema = oldSchemas[OLD_MAC_V2_PLATFORM][fileName];
             }
@@ -3429,7 +3511,7 @@ const validateDir = (dir, validator, schemas, oldSchemas, filtersRequiredAmount)
             if (schema) {
                 logger.info(`Validating ${item}`);
 
-                const json = JSON.parse(fs.readFileSync(item));
+                const json = JSON.parse(fs$1.readFileSync(item));
 
                 // Validate filters amount
                 if (fileName === 'filters') {
@@ -3443,12 +3525,12 @@ const validateDir = (dir, validator, schemas, oldSchemas, filtersRequiredAmount)
                 const valid = validate(json);
 
                 // json can be updated with default values
-                fs.writeFileSync(item, JSON.stringify(json, null, '\t'));
+                fs$1.writeFileSync(item, JSON.stringify(json, null, '\t'));
 
                 // duplicate to .js file as well
                 const jsFileName = `${fileName}.js`;
-                fs.writeFileSync(
-                    path.join(path.dirname(item), jsFileName),
+                fs$1.writeFileSync(
+                    path$1.join(path$1.dirname(item), jsFileName),
                     JSON.stringify(json, null, '\t'),
                 );
 
@@ -3476,8 +3558,8 @@ const validate$1 = (platformsPath, jsonSchemasConfigDir, filtersRequiredAmount)
 
     const schemas = loadSchemas(jsonSchemasConfigDir);
 
-    const oldSchemasMacV1 = loadSchemas(path.join(jsonSchemasConfigDir, OLD_MAC_V1_PLATFORM));
-    const oldSchemasMacV2 = loadSchemas(path.join(jsonSchemasConfigDir, OLD_MAC_V2_PLATFORM));
+    const oldSchemasMacV1 = loadSchemas(path$1.join(jsonSchemasConfigDir, OLD_MAC_V1_PLATFORM));
+    const oldSchemasMacV2 = loadSchemas(path$1.join(jsonSchemasConfigDir, OLD_MAC_V2_PLATFORM));
     const oldSchemas = {
         [OLD_MAC_V1_PLATFORM]: oldSchemasMacV1,
         [OLD_MAC_V2_PLATFORM]: oldSchemasMacV2,
@@ -3500,7 +3582,7 @@ const schemaValidator = { validate: validate$1 };
 
 /* eslint-disable global-require */
 
-const __dirname$1 = path.dirname(new URL(import.meta.url).pathname);
+const __dirname$1 = path$1.dirname(new URL(import.meta.url).pathname);
 
 /**
  * Each filter, group, tag should have two keys.
@@ -3538,13 +3620,13 @@ const WARNING_TYPES = {
  * Sync reads file content
  * @param filePath - path to locales file
  */
-const readFile = (filePath) => fs.readFileSync(path.resolve(__dirname$1, filePath), 'utf8');
+const readFile = (filePath) => fs$1.readFileSync(path$1.resolve(__dirname$1, filePath), 'utf8');
 
 /**
  * Sync reads directory content
  * @param dirPath - path to directory
  */
-const readDir = (dirPath) => fs.readdirSync(path.resolve(__dirname$1, dirPath), 'utf8');
+const readDir = (dirPath) => fs$1.readdirSync(path$1.resolve(__dirname$1, dirPath), 'utf8');
 
 /**
  * Validates messages keys
@@ -3589,11 +3671,11 @@ const prepareWarningDetails = (obj) => Object.entries(obj).map(([key, value]) =>
 const getBaseLocaleKeys = (dirPath) => {
     const baseLocaleKeys = {};
 
-    const baseLocalePath = path.join(dirPath, BASE_LOCALE);
+    const baseLocalePath = path$1.join(dirPath, BASE_LOCALE);
     const baseLocaleFiles = readDir(baseLocalePath);
 
     baseLocaleFiles.forEach((fileName) => {
-        const baseLocaleData = JSON.parse(readFile(path.join(baseLocalePath, fileName)));
+        const baseLocaleData = JSON.parse(readFile(path$1.join(baseLocalePath, fileName)));
         baseLocaleKeys[fileName] = baseLocaleData.flatMap((entry) => Object.keys(entry));
     });
     return baseLocaleKeys;
@@ -3689,7 +3771,7 @@ const validate = (dirPath, requiredLocales) => {
 
     locales.forEach((locale) => {
         const localeWarnings = [];
-        const filesList = readDir(path.join(dirPath, locale));
+        const filesList = readDir(path$1.join(dirPath, locale));
         // checks all needed files presence
         const missedFiles = REQUIRED_FILES
             .filter((el) => !filesList.includes(el));
@@ -3707,7 +3789,7 @@ const validate = (dirPath, requiredLocales) => {
 
         // iterate over existent files
         presentFiles.forEach((fileName) => {
-            const messagesPath = path.join(dirPath, locale, fileName);
+            const messagesPath = path$1.join(dirPath, locale, fileName);
             let messagesData;
             try {
                 messagesData = JSON.parse(readFile(messagesPath));
@@ -4280,7 +4362,8 @@ const EXTENDED_CSS_RULES_PATTERNS = [
 ];
 
 /**
- * Used for `EXTENSION_CHROMIUM`, `EXTENSION_CHROMIUM_MV3`, `EXTENSION_EDGE`, and `EXTENSION_OPERA` platforms.
+ * Used for `EXTENSION_CHROMIUM`, `EXTENSION_CHROMIUM_MV3`, `EXTENSION_EDGE`,
+ * `EXTENSION_OPERA`, and `EXTENSION_OPERA_MV3` platforms.
  */
 const CHROMIUM_BASED_EXTENSION_PATTERNS = [
     ...HTML_FILTERING_MODIFIER_PATTERNS,
@@ -4487,6 +4570,24 @@ const platformsConfig = {
             'adguard_ext_chromium': true,
         },
     },
+    'EXTENSION_OPERA_MV3': {
+        'platform': 'ext_opera_mv3',
+        'path': 'extension/opera-mv3',
+        'expires': '10 days',
+        'configuration': {
+            'removeRulePatterns': [
+                ...CHROMIUM_BASED_EXTENSION_PATTERNS,
+                ...REDIRECT_MODIFIER_PATTERNS,
+            ],
+            'replacements': null,
+            'ignoreRuleHints': false,
+        },
+        'defines': {
+            'adguard': true,
+            'adguard_ext_opera_mv3': true,
+            'adguard_ext_chromium_mv3': true,
+        },
+    },
     'EXTENSION_FIREFOX': {
         'platform': 'ext_ff',
         'path': 'extension/firefox',
@@ -4615,9 +4716,9 @@ const platformsConfig = {
 // Sets configuration compatibility
 setConfiguration({ compatibility: CompatibilityTypes.Corelibs });
 
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const __dirname = path$1.dirname(new URL(import.meta.url).pathname);
 
-const jsonSchemasConfigDir = path.join(__dirname, './schemas/');
+const jsonSchemasConfigDir = path$1.join(__dirname, './schemas/');
 
 process.on('unhandledRejection', (error) => {
     throw error;