@adguard/agtree 2.1.3 → 3.0.0-alpha.1

package/dist/cjs/utils/index.js

@@ -0,0 +1,69 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var constants = require('./constants.js');
+var binarySchemaVersion = require('./binary-schema-version.js');
+var adblockers = require('./adblockers.js');
+var cosmeticRuleSeparator = require('./cosmetic-rule-separator.js');
+var domain = require('./domain.js');
+var logicalExpression = require('./logical-expression.js');
+var regexp = require('./regexp.js');
+var quotes = require('./quotes.js');
+var positionProvider = require('./position-provider.js');
+var outputByteBuffer = require('./output-byte-buffer.js');
+var inputByteBuffer = require('./input-byte-buffer.js');
+var byteBuffer = require('./byte-buffer.js');
+var textEncoderPolyfill = require('./text-encoder-polyfill.js');
+var textDecoderPolyfill = require('./text-decoder-polyfill.js');
+var categorizer = require('./categorizer.js');
+
+
+
+exports.ADG_SCRIPTLET_MASK = constants.ADG_SCRIPTLET_MASK;
+exports.AGLINT_COMMAND_PREFIX = constants.AGLINT_COMMAND_PREFIX;
+exports.COMMA_DOMAIN_LIST_SEPARATOR = constants.COMMA_DOMAIN_LIST_SEPARATOR;
+exports.HINT_MARKER = constants.HINT_MARKER;
+exports.IF = constants.IF;
+exports.INCLUDE = constants.INCLUDE;
+exports.MODIFIERS_SEPARATOR = constants.MODIFIERS_SEPARATOR;
+exports.MODIFIER_ASSIGN_OPERATOR = constants.MODIFIER_ASSIGN_OPERATOR;
+exports.NEGATION_MARKER = constants.NEGATION_MARKER;
+exports.NETWORK_RULE_EXCEPTION_MARKER = constants.NETWORK_RULE_EXCEPTION_MARKER;
+exports.NETWORK_RULE_SEPARATOR = constants.NETWORK_RULE_SEPARATOR;
+exports.PIPE_MODIFIER_SEPARATOR = constants.PIPE_MODIFIER_SEPARATOR;
+exports.PREPROCESSOR_MARKER = constants.PREPROCESSOR_MARKER;
+exports.SAFARI_CB_AFFINITY = constants.SAFARI_CB_AFFINITY;
+exports.UBO_SCRIPTLET_MASK = constants.UBO_SCRIPTLET_MASK;
+exports.BINARY_SCHEMA_VERSION = binarySchemaVersion.BINARY_SCHEMA_VERSION;
+Object.defineProperty(exports, "AdblockSyntax", {
+	enumerable: true,
+	get: function () { return adblockers.AdblockSyntax; }
+});
+exports.CosmeticRuleSeparatorUtils = cosmeticRuleSeparator.CosmeticRuleSeparatorUtils;
+exports.DomainUtils = domain.DomainUtils;
+exports.LogicalExpressionUtils = logicalExpression.LogicalExpressionUtils;
+exports.ADBLOCK_URL_SEPARATOR = regexp.ADBLOCK_URL_SEPARATOR;
+exports.ADBLOCK_URL_SEPARATOR_REGEX = regexp.ADBLOCK_URL_SEPARATOR_REGEX;
+exports.ADBLOCK_URL_START = regexp.ADBLOCK_URL_START;
+exports.ADBLOCK_URL_START_REGEX = regexp.ADBLOCK_URL_START_REGEX;
+exports.ADBLOCK_WILDCARD = regexp.ADBLOCK_WILDCARD;
+exports.ADBLOCK_WILDCARD_REGEX = regexp.ADBLOCK_WILDCARD_REGEX;
+exports.RegExpUtils = regexp.RegExpUtils;
+exports.SPECIAL_REGEX_SYMBOLS = regexp.SPECIAL_REGEX_SYMBOLS;
+Object.defineProperty(exports, "QuoteType", {
+	enumerable: true,
+	get: function () { return quotes.QuoteType; }
+});
+exports.QuoteUtils = quotes.QuoteUtils;
+exports.PositionProvider = positionProvider.PositionProvider;
+exports.OutputByteBuffer = outputByteBuffer.OutputByteBuffer;
+exports.InputByteBuffer = inputByteBuffer.InputByteBuffer;
+exports.ByteBuffer = byteBuffer.ByteBuffer;
+exports.encodeIntoPolyfill = textEncoderPolyfill.encodeIntoPolyfill;
+exports.decodeTextPolyfill = textDecoderPolyfill.decodeTextPolyfill;
+exports.RuleCategorizer = categorizer.RuleCategorizer;

package/dist/cjs/utils/input-byte-buffer.js

@@ -0,0 +1,259 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var byteBuffer = require('./byte-buffer.js');
+var typeGuards = require('./type-guards.js');
+var isChromium = require('./is-chromium.js');
+var textDecoderPolyfill = require('./text-decoder-polyfill.js');
+var binarySchemaVersion = require('./binary-schema-version.js');
+var binarySchemaMismatchError = require('../errors/binary-schema-mismatch-error.js');
+
+/* eslint-disable max-len */
+/* eslint-disable no-plusplus */
+/* eslint-disable no-bitwise */
+/**
+ * @file Input byte buffer for reading binary data.
+ */
+/**
+ * Input byte buffer for reading binary data.
+ *
+ * @note Internally, this class uses a {@link ByteBuffer} instance, just providing a convenient API for reading data.
+ */
+class InputByteBuffer extends byteBuffer.ByteBuffer {
+    /**
+     * Current offset in the buffer for reading.
+     */
+    offset;
+    /**
+     * Shared native decoder for decoding strings.
+     */
+    sharedNativeDecoder;
+    /**
+     * Flag indicating if the current environment is Chromium.
+     * This is used for performance optimizations, because Chromium's TextEncoder/TextDecoder has a relatively
+     * large marshalling overhead for small strings.
+     */
+    isChromium;
+    /**
+     * Constructs a new `InputByteBuffer` instance.
+     *
+     * @param chunks Array of chunks to initialize the ByteBuffer with.
+     * @param cloneChunks Flag indicating if the chunks should be cloned. For performance reasons,
+     * its default value is `false`. If the original chunks are guaranteed not to change,
+     * leave this flag as `false` to avoid unnecessary copying.
+     * @param initialOffset Initial offset in the buffer for reading.
+     *
+     * @throws If the specified chunks array is empty.
+     * @throws If the binary schema version in the buffer is not equal to the expected version.
+     * @throws If the initial offset is out of bounds.
+     */
+    constructor(chunks, cloneChunks = false, initialOffset = 0) {
+        super(chunks, cloneChunks);
+        // Check binary schema version
+        if (chunks.length === 0) {
+            throw new Error('No data in the buffer');
+        }
+        const actualVersion = this.readSchemaVersion();
+        if (actualVersion !== binarySchemaVersion.BINARY_SCHEMA_VERSION) {
+            throw new binarySchemaMismatchError.BinarySchemaMismatchError(binarySchemaVersion.BINARY_SCHEMA_VERSION, actualVersion);
+        }
+        // Throw an error if the initial offset is out of bounds
+        if (initialOffset < 0 || initialOffset > this.chunks.length * byteBuffer.ByteBuffer.CHUNK_SIZE) {
+            throw new Error(`Invalid offset: ${initialOffset}`);
+        }
+        // Schema version is always stored at the beginning of the buffer - skip it, because it is already processed
+        this.offset = Math.max(4, initialOffset);
+        this.sharedNativeDecoder = new TextDecoder();
+        this.isChromium = isChromium.isChromium();
+    }
+    /**
+     * Creates a new InputByteBuffer instance from a Storage instance by reading chunks from the storage.
+     *
+     * @param storage Storage instance.
+     * @param key Key to read from the storage.
+     * @returns New InputByteBuffer instance.
+     * @note For performance reasons, chunks are passed by reference and not copied.
+     */
+    static async createFromStorage(storage, key) {
+        const chunks = await storage.get(key);
+        if (!typeGuards.isArrayOfUint8Arrays(chunks)) {
+            throw new Error('The data from storage is not an array of Uint8Arrays');
+        }
+        return new InputByteBuffer(chunks);
+    }
+    /**
+     * Reads a 8-bit unsigned integer from the buffer.
+     *
+     * @returns 8-bit unsigned integer from the buffer.
+     */
+    readUint8() {
+        const result = this.readByte(this.offset++) ?? 0;
+        return result;
+    }
+    /**
+     * Reads a 16-bit unsigned integer from the buffer.
+     *
+     * @returns 16-bit unsigned integer from the buffer.
+     */
+    readUint16() {
+        const result = (((this.readByte(this.offset++) ?? 0) << 8)
+            | ((this.readByte(this.offset++) ?? 0))) >>> 0;
+        return result;
+    }
+    /**
+     * Reads a 32-bit unsigned integer from the buffer at the specified index.
+     *
+     * @param index Index to read the 32-bit unsigned integer from.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     */
+    readUint32FromIndex(index) {
+        const result = (((this.readByte(index) ?? 0) << 24)
+            | ((this.readByte(index + 1) ?? 0) << 16)
+            | ((this.readByte(index + 2) ?? 0) << 8)
+            | ((this.readByte(index + 3) ?? 0))) >>> 0;
+        return result;
+    }
+    /**
+     * Reads a 32-bit unsigned integer from the buffer.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     */
+    readUint32() {
+        const result = this.readUint32FromIndex(this.offset);
+        this.offset += 4;
+        return result;
+    }
+    /**
+     * Reads schema version from the buffer.
+     *
+     * @returns 32-bit unsigned integer from the buffer.
+     * @note Schema version is always stored at the beginning of the buffer.
+     */
+    readSchemaVersion() {
+        return this.readUint32FromIndex(0);
+    }
+    /**
+     * Reads a 32-bit signed integer from the buffer.
+     *
+     * @returns 32-bit signed integer from the buffer.
+     */
+    readInt32() {
+        const result = this.readUint32();
+        return result > 0x7fffffff ? result - 0x100000000 : result;
+    }
+    /**
+     * Reads an optimized unsigned integer from the buffer.
+     * 'Optimized' means that the integer is stored in a variable number of bytes, depending on its value,
+     * so that smaller numbers occupy less space.
+     *
+     * @returns Decoded unsigned integer from the buffer.
+     */
+    readOptimizedUint() {
+        let result = 0;
+        let shift = 0;
+        while (shift <= 28) {
+            const byteValue = this.readByte(this.offset++) ?? 0;
+            result |= (byteValue & 0x7F) << shift;
+            shift += 7;
+            if ((byteValue & 0x80) === 0) {
+                break;
+            }
+        }
+        return result;
+    }
+    /**
+     * Reads a string from the buffer.
+     *
+     * @returns Decoded string from the buffer.
+     */
+    readString() {
+        const length = this.readOptimizedUint();
+        let chunkIndex = this.offset >>> 0x000F;
+        const chunkOffset = this.offset & 0x7FFF; // offset is only relevant for the first chunk
+        const endOffset = chunkOffset + length;
+        // In most cases, the string is stored in the current chunk
+        if (endOffset < byteBuffer.ByteBuffer.CHUNK_SIZE) {
+            this.offset += length;
+            if (this.isChromium) {
+                return textDecoderPolyfill.decodeTextPolyfill(this.chunks[chunkIndex], chunkOffset, endOffset);
+            }
+            return this.sharedNativeDecoder.decode(this.chunks[chunkIndex].subarray(chunkOffset, endOffset));
+        }
+        const result = [];
+        result.push(this.sharedNativeDecoder.decode(this.chunks[chunkIndex++].subarray(chunkOffset), { stream: true }));
+        let remaining = length - (byteBuffer.ByteBuffer.CHUNK_SIZE - chunkOffset);
+        while (remaining) {
+            const chunk = this.chunks[chunkIndex];
+            if (!chunk) {
+                break;
+            }
+            const toRead = Math.min(remaining, byteBuffer.ByteBuffer.CHUNK_SIZE);
+            result.push(this.sharedNativeDecoder.decode(chunk.subarray(0, toRead), { stream: true }));
+            remaining -= toRead;
+            chunkIndex += 1;
+        }
+        // Finish decoding, if something is left
+        result.push(this.sharedNativeDecoder.decode());
+        this.offset += length;
+        return result.join('');
+    }
+    /**
+     * Reads a 8-bit unsigned integer from the buffer without advancing the offset.
+     *
+     * @returns 8-bit unsigned integer from the buffer.
+     */
+    peekUint8() {
+        return this.readByte(this.offset) ?? 0;
+    }
+    /**
+     * Helper method for asserting the next 8-bit unsigned integer in the buffer.
+     *
+     * @param value Expected value.
+     * @throws If the next value in the buffer is not equal to the expected value.
+     */
+    assertUint8(value) {
+        const result = this.readUint8();
+        if (result !== value) {
+            throw new Error(`Expected ${value}, but got ${result}`);
+        }
+    }
+    /**
+     * Creates a new `InputByteBuffer` instance with the given initial offset.
+     *
+     * @param initialOffset Initial offset for the new buffer.
+     * @param cloneChunks Flag indicating if the chunks should be cloned. For performance reasons,
+     * its default value is `false`. If the original chunks are guaranteed not to change,
+     * leave this flag as `false` to avoid unnecessary copying.
+     *
+     * @returns New `InputByteBuffer` instance with the given initial offset.
+     *
+     * @note This method is useful if you want to read some data from a specific index.
+     */
+    createCopyWithOffset(initialOffset, cloneChunks = false) {
+        return new InputByteBuffer(this.chunks, cloneChunks, initialOffset);
+    }
+    /**
+     * Gets the current offset in the buffer for reading.
+     *
+     * @returns Current offset in the buffer for reading.
+     */
+    get currentOffset() {
+        return this.offset;
+    }
+    /**
+     * Gets the capacity of the buffer.
+     *
+     * @returns Capacity of the buffer.
+     */
+    get capacity() {
+        return this.chunks.length * byteBuffer.ByteBuffer.CHUNK_SIZE;
+    }
+}
+
+exports.InputByteBuffer = InputByteBuffer;

package/dist/cjs/utils/is-chromium.js

@@ -0,0 +1,22 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+/**
+ * A simple function to check if the current browser is Chromium-based.
+ *
+ * @returns `true` if the current browser is Chromium-based, `false` otherwise.
+ * @see {@link https://stackoverflow.com/a/62797156}
+ */
+const isChromium = () => {
+    return typeof window !== 'undefined'
+        && (Object.prototype.hasOwnProperty.call(window, 'chrome')
+            || (typeof window.navigator !== 'undefined'
+                && /chrome/i.test(window.navigator.userAgent)));
+};
+
+exports.isChromium = isChromium;

package/dist/cjs/utils/logical-expression.js

@@ -0,0 +1,94 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var index = require('../nodes/index.js');
+var logicalExpressionParser = require('../parser/misc/logical-expression-parser.js');
+
+/**
+ * @file Utility functions for logical expression node.
+ */
+const ERROR_PREFIX = {
+    UNEXPECTED_NODE_TYPE: 'Unexpected node type',
+    UNEXPECTED_OPERATOR: 'Unexpected operator',
+};
+/**
+ * Utility functions for logical expression node.
+ */
+class LogicalExpressionUtils {
+    /**
+     * Get all variables in the expression.
+     *
+     * @param node Logical expression node
+     * @returns List of variables in the expression (nodes)
+     * @example
+     * If the expression is `a && b || c`, the returned list will be
+     * nodes for `a`, `b`, and `c`.
+     */
+    static getVariables(node) {
+        if (node.type === logicalExpressionParser.NodeType.Variable) {
+            return [node];
+        }
+        if (node.type === logicalExpressionParser.NodeType.Operator) {
+            const leftVars = LogicalExpressionUtils.getVariables(node.left);
+            const rightVars = node.right ? LogicalExpressionUtils.getVariables(node.right) : [];
+            return [...leftVars, ...rightVars];
+        }
+        if (node.type === logicalExpressionParser.NodeType.Parenthesis) {
+            return LogicalExpressionUtils.getVariables(node.expression);
+        }
+        throw new Error(ERROR_PREFIX.UNEXPECTED_NODE_TYPE);
+    }
+    /**
+     * Evaluate the parsed logical expression. You'll need to provide a
+     * variable table.
+     *
+     * @param node Logical expression node
+     * @param table Variable table (key: variable name, value: boolean)
+     * @returns Evaluation result
+     * @example
+     * If the expression is `a && b`, and the variable table is
+     * `{ a: true, b: false }`, the result will be `false`.
+     *
+     * Example code:
+     * ```js
+     * LogicalExpressionUtils.evaluate(
+     *     LogicalExpressionParser.parse('a && b'),
+     *     { a: true, b: false }
+     * );
+     * ```
+     */
+    static evaluate(node, table) {
+        if (node.type === logicalExpressionParser.NodeType.Variable) {
+            return !!table[node.name];
+        }
+        if (node.type === logicalExpressionParser.NodeType.Operator) {
+            if (node.operator === index.OperatorValue.And || node.operator === index.OperatorValue.Or) {
+                if (!node.right) {
+                    throw new Error(`${ERROR_PREFIX.UNEXPECTED_OPERATOR} '${node.operator}'`);
+                }
+                if (node.operator === index.OperatorValue.And) {
+                    // eslint-disable-next-line max-len
+                    return LogicalExpressionUtils.evaluate(node.left, table) && LogicalExpressionUtils.evaluate(node.right, table);
+                }
+                if (node.operator === index.OperatorValue.Or) {
+                    // eslint-disable-next-line max-len
+                    return LogicalExpressionUtils.evaluate(node.left, table) || LogicalExpressionUtils.evaluate(node.right, table);
+                }
+            }
+            else if (node.operator === index.OperatorValue.Not) {
+                return !LogicalExpressionUtils.evaluate(node.left, table);
+            }
+        }
+        else if (node.type === logicalExpressionParser.NodeType.Parenthesis) {
+            return LogicalExpressionUtils.evaluate(node.expression, table);
+        }
+        throw new Error(`${ERROR_PREFIX.UNEXPECTED_NODE_TYPE} '${node.type}'`);
+    }
+}
+
+exports.LogicalExpressionUtils = LogicalExpressionUtils;

package/dist/cjs/utils/multi-value-map.js

@@ -0,0 +1,35 @@
+/*
+ * AGTree v3.0.0-alpha.1 (build date: Tue, 12 Nov 2024 16:11:58 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+'use strict';
+
+var typeGuards = require('./type-guards.js');
+
+/**
+ * A very simple map extension that allows to store multiple values for the same key
+ * by storing them in an array.
+ *
+ * @todo Add more methods if needed
+ */
+class MultiValueMap extends Map {
+    /**
+     * Adds a value to the map. If the key already exists, the value will be appended to the existing array,
+     * otherwise a new array will be created for the key.
+     *
+     * @param key Key to add
+     * @param values Value(s) to add
+     */
+    add(key, ...values) {
+        let currentValues = super.get(key);
+        if (typeGuards.isUndefined(currentValues)) {
+            currentValues = [];
+            super.set(key, values);
+        }
+        currentValues.push(...values);
+    }
+}
+
+exports.MultiValueMap = MultiValueMap;