@adguard/agtree 2.2.0 → 3.0.0-alpha.2

package/dist/compatibility-tables/modifiers.js

@@ -0,0 +1,55 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { CompatibilityTableBase } from './base.js';
+import { modifiersCompatibilityTableData } from './compatibility-table-data.js';
+import { UNDERSCORE, EMPTY } from '../utils/constants.js';
+import { deepFreeze } from '../utils/deep-freeze.js';
+
+/**
+ * @file Compatibility tables for modifiers.
+ */
+/**
+ * Transforms the name of the modifier to a normalized form.
+ * This is a special case: the noop modifier normally '_', but it can consist of any number of characters,
+ * e.g. '____' is also valid. In this case, we need to normalize the name to '_'.
+ *
+ * @param name Modifier name to normalize.
+ * @returns Normalized modifier name.
+ */
+const noopModifierNameNormalizer = (name) => {
+    if (name.startsWith(UNDERSCORE)) {
+        if (name.split(EMPTY).every((char) => char === UNDERSCORE)) {
+            // in compatibility tables, we just store '_', so we need to reduce the number of underscores to 1
+            // before checking the existence of the noop modifier
+            return UNDERSCORE;
+        }
+    }
+    return name;
+};
+/**
+ * Compatibility table for modifiers.
+ */
+class ModifiersCompatibilityTable extends CompatibilityTableBase {
+    /**
+     * Creates a new instance of the compatibility table for modifiers.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data) {
+        super(data, noopModifierNameNormalizer);
+    }
+}
+/**
+ * Deep freeze the compatibility table data to avoid accidental modifications.
+ */
+deepFreeze(modifiersCompatibilityTableData);
+/**
+ * Compatibility table instance for modifiers.
+ */
+const modifiersCompatibilityTable = new ModifiersCompatibilityTable(modifiersCompatibilityTableData);
+
+export { modifiersCompatibilityTable };

package/dist/compatibility-tables/platforms.js

@@ -0,0 +1,76 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+/* eslint-disable no-bitwise */
+/**
+ * @file Provides platform enums.
+ * The difference between specific and generic platforms is that specific platforms are individual platforms
+ * (e.g. AdGuard for Windows, AdGuard for Android, etc.),
+ * while generic platforms are groups of specific platforms
+ * (e.g. AdGuard for any OS, AdGuard for any Chromium-based extension, etc.).
+ */
+/**
+ * List of specific platforms.
+ */
+const SpecificPlatform = {
+    AdgOsWindows: 1,
+    AdgOsMac: 1 << 1,
+    AdgOsAndroid: 1 << 2,
+    AdgExtChrome: 1 << 3,
+    AdgExtOpera: 1 << 4,
+    AdgExtEdge: 1 << 5,
+    AdgExtFirefox: 1 << 6,
+    AdgCbAndroid: 1 << 7,
+    AdgCbIos: 1 << 8,
+    AdgCbSafari: 1 << 9,
+    UboExtChrome: 1 << 10,
+    UboExtOpera: 1 << 11,
+    UboExtEdge: 1 << 12,
+    UboExtFirefox: 1 << 13,
+    AbpExtChrome: 1 << 14,
+    AbpExtOpera: 1 << 15,
+    AbpExtEdge: 1 << 16,
+    AbpExtFirefox: 1 << 17,
+};
+const AdgOsAny = SpecificPlatform.AdgOsWindows
+    | SpecificPlatform.AdgOsMac
+    | SpecificPlatform.AdgOsAndroid;
+const AdgSafariAny = SpecificPlatform.AdgCbSafari | SpecificPlatform.AdgCbIos;
+const AdgExtChromium = SpecificPlatform.AdgExtChrome
+    | SpecificPlatform.AdgExtOpera
+    | SpecificPlatform.AdgExtEdge;
+const AdgExtAny = AdgExtChromium | SpecificPlatform.AdgExtFirefox;
+const AdgAny = AdgExtAny | AdgOsAny | AdgSafariAny | SpecificPlatform.AdgCbAndroid;
+const UboExtChromium = SpecificPlatform.UboExtChrome
+    | SpecificPlatform.UboExtOpera
+    | SpecificPlatform.UboExtEdge;
+const UboExtAny = UboExtChromium | SpecificPlatform.UboExtFirefox;
+const UboAny = UboExtAny;
+const AbpExtChromium = SpecificPlatform.AbpExtChrome
+    | SpecificPlatform.AbpExtOpera
+    | SpecificPlatform.AbpExtEdge;
+const AbpExtAny = AbpExtChromium | SpecificPlatform.AbpExtFirefox;
+const AbpAny = AbpExtAny;
+const Any = AdgAny | UboAny | AbpAny;
+/**
+ * List of generic platforms (combinations of specific platforms).
+ */
+const GenericPlatform = {
+    AdgOsAny,
+    AdgSafariAny,
+    AdgExtChromium,
+    AdgExtAny,
+    AdgAny,
+    UboExtChromium,
+    UboExtAny,
+    UboAny,
+    AbpExtChromium,
+    AbpExtAny,
+    AbpAny,
+    Any,
+};
+
+export { GenericPlatform, SpecificPlatform };

package/dist/compatibility-tables/redirects.js

@@ -0,0 +1,100 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import { CompatibilityTableBase } from './base.js';
+import { redirectsCompatibilityTableData } from './compatibility-table-data.js';
+import { deepFreeze } from '../utils/deep-freeze.js';
+import { COLON } from '../utils/constants.js';
+import { getResourceTypeModifier } from './utils/resource-type-helpers.js';
+import { isString, isNull, isUndefined } from '../utils/type-guards.js';
+
+/**
+ * @file Compatibility tables for redirects.
+ */
+/**
+ * Prefix for resource redirection names.
+ */
+const ABP_RESOURCE_PREFIX = 'abp-resource:';
+const ABP_RESOURCE_PREFIX_LENGTH = ABP_RESOURCE_PREFIX.length;
+/**
+ * Normalizes the redirect name.
+ *
+ * @param name Redirect name to normalize.
+ *
+ * @returns Normalized redirect name.
+ *
+ * @example
+ * redirectNameNormalizer('abp-resource:my-resource') // => 'my-resource'
+ * redirectNameNormalizer('noop.js:99') // => 'noop.js'
+ */
+const redirectNameNormalizer = (name) => {
+    // Remove ABP resource prefix, if present
+    if (name.startsWith(ABP_RESOURCE_PREFIX)) {
+        return name.slice(ABP_RESOURCE_PREFIX_LENGTH);
+    }
+    // Remove :[integer] priority suffix from the name, if present
+    // See:
+    // - https://github.com/AdguardTeam/tsurlfilter/issues/59
+    // - https://github.com/gorhill/uBlock/wiki/Static-filter-syntax#redirect
+    const colonIndex = name.lastIndexOf(COLON);
+    if (colonIndex !== -1 && /^\d+$/.test(name.slice(colonIndex + 1))) {
+        return name.slice(0, colonIndex);
+    }
+    return name;
+};
+/**
+ * Compatibility table for redirects.
+ */
+class RedirectsCompatibilityTable extends CompatibilityTableBase {
+    /**
+     * Creates a new instance of the compatibility table for redirects.
+     *
+     * @param data Compatibility table data.
+     */
+    constructor(data) {
+        super(data, redirectNameNormalizer);
+    }
+    /**
+     * Gets the resource type adblock modifiers for the redirect for the given platform
+     * based on the `resourceTypes` field.
+     *
+     * @param redirect Redirect name or redirect data.
+     * @param platform Platform to get the modifiers for.
+     *
+     * @returns Set of resource type modifiers or an empty set if the redirect is not found or has no resource types.
+     */
+    getResourceTypeModifiers(redirect, platform) {
+        let redirectData = null;
+        if (isString(redirect)) {
+            redirectData = this.getFirst(redirect, platform);
+        }
+        else {
+            redirectData = redirect;
+        }
+        const modifierNames = new Set();
+        if (isNull(redirectData) || isUndefined(redirectData.resourceTypes)) {
+            return modifierNames;
+        }
+        for (const resourceType of redirectData.resourceTypes) {
+            const modifierName = getResourceTypeModifier(resourceType, platform);
+            if (isNull(modifierName)) {
+                continue;
+            }
+            modifierNames.add(modifierName);
+        }
+        return modifierNames;
+    }
+}
+/**
+ * Deep freeze the compatibility table data to avoid accidental modifications.
+ */
+deepFreeze(redirectsCompatibilityTableData);
+/**
+ * Compatibility table instance for redirects.
+ */
+const redirectsCompatibilityTable = new RedirectsCompatibilityTable(redirectsCompatibilityTableData);
+
+export { redirectsCompatibilityTable };

package/dist/compatibility-tables/schemas/base.js

@@ -0,0 +1,111 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+import './platform.js';
+import { zodToCamelCase } from '../utils/zod-camelcase.js';
+
+/**
+ * @file Base compatibility data schema, which is commonly used in compatibility tables.
+ */
+/**
+ * Zod schema for boolean values. Accepts both boolean and string values.
+ */
+const booleanSchema = zod.union([
+    zod.string().transform((val) => val.trim().toLowerCase() === 'true'),
+    zod.boolean(),
+]);
+/**
+ * Zod schema for non-empty string values.
+ */
+const nonEmptyStringSchema = zod
+    .string()
+    .transform((val) => val.trim())
+    .pipe(zod.string().min(1));
+/**
+ * Zod schema for base compatibility data.
+ * Here we use snake_case properties because the compatibility data is stored in YAML files.
+ */
+const baseCompatibilityDataSchema = zod.object({
+    /**
+     * Name of the actual entity.
+     */
+    name: nonEmptyStringSchema,
+    /**
+     * List of aliases for the entity (if any).
+     */
+    aliases: zod.array(nonEmptyStringSchema).nullable().default(null),
+    /**
+     * Short description of the actual entity.
+     * If not specified or it's value is `null`, then the description is not available.
+     */
+    description: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Link to the documentation. If not specified or it's value is `null`, then the documentation is not available.
+     */
+    docs: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * The version of the adblocker in which the entity was added.
+     * For AdGuard resources, the version of the library is specified.
+     */
+    version_added: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * The version of the adblocker when the entity was removed.
+     */
+    version_removed: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Describes whether the entity is deprecated.
+     */
+    deprecated: booleanSchema.default(false),
+    /**
+     * Message that describes why the entity is deprecated.
+     * If not specified or it's value is `null`, then the message is not available.
+     * It's value is omitted if the entity is not marked as deprecated.
+     */
+    deprecation_message: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Describes whether the entity is removed; for *already removed* features.
+     */
+    removed: booleanSchema.default(false),
+    /**
+     * Message that describes why the entity is removed.
+     * If not specified or it's value is `null`, then the message is not available.
+     * It's value is omitted if the entity is not marked as deprecated.
+     */
+    removal_message: nonEmptyStringSchema.nullable().default(null),
+});
+/**
+ * Zod schema for base compatibility data with camelCase properties.
+ */
+zodToCamelCase(baseCompatibilityDataSchema);
+/**
+ * Refinement logic for base compatibility data.
+ *
+ * @param data Base compatibility data.
+ * @param ctx Refinement context.
+ */
+const baseRefineLogic = (data, ctx) => {
+    if (data.deprecated && !data.deprecation_message) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'deprecation_message is required for deprecated modifiers',
+        });
+    }
+    if (!data.deprecated && data.deprecation_message) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'deprecation_message is only allowed for deprecated modifiers',
+        });
+    }
+    if (data.aliases && data.aliases.length !== new Set(data.aliases).size) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'Aliases must be unique',
+        });
+    }
+};
+
+export { baseCompatibilityDataSchema, baseRefineLogic, booleanSchema, nonEmptyStringSchema };

package/dist/compatibility-tables/schemas/modifier.js

@@ -0,0 +1,129 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+import { zodToCamelCase } from '../utils/zod-camelcase.js';
+import { baseCompatibilityDataSchema, nonEmptyStringSchema, booleanSchema, baseRefineLogic } from './base.js';
+import { getErrorMessage } from '../../utils/error.js';
+import { EMPTY } from '../../utils/constants.js';
+
+/**
+ * @file Schema for modifier data.
+ */
+/**
+ * Known validators that don't need to be validated as regex.
+ */
+const KNOWN_VALIDATORS = new Set([
+    'csp_value',
+    'domain',
+    'permissions_value',
+    'pipe_separated_apps',
+    'pipe_separated_denyallow_domains',
+    'pipe_separated_domains',
+    'pipe_separated_methods',
+    'pipe_separated_stealth_options',
+    'regexp',
+    'url',
+]);
+/**
+ * Zod schema for modifier data.
+ */
+zodToCamelCase(baseCompatibilityDataSchema.extend({
+    /**
+     * List of modifiers that are incompatible with the actual one.
+     */
+    conflicts: zod.array(nonEmptyStringSchema).nullable().default(null),
+    /**
+     * The actual modifier is incompatible with all other modifiers, except the ones listed in `conflicts`.
+     */
+    inverse_conflicts: booleanSchema.default(false),
+    /**
+     * Describes whether the actual modifier supports value assignment. For example, `$domain` is assignable,
+     * so it can be used like this: `$domain=domain.com\|~subdomain.domain.com`, where `=` is the assignment operator
+     * and `domain.com\|~subdomain.domain.com` is the value.
+     */
+    assignable: booleanSchema.default(false),
+    /**
+     * Describes whether the actual modifier can be negated. For example, `$third-party` is negatable,
+     * so it can be used like this: `$~third-party`.
+     */
+    negatable: booleanSchema.default(true),
+    /**
+     * The actual modifier can only be used in blocking rules, it cannot be used in exceptions.
+     * If it's value is `true`, then the modifier can be used only in blocking rules.
+     * `exception_only` and `block_only` cannot be used together (they are mutually exclusive).
+     */
+    block_only: booleanSchema.default(false),
+    /**
+     * The actual modifier can only be used in exceptions, it cannot be used in blocking rules.
+     * If it's value is `true`, then the modifier can be used only in exceptions.
+     * `exception_only` and `block_only` cannot be used together (they are mutually exclusive).
+     */
+    exception_only: booleanSchema.default(false),
+    /**
+     * Describes whether the *assignable* modifier value is required.
+     * For example, `$cookie` is assignable but it can be used without a value in exception rules:
+     * `@@\|\|example.com^$cookie`.
+     * If `false`, the `value_format` is required, e.g. the value of `$app` should always be specified
+     */
+    value_optional: booleanSchema.default(false),
+    /**
+     * Describes the format of the value for the *assignable* modifier.
+     * Its value can be a regex pattern or a known validator name (e.g. `domain`, `pipe_separated_domains`, etc.).
+     */
+    value_format: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Describes the flags for the `value_format` regex pattern.
+     */
+    value_format_flags: nonEmptyStringSchema.nullable().default(null),
+}).superRefine((data, ctx) => {
+    // TODO: find something better, for now we can't add refine logic to the base schema:
+    // https://github.com/colinhacks/zod/issues/454#issuecomment-848370721
+    baseRefineLogic(data, ctx);
+    if (data.block_only && data.exception_only) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'block_only and exception_only are mutually exclusive',
+        });
+    }
+    if (data.assignable && !data.value_format) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'value_format is required for assignable modifiers',
+        });
+    }
+    if (data.value_format) {
+        const valueFormat = data.value_format.trim();
+        // if it is a known validator, we don't need to validate it further
+        if (KNOWN_VALIDATORS.has(valueFormat)) {
+            if (data.value_format_flags) {
+                ctx.addIssue({
+                    code: zod.ZodIssueCode.custom,
+                    message: 'value_format_flags are not allowed for known validators',
+                });
+            }
+            return;
+        }
+        // otherwise, we need to validate it as a regex
+        try {
+            new RegExp(valueFormat, data.value_format_flags ?? EMPTY);
+        }
+        catch (error) {
+            ctx.addIssue({
+                code: zod.ZodIssueCode.custom,
+                message: getErrorMessage(error),
+            });
+        }
+    }
+    else if (data.value_format_flags) {
+        ctx.addIssue({
+            code: zod.ZodIssueCode.custom,
+            message: 'value_format is required for value_format_flags',
+        });
+    }
+}));
+
+export { KNOWN_VALIDATORS };

package/dist/compatibility-tables/schemas/platform.js

@@ -0,0 +1,69 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+import { SPECIFIC_PLATFORM_MAP, GENERIC_PLATFORM_MAP } from '../utils/platform-helpers.js';
+import { isUndefined } from '../../utils/type-guards.js';
+
+/* eslint-disable no-bitwise */
+/**
+ * @file Platform schema.
+ */
+/**
+ * Platform separator, e.g. 'adg_os_any|adg_safari_any' means any AdGuard OS platform and
+ * any AdGuard Safari content blocker platform.
+ */
+const PLATFORM_SEPARATOR = '|';
+/**
+ * Platform negation character, e.g. 'adg_any|~adg_safari_any' means any AdGuard product except
+ * Safari content blockers.
+ */
+const PLATFORM_NEGATION = '~';
+/**
+ * Parses a raw platform string into a platform bitmask.
+ *
+ * @param rawPlatforms Raw platform string, e.g. 'adg_safari_any|adg_os_any'.
+ *
+ * @returns Platform bitmask.
+ */
+const parseRawPlatforms = (rawPlatforms) => {
+    // e.g. 'adg_safari_any|adg_os_any'
+    const rawPlatformList = rawPlatforms
+        .split(PLATFORM_SEPARATOR)
+        .map((rawPlatform) => rawPlatform.trim());
+    let result = 0;
+    for (let rawPlatform of rawPlatformList) {
+        // negation, e.g. 'adg_any|~adg_safari_any' means any AdGuard product except Safari content blockers
+        let negated = false;
+        if (rawPlatform.startsWith(PLATFORM_NEGATION)) {
+            negated = true;
+            rawPlatform = rawPlatform.slice(1).trim();
+        }
+        const platform = SPECIFIC_PLATFORM_MAP.get(rawPlatform) ?? GENERIC_PLATFORM_MAP.get(rawPlatform);
+        if (isUndefined(platform)) {
+            throw new Error(`Unknown platform: ${rawPlatform}`);
+        }
+        if (negated) {
+            result &= ~platform;
+        }
+        else {
+            result |= platform;
+        }
+    }
+    if (result === 0) {
+        throw new Error('No platforms specified');
+    }
+    return result;
+};
+/**
+ * Platform schema.
+ */
+zod
+    .string()
+    .min(1)
+    .transform((value) => parseRawPlatforms(value));
+
+export { parseRawPlatforms };

package/dist/compatibility-tables/schemas/redirect.js

@@ -0,0 +1,29 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+import { zodToCamelCase } from '../utils/zod-camelcase.js';
+import { baseCompatibilityDataSchema, booleanSchema, baseRefineLogic } from './base.js';
+import { resourceTypeSchema } from './resource-type.js';
+
+/**
+ * @file Schema for redirect data.
+ */
+/**
+ * Zod schema for redirect data.
+ */
+zodToCamelCase(baseCompatibilityDataSchema.extend({
+    /**
+     * Whether the redirect is blocking.
+     */
+    is_blocking: booleanSchema.default(false),
+    /**
+     * Resource type(s) belonging to the redirect.
+     *
+     * @see {@link https://developer.chrome.com/docs/extensions/reference/declarativeNetRequest/#type-ResourceType}
+     */
+    resource_types: zod.array(resourceTypeSchema).default([]),
+}).superRefine(baseRefineLogic));

package/dist/compatibility-tables/schemas/resource-type.js

@@ -0,0 +1,36 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+
+/**
+ * @file Resource type schema.
+ */
+/**
+ * Resource type.
+ *
+ * @see {@link https://developer.chrome.com/docs/extensions/reference/declarativeNetRequest/#type-ResourceType}
+ */
+const ResourceType = {
+    MainFrame: 'main_frame',
+    SubFrame: 'sub_frame',
+    Stylesheet: 'stylesheet',
+    Script: 'script',
+    Image: 'image',
+    Font: 'font',
+    Object: 'object',
+    XmlHttpRequest: 'xmlhttprequest',
+    Ping: 'ping',
+    Media: 'media',
+    WebSocket: 'websocket',
+    Other: 'other',
+};
+/**
+ * Resource type schema.
+ */
+const resourceTypeSchema = zod.nativeEnum(ResourceType);
+
+export { ResourceType, resourceTypeSchema };

package/dist/compatibility-tables/schemas/scriptlet.js

@@ -0,0 +1,79 @@
+/*
+ * AGTree v3.0.0-alpha.2 (build date: Tue, 17 Dec 2024 16:50:04 GMT)
+ * (c) 2024 Adguard Software Ltd.
+ * Released under the MIT license
+ * https://github.com/AdguardTeam/tsurlfilter/tree/master/packages/agtree#readme
+ */
+import zod from 'zod';
+import { zodToCamelCase } from '../utils/zod-camelcase.js';
+import { nonEmptyStringSchema, booleanSchema, baseCompatibilityDataSchema, baseRefineLogic } from './base.js';
+
+/**
+ * @file Schema for scriptlet data.
+ */
+/**
+ * Zod schema for scriptlet parameter data.
+ */
+const scriptletParameterSchema = zod.object({
+    /**
+     * Name of the actual parameter.
+     */
+    name: nonEmptyStringSchema,
+    /**
+     * Describes whether the parameter is required. Empty parameters are not allowed.
+     */
+    required: booleanSchema,
+    /**
+     * Short description of the parameter.
+     * If not specified or it's value is `null`,then the description is not available.
+     */
+    description: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Regular expression that matches the value of the parameter.
+     * If it's value is `null`, then the parameter value is not checked.
+     */
+    pattern: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Default value of the parameter (if any).
+     */
+    default: nonEmptyStringSchema.nullable().default(null),
+    /**
+     * Describes whether the parameter is used only for debugging purposes.
+     */
+    debug: booleanSchema.default(false),
+});
+/**
+ * Zod schema for scriptlet parameters.
+ */
+const scriptletParametersSchema = zod.array(scriptletParameterSchema);
+/**
+ * Zod schema for scriptlet data.
+ */
+zodToCamelCase(baseCompatibilityDataSchema.extend({
+    /**
+     * List of parameters that the scriptlet accepts.
+     * **Every** parameter should be listed here, because we check that the scriptlet is used correctly
+     * (e.g. that the number of parameters is correct).
+     */
+    parameters: scriptletParametersSchema.optional(),
+}).superRefine((data, ctx) => {
+    // TODO: find something better, for now we can't add refine logic to the base schema:
+    // https://github.com/colinhacks/zod/issues/454#issuecomment-848370721
+    baseRefineLogic(data, ctx);
+    // we don't allow required parameters after optional ones
+    if (!data.parameters) {
+        return;
+    }
+    let optionalFound = false;
+    for (const parameter of data.parameters) {
+        if (optionalFound && parameter.required) {
+            ctx.addIssue({
+                code: zod.ZodIssueCode.custom,
+                message: 'Required parameters must be before optional ones',
+            });
+        }
+        if (!parameter.required) {
+            optionalFound = true;
+        }
+    }
+}));