@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/esm/utils/cosmetic-rule-separator.mjs

@@ -0,0 +1,127 @@
+/*
+ * 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
+ */
+import { CosmeticRuleSeparator } from '../nodes/index.mjs';
+import { AT_SIGN, SPACE } from './constants.mjs';
+
+/**
+ * @file Cosmetic rule separator finder and categorizer
+ */
+/**
+ * Utility class for cosmetic rule separators.
+ */
+class CosmeticRuleSeparatorUtils {
+    /**
+     * Checks whether the specified separator is an exception.
+     *
+     * @param separator Separator to check
+     * @returns `true` if the separator is an exception, `false` otherwise
+     */
+    static isException(separator) {
+        // Simply check the second character
+        return separator[1] === AT_SIGN;
+    }
+    /**
+     * Checks whether the specified separator is marks an Extended CSS cosmetic rule.
+     *
+     * @param separator Separator to check
+     * @returns `true` if the separator is marks an Extended CSS cosmetic rule, `false` otherwise
+     */
+    static isExtendedCssMarker(separator) {
+        return (separator === CosmeticRuleSeparator.ExtendedElementHiding
+            || separator === CosmeticRuleSeparator.ExtendedElementHidingException
+            || separator === CosmeticRuleSeparator.AdgExtendedCssInjection
+            || separator === CosmeticRuleSeparator.AdgExtendedCssInjectionException);
+    }
+    /**
+     * Looks for the cosmetic rule separator in the rule. This is a simplified version that
+     * masks the recursive function.
+     *
+     * @param rule Raw rule
+     * @returns Separator result or null if no separator was found
+     */
+    static find(rule) {
+        /**
+         * Helper function to create results of the `find` method.
+         *
+         * @param start Start position
+         * @param separator Separator type
+         * @returns Cosmetic rule separator node
+         */
+        // eslint-disable-next-line max-len
+        function createResult(start, separator) {
+            return {
+                separator,
+                start,
+                end: start + separator.length,
+            };
+        }
+        for (let i = 0; i < rule.length; i += 1) {
+            if (rule[i] === '#') {
+                if (rule[i + 1] === '#' && rule[i - 1] !== SPACE) {
+                    // ##
+                    return createResult(i, CosmeticRuleSeparator.ElementHiding);
+                }
+                if (rule[i + 1] === '?' && rule[i + 2] === '#') {
+                    // #?#
+                    return createResult(i, CosmeticRuleSeparator.ExtendedElementHiding);
+                }
+                if (rule[i + 1] === '%' && rule[i + 2] === '#') {
+                    // #%#
+                    return createResult(i, CosmeticRuleSeparator.AdgJsInjection);
+                }
+                if (rule[i + 1] === '$') {
+                    if (rule[i + 2] === '#') {
+                        // #$#
+                        return createResult(i, CosmeticRuleSeparator.AdgCssInjection);
+                    }
+                    if (rule[i + 2] === '?' && rule[i + 3] === '#') {
+                        // #$?#
+                        return createResult(i, CosmeticRuleSeparator.AdgExtendedCssInjection);
+                    }
+                }
+                // Exceptions
+                if (rule[i + 1] === '@') {
+                    if (rule[i + 2] === '#' && rule[i - 1] !== SPACE) {
+                        // #@#
+                        return createResult(i, CosmeticRuleSeparator.ElementHidingException);
+                    }
+                    if (rule[i + 2] === '?' && rule[i + 3] === '#') {
+                        // #@?#
+                        return createResult(i, CosmeticRuleSeparator.ExtendedElementHidingException);
+                    }
+                    if (rule[i + 2] === '%' && rule[i + 3] === '#') {
+                        // #@%#
+                        return createResult(i, CosmeticRuleSeparator.AdgJsInjectionException);
+                    }
+                    if (rule[i + 2] === '$') {
+                        if (rule[i + 3] === '#') {
+                            // #@$#
+                            return createResult(i, CosmeticRuleSeparator.AdgCssInjectionException);
+                        }
+                        if (rule[i + 3] === '?' && rule[i + 4] === '#') {
+                            // #@$?#
+                            return createResult(i, CosmeticRuleSeparator.AdgExtendedCssInjectionException);
+                        }
+                    }
+                }
+            }
+            if (rule[i] === '$') {
+                if (rule[i + 1] === '$') {
+                    // $$
+                    return createResult(i, CosmeticRuleSeparator.AdgHtmlFiltering);
+                }
+                if (rule[i + 1] === '@' && rule[i + 2] === '$') {
+                    // $@$
+                    return createResult(i, CosmeticRuleSeparator.AdgHtmlFilteringException);
+                }
+            }
+        }
+        return null;
+    }
+}
+
+export { CosmeticRuleSeparatorUtils };

package/dist/esm/utils/deep-freeze.mjs

@@ -0,0 +1,32 @@
+/*
+ * 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
+ */
+/**
+ * Simple deep freeze implementation.
+ * It freezes the object and all its properties recursively.
+ *
+ * @param object Object to freeze.
+ *
+ * @returns Frozen object.
+ *
+ * @template T Type of the object to freeze.
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze#deep_freezing}
+ */
+const deepFreeze = (object) => {
+    // Retrieve the property names defined on object
+    const propNames = Reflect.ownKeys(object);
+    // Freeze properties before freezing self
+    for (const name of propNames) {
+        const value = object[name];
+        if ((value && typeof value === 'object') || typeof value === 'function') {
+            deepFreeze(value);
+        }
+    }
+    return Object.freeze(object);
+};
+
+export { deepFreeze };

package/dist/esm/utils/domain.mjs

@@ -0,0 +1,56 @@
+/*
+ * 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
+ */
+import { parse } from 'tldts';
+import { WILDCARD, DOT } from './constants.mjs';
+
+/**
+ * @file Utility functions for domain and hostname validation.
+ */
+/**
+ * Marker for a wildcard top-level domain — `.*`.
+ *
+ * @example
+ * `example.*` — matches with any TLD, e.g. `example.org`, `example.com`, etc.
+ */
+const WILDCARD_TLD = DOT + WILDCARD;
+/**
+ * Marker for a wildcard subdomain — `*.`.
+ *
+ * @example
+ * `*.example.org` — matches with any subdomain, e.g. `foo.example.org` or `bar.example.org`
+ */
+const WILDCARD_SUBDOMAIN = WILDCARD + DOT;
+class DomainUtils {
+    /**
+     * Check if the input is a valid domain or hostname.
+     *
+     * @param domain Domain to check
+     * @returns `true` if the domain is valid, `false` otherwise
+     */
+    static isValidDomainOrHostname(domain) {
+        let domainToCheck = domain;
+        // Wildcard-only domain, typically a generic rule
+        if (domainToCheck === WILDCARD) {
+            return true;
+        }
+        // https://adguard.com/kb/general/ad-filtering/create-own-filters/#wildcard-for-tld
+        if (domainToCheck.endsWith(WILDCARD_TLD)) {
+            // Remove the wildcard TLD
+            domainToCheck = domainToCheck.substring(0, domainToCheck.length - WILDCARD_TLD.length);
+        }
+        if (domainToCheck.startsWith(WILDCARD_SUBDOMAIN)) {
+            // Remove the wildcard subdomain
+            domainToCheck = domainToCheck.substring(WILDCARD_SUBDOMAIN.length);
+        }
+        // Parse the domain with tldts
+        const tldtsResult = parse(domainToCheck);
+        // Check if the domain is valid
+        return domainToCheck === tldtsResult.domain || domainToCheck === tldtsResult.hostname;
+    }
+}
+
+export { DomainUtils, WILDCARD_SUBDOMAIN, WILDCARD_TLD };

package/dist/esm/utils/error.mjs

@@ -0,0 +1,49 @@
+/*
+ * 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
+ */
+/**
+ * Checks if error has message.
+ *
+ * @param error Error object.
+ * @returns If param is error.
+ */
+function isErrorWithMessage(error) {
+    return (typeof error === 'object'
+        && error !== null
+        && 'message' in error
+        && typeof error.message === 'string');
+}
+/**
+ * Converts error to the error with message.
+ *
+ * @param maybeError Possible error.
+ * @returns Error with message.
+ */
+function toErrorWithMessage(maybeError) {
+    if (isErrorWithMessage(maybeError)) {
+        return maybeError;
+    }
+    try {
+        return new Error(JSON.stringify(maybeError));
+    }
+    catch {
+        // fallback in case there's an error stringifying the maybeError
+        // like with circular references for example.
+        return new Error(String(maybeError));
+    }
+}
+/**
+ * Converts error object to error with message. This method might be helpful to handle thrown errors.
+ *
+ * @param error Error object.
+ *
+ * @returns Message of the error.
+ */
+function getErrorMessage(error) {
+    return toErrorWithMessage(error).message;
+}
+
+export { getErrorMessage };

package/dist/esm/utils/index.mjs

@@ -0,0 +1,21 @@
+/*
+ * 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
+ */
+export { ADG_SCRIPTLET_MASK, AGLINT_COMMAND_PREFIX, COMMA_DOMAIN_LIST_SEPARATOR, HINT_MARKER, IF, INCLUDE, MODIFIERS_SEPARATOR, MODIFIER_ASSIGN_OPERATOR, NEGATION_MARKER, NETWORK_RULE_EXCEPTION_MARKER, NETWORK_RULE_SEPARATOR, PIPE_MODIFIER_SEPARATOR, PREPROCESSOR_MARKER, SAFARI_CB_AFFINITY, UBO_SCRIPTLET_MASK } from './constants.mjs';
+export { BINARY_SCHEMA_VERSION } from './binary-schema-version.mjs';
+export { AdblockSyntax } from './adblockers.mjs';
+export { CosmeticRuleSeparatorUtils } from './cosmetic-rule-separator.mjs';
+export { DomainUtils } from './domain.mjs';
+export { LogicalExpressionUtils } from './logical-expression.mjs';
+export { ADBLOCK_URL_SEPARATOR, ADBLOCK_URL_SEPARATOR_REGEX, ADBLOCK_URL_START, ADBLOCK_URL_START_REGEX, ADBLOCK_WILDCARD, ADBLOCK_WILDCARD_REGEX, RegExpUtils, SPECIAL_REGEX_SYMBOLS } from './regexp.mjs';
+export { QuoteType, QuoteUtils } from './quotes.mjs';
+export { PositionProvider } from './position-provider.mjs';
+export { OutputByteBuffer } from './output-byte-buffer.mjs';
+export { InputByteBuffer } from './input-byte-buffer.mjs';
+export { ByteBuffer } from './byte-buffer.mjs';
+export { encodeIntoPolyfill } from './text-encoder-polyfill.mjs';
+export { decodeTextPolyfill } from './text-decoder-polyfill.mjs';
+export { RuleCategorizer } from './categorizer.mjs';

package/dist/esm/utils/input-byte-buffer.mjs

@@ -0,0 +1,257 @@
+/*
+ * 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
+ */
+import { ByteBuffer } from './byte-buffer.mjs';
+import { isArrayOfUint8Arrays } from './type-guards.mjs';
+import { isChromium } from './is-chromium.mjs';
+import { decodeTextPolyfill } from './text-decoder-polyfill.mjs';
+import { BINARY_SCHEMA_VERSION } from './binary-schema-version.mjs';
+import { BinarySchemaMismatchError } from '../errors/binary-schema-mismatch-error.mjs';
+
+/* 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 {
+    /**
+     * 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 !== BINARY_SCHEMA_VERSION) {
+            throw new BinarySchemaMismatchError(BINARY_SCHEMA_VERSION, actualVersion);
+        }
+        // Throw an error if the initial offset is out of bounds
+        if (initialOffset < 0 || initialOffset > this.chunks.length * 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();
+    }
+    /**
+     * 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 (!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.CHUNK_SIZE) {
+            this.offset += length;
+            if (this.isChromium) {
+                return 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.CHUNK_SIZE - chunkOffset);
+        while (remaining) {
+            const chunk = this.chunks[chunkIndex];
+            if (!chunk) {
+                break;
+            }
+            const toRead = Math.min(remaining, 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.CHUNK_SIZE;
+    }
+}
+
+export { InputByteBuffer };

package/dist/esm/utils/is-chromium.mjs

@@ -0,0 +1,20 @@
+/*
+ * 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
+ */
+/**
+ * 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)));
+};
+
+export { isChromium };

package/dist/esm/utils/logical-expression.mjs

@@ -0,0 +1,92 @@
+/*
+ * 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
+ */
+import { OperatorValue } from '../nodes/index.mjs';
+import { NodeType } from '../parser/misc/logical-expression-parser.mjs';
+
+/**
+ * @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 === NodeType.Variable) {
+            return [node];
+        }
+        if (node.type === NodeType.Operator) {
+            const leftVars = LogicalExpressionUtils.getVariables(node.left);
+            const rightVars = node.right ? LogicalExpressionUtils.getVariables(node.right) : [];
+            return [...leftVars, ...rightVars];
+        }
+        if (node.type === 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 === NodeType.Variable) {
+            return !!table[node.name];
+        }
+        if (node.type === NodeType.Operator) {
+            if (node.operator === OperatorValue.And || node.operator === OperatorValue.Or) {
+                if (!node.right) {
+                    throw new Error(`${ERROR_PREFIX.UNEXPECTED_OPERATOR} '${node.operator}'`);
+                }
+                if (node.operator === OperatorValue.And) {
+                    // eslint-disable-next-line max-len
+                    return LogicalExpressionUtils.evaluate(node.left, table) && LogicalExpressionUtils.evaluate(node.right, table);
+                }
+                if (node.operator === OperatorValue.Or) {
+                    // eslint-disable-next-line max-len
+                    return LogicalExpressionUtils.evaluate(node.left, table) || LogicalExpressionUtils.evaluate(node.right, table);
+                }
+            }
+            else if (node.operator === OperatorValue.Not) {
+                return !LogicalExpressionUtils.evaluate(node.left, table);
+            }
+        }
+        else if (node.type === NodeType.Parenthesis) {
+            return LogicalExpressionUtils.evaluate(node.expression, table);
+        }
+        throw new Error(`${ERROR_PREFIX.UNEXPECTED_NODE_TYPE} '${node.type}'`);
+    }
+}
+
+export { LogicalExpressionUtils };