@adguard/agtree 2.1.2 → 3.0.0-alpha.1

package/dist/cjs/deserializer/cosmetic/scriptlet-body/scriptlet-body-deserializer.js

@@ -0,0 +1,52 @@
+/*
+ * 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('../../../utils/constants.js');
+var parameterListDeserializer = require('../../misc/parameter-list-deserializer.js');
+var baseDeserializer = require('../../base-deserializer.js');
+var abpSnippetInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/abp-snippet-injection-body-common.js');
+var binaryTypeCommon = require('../../../marshalling-utils/misc/binary-type-common.js');
+
+class ScriptletBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a hint rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @param frequentScriptletArgs Map of frequently used scriptlet names / arguments
+     * and their serialization index (optional).
+     * @throws If the binary data is malformed.
+     */
+    static deserialize = (buffer, node, frequentScriptletArgs) => {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.ScriptletInjectionRuleBodyNode);
+        node.type = 'ScriptletInjectionRuleBody';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint8());
+                    // read children
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        parameterListDeserializer.ParameterListDeserializer.deserialize(buffer, node.children[i] = {}, frequentScriptletArgs);
+                    }
+                    break;
+                case abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case abpSnippetInjectionBodyCommon.AbpSnippetBodyMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}`);
+            }
+            prop = buffer.readUint8();
+        }
+    };
+}
+
+exports.ScriptletBodyDeserializer = ScriptletBodyDeserializer;

package/dist/cjs/deserializer/cosmetic/scriptlet-body/ubo-scriptlet-injection-body-deserializer.js

@@ -0,0 +1,38 @@
+/*
+ * 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 baseDeserializer = require('../../base-deserializer.js');
+var scriptletBodyDeserializer = require('./scriptlet-body-deserializer.js');
+var uboScriptletInjectionBodyCommon = require('../../../marshalling-utils/cosmetic/body/ubo-scriptlet-injection-body-common.js');
+
+/**
+ * Value map for binary deserialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ */
+let frequentUboScriptletArgsDeserializationMap;
+const getFrequentPlatformsDeserializationMap = () => {
+    if (!frequentUboScriptletArgsDeserializationMap) {
+        frequentUboScriptletArgsDeserializationMap = new Map(Array.from(uboScriptletInjectionBodyCommon.FREQUENT_UBO_SCRIPTLET_ARGS_SERIALIZATION_MAP).map(([key, value]) => [value, key]));
+    }
+    return frequentUboScriptletArgsDeserializationMap;
+};
+class UboScriptletInjectionBodyDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a scriptlet call body node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     * @throws If the binary data is malformed.
+     */
+    static deserialize(buffer, node) {
+        scriptletBodyDeserializer.ScriptletBodyDeserializer.deserialize(buffer, node, getFrequentPlatformsDeserializationMap());
+    }
+}
+
+exports.UboScriptletInjectionBodyDeserializer = UboScriptletInjectionBodyDeserializer;
+exports.getFrequentPlatformsDeserializationMap = getFrequentPlatformsDeserializationMap;

package/dist/cjs/deserializer/empty-rule-deserializer.js

@@ -0,0 +1,46 @@
+/*
+ * 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 baseDeserializer = require('./base-deserializer.js');
+var index = require('../nodes/index.js');
+var constants = require('../utils/constants.js');
+var emptyRuleCommon = require('../marshalling-utils/empty-rule-common.js');
+var adblockers = require('../utils/adblockers.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class EmptyRuleDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an empty rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.EmptyRule);
+        node.type = 'EmptyRule';
+        node.category = index.RuleCategory.Empty;
+        node.syntax = adblockers.AdblockSyntax.Common;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case emptyRuleCommon.EmptyRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case emptyRuleCommon.EmptyRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.EmptyRuleDeserializer = EmptyRuleDeserializer;

package/dist/cjs/deserializer/filterlist-deserializer.js

@@ -0,0 +1,83 @@
+/*
+ * 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('../utils/constants.js');
+var baseDeserializer = require('./base-deserializer.js');
+var ruleDeserializer = require('./rule-deserializer.js');
+var filterListCommon = require('../marshalling-utils/filter-list-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+class FilterListDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a filter list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.FilterListNode);
+        node.type = 'FilterList';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case filterListCommon.FilterListNodeMarshallingMap.Children:
+                    node.children = new Array(buffer.readUint32());
+                    for (let i = 0; i < node.children.length; i += 1) {
+                        ruleDeserializer.RuleDeserializer.deserialize(buffer, node.children[i] = {});
+                    }
+                    break;
+                case filterListCommon.FilterListNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case filterListCommon.FilterListNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+    /**
+     * Helper method to jump to the children of the filter list node.
+     *
+     * Filter lists serialized in binary format are structured as follows:
+     * - `FilterListNode` filter list node indicator (1 byte)
+     * - Properties:
+     *      - `Children` (1 byte) - children count, followed by children nodes
+     *      - `Start` (1 byte) - start offset, if present, followed by the value
+     *      - `End` (1 byte) - end offset, if present, followed by the value
+     *      - `NULL` (1 byte) - closing indicator
+     *
+     * This method skips indicators, reads the children count and returns it.
+     * This way the buffer is positioned at the beginning of the children nodes.
+     *
+     * @param buffer Reference to the input byte buffer.
+     * @returns Number of children nodes.
+     */
+    static jumpToChildren(buffer) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.FilterListNode); // filter list indicator
+        let prop = buffer.readUint8();
+        while (prop) {
+            switch (prop) {
+                case filterListCommon.FilterListNodeMarshallingMap.Children:
+                    return buffer.readUint32();
+                case filterListCommon.FilterListNodeMarshallingMap.Start:
+                case filterListCommon.FilterListNodeMarshallingMap.End:
+                    buffer.readUint32(); // ignore value
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+        return 0;
+    }
+}
+
+exports.FilterListDeserializer = FilterListDeserializer;

package/dist/cjs/deserializer/index.js

@@ -0,0 +1,15 @@
+/*
+ * 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 ruleDeserializer = require('./rule-deserializer.js');
+var syntaxDeserializationMap = require('./syntax-deserialization-map.js');
+
+
+
+exports.RuleDeserializer = ruleDeserializer.RuleDeserializer;
+exports.getSyntaxDeserializationMap = syntaxDeserializationMap.getSyntaxDeserializationMap;

package/dist/cjs/deserializer/invalid-rule-deserializer.js

@@ -0,0 +1,48 @@
+/*
+ * 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 baseDeserializer = require('./base-deserializer.js');
+var index = require('../nodes/index.js');
+var constants = require('../utils/constants.js');
+var invalidRuleErrorNodeDeserializer = require('./invalid-rule-error-node-deserializer.js');
+var invalidRuleCommon = require('../marshalling-utils/invalid-rule-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class InvalidRuleDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an invalid rule node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.InvalidRule);
+        node.type = 'InvalidRule';
+        node.category = index.RuleCategory.Invalid;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case invalidRuleCommon.InvalidRuleMarshallingMap.Error:
+                    invalidRuleErrorNodeDeserializer.InvalidRuleErrorNodeDeserializer.deserialize(buffer, node.error = {});
+                    break;
+                case invalidRuleCommon.InvalidRuleMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case invalidRuleCommon.InvalidRuleMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.InvalidRuleDeserializer = InvalidRuleDeserializer;

package/dist/cjs/deserializer/invalid-rule-error-node-deserializer.js

@@ -0,0 +1,48 @@
+/*
+ * 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 baseDeserializer = require('./base-deserializer.js');
+var constants = require('../utils/constants.js');
+var invalidRuleErrorNodeCommon = require('../marshalling-utils/invalid-rule-error-node-common.js');
+var binaryTypeCommon = require('../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class InvalidRuleErrorNodeDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes an invalid rule error node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.InvalidRuleErrorNode);
+        node.type = 'InvalidRuleError';
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Name:
+                    node.name = buffer.readString();
+                    break;
+                case invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Message:
+                    node.message = buffer.readString();
+                    break;
+                case invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case invalidRuleErrorNodeCommon.InvalidRuleErrorNodeMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.InvalidRuleErrorNodeDeserializer = InvalidRuleErrorNodeDeserializer;

package/dist/cjs/deserializer/misc/domain-list-deserializer.js

@@ -0,0 +1,66 @@
+/*
+ * 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('../../utils/constants.js');
+var index = require('../../nodes/index.js');
+var baseDeserializer = require('../base-deserializer.js');
+var domainListCommon = require('../../marshalling-utils/misc/domain-list-common.js');
+var listItemsDeserializer = require('./list-items-deserializer.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+/**
+ * Value map for binary deserialization. This helps to reduce the size of the serialized data,
+ * as it allows us to use a single byte to represent frequently used values.
+ */
+let separatorDeserializationMap;
+const getSeparatorDeserializationMap = () => {
+    if (!separatorDeserializationMap) {
+        separatorDeserializationMap = new Map(Array.from(domainListCommon.SEPARATOR_SERIALIZATION_MAP)
+            .map(([key, value]) => [value, key]));
+    }
+    return separatorDeserializationMap;
+};
+/**
+ * `DomainListDeserializer` is responsible for deserializing a domain list.
+ */
+class DomainListDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a modifier list node from binary format.
+     *
+     * @param buffer ByteBuffer for reading binary data.
+     * @param node Destination node.
+     */
+    static deserialize(buffer, node) {
+        buffer.assertUint8(binaryTypeCommon.BinaryTypeMarshallingMap.DomainListNode);
+        node.type = index.ListNodeType.DomainList;
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case domainListCommon.DomainListMarshallingMap.Separator:
+                    // eslint-disable-next-line max-len
+                    node.separator = (getSeparatorDeserializationMap().get(buffer.readUint8()) ?? constants.COMMA);
+                    break;
+                case domainListCommon.DomainListMarshallingMap.Children:
+                    listItemsDeserializer.ListItemsDeserializer.deserialize(buffer, node.children = []);
+                    break;
+                case domainListCommon.DomainListMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case domainListCommon.DomainListMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${prop}.`);
+            }
+            prop = buffer.readUint8();
+        }
+    }
+}
+
+exports.DomainListDeserializer = DomainListDeserializer;

package/dist/cjs/deserializer/misc/list-item-deserializer.js

@@ -0,0 +1,65 @@
+/*
+ * 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 baseDeserializer = require('../base-deserializer.js');
+var index = require('../../nodes/index.js');
+var constants = require('../../utils/constants.js');
+var listItemCommon = require('../../marshalling-utils/misc/list-item-common.js');
+var binaryTypeCommon = require('../../marshalling-utils/misc/binary-type-common.js');
+
+/* eslint-disable no-param-reassign */
+class ListItemDeserializer extends baseDeserializer.BaseDeserializer {
+    /**
+     * Deserializes a list item from binary format.
+     *
+     * @param buffer Input byte buffer.
+     * @param node Partial list item to deserialize.
+     * @template T Type of the list item.
+     */
+    static deserialize = (buffer, node) => {
+        const type = buffer.readUint8();
+        switch (type) {
+            case binaryTypeCommon.BinaryTypeMarshallingMap.AppNode:
+                node.type = index.ListItemNodeType.App;
+                break;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.DomainNode:
+                node.type = index.ListItemNodeType.Domain;
+                break;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.MethodNode:
+                node.type = index.ListItemNodeType.Method;
+                break;
+            case binaryTypeCommon.BinaryTypeMarshallingMap.StealthOptionNode:
+                node.type = index.ListItemNodeType.StealthOption;
+                break;
+            default:
+                throw new Error(`Invalid list item type: ${type}`);
+        }
+        let prop = buffer.readUint8();
+        while (prop !== constants.NULL) {
+            switch (prop) {
+                case listItemCommon.ListItemMarshallingMap.Exception:
+                    node.exception = buffer.readUint8() === 1;
+                    break;
+                case listItemCommon.ListItemMarshallingMap.Value:
+                    node.value = buffer.readString();
+                    break;
+                case listItemCommon.ListItemMarshallingMap.Start:
+                    node.start = buffer.readUint32();
+                    break;
+                case listItemCommon.ListItemMarshallingMap.End:
+                    node.end = buffer.readUint32();
+                    break;
+                default:
+                    throw new Error(`Invalid property: ${type}`);
+            }
+            prop = buffer.readUint8();
+        }
+    };
+}
+
+exports.ListItemDeserializer = ListItemDeserializer;

package/dist/cjs/deserializer/misc/list-items-deserializer.js

@@ -0,0 +1,28 @@
+/*
+ * 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 listItemDeserializer = require('./list-item-deserializer.js');
+
+class ListItemsDeserializer {
+    /**
+     * Deserializes a list of items from binary format.
+     *
+     * @param buffer Input byte buffer.
+     * @param items Partial list of items to deserialize.
+     * @template T Type of the list items.
+     */
+    static deserialize = (buffer, items) => {
+        const length = buffer.readUint16();
+        items.length = length;
+        for (let i = 0; i < length; i += 1) {
+            listItemDeserializer.ListItemDeserializer.deserialize(buffer, items[i] = {});
+        }
+    };
+}
+
+exports.ListItemsDeserializer = ListItemsDeserializer;