@via-profit/ability 2.1.0 → 3.1.0

package/dist/index.js

@@ -2,7 +2,99 @@
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 19:
+/***/ 6:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+
+
+/***/ }),
+
+/***/ 829:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityInMemoryCache = void 0;
+class AbilityInMemoryCache {
+    store = new Map();
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expires) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    async set(key, value, ttlSeconds = 60) {
+        this.store.set(key, {
+            value,
+            expires: Date.now() + ttlSeconds * 1000,
+        });
+    }
+    serialize(input) {
+        return this.fastHash(this.stableStringify(input));
+    }
+    async delete(key) {
+        this.store.delete(key);
+    }
+    async clear() {
+        this.store.clear();
+    }
+    async deleteByPrefix(prefix) {
+        for (const key of this.store.keys()) {
+            if (key.startsWith(prefix)) {
+                this.store.delete(key);
+            }
+        }
+    }
+    fastHash(str) {
+        let hash = 5381;
+        for (let i = 0; i < str.length; i++) {
+            hash = (hash * 33) ^ str.charCodeAt(i);
+        }
+        return (hash >>> 0).toString(36);
+    }
+    stableStringify(obj) {
+        if (obj === null)
+            return 'null';
+        const type = typeof obj;
+        if (type === 'string')
+            return JSON.stringify(obj);
+        if (type === 'number' || type === 'boolean')
+            return String(obj);
+        if (type === 'undefined')
+            return 'undefined';
+        if (Array.isArray(obj)) {
+            let out = '[';
+            for (let i = 0; i < obj.length; i++) {
+                if (i > 0)
+                    out += ',';
+                out += this.stableStringify(obj[i]);
+            }
+            return out + ']';
+        }
+        const keys = Object.keys(obj);
+        keys.sort();
+        let out = '{';
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            if (i > 0)
+                out += ',';
+            out += k + ':' + this.stableStringify(obj[k]);
+        }
+        return out + '}';
+    }
+}
+exports.AbilityInMemoryCache = AbilityInMemoryCache;
+
+
+/***/ }),
+
+/***/ 301:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -29,7 +121,7 @@ exports["default"] = AbilityCode;
 
 /***/ }),
 
-/***/ 923:
+/***/ 413:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -38,7 +130,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityCompare = void 0;
-const AbilityCode_1 = __importDefault(__webpack_require__(19));
+const AbilityCode_1 = __importDefault(__webpack_require__(301));
 class AbilityCompare extends AbilityCode_1.default {
     static and = new AbilityCompare('and');
     static or = new AbilityCompare('or');
@@ -49,7 +141,7 @@ exports["default"] = AbilityCompare;
 
 /***/ }),
 
-/***/ 261:
+/***/ 167:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -58,23 +150,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityCondition = void 0;
-const AbilityCode_1 = __importDefault(__webpack_require__(19));
-const AbilityError_1 = __webpack_require__(122);
+const AbilityCode_1 = __importDefault(__webpack_require__(301));
+const AbilityError_1 = __webpack_require__(216);
 class AbilityCondition extends AbilityCode_1.default {
-    static equal = new AbilityCondition('=');
-    static not_equal = new AbilityCondition('<>');
-    static more_than = new AbilityCondition('>');
+    static equals = new AbilityCondition('=');
+    static not_equals = new AbilityCondition('<>');
+    static greater_than = new AbilityCondition('>');
     static less_than = new AbilityCondition('<');
     static less_or_equal = new AbilityCondition('<=');
-    static more_or_equal = new AbilityCondition('>=');
+    static greater_or_equal = new AbilityCondition('>=');
     static in = new AbilityCondition('in');
     static not_in = new AbilityCondition('not in');
+    static contains = new AbilityCondition('contains');
+    static not_contains = new AbilityCondition('not contains');
+    static length_greater_than = new AbilityCondition('length greater than');
+    static length_less_than = new AbilityCondition('length less than');
+    static length_equals = new AbilityCondition('length equals');
     static fromLiteral(literal) {
-        const code = AbilityCondition[literal]?.code || null;
-        if (code === null) {
-            throw new AbilityError_1.AbilityParserError(`Literal ${literal} does not found in AbilityCondition class`);
+        switch (literal) {
+            case 'equals':
+                return this.equals;
+            case 'not_equals':
+                return this.not_equals;
+            case 'greater_than':
+                return this.greater_than;
+            case 'less_than':
+                return this.less_than;
+            case 'less_or_equal':
+                return this.less_or_equal;
+            case 'greater_or_equal':
+                return this.greater_or_equal;
+            case 'contains':
+                return this.contains;
+            case 'no_contains':
+                return this.not_contains;
+            case 'in':
+                return this.in;
+            case 'not_in':
+                return this.not_in;
+            case 'length_greater_than':
+                return this.length_greater_than;
+            case 'length_equals':
+                return this.length_equals;
+            default:
+                throw new AbilityError_1.AbilityParserError(`Literal ${literal} does not found in AbilityCondition class`);
         }
-        return new AbilityCondition(code);
     }
     get literal() {
         const literal = Object.keys(AbilityCondition).find(member => {
@@ -93,7 +213,7 @@ exports["default"] = AbilityCondition;
 
 /***/ }),
 
-/***/ 122:
+/***/ 216:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -115,7 +235,75 @@ exports.AbilityParserError = AbilityParserError;
 
 /***/ }),
 
-/***/ 909:
+/***/ 221:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityExplainPolicy = exports.AbilityExplainRuleSet = exports.AbilityExplainRule = exports.AbilityExplain = void 0;
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
+class AbilityExplain {
+    type;
+    children;
+    name;
+    match;
+    constructor(config, children = []) {
+        this.type = config.type;
+        this.children = children;
+        this.name = config.name;
+        this.match = config.match;
+    }
+    toString(indent = 0) {
+        const pad = ' '.repeat(indent);
+        const mark = this.match.code === AbilityMatch_1.default.match.code ? '✓' : '✗';
+        let out = `${pad}${mark} ${this.type} «${this.name}» is ${this.match.code}`;
+        this.children.forEach(child => {
+            out += '\n' + child.toString(indent + 1);
+        });
+        return out;
+    }
+}
+exports.AbilityExplain = AbilityExplain;
+class AbilityExplainRule extends AbilityExplain {
+    constructor(rule) {
+        super({
+            type: 'rule',
+            match: rule.state,
+            name: rule.name,
+        });
+    }
+}
+exports.AbilityExplainRule = AbilityExplainRule;
+class AbilityExplainRuleSet extends AbilityExplain {
+    constructor(ruleSet) {
+        const children = ruleSet.rules.map(rule => new AbilityExplainRule(rule));
+        super({
+            type: 'ruleSet',
+            match: ruleSet.state,
+            name: ruleSet.name,
+        }, children);
+    }
+}
+exports.AbilityExplainRuleSet = AbilityExplainRuleSet;
+class AbilityExplainPolicy extends AbilityExplain {
+    constructor(policy) {
+        const children = policy.ruleSet.map(ruleSet => new AbilityExplainRuleSet(ruleSet));
+        super({
+            type: 'policy',
+            name: policy.name,
+            match: policy.matchState,
+        }, children);
+    }
+}
+exports.AbilityExplainPolicy = AbilityExplainPolicy;
+
+
+/***/ }),
+
+/***/ 247:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -124,7 +312,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityMatch = void 0;
-const AbilityCode_1 = __importDefault(__webpack_require__(19));
+const AbilityCode_1 = __importDefault(__webpack_require__(301));
 class AbilityMatch extends AbilityCode_1.default {
     static pending = new AbilityMatch('pending');
     static match = new AbilityMatch('match');
@@ -136,7 +324,7 @@ exports["default"] = AbilityMatch;
 
 /***/ }),
 
-/***/ 189:
+/***/ 147:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -145,23 +333,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityParser = void 0;
-const AbilityError_1 = __webpack_require__(122);
-const AbilityCondition_1 = __importDefault(__webpack_require__(261));
+const AbilityError_1 = __webpack_require__(216);
+const AbilityCondition_1 = __importDefault(__webpack_require__(167));
 class AbilityParser {
-    /*
-     *
-     *  readonly ['order.update']: {
-     *     readonly user: {
-     *       readonly roles: readonly string[];
-     *       readonly department: string;
-     *     };
-     *     readonly order: {
-     *       readonly estimatedArrivalAt: number;
-     *       readonly status: string;
-     *     }
-     *  }
-     *
-     * */
     /**
      * Sets a value in a nested object structure based on a dot/bracket notation path.
      * @param object - The target object to modify.
@@ -169,52 +343,223 @@ class AbilityParser {
      * @param value - The value to set at the specified path.
      */
     static setValueDotValue(object, path, value) {
-        const way = path.replace(/\[/g, '.').replace(/\]/g, '').split('.');
+        if (!path || path.trim().length === 0) {
+            throw new AbilityError_1.AbilityParserError(`Invalid path provided on a [${path}]`);
+        }
+        const way = path.replace(/\[/g, '.').replace(/]/g, '').split('.');
         const last = way.pop();
         if (!last) {
             throw new AbilityError_1.AbilityParserError(`Invalid path provided on a [${path}]`);
         }
-        way.reduce((o, k, i, kk) => {
-            if (!o[k]) {
-                o[k] = isFinite(Number(kk[i + 1])) ? [] : {};
+        const lastObj = way.reduce((acc, key, index, array) => {
+            const currentValue = acc[key];
+            const nextKey = array[index + 1];
+            const shouldBeArray = nextKey !== undefined && isFinite(Number(nextKey));
+            if (currentValue === undefined || currentValue === null) {
+                // Create missing property
+                const newValue = shouldBeArray ? [] : {};
+                acc[key] = newValue;
+                return newValue;
+            }
+            if (typeof currentValue !== 'object') {
+                throw new AbilityError_1.AbilityParserError(`Cannot set property '${key}' on non-object value at path: ${path}`);
             }
-            return o[k];
-        }, object)[last] = value;
+            return currentValue;
+        }, object);
+        const existingValue = lastObj[last];
+        if (existingValue !== undefined &&
+            typeof existingValue === 'object' &&
+            existingValue !== null &&
+            !Array.isArray(existingValue)) {
+            throw new AbilityError_1.AbilityParserError(`Cannot set primitive value on existing object at path: ${path}`);
+        }
+        lastObj[last] = value;
     }
     /**
      * Generates TypeScript type definitions based on the provided policies.
      * @param policies - An array of AbilityPolicy instances.
-     * @param outPath - The output path for the generated type definitions.
-     * @returns A record containing the generated type definitions.
+     * @returns A generated type definitions.
      */
-    static generateTypeDefs(policies, outPath) {
-        const record = {};
+    static generateTypeDefs(policies) {
+        // Structure to store types: { [action]: { [subjectPath]: type } }
+        const typeStructure = {};
+        // Iterate through all policies
         policies.forEach(policy => {
+            const action = policy.permission;
+            // Initialize object for action if it doesn't exist
+            if (!typeStructure[action]) {
+                typeStructure[action] = {};
+            }
+            // Iterate through all ruleSets in the policy
             policy.ruleSet.forEach(ruleSet => {
+                // Iterate through all rules in the ruleSet
                 ruleSet.rules.forEach(rule => {
-                    let value = 'any';
-                    switch (true) {
-                        case rule.condition.isEqual(AbilityCondition_1.default.not_equal):
-                        case rule.condition.isEqual(AbilityCondition_1.default.equal):
-                            value = typeof rule.resource;
-                            break;
-                        case rule.condition.isEqual(AbilityCondition_1.default.in):
-                        case rule.condition.isEqual(AbilityCondition_1.default.not_in):
-                            value = `${typeof rule.resource}[]`;
-                            break;
-                        case rule.condition.isEqual(AbilityCondition_1.default.more_or_equal):
-                        case rule.condition.isEqual(AbilityCondition_1.default.more_than):
-                        case rule.condition.isEqual(AbilityCondition_1.default.less_or_equal):
-                        case rule.condition.isEqual(AbilityCondition_1.default.less_than):
-                            value = 'number';
-                            break;
+                    const subjectPath = rule.subject;
+                    const existingType = typeStructure[action][subjectPath];
+                    const ruleType = this.determineTypeFromRule(rule);
+                    // If a type already exists for this path, create a union
+                    if (existingType && existingType !== ruleType) {
+                        typeStructure[action][subjectPath] = `${existingType} | ${ruleType}`;
+                    }
+                    else {
+                        typeStructure[action][subjectPath] = ruleType;
                     }
-                    AbilityParser.setValueDotValue(record, rule.subject, value);
                 });
             });
         });
-        console.log(JSON.stringify(record));
-        return record;
+        // Transform flat structure into nested structure for easier use
+        const nestedStructure = this.buildNestedStructure(typeStructure);
+        return this.formatTypeDefinitions(nestedStructure);
+    }
+    /**
+     * Determines TypeScript type based on the rule
+     * @param rule - The rule to analyze
+     * @returns TypeScript type as string
+     */
+    static determineTypeFromRule(rule) {
+        // Numeric comparisons - always number
+        if (rule.condition.isEqual(AbilityCondition_1.default.greater_than) ||
+            rule.condition.isEqual(AbilityCondition_1.default.less_than) ||
+            rule.condition.isEqual(AbilityCondition_1.default.greater_or_equal) ||
+            rule.condition.isEqual(AbilityCondition_1.default.less_or_equal)) {
+            return 'number';
+        }
+        // Array operations
+        if (rule.condition.isEqual(AbilityCondition_1.default.in) ||
+            rule.condition.isEqual(AbilityCondition_1.default.not_in)) {
+            return this.getArrayType(rule.resource);
+        }
+        // Equality/Inequality operations
+        if (rule.condition.isEqual(AbilityCondition_1.default.equals) ||
+            rule.condition.isEqual(AbilityCondition_1.default.not_equals)) {
+            return this.getPrimitiveType(rule.resource);
+        }
+        return 'any';
+    }
+    /**
+     * Gets TypeScript type for array values
+     * @param resource - The resource value to analyze
+     * @returns TypeScript array type as string
+     */
+    static getArrayType(resource) {
+        if (Array.isArray(resource)) {
+            if (resource.length === 0)
+                return 'any[]';
+            // Determine types of array elements
+            const elementTypes = new Set(resource.map(item => this.getPrimitiveType(item)));
+            const elementType = elementTypes.size === 1
+                ? Array.from(elementTypes)[0]
+                : `(${Array.from(elementTypes).join(' | ')})`;
+            return `${elementType}[]`;
+        }
+        // If resource is not an array but condition is in/not_in,
+        // it expects an array of such elements
+        return `${this.getPrimitiveType(resource)}[]`;
+    }
+    /**
+     * Gets primitive TypeScript type for a value
+     * @param value - The value to analyze
+     * @returns TypeScript primitive type as string
+     */
+    static getPrimitiveType(value) {
+        if (value === null)
+            return 'null';
+        if (value === undefined)
+            return 'undefined';
+        switch (typeof value) {
+            case 'string':
+                return 'string';
+            case 'number':
+                return 'number';
+            case 'boolean':
+                return 'boolean';
+            case 'object':
+                if (Array.isArray(value)) {
+                    return 'array'; // special marker, handled separately
+                }
+                return 'object';
+            default:
+                return 'any';
+        }
+    }
+    /**
+     * Builds nested structure from flat paths
+     * Example: 'user.profile.name' -> { user: { profile: { name: 'string' } } }
+     * @param flatStructure - Flat structure with dot notation paths
+     * @returns Nested object structure
+     */
+    static buildNestedStructure(flatStructure) {
+        const result = {};
+        Object.entries(flatStructure).forEach(([action, paths]) => {
+            result[action] = {};
+            Object.entries(paths).forEach(([path, type]) => {
+                const parts = path.split('.');
+                let current = result[action];
+                // Iterate through all parts except the last one
+                for (let i = 0; i < parts.length - 1; i++) {
+                    const part = parts[i];
+                    const currentValue = current[part];
+                    if (!currentValue || typeof currentValue !== 'object') {
+                        const newObj = {};
+                        current[part] = newObj;
+                        current = newObj;
+                    }
+                    else {
+                        current = currentValue;
+                    }
+                }
+                // Set type for the last part
+                const lastPart = parts[parts.length - 1];
+                current[lastPart] = type;
+            });
+        });
+        return result;
+    }
+    /**
+     * Formats type structure into a string
+     * @param structure - Nested type structure
+     * @returns Formatted TypeScript type definition string
+     */
+    static formatTypeDefinitions(structure) {
+        let output = '// Automatically generated by via-profit/ability\n';
+        output += '// Do not edit manually\n';
+        output += '\n/* eslint-disable */\n\n';
+        output += 'export type Resources = {\n';
+        // Sort actions for stable output
+        const sortedActions = Object.keys(structure).sort();
+        sortedActions.forEach(action => {
+            output += `  ['${action}']: {\n`;
+            output += this.formatNestedObject(structure[action], 4);
+            output += '  };\n';
+        });
+        output += '}\n';
+        return output;
+    }
+    /**
+     * Recursively formats nested object
+     * @param obj - Object to format
+     * @param indent - Current indentation level
+     * @returns Formatted string
+     */
+    static formatNestedObject(obj, indent) {
+        const spaces = ' '.repeat(indent);
+        let output = '';
+        // Sort keys for stable output
+        const sortedKeys = Object.keys(obj).sort();
+        sortedKeys.forEach(key => {
+            const value = obj[key];
+            if (typeof value === 'object' && value !== null) {
+                // Nested object
+                output += `${spaces}readonly ${key}: {\n`;
+                output += this.formatNestedObject(value, indent + 2);
+                output += `${spaces}};\n`;
+            }
+            else {
+                // Primitive type
+                output += `${spaces}readonly ${key}: ${value};\n`;
+            }
+        });
+        return output;
     }
 }
 exports.AbilityParser = AbilityParser;
@@ -223,7 +568,7 @@ exports["default"] = AbilityParser;
 
 /***/ }),
 
-/***/ 844:
+/***/ 278:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -232,10 +577,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityPolicy = void 0;
-const AbilityRuleSet_1 = __importDefault(__webpack_require__(402));
-const AbilityMatch_1 = __importDefault(__webpack_require__(909));
-const AbilityCompare_1 = __importDefault(__webpack_require__(923));
-const AbilityPolicyEffect_1 = __importDefault(__webpack_require__(277));
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
+const AbilityCompare_1 = __importDefault(__webpack_require__(413));
+const AbilityExplain_1 = __webpack_require__(221);
+const AbilityError_1 = __webpack_require__(216);
+const AbilityJSONParser_1 = __webpack_require__(909);
+const AbilityDSLParser_1 = __webpack_require__(577);
 class AbilityPolicy {
     matchState = AbilityMatch_1.default.pending;
     /**
@@ -262,15 +609,17 @@ class AbilityPolicy {
      */
     id;
     /**
-     * Soon
+     * Running the `enforce` or `resolve` method
+     * will select only those from all passed policies that fall under the specified permission key.
      */
-    action;
+    permission;
     constructor(params) {
-        const { name, id, action, effect } = params;
+        const { name, id, permission, effect, compareMethod = AbilityCompare_1.default.and } = params;
         this.name = name;
         this.id = id;
-        this.action = action;
+        this.permission = permission;
         this.effect = effect;
+        this.compareMethod = compareMethod;
     }
     /**
      * Add rule set to the policy
@@ -280,57 +629,78 @@ class AbilityPolicy {
         this.ruleSet.push(ruleSet);
         return this;
     }
+    /**
+     * Add rule set to the policy
+     * @param ruleSets - The array of rule set to add
+     */
+    addRuleSets(ruleSets) {
+        for (const ruleSet of ruleSets) {
+            this.ruleSet.push(ruleSet);
+        }
+        return this;
+    }
     /**
      * Check if the policy is matched
-     * @param resources - The resource to check
+     * @param resource - The resource to check
+     * @param environment - The user environment object
      */
-    check(resources) {
+    async check(resource, environment) {
         this.matchState = AbilityMatch_1.default.mismatch;
         if (!this.ruleSet.length) {
             return this.matchState;
         }
-        const rulesetCheckStates = this.ruleSet.reduce((collect, ruleSet) => {
-            return collect.concat(ruleSet.check(resources));
-        }, []);
+        const rulesetCheckStates = [];
+        for (const ruleSet of this.ruleSet) {
+            const state = await ruleSet.check(resource, environment);
+            rulesetCheckStates.push(state);
+            if (AbilityCompare_1.default.and.isEqual(this.compareMethod) && AbilityMatch_1.default.mismatch.isEqual(state)) {
+                return this.matchState; // mismatch
+            }
+            if (AbilityCompare_1.default.or.isEqual(this.compareMethod) && AbilityMatch_1.default.match.isEqual(state)) {
+                this.matchState = AbilityMatch_1.default.match;
+                return this.matchState;
+            }
+        }
         if (AbilityCompare_1.default.and.isEqual(this.compareMethod)) {
-            if (rulesetCheckStates.every(ruleState => AbilityMatch_1.default.match.isEqual(ruleState))) {
+            if (rulesetCheckStates.every(s => AbilityMatch_1.default.match.isEqual(s))) {
                 this.matchState = AbilityMatch_1.default.match;
             }
         }
         if (AbilityCompare_1.default.or.isEqual(this.compareMethod)) {
-            if (rulesetCheckStates.some(ruleState => AbilityMatch_1.default.match.isEqual(ruleState))) {
+            if (rulesetCheckStates.some(s => AbilityMatch_1.default.match.isEqual(s))) {
                 this.matchState = AbilityMatch_1.default.match;
             }
         }
         return this.matchState;
     }
+    explain() {
+        if (this.matchState === AbilityMatch_1.default.pending) {
+            throw new AbilityError_1.AbilityError('First, run the check method, then explain');
+        }
+        return new AbilityExplain_1.AbilityExplainPolicy(this);
+    }
+    /**
+     * Parses an array of policy configurations into an array of AbilityPolicy instances.
+     * @param configs - Array of policy configurations
+     * @returns Array of AbilityPolicy instances
+     */
+    static fromJSONAll(configs) {
+        return AbilityJSONParser_1.AbilityJSONParser.parse(configs);
+    }
     /**
      * Parse the config JSON format to Policy class instance
      */
-    static parse(config) {
-        const { id, name, ruleSet, compareMethod, action, effect } = config;
-        // Create the empty policy
-        const policy = new AbilityPolicy({
-            name,
-            id,
-            action,
-            effect: new AbilityPolicyEffect_1.default(effect),
-        });
-        policy.compareMethod = new AbilityCompare_1.default(compareMethod);
-        ruleSet.forEach(ruleSetConfig => {
-            policy.addRuleSet(AbilityRuleSet_1.default.parse(ruleSetConfig));
-        });
-        return policy;
+    static fromJSON(config) {
+        return AbilityJSONParser_1.AbilityJSONParser.parsePolicy(config);
     }
-    export() {
-        return {
-            id: this.id.toString(),
-            name: this.name.toString(),
-            compareMethod: this.compareMethod.code.toString(),
-            ruleSet: this.ruleSet.map(rule => rule.export()),
-            action: this.action,
-            effect: this.effect.code,
-        };
+    static fromDSL(dsl) {
+        return new AbilityDSLParser_1.AbilityDSLParser(dsl).parse()[0];
+    }
+    toJSON() {
+        return AbilityJSONParser_1.AbilityJSONParser.toJSON([this])[0];
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
     }
 }
 exports.AbilityPolicy = AbilityPolicy;
@@ -339,7 +709,7 @@ exports["default"] = AbilityPolicy;
 
 /***/ }),
 
-/***/ 277:
+/***/ 179:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -348,7 +718,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityPolicyEffect = void 0;
-const AbilityCode_1 = __importDefault(__webpack_require__(19));
+const AbilityCode_1 = __importDefault(__webpack_require__(301));
 class AbilityPolicyEffect extends AbilityCode_1.default {
     static deny = new AbilityPolicyEffect('deny');
     static permit = new AbilityPolicyEffect('permit');
@@ -359,7 +729,7 @@ exports["default"] = AbilityPolicyEffect;
 
 /***/ }),
 
-/***/ 668:
+/***/ 634:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -368,90 +738,159 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityResolver = void 0;
-const AbilityPolicyEffect_1 = __importDefault(__webpack_require__(277));
-const AbilityMatch_1 = __importDefault(__webpack_require__(909));
-const AbilityError_1 = __webpack_require__(122);
+const AbilityError_1 = __webpack_require__(216);
+const AbilityResult_1 = __webpack_require__(941);
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
 class AbilityResolver {
     policies;
-    constructor(policyOrListOfPolicies) {
+    cache;
+    constructor(
+    /**
+     * `Important!` The incorrect Resources type was intentionally passed to AbilityPolicy so that TypeScript could suggest the name of the permission and the structure of its resource in the parse method.
+     */
+    policyOrListOfPolicies, options) {
+        const { cache } = options || {};
+        this.cache = cache;
         this.policies = Array.isArray(policyOrListOfPolicies)
             ? policyOrListOfPolicies
             : [policyOrListOfPolicies];
     }
     /**
-     * Resolve policy for the resource and action
+     * Resolve policy for the resource and permission key
      *
-     @param action - Action
+     * @param permission - Permission key
      * @param resource - Resource
+     * @param environment
+     */
+    async resolve(permission, resource, environment) {
+        const filteredPolicies = this.policies.filter(policy => AbilityResolver.isInPermissionContain(policy.permission, String(permission).replace(/^permission\./, '')));
+        for (const policy of filteredPolicies) {
+            const cacheKey = this.cache ? this.makeCacheKey(policy.id, resource, environment) : '';
+            // cache
+            if (this.cache) {
+                const cached = await this.cache.get(cacheKey);
+                if (cached !== undefined) {
+                    policy.matchState = cached;
+                    continue;
+                }
+            }
+            const policyMatchState = await policy.check(resource, environment);
+            if (policyMatchState === AbilityMatch_1.default.pending) {
+                throw new AbilityError_1.AbilityError(`The policy "${policy.name}" is still in a pending state. Make sure to call "check" to evaluate the policy before resolving permissions.`);
+            }
+            if (this.cache) {
+                await this.cache.set(cacheKey, policyMatchState);
+            }
+        }
+        return new AbilityResult_1.AbilityResult(filteredPolicies);
+    }
+    async enforce(permission, resource, environment) {
+        const result = await this.resolve(permission, resource, environment);
+        if (result.isDenied()) {
+            const policyName = result.getLastMatchedPolicy()?.name?.toString() || 'unknown';
+            throw new AbilityError_1.AbilityError(`Permission denied by policy "${policyName}"`);
+        }
+    }
+    /**
+     * Check if the permission key is contained in another permission key
+     * @param permissionA - The first permission to check
+     * @param permissionB - The second permission to check
      */
-    resolve(action, resource) {
-        const filteredPolicies = this.policies.filter(policy => {
-            return AbilityResolver.isInActionContain(policy.action, String(action));
+    static isInPermissionContain(permissionA, permissionB) {
+        const A = permissionA.split('.');
+        const B = permissionB.split('.');
+        const [longer, shorter] = A.length >= B.length ? [A, B] : [B, A];
+        return shorter.every((chunk, i) => {
+            return chunk === '*' || longer[i] === '*' || chunk === longer[i];
         });
-        filteredPolicies.map(policy => policy.check(resource));
-        this.policies = filteredPolicies;
-        return this;
     }
-    enforce(action, resource) {
-        const resolver = this.resolve(action, resource);
-        if (resolver.isDeny()) {
-            throw new AbilityError_1.AbilityError(resolver.getMatchedPolicy()?.name?.toString() || 'Unknown permission error');
+    makeCacheKey(policyId, resource, environment) {
+        if (!this.cache) {
+            return '';
         }
+        return `policy:${policyId}:res:${this.cache.serialize(resource)}:env:${this.cache.serialize(environment)}`;
+    }
+    async invalidatePolicy(policyId) {
+        await this.cache?.deleteByPrefix(policyId);
+    }
+    async invalidateCache() {
+        await this.cache?.clear();
     }
+}
+exports.AbilityResolver = AbilityResolver;
+exports["default"] = AbilityResolver;
+
+
+/***/ }),
+
+/***/ 941:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityResult = void 0;
+const AbilityExplain_1 = __webpack_require__(221);
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
+const AbilityPolicyEffect_1 = __importDefault(__webpack_require__(179));
+class AbilityResult {
     /**
-     * Get the last effect of the policy
+     * Already checked policies (after call the policy.check())
+     */
+    policies;
+    constructor(policies) {
+        this.policies = policies;
+    }
+    /**
+     * Returns a list of explanations for each policy involved in the ability evaluation.
+     * Each item describes how a specific policy contributed to the final permission result.
      *
-     * @returns {AbilityPolicyEffect | null}
+     * Useful for debugging, logging, or building UI tools that visualize permission logic.
      */
-    getEffect() {
-        const effects = this.policies.reduce((collect, policy, _index) => {
-            if (policy.matchState.isEqual(AbilityMatch_1.default.match)) {
-                return collect.concat(policy.effect);
+    explain() {
+        return this.policies.map(policy => {
+            return new AbilityExplain_1.AbilityExplainPolicy(policy);
+        });
+    }
+    getLastMatchedPolicy() {
+        for (let i = this.policies.length - 1; i >= 0; i--) {
+            if (this.policies[i].matchState.isEqual(AbilityMatch_1.default.match)) {
+                return this.policies[i];
             }
-            return collect;
-        }, []);
-        if (effects.length) {
-            return effects[effects.length - 1];
         }
         return null;
     }
-    isPermit() {
-        const effect = this.getEffect();
-        return effect !== null && effect.isEqual(AbilityPolicyEffect_1.default.permit);
+    isAllowed() {
+        const effect = this.getLastEffectOfMatchedPolicy();
+        return effect?.isEqual(AbilityPolicyEffect_1.default.permit) ?? false;
     }
-    isDeny() {
-        const effect = this.getEffect();
-        return effect !== null && effect.isEqual(AbilityPolicyEffect_1.default.deny);
-    }
-    getMatchedPolicy() {
-        const matchedPolicies = this.policies.filter(policy => policy.matchState.isEqual(AbilityMatch_1.default.match));
-        const lastPolicy = matchedPolicies.length ? matchedPolicies[matchedPolicies.length - 1] : null;
-        return lastPolicy || null;
+    isDenied() {
+        const effect = this.getLastEffectOfMatchedPolicy();
+        return effect?.isEqual(AbilityPolicyEffect_1.default.deny) ?? true;
     }
     /**
-     * Check if the action is contained in another action
-     * @param actionA - The first action to check
-     * @param actionB - The second action to check
+     * Get the last effect of the policy
+     *
+     * @returns {AbilityPolicyEffect | null}
      */
-    static isInActionContain(actionA, actionB) {
-        const actionAArray = String(actionA).split('.');
-        const actionBArray = String(actionB).split('.');
-        const a = actionAArray.length >= actionBArray.length ? actionAArray : actionBArray;
-        const b = actionBArray.length <= actionAArray.length ? actionBArray : actionAArray;
-        const c = a.reduce((acc, chunk, index) => {
-            const iterationRes = chunk === b[index] || b[index] === '*' || chunk === '*';
-            return acc.concat(iterationRes);
-        }, []);
-        return c.every(Boolean);
+    getLastEffectOfMatchedPolicy() {
+        for (let i = this.policies.length - 1; i >= 0; i--) {
+            const p = this.policies[i];
+            if (p.matchState.isEqual(AbilityMatch_1.default.match)) {
+                return p.effect;
+            }
+        }
+        return null;
     }
 }
-exports.AbilityResolver = AbilityResolver;
-exports["default"] = AbilityResolver;
+exports.AbilityResult = AbilityResult;
 
 
 /***/ }),
 
-/***/ 476:
+/***/ 306:
 /***/ (function(__unused_webpack_module, exports, __webpack_require__) {
 
 
@@ -460,8 +899,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AbilityRule = void 0;
-const AbilityMatch_1 = __importDefault(__webpack_require__(909));
-const AbilityCondition_1 = __importDefault(__webpack_require__(261));
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
+const AbilityCondition_1 = __importDefault(__webpack_require__(167));
+const AbilityJSONParser_1 = __webpack_require__(909);
 /**
  * Represents a rule that defines a condition to be checked against a subject and resource.
  */
@@ -480,17 +920,17 @@ class AbilityRule {
     state = AbilityMatch_1.default.pending;
     /**
      * Creates an instance of AbilityRule.
-     * @param {string} options.id - The unique identifier of the rule.
-     * @param {string} options.name - The name of the rule.
-     * @param {AbilityCondition} options.condition - The condition to evaluate.
-     * @param {string} options.subject - The subject of the rule.
-     * @param {string} options.resource - The resource to compare against.
+     * @param {string} params.id - The unique identifier of the rule.
+     * @param {string} params.name - The name of the rule.
+     * @param {AbilityCondition} params.condition - The condition to evaluate.
+     * @param {string} params.subject - The subject of the rule.
+     * @param {string} params.resource - The resource to compare against.
      * @param params
      */
     constructor(params) {
         const { id, name, subject, resource, condition } = params;
-        this.id = id;
-        this.name = name;
+        this.name = name || `${JSON.stringify(subject)} ${condition.code} ${JSON.stringify(resource)}`;
+        this.id = id || this.name;
         this.subject = subject;
         this.resource = resource;
         this.condition = condition;
@@ -498,54 +938,139 @@ class AbilityRule {
     /**
      * Check if the rule is matched
      * @param resource - The resource to check
+     * @param environment
      */
-    check(resource) {
+    async check(resource, environment) {
         let is = false;
-        const [valueS, valueO] = this.extractValues(resource);
+        const [subjectValue, resourceValue] = this.extractValues(resource, environment);
+        const isValue = (v) => typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || v === null;
+        // equals
+        if (AbilityCondition_1.default.equals.isEqual(this.condition)) {
+            is = subjectValue === resourceValue;
+        }
+        // not equals
+        if (AbilityCondition_1.default.not_equals.isEqual(this.condition)) {
+            is = subjectValue !== resourceValue;
+        }
+        // less than
         if (AbilityCondition_1.default.less_than.isEqual(this.condition)) {
-            is = Number(valueS) < Number(valueO);
+            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
+                is = subjectValue < resourceValue;
+            }
         }
+        // less or equal
         if (AbilityCondition_1.default.less_or_equal.isEqual(this.condition)) {
-            is = Number(valueS) <= Number(valueO);
+            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
+                is = subjectValue <= resourceValue;
+            }
         }
-        if (AbilityCondition_1.default.more_than.isEqual(this.condition)) {
-            is = Number(valueS) > Number(valueO);
+        // more than
+        if (AbilityCondition_1.default.greater_than.isEqual(this.condition)) {
+            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
+                is = subjectValue > resourceValue;
+            }
         }
-        if (AbilityCondition_1.default.more_or_equal.isEqual(this.condition)) {
-            is = Number(valueS) >= Number(valueO);
+        // more or equal
+        if (AbilityCondition_1.default.greater_or_equal.isEqual(this.condition)) {
+            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
+                is = subjectValue >= resourceValue;
+            }
         }
-        if (AbilityCondition_1.default.equal.isEqual(this.condition)) {
-            is = valueS === valueO;
+        // in
+        if (AbilityCondition_1.default.in.isEqual(this.condition)) {
+            // value in array
+            if (isValue(subjectValue) && Array.isArray(resourceValue)) {
+                is = resourceValue.includes(subjectValue);
+            }
+            // array intersects array
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = subjectValue.some(v => resourceValue.includes(v));
+            }
         }
-        if (AbilityCondition_1.default.not_equal.isEqual(this.condition)) {
-            is = valueS !== valueO;
+        // not in
+        if (AbilityCondition_1.default.not_in.isEqual(this.condition)) {
+            if (isValue(subjectValue) && Array.isArray(resourceValue)) {
+                is = !resourceValue.includes(subjectValue);
+            }
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = !subjectValue.some(v => resourceValue.includes(v));
+            }
         }
-        if (AbilityCondition_1.default.in.isEqual(this.condition)) {
-            // [<some>] and [<some>]
-            if (Array.isArray(valueS) && Array.isArray(valueO)) {
-                is = valueS.some(v => valueO.find(v1 => v1 === v));
+        // contains
+        if (AbilityCondition_1.default.contains.isEqual(this.condition)) {
+            // array contains value
+            if (Array.isArray(subjectValue) && isValue(resourceValue)) {
+                is = subjectValue.includes(resourceValue);
+            }
+            // array intersects array
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = subjectValue.some(v => resourceValue.includes(v));
+            }
+        }
+        // not contains
+        if (AbilityCondition_1.default.not_contains.isEqual(this.condition)) {
+            if (Array.isArray(subjectValue) && isValue(resourceValue)) {
+                is = !subjectValue.includes(resourceValue);
+            }
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = !subjectValue.some(v => resourceValue.includes(v));
+            }
+        }
+        // length equals
+        if (AbilityCondition_1.default.length_equals.isEqual(this.condition)) {
+            // foo.bar == n
+            if (isValue(subjectValue) && typeof resourceValue === 'number') {
+                is = String(subjectValue).length === resourceValue;
             }
-            // <some> and [<some>]
-            if ((typeof valueS === 'string' || typeof valueS === 'number') && Array.isArray(valueO)) {
-                is = valueO.includes(valueS);
+            // ['foo', 'bar'] = n
+            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
+                is = subjectValue.length === resourceValue;
             }
-            // [<some>] and <some>
-            if ((typeof valueO === 'string' || typeof valueO === 'number') && Array.isArray(valueS)) {
-                is = valueS.includes(valueO);
+            // ['foo', 'bar'] = ['baz', 'taz']
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = subjectValue.length === resourceValue.length;
+            }
+            // 'foo' = 'bar'
+            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
+                is = subjectValue.length === resourceValue.length;
             }
         }
-        if (AbilityCondition_1.default.not_in.isEqual(this.condition)) {
-            // [<some>] and [<some>]
-            if (Array.isArray(valueS) && Array.isArray(valueO)) {
-                is = !valueS.some(v => valueO.find(v1 => v1 === v));
+        // length greater than
+        if (AbilityCondition_1.default.length_greater_than.isEqual(this.condition)) {
+            // foo.bar > n
+            if (isValue(subjectValue) && typeof resourceValue === 'number') {
+                is = String(subjectValue).length > resourceValue;
+            }
+            // ['foo', 'bar'] > n
+            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
+                is = subjectValue.length > resourceValue;
+            }
+            // ['foo', 'bar'] > ['baz', 'taz']
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = subjectValue.length > resourceValue.length;
             }
-            // <some> and [<some>]
-            if ((typeof valueS === 'string' || typeof valueS === 'number') && Array.isArray(valueO)) {
-                is = !valueO.includes(valueS);
+            // 'foo' > 'bar'
+            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
+                is = subjectValue.length > resourceValue.length;
             }
-            // [<some>] and <some>
-            if ((typeof valueO === 'string' || typeof valueO === 'number') && Array.isArray(valueS)) {
-                is = !valueS.includes(valueO);
+        }
+        // length greater than
+        if (AbilityCondition_1.default.length_less_than.isEqual(this.condition)) {
+            // foo.bar < n
+            if (isValue(subjectValue) && typeof resourceValue === 'number') {
+                is = String(subjectValue).length < resourceValue;
+            }
+            // ['foo', 'bar'] < n
+            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
+                is = subjectValue.length < resourceValue;
+            }
+            // ['foo', 'bar'] < ['baz', 'taz']
+            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
+                is = subjectValue.length < resourceValue.length;
+            }
+            // 'foo' < 'bar'
+            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
+                is = subjectValue.length < resourceValue.length;
             }
         }
         this.state = is ? AbilityMatch_1.default.match : AbilityMatch_1.default.mismatch;
@@ -554,29 +1079,44 @@ class AbilityRule {
     /**
      * Extract values from the resourceData
      * @param resourceData - The resourceData to extract values from
+     * @param environment - Environment data
      */
-    extractValues(resourceData) {
-        let leftSideValue;
-        let rightSideValue;
-        if (resourceData === null || typeof resourceData === 'undefined') {
+    extractValues(resourceData, environment) {
+        let subjectValue;
+        let resourceValue;
+        if ((resourceData === null || typeof resourceData === 'undefined') &&
+            (environment === null || typeof environment === 'undefined')) {
             return [NaN, NaN];
         }
-        const isPath = (str) => {
-            return typeof str === 'string' && str.match(/\./g) !== null;
-        };
-        if (isPath(this.subject)) {
-            leftSideValue = this.getDotNotationValue(resourceData, this.subject);
+        // left side resolve
+        if (this.subject.includes('.')) {
+            // if is environment
+            if (this.subject.startsWith('env.') && typeof environment !== 'undefined') {
+                subjectValue = this.getDotNotationValue(environment, this.subject.replace(/^env\./, ''));
+                // if is resource
+            }
+            else {
+                subjectValue = this.getDotNotationValue(resourceData, this.subject);
+            }
         }
         else {
-            leftSideValue = this.subject;
+            subjectValue = this.subject;
         }
-        if (isPath(this.resource)) {
-            rightSideValue = this.getDotNotationValue(resourceData, this.resource);
+        // right side resolve
+        if (typeof this.resource === 'string' && this.resource.includes('.')) {
+            // if is environment
+            if (this.resource.startsWith('env.') && typeof environment !== 'undefined') {
+                resourceValue = this.getDotNotationValue(environment, this.resource.replace(/^env\./, ''));
+            }
+            else {
+                // if is resource
+                resourceValue = this.getDotNotationValue(resourceData, this.resource);
+            }
         }
         else {
-            rightSideValue = this.resource;
+            resourceValue = this.resource;
         }
-        return [leftSideValue, rightSideValue];
+        return [subjectValue, resourceValue];
     }
     /**
      * Get the value of the object by dot notation
@@ -587,7 +1127,7 @@ class AbilityRule {
         const arr = desc.split('.');
         while (arr.length && resource) {
             const comp = arr.shift() || '';
-            const match = new RegExp('(.+)\\[([0-9]*)\\]').exec(comp);
+            const match = new RegExp('(.+)\\[([0-9]*)]').exec(comp);
             if (match !== null && match.length == 3) {
                 const arrayData = {
                     arrName: match[1],
@@ -606,63 +1146,124 @@ class AbilityRule {
         }
         return resource;
     }
-    static parse(config) {
-        const { id, name, subject, resource, condition } = config;
+    toString() {
+        return `AbilityRule: ${this.name} condition: ${this.condition.code} subject: "${this.subject?.toString()}" resource: "${this.resource?.toString()}"`;
+    }
+    static fromJSON(config) {
+        return AbilityJSONParser_1.AbilityJSONParser.parseRule(config);
+    }
+    static equals(subject, resource) {
         return new AbilityRule({
-            id,
-            name,
+            condition: AbilityCondition_1.default.equals,
             subject,
             resource,
-            condition: new AbilityCondition_1.default(condition),
         });
     }
-    /**
-     * Export the rule to config object
-     */
-    export() {
-        return {
-            id: this.id,
-            name: this.name,
-            subject: this.subject,
-            resource: this.resource,
-            condition: this.condition.code,
-        };
+    static notEquals(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.not_equals,
+            subject,
+            resource,
+        });
     }
-}
-exports.AbilityRule = AbilityRule;
-exports["default"] = AbilityRule;
-
-
-/***/ }),
-
-/***/ 402:
-/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
-
-
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbilityRuleSet = void 0;
-const AbilityRule_1 = __importDefault(__webpack_require__(476));
-const AbilityCompare_1 = __importDefault(__webpack_require__(923));
-const AbilityMatch_1 = __importDefault(__webpack_require__(909));
-class AbilityRuleSet {
-    state = AbilityMatch_1.default.pending;
-    /**
-     * List of rules
-     */
-    rules = [];
-    /**
-     * Rules compare method.\
-     * For the «and» method the rule will be permitted if all\
-     * rules will be returns «permit» status and for the «or» - if\
-     * one of the rules returns as «permit»
-     */
-    compareMethod = AbilityCompare_1.default.and;
-    /**
-     * Group name
-     */
+    static contains(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.contains,
+            subject,
+            resource,
+        });
+    }
+    static notContains(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.not_contains,
+            subject,
+            resource,
+        });
+    }
+    static notIn(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.not_in,
+            subject,
+            resource,
+        });
+    }
+    static in(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.in,
+            subject,
+            resource,
+        });
+    }
+    static notEqual(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.not_equals,
+            subject,
+            resource,
+        });
+    }
+    static lessThan(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.less_than,
+            subject,
+            resource,
+        });
+    }
+    static lessOrEqual(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.less_or_equal,
+            subject,
+            resource,
+        });
+    }
+    static moreThan(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.greater_than,
+            subject,
+            resource,
+        });
+    }
+    static moreOrEqual(subject, resource) {
+        return new AbilityRule({
+            condition: AbilityCondition_1.default.greater_or_equal,
+            subject,
+            resource,
+        });
+    }
+}
+exports.AbilityRule = AbilityRule;
+exports["default"] = AbilityRule;
+
+
+/***/ }),
+
+/***/ 56:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityRuleSet = void 0;
+const AbilityCompare_1 = __importDefault(__webpack_require__(413));
+const AbilityMatch_1 = __importDefault(__webpack_require__(247));
+const AbilityJSONParser_1 = __webpack_require__(909);
+class AbilityRuleSet {
+    state = AbilityMatch_1.default.pending;
+    /**
+     * List of rules
+     */
+    rules = [];
+    /**
+     * Rules compare method.\
+     * For the «and» method the rule will be permitted if all\
+     * rules will be returns «permit» status and for the «or» - if\
+     * one of the rules returns as «permit»
+     */
+    compareMethod = AbilityCompare_1.default.and;
+    /**
+     * Group name
+     */
     name;
     /**
      * Group ID
@@ -670,8 +1271,8 @@ class AbilityRuleSet {
     id;
     constructor(params) {
         const { name, id, compareMethod } = params;
-        this.name = name;
-        this.id = id;
+        this.name = name || '';
+        this.id = id || this.name;
         this.compareMethod = compareMethod;
     }
     addRule(rule) {
@@ -682,50 +1283,53 @@ class AbilityRuleSet {
         rules.forEach(rule => this.addRule(rule));
         return this;
     }
-    check(resources) {
+    async check(resources, environment) {
         this.state = AbilityMatch_1.default.mismatch;
         if (!this.rules.length) {
             return this.state;
         }
-        const ruleCheckStates = this.rules.reduce((collect, rule) => {
-            return collect.concat(rule.check(resources));
-        }, []);
+        const ruleCheckStates = [];
+        for (const rule of this.rules) {
+            const state = await rule.check(resources, environment);
+            ruleCheckStates.push(state);
+            if (AbilityCompare_1.default.and.isEqual(this.compareMethod) && AbilityMatch_1.default.mismatch.isEqual(state)) {
+                return this.state; // mismatch
+            }
+            if (AbilityCompare_1.default.or.isEqual(this.compareMethod) && AbilityMatch_1.default.match.isEqual(state)) {
+                this.state = AbilityMatch_1.default.match;
+                return this.state;
+            }
+        }
         if (AbilityCompare_1.default.and.isEqual(this.compareMethod)) {
-            if (ruleCheckStates.every(ruleState => AbilityMatch_1.default.match.isEqual(ruleState))) {
+            if (ruleCheckStates.every(s => AbilityMatch_1.default.match.isEqual(s))) {
                 this.state = AbilityMatch_1.default.match;
             }
         }
         if (AbilityCompare_1.default.or.isEqual(this.compareMethod)) {
-            if (ruleCheckStates.some(ruleState => AbilityMatch_1.default.match.isEqual(ruleState))) {
+            if (ruleCheckStates.some(s => AbilityMatch_1.default.match.isEqual(s))) {
                 this.state = AbilityMatch_1.default.match;
             }
         }
         return this.state;
     }
+    toString() {
+        return `AbilityRuleSet: ${this.name} compareMethod: ${this.compareMethod.code}, rules: ${this.rules.map(rule => rule.toString()).join('\n')}`;
+    }
     /**
      * Parse the config JSON format to Group class instance
      */
-    static parse(config) {
-        const { id, name, rules, compareMethod } = config;
-        const ruleSet = new AbilityRuleSet({
-            compareMethod: new AbilityCompare_1.default(compareMethod),
-            name,
-            id,
-        });
-        // Adding rules if exists
-        if (rules && rules.length > 0) {
-            const abilityRules = rules.map(ruleConfig => AbilityRule_1.default.parse(ruleConfig));
-            ruleSet.addRules(abilityRules);
-        }
-        return ruleSet;
+    static fromJSON(config) {
+        return AbilityJSONParser_1.AbilityJSONParser.parseRuleSet(config);
     }
-    export() {
-        return {
-            id: this.id.toString(),
-            name: this.name.toString(),
-            compareMethod: this.compareMethod.code.toString(),
-            rules: this.rules.map(rule => rule.export()),
-        };
+    static and(rules) {
+        return new AbilityRuleSet({
+            compareMethod: AbilityCompare_1.default.and,
+        }).addRules(rules);
+    }
+    static or(rules) {
+        return new AbilityRuleSet({
+            compareMethod: AbilityCompare_1.default.or,
+        }).addRules(rules);
     }
 }
 exports.AbilityRuleSet = AbilityRuleSet;
@@ -753,17 +1357,1207 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__webpack_require__(19), exports);
-__exportStar(__webpack_require__(923), exports);
-__exportStar(__webpack_require__(261), exports);
-__exportStar(__webpack_require__(122), exports);
+__exportStar(__webpack_require__(301), exports);
+__exportStar(__webpack_require__(413), exports);
+__exportStar(__webpack_require__(167), exports);
+__exportStar(__webpack_require__(216), exports);
+__exportStar(__webpack_require__(247), exports);
+__exportStar(__webpack_require__(147), exports);
+__exportStar(__webpack_require__(278), exports);
+__exportStar(__webpack_require__(179), exports);
+__exportStar(__webpack_require__(634), exports);
+__exportStar(__webpack_require__(306), exports);
+__exportStar(__webpack_require__(56), exports);
+__exportStar(__webpack_require__(221), exports);
+__exportStar(__webpack_require__(941), exports);
+__exportStar(__webpack_require__(6), exports);
+__exportStar(__webpack_require__(829), exports);
 __exportStar(__webpack_require__(909), exports);
-__exportStar(__webpack_require__(189), exports);
-__exportStar(__webpack_require__(844), exports);
-__exportStar(__webpack_require__(277), exports);
-__exportStar(__webpack_require__(668), exports);
-__exportStar(__webpack_require__(476), exports);
-__exportStar(__webpack_require__(402), exports);
+__exportStar(__webpack_require__(577), exports);
+__exportStar(__webpack_require__(10), exports);
+__exportStar(__webpack_require__(325), exports);
+
+
+/***/ }),
+
+/***/ 10:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityDSLLexer = void 0;
+const AbilityDSLToken_1 = __webpack_require__(325);
+class AbilityDSLLexer {
+    input;
+    pos = 0;
+    tokens = [];
+    line = 1;
+    column = 1;
+    // Список ключевых слов
+    keywords = new Set([
+        'if',
+        'all',
+        'any',
+        'of',
+        'permit',
+        'allow',
+        'deny',
+        'forbidden',
+        'true',
+        'false',
+        'null',
+        'contains',
+        'includes',
+        'length',
+        'has',
+        'in',
+        'gt',
+        'lt',
+        'gte',
+        'lte',
+        'equals',
+        'greater',
+        'less',
+        'not',
+        'is',
+        'or',
+        'than',
+    ]);
+    constructor(input) {
+        this.input = input;
+    }
+    tokenize() {
+        while (!this.isAtEnd()) {
+            this.skipWhitespace();
+            if (this.isAtEnd())
+                break;
+            const char = this.peek();
+            if (char === '#') {
+                this.tokens.push(this.readComment());
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                this.tokens.push(this.readString());
+                continue;
+            }
+            if (this.isDigit(char)) {
+                this.tokens.push(this.readNumber());
+                continue;
+            }
+            if (this.isSymbol(char)) {
+                this.tokens.push(this.readSymbol());
+                continue;
+            }
+            if (this.isAlpha(char)) {
+                this.tokens.push(this.readWord());
+                continue;
+            }
+            throw new Error(`Unexpected character '${char}' at ${this.line}:${this.column}`);
+        }
+        this.tokens.push(new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.EOF, '', this.line, this.column));
+        return this.tokens;
+    }
+    readComment() {
+        const startLine = this.line;
+        const startColumn = this.column;
+        this.advance(); // skip '#'
+        let value = '';
+        while (!this.isAtEnd() && !this.isNewline()) {
+            value += this.advance();
+        }
+        return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.COMMENT, value.trim(), startLine, startColumn);
+    }
+    readString() {
+        const startLine = this.line;
+        const startColumn = this.column;
+        const quote = this.advance();
+        let value = '';
+        let escaped = false;
+        while (!this.isAtEnd()) {
+            const char = this.advance();
+            if (escaped) {
+                value += char;
+                escaped = false;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (char === quote) {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.STRING, value, startLine, startColumn);
+            }
+            value += char;
+        }
+        throw new Error(`Unterminated string at ${startLine}:${startColumn}`);
+    }
+    readNumber() {
+        const startLine = this.line;
+        const startColumn = this.column;
+        const start = this.pos;
+        while (!this.isAtEnd() && this.isDigit(this.peek())) {
+            this.advance();
+        }
+        const value = this.input.slice(start, this.pos);
+        return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.NUMBER, value, startLine, startColumn);
+    }
+    readSymbol() {
+        const startLine = this.line;
+        const startColumn = this.column;
+        const char = this.advance();
+        switch (char) {
+            case '.':
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.DOT, char, startLine, startColumn);
+            case ':':
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.COLON, char, startLine, startColumn);
+            case ',':
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.COMMA, char, startLine, startColumn);
+            case '[':
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.LBRACKET, char, startLine, startColumn);
+            case ']':
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.RBRACKET, char, startLine, startColumn);
+            case '>':
+                if (this.peek() === '=') {
+                    this.advance();
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '>=', startLine, startColumn);
+                }
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '>', startLine, startColumn);
+            case '<':
+                if (this.peek() === '=') {
+                    this.advance();
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '<=', startLine, startColumn);
+                }
+                if (this.peek() === '>') {
+                    this.advance();
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '<>', startLine, startColumn);
+                }
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '<', startLine, startColumn);
+            case '=':
+                if (this.peek() === '=') {
+                    this.advance();
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '==', startLine, startColumn);
+                }
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '=', startLine, startColumn);
+            case '!':
+                if (this.peek() === '=') {
+                    this.advance();
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.SYMBOL, '!=', startLine, startColumn);
+                }
+                throw new Error(`Unexpected symbol '!' at ${this.line}:${this.column}`);
+            default:
+                throw new Error(`Unknown symbol '${char}' at ${this.line}:${this.column}`);
+        }
+    }
+    readWord() {
+        const startLine = this.line;
+        const startColumn = this.column;
+        const start = this.pos;
+        // Первый сегмент
+        while (!this.isAtEnd() && /[a-zA-Z0-9_*]/.test(this.peek())) {
+            this.advance();
+        }
+        // Сегменты через точку
+        while (!this.isAtEnd() && this.peek() === '.') {
+            this.advance(); // dot
+            if (!/[a-zA-Z_*]/.test(this.peek())) {
+                break;
+            }
+            while (!this.isAtEnd() && /[a-zA-Z0-9_*]/.test(this.peek())) {
+                this.advance();
+            }
+        }
+        const word = this.input.slice(start, this.pos);
+        // Если есть точка — это путь (identifier или permission)
+        if (word.includes('.')) {
+            const last = this.tokens[this.tokens.length - 1];
+            if (last?.code === AbilityDSLToken_1.AbilityDSLToken.EFFECT) {
+                if (word.startsWith('permission.')) {
+                    return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.PERMISSION, word, startLine, startColumn);
+                }
+            }
+            return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER, word, startLine, startColumn);
+        }
+        // Ключевые слова
+        if (this.keywords.has(word)) {
+            // Эффекты
+            if (word === 'permit' || word === 'allow') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.EFFECT, 'permit', startLine, startColumn);
+            }
+            if (word === 'deny' || word === 'forbidden') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.EFFECT, 'deny', startLine, startColumn);
+            }
+            // Групповые ключевые слова
+            if (word === 'all') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.ALL, word, startLine, startColumn);
+            }
+            if (word === 'any') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.ANY, word, startLine, startColumn);
+            }
+            if (word === 'of') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.OF, word, startLine, startColumn);
+            }
+            if (word === 'if') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.IF, word, startLine, startColumn);
+            }
+            // Булевы и null
+            if (word === 'true' || word === 'false') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.BOOLEAN, word, startLine, startColumn);
+            }
+            if (word === 'null') {
+                return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.NULL, word, startLine, startColumn);
+            }
+            // Остальные ключевые слова (contains, in, equals, greater, less, not, is, or, than, equal)
+            return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.KEYWORD, word, startLine, startColumn);
+        }
+        // Если после EFFECT и нет точки — действие (например, "create")
+        const lastToken = this.tokens[this.tokens.length - 1];
+        if (lastToken?.code === AbilityDSLToken_1.AbilityDSLToken.EFFECT) {
+            return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.PERMISSION, word, startLine, startColumn);
+        }
+        // Обычный идентификатор
+        return new AbilityDSLToken_1.AbilityDSLToken(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER, word, startLine, startColumn);
+    }
+    skipWhitespace() {
+        while (!this.isAtEnd() && /\s/.test(this.peek())) {
+            this.advance();
+        }
+    }
+    isDigit(char) {
+        return char >= '0' && char <= '9';
+    }
+    isAlpha(char) {
+        return /[a-zA-Z_]/.test(char);
+    }
+    isSymbol(char) {
+        return ['.', ':', ',', '[', ']', '>', '<', '=', '!'].includes(char);
+    }
+    isNewline() {
+        return this.peek() === '\n';
+    }
+    peek() {
+        return this.input[this.pos];
+    }
+    advance() {
+        const ch = this.input[this.pos++];
+        if (ch === '\n') {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        return ch;
+    }
+    isAtEnd() {
+        return this.pos >= this.input.length;
+    }
+}
+exports.AbilityDSLLexer = AbilityDSLLexer;
+
+
+/***/ }),
+
+/***/ 577:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityDSLParser = void 0;
+const AbilityCompare_1 = __importDefault(__webpack_require__(413));
+const AbilityCondition_1 = __importDefault(__webpack_require__(167));
+const AbilityPolicy_1 = __importDefault(__webpack_require__(278));
+const AbilityPolicyEffect_1 = __importDefault(__webpack_require__(179));
+const AbilityRule_1 = __importDefault(__webpack_require__(306));
+const AbilityRuleSet_1 = __importDefault(__webpack_require__(56));
+const AbilityDSLLexer_1 = __webpack_require__(10);
+const AbilityDSLToken_1 = __webpack_require__(325);
+const AbilityDSLSyntaxError_1 = __webpack_require__(883);
+/**
+ * Parser for the Ability DSL.
+ *
+ * Converts a DSL string into one or more AbilityPolicy instances.
+ * The grammar follows the structure:
+ *
+ *   <effect> <permission> if <group> [ <group> ... ]
+ *
+ * where <group> is either "all of:" or "any of:", followed by a colon,
+ * and then a list of rules (one per line).
+ *
+ * Each rule is: <identifier> <operator> <value>
+ *
+ * Operators can be simple (equals, contains, in) or
+ * composed (is null, is not null, greater than, less than or equal, etc.).
+ */
+class AbilityDSLParser {
+    dsl;
+    tokens = [];
+    pos = 0;
+    annotationBuffer = {
+        name: null,
+        description: null,
+    };
+    constructor(dsl) {
+        this.dsl = dsl;
+    }
+    /**
+     * Main entry point: tokenize the input and parse all policies.
+     * @returns Array of AbilityPolicy instances.
+     */
+    parse() {
+        // Tokenize the entire DSL string.
+        this.tokens = new AbilityDSLLexer_1.AbilityDSLLexer(this.dsl).tokenize();
+        this.pos = 0;
+        const policies = [];
+        // Keep parsing until we've consumed all tokens.
+        while (!this.isAtEnd()) {
+            this.consumeLeadingComments();
+            // Every policy must start with an EFFECT token.
+            if (!this.isStartOfPolicy()) {
+                const token = this.peek();
+                this.syntaxError(`Expected policy, got ${token.code}.`, token, ['EFFECT']);
+            }
+            policies.push(this.parsePolicy());
+        }
+        return policies;
+    }
+    // -------------------------------------------------------------------------
+    // #region Policy parsing
+    // -------------------------------------------------------------------------
+    /**
+     * Parses a single policy from the current token position.
+     *
+     * Grammar:
+     *   policy = EFFECT PERMISSION IF (ALL | ANY) COLON ruleSets
+     */
+    parsePolicy() {
+        this.consumeLeadingComments();
+        const meta = this.takeAnnotations();
+        // Effect: "permit" or "deny"
+        const effectToken = this.consume(AbilityDSLToken_1.AbilityDSLToken.EFFECT, 'Expected effect');
+        const effect = effectToken.value;
+        // Permission: e.g. "order.update"
+        const permissionToken = this.consume(AbilityDSLToken_1.AbilityDSLToken.PERMISSION, 'Expected permission');
+        const permission = permissionToken.value;
+        if (!permission.startsWith('permission.')) {
+            return this.syntaxError(`Unexpected token. The permission key, must be starts with prefix \`permission.\`, but got \`${permission}\`.\nDid you mean \`permission.${permission}\`?`, permissionToken);
+        }
+        // "if" keyword
+        this.consume(AbilityDSLToken_1.AbilityDSLToken.IF, 'Expected "if"');
+        // Group selector: "all" or "any" – determines how the top‑level rule sets are combined.
+        const compareToken = this.consumeOneOf([AbilityDSLToken_1.AbilityDSLToken.ALL, AbilityDSLToken_1.AbilityDSLToken.ANY], 'Expected "all" or "any"');
+        const compareMethod = compareToken.code === AbilityDSLToken_1.AbilityDSLToken.ALL ? AbilityCompare_1.default.and : AbilityCompare_1.default.or;
+        // Colon after the group keyword
+        this.consume(AbilityDSLToken_1.AbilityDSLToken.COLON, 'Expected ":"');
+        // Parse the list of rule sets (each "all of:" or "any of:" block)
+        const ruleSets = this.parseRuleSets(compareMethod);
+        // Construct the policy instance.
+        return new AbilityPolicy_1.default({
+            id: `${effect}:${permission}:${Math.random()}`,
+            name: meta.name ?? `${effect} ${permission}`,
+            permission: permission.replace(/^permission\./, ''),
+            effect: effect === 'permit' ? AbilityPolicyEffect_1.default.permit : AbilityPolicyEffect_1.default.deny,
+            compareMethod,
+        }).addRuleSets(ruleSets);
+    }
+    // -------------------------------------------------------------------------
+    // #region Rule set parsing (groups of rules)
+    // -------------------------------------------------------------------------
+    /**
+     * Parses a sequence of rule sets (groups) until a new policy starts or EOF.
+     */
+    parseRuleSets(policyCompareMethod) {
+        const sets = [];
+        while (!this.isAtEnd() && !this.isStartOfPolicy()) {
+            this.consumeLeadingComments();
+            // Если начинается новая группа — парсим её
+            if (this.isStartOfGroup()) {
+                sets.push(this.parseGroup());
+                continue;
+            }
+            // Иначе — implicit group (all-of по умолчанию)
+            const meta = this.takeAnnotations();
+            const group = new AbilityRuleSet_1.default({
+                compareMethod: policyCompareMethod,
+                name: meta.name,
+            });
+            // Читаем правила implicit-группы
+            while (!this.isAtEnd()) {
+                this.consumeLeadingComments();
+                if (this.isStartOfGroup() || this.isStartOfPolicy()) {
+                    break;
+                }
+                if (this.check(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER)) {
+                    group.addRule(this.parseRule());
+                }
+                else {
+                    this.syntaxError(`Unexpected token in implicit group: ${this.peek().code}`, this.peek());
+                }
+            }
+            sets.push(group);
+        }
+        return sets;
+    }
+    /**
+     * Parses a single group, e.g. "all of:" or "any of:", and returns a RuleSet.
+     */
+    parseGroup() {
+        this.consumeLeadingComments();
+        const meta = this.takeAnnotations();
+        const compareToken = this.consumeOneOf([AbilityDSLToken_1.AbilityDSLToken.ALL, AbilityDSLToken_1.AbilityDSLToken.ANY], 'Expected "all" or "any"');
+        const compareMethod = compareToken.code === AbilityDSLToken_1.AbilityDSLToken.ALL ? AbilityCompare_1.default.and : AbilityCompare_1.default.or;
+        if (this.check(AbilityDSLToken_1.AbilityDSLToken.OF)) {
+            this.advance();
+        }
+        this.consume(AbilityDSLToken_1.AbilityDSLToken.COLON, 'Expected ":"');
+        const group = new AbilityRuleSet_1.default({ compareMethod, name: meta.name });
+        while (!this.isAtEnd()) {
+            this.consumeLeadingComments();
+            if (this.isStartOfGroup() || this.isStartOfPolicy()) {
+                break;
+            }
+            if (this.check(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER)) {
+                group.addRule(this.parseRule());
+            }
+            else {
+                this.syntaxError(`Unexpected token in group: ${this.peek().code}`, this.peek());
+            }
+        }
+        return group;
+    }
+    // -------------------------------------------------------------------------
+    // #region Rule parsing
+    // -------------------------------------------------------------------------
+    /**
+     * Parses a single rule: subject operator value
+     */
+    parseRule() {
+        this.consumeLeadingComments();
+        const meta = this.takeAnnotations();
+        if (!this.check(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER)) {
+            this.syntaxError(`Expected identifier, got ${this.peek().code}`, this.peek());
+        }
+        // Subject (e.g., "user.roles")
+        const subject = this.consume(AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER, 'Expected field').value;
+        // Operator (e.g., "contains", "equals", "is not null")
+        const { condition, operator } = this.parseConditionOperator();
+        let resource;
+        let beforePos = this.pos;
+        // Special operators that don't consume a value token.
+        if (operator === AbilityDSLToken_1.AbilityDSLToken.EQ_NULL ||
+            operator === AbilityDSLToken_1.AbilityDSLToken.NOT_EQ_NULL ||
+            operator === AbilityDSLToken_1.AbilityDSLToken.NULL) {
+            resource = null;
+        }
+        else {
+            beforePos = this.pos;
+            resource = this.parseValue();
+        }
+        // Checking that there are no extra tokens after the value
+        // (skip comments)
+        this.consumeLeadingComments();
+        const resourceToken = this.tokens[beforePos];
+        if (typeof resource === 'string' &&
+            resourceToken.code === AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER &&
+            !resourceToken.value.includes('.')) {
+            this.syntaxError(`Expected comparison operator or value, got \`${resource}\``, this.tokens[beforePos], [AbilityDSLToken_1.AbilityDSLToken.KEYWORD]);
+        }
+        return new AbilityRule_1.default({
+            subject,
+            resource,
+            condition,
+            name: meta.name,
+        });
+    }
+    // -------------------------------------------------------------------------
+    // #region Operator parsing
+    // -------------------------------------------------------------------------
+    /**
+     * Parses the comparison operator part of a rule.
+     * Returns both the resulting AbilityCondition and the token type that was consumed.
+     */
+    parseConditionOperator() {
+        const savedPos = this.pos;
+        // "length equals"
+        if (this.matchWord('length') && this.matchWord('equals')) {
+            return { condition: AbilityCondition_1.default.length_equals, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_EQ };
+        }
+        this.pos = savedPos;
+        // "length ="
+        if (this.matchWord('length') && this.matchSymbol('=')) {
+            return { condition: AbilityCondition_1.default.length_equals, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_EQ };
+        }
+        this.pos = savedPos;
+        // "length greater than"
+        if (this.matchWord('length') && this.matchWord('greater') && this.matchWord('than')) {
+            return { condition: AbilityCondition_1.default.length_greater_than, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_GT };
+        }
+        this.pos = savedPos;
+        // "length >"
+        if (this.matchWord('length') && this.matchSymbol('>')) {
+            return { condition: AbilityCondition_1.default.length_greater_than, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_GT };
+        }
+        this.pos = savedPos;
+        // "length less than"
+        if (this.matchWord('length') && this.matchWord('less') && this.matchWord('than')) {
+            return { condition: AbilityCondition_1.default.length_less_than, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_LT };
+        }
+        this.pos = savedPos;
+        // "length <"
+        if (this.matchWord('length') && this.matchSymbol('<')) {
+            return { condition: AbilityCondition_1.default.length_less_than, operator: AbilityDSLToken_1.AbilityDSLToken.LEN_LT };
+        }
+        this.pos = savedPos;
+        // "greater than or equal"
+        if (this.matchWord('greater') &&
+            this.matchWord('than') &&
+            this.matchWord('or') &&
+            this.matchWord('equal')) {
+            return { condition: AbilityCondition_1.default.greater_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.GTE };
+        }
+        this.pos = savedPos;
+        // greater than
+        if (this.matchWord('greater') && this.matchWord('than')) {
+            return { condition: AbilityCondition_1.default.greater_than, operator: AbilityDSLToken_1.AbilityDSLToken.GT };
+        }
+        this.pos = savedPos;
+        // less than or equal
+        if (this.matchWord('less') &&
+            this.matchWord('than') &&
+            this.matchWord('or') &&
+            this.matchWord('equal')) {
+            return { condition: AbilityCondition_1.default.less_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.LTE };
+        }
+        this.pos = savedPos;
+        // less than
+        if (this.matchWord('less') && this.matchWord('than')) {
+            return { condition: AbilityCondition_1.default.less_than, operator: AbilityDSLToken_1.AbilityDSLToken.LT };
+        }
+        this.pos = savedPos;
+        // "not contains"
+        if (this.matchWord('not') && this.matchWord('contains')) {
+            return {
+                condition: AbilityCondition_1.default.not_contains,
+                operator: AbilityDSLToken_1.AbilityDSLToken.NOT_CONTAINS,
+            };
+        }
+        this.pos = savedPos;
+        // "not includes"
+        if (this.matchWord('not') && this.matchWord('includes')) {
+            return {
+                condition: AbilityCondition_1.default.not_contains,
+                operator: AbilityDSLToken_1.AbilityDSLToken.NOT_CONTAINS,
+            };
+        }
+        this.pos = savedPos;
+        // "not includes"
+        if (this.matchWord('not') && this.matchWord('has')) {
+            return {
+                condition: AbilityCondition_1.default.not_contains,
+                operator: AbilityDSLToken_1.AbilityDSLToken.NOT_CONTAINS,
+            };
+        }
+        this.pos = savedPos;
+        // "is equals"
+        if (this.matchWord('is') && this.matchWord('equals')) {
+            return { condition: AbilityCondition_1.default.equals, operator: AbilityDSLToken_1.AbilityDSLToken.EQ };
+        }
+        this.pos = savedPos;
+        // not equal
+        if (this.matchWord('not') && this.matchWord('equals')) {
+            return { condition: AbilityCondition_1.default.not_equals, operator: AbilityDSLToken_1.AbilityDSLToken.NOT_EQ };
+        }
+        this.pos = savedPos;
+        // is not equals
+        if (this.matchWord('is') && this.matchWord('not') && this.matchWord('equals')) {
+            return { condition: AbilityCondition_1.default.not_equals, operator: AbilityDSLToken_1.AbilityDSLToken.NOT_EQ };
+        }
+        this.pos = savedPos;
+        // is in
+        if (this.matchWord('is') && this.matchWord('in')) {
+            return { condition: AbilityCondition_1.default.in, operator: AbilityDSLToken_1.AbilityDSLToken.IN };
+        }
+        this.pos = savedPos;
+        // not in
+        if (this.matchWord('not') && this.matchWord('in')) {
+            return { condition: AbilityCondition_1.default.not_in, operator: AbilityDSLToken_1.AbilityDSLToken.NOT_IN };
+        }
+        this.pos = savedPos;
+        // is not null
+        if (this.matchWord('is') && this.matchWord('not')) {
+            if (this.check(AbilityDSLToken_1.AbilityDSLToken.NULL)) {
+                this.advance();
+                return {
+                    condition: AbilityCondition_1.default.not_equals,
+                    operator: AbilityDSLToken_1.AbilityDSLToken.NOT_EQ_NULL,
+                };
+            }
+        }
+        this.pos = savedPos;
+        // is null
+        if (this.matchWord('is') && this.matchWord('null')) {
+            if (this.check(AbilityDSLToken_1.AbilityDSLToken.NULL)) {
+                this.advance();
+                return {
+                    condition: AbilityCondition_1.default.equals,
+                    operator: AbilityDSLToken_1.AbilityDSLToken.EQ_NULL,
+                };
+            }
+        }
+        this.pos = savedPos;
+        // Single token (symbol or keyword)
+        const token = this.peek();
+        if (token.code !== AbilityDSLToken_1.AbilityDSLToken.SYMBOL &&
+            token.code !== AbilityDSLToken_1.AbilityDSLToken.KEYWORD &&
+            token.code !== AbilityDSLToken_1.AbilityDSLToken.NULL) {
+            this.syntaxError(`Expected comparison operator, got \`${token.value}\``, token, [
+                AbilityDSLToken_1.AbilityDSLToken.SYMBOL,
+                AbilityDSLToken_1.AbilityDSLToken.KEYWORD,
+                AbilityDSLToken_1.AbilityDSLToken.NULL,
+            ]);
+        }
+        this.advance();
+        switch (token.code) {
+            case AbilityDSLToken_1.AbilityDSLToken.SYMBOL:
+                if (token.value === '=' || token.value === '==')
+                    return { condition: AbilityCondition_1.default.equals, operator: AbilityDSLToken_1.AbilityDSLToken.EQ };
+                if (token.value === '!=' || token.value === '<>')
+                    return { condition: AbilityCondition_1.default.not_equals, operator: AbilityDSLToken_1.AbilityDSLToken.NOT_EQ };
+                if (token.value === '>')
+                    return { condition: AbilityCondition_1.default.greater_than, operator: AbilityDSLToken_1.AbilityDSLToken.GT };
+                if (token.value === '<')
+                    return { condition: AbilityCondition_1.default.less_than, operator: AbilityDSLToken_1.AbilityDSLToken.LT };
+                if (token.value === '>=')
+                    return { condition: AbilityCondition_1.default.greater_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.GTE };
+                if (token.value === '<=')
+                    return { condition: AbilityCondition_1.default.less_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.LTE };
+                break;
+            case AbilityDSLToken_1.AbilityDSLToken.KEYWORD:
+                if (token.value === 'contains' || token.value === 'includes' || token.value === 'has')
+                    return { condition: AbilityCondition_1.default.contains, operator: AbilityDSLToken_1.AbilityDSLToken.CONTAINS };
+                if (token.value === 'in')
+                    return { condition: AbilityCondition_1.default.in, operator: AbilityDSLToken_1.AbilityDSLToken.IN };
+                if (token.value === 'equals')
+                    return { condition: AbilityCondition_1.default.equals, operator: AbilityDSLToken_1.AbilityDSLToken.EQ };
+                if (token.value === 'gte') {
+                    return { condition: AbilityCondition_1.default.greater_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.GTE };
+                }
+                if (token.value === 'greater' || token.value === 'gt') {
+                    // If we come here, it means "greater" without "than" – treat as '>'
+                    return { condition: AbilityCondition_1.default.greater_than, operator: AbilityDSLToken_1.AbilityDSLToken.GT };
+                }
+                if (token.value === 'less' || token.value === 'lt') {
+                    return { condition: AbilityCondition_1.default.less_than, operator: AbilityDSLToken_1.AbilityDSLToken.LT };
+                }
+                if (token.value === 'lte') {
+                    return { condition: AbilityCondition_1.default.less_or_equal, operator: AbilityDSLToken_1.AbilityDSLToken.LTE };
+                }
+                if (token.value === 'is') {
+                    // "is" alone -> equals
+                    return { condition: AbilityCondition_1.default.equals, operator: AbilityDSLToken_1.AbilityDSLToken.EQ };
+                }
+                break;
+            default:
+                break;
+        }
+        return this.syntaxError(`Unexpected operator token \`${token.value}\``, token, [
+            AbilityDSLToken_1.AbilityDSLToken.SYMBOL,
+            AbilityDSLToken_1.AbilityDSLToken.KEYWORD,
+        ]);
+    }
+    /**
+     * Helper to match and consume a specific word token (KEYWORD or IDENTIFIER).
+     * @param word The exact string to look for.
+     * @returns True if the next token has that value.
+     */
+    matchWord(word) {
+        if (this.isAtEnd()) {
+            return false;
+        }
+        const token = this.peek();
+        if ((token.code === AbilityDSLToken_1.AbilityDSLToken.KEYWORD || token.code === AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER) &&
+            token.value === word) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    matchSymbol(symbol) {
+        if (this.isAtEnd())
+            return false;
+        const token = this.peek();
+        if (token.code === AbilityDSLToken_1.AbilityDSLToken.SYMBOL && token.value === symbol) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    // -------------------------------------------------------------------------
+    // #region Value parsing (literals, arrays, identifiers)
+    // -------------------------------------------------------------------------
+    /**
+     * Parses a resource value. Can be a string literal, number, boolean,
+     * null, a path (identifier), or an array.
+     */
+    parseValue() {
+        // Arrays start with a left bracket
+        if (this.check(AbilityDSLToken_1.AbilityDSLToken.LBRACKET)) {
+            this.advance();
+            return this.parseArray();
+        }
+        // Ensure we are not about to read a structural token as a value.
+        const token = this.peek();
+        if (token.code === AbilityDSLToken_1.AbilityDSLToken.ALL ||
+            token.code === AbilityDSLToken_1.AbilityDSLToken.ANY ||
+            token.code === AbilityDSLToken_1.AbilityDSLToken.EFFECT) {
+            this.syntaxError(`Unexpected ${token.code} in value position`, token);
+        }
+        this.advance();
+        // CHECK THIS SWITCH COMPARE
+        switch (token.code) {
+            case AbilityDSLToken_1.AbilityDSLToken.STRING:
+                return token.value;
+            case AbilityDSLToken_1.AbilityDSLToken.NUMBER:
+                return Number(token.value);
+            case AbilityDSLToken_1.AbilityDSLToken.BOOLEAN:
+                return token.value === 'true';
+            case AbilityDSLToken_1.AbilityDSLToken.NULL:
+                return null;
+            case AbilityDSLToken_1.AbilityDSLToken.IDENTIFIER:
+                return token.value;
+            default: {
+                this.syntaxError(`Unexpected value token "${token.value}"`, token ?? this.tokens[this.tokens.length - 1], [AbilityDSLToken_1.AbilityDSLToken.KEYWORD]);
+            }
+        }
+    }
+    /**
+     * Parses an array literal: [ <value>, <value>, ... ]
+     * The opening bracket has already been consumed.
+     */
+    parseArray() {
+        const arr = [];
+        // Handle empty array
+        if (this.check(AbilityDSLToken_1.AbilityDSLToken.RBRACKET)) {
+            this.advance();
+            return arr;
+        }
+        while (!this.isAtEnd() && !this.check(AbilityDSLToken_1.AbilityDSLToken.RBRACKET)) {
+            const value = this.parseValue();
+            // Flatten nested arrays if they appear (though grammar doesn't currently allow nesting).
+            if (Array.isArray(value)) {
+                arr.push(...value);
+            }
+            else if (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean') {
+                arr.push(value);
+            }
+            else if (value === null) {
+                // Null is allowed in arrays? Currently, we throw.
+                this.syntaxError('Unexpected null in array', this.peek());
+            }
+            // Optional comma between elements
+            if (this.check(AbilityDSLToken_1.AbilityDSLToken.COMMA)) {
+                this.advance();
+            }
+        }
+        this.consume(AbilityDSLToken_1.AbilityDSLToken.RBRACKET, 'Expected "]"');
+        return arr;
+    }
+    // -------------------------------------------------------------------------
+    // #region Annotations and comments
+    // -------------------------------------------------------------------------
+    consumeLeadingComments() {
+        while (this.check(AbilityDSLToken_1.AbilityDSLToken.COMMENT)) {
+            const token = this.advance();
+            this.processCommentToken(token);
+        }
+    }
+    processCommentToken(token) {
+        const text = token.value.trim();
+        if (text.startsWith('@name ')) {
+            this.annotationBuffer.name = text.slice(6).trim();
+        }
+        if (text.startsWith('@description ')) {
+            this.annotationBuffer.description = text.slice(13).trim();
+        }
+    }
+    takeAnnotations() {
+        const meta = { ...this.annotationBuffer };
+        this.annotationBuffer = {
+            name: null,
+            description: null,
+        };
+        return meta;
+    }
+    // -------------------------------------------------------------------------
+    // #region Errors
+    // -------------------------------------------------------------------------
+    syntaxError(details, token, expected) {
+        const lines = this.dsl.split(/\r?\n/);
+        const lineIdx = token.line - 1;
+        const lineBefore = lineIdx > 0 ? lines[lineIdx - 1] : '';
+        const current = lines[lineIdx];
+        const linesAfter = lineIdx + 1 < lines.length ? lines[lineIdx + 1] : '';
+        const wave = ' '.repeat(Math.max(0, token.column - 1)) + '~'.repeat(token.value.length);
+        const lineNumWidth = String(token.line + 1).length;
+        const num = (n) => String(n).padStart(lineNumWidth, ' ');
+        let context = '';
+        if (lineBefore.trim() !== '') {
+            context += `${num(token.line - 1)} | ${lineBefore}\n`;
+        }
+        context += `${num(token.line)} | ${current}\n`;
+        context += `${' '.repeat(lineNumWidth)} | ${wave}\n`;
+        if (linesAfter.trim() !== '') {
+            context += `${num(token.line + 1)} | ${linesAfter}`;
+        }
+        let finalDetails = details;
+        if (expected && expected?.length > 0) {
+            const actual = token.value;
+            const suggestion = this.suggest(actual, expected);
+            const detailsMsg = `${details}\nDetails: Unexpected value token \`${actual}\``;
+            finalDetails = suggestion ? `${detailsMsg} Did you mean \`${suggestion}\`?` : detailsMsg;
+        }
+        throw new AbilityDSLSyntaxError_1.AbilityDSLSyntaxError(token.line, token.column, context + '\n', finalDetails);
+    }
+    getLine(lineNumber) {
+        return this.dsl.split(/\r?\n/)[lineNumber - 1] ?? '';
+    }
+    suggest(actual, expectedTypes) {
+        const candidates = [];
+        for (const type of expectedTypes) {
+            candidates.push(type);
+        }
+        const uniqueCandidates = [...new Set(candidates)];
+        let best = null;
+        let bestDist = 3;
+        for (const candidate of uniqueCandidates) {
+            const d = this.levenshteinDistance(actual.toLowerCase(), candidate.toLowerCase());
+            if (d < bestDist) {
+                bestDist = d;
+                best = candidate;
+            }
+        }
+        return best;
+    }
+    levenshteinDistance(a, b) {
+        const matrix = Array(b.length + 1)
+            .fill(null)
+            .map(() => Array(a.length + 1).fill(null));
+        for (let i = 0; i <= a.length; i++)
+            matrix[0][i] = i;
+        for (let j = 0; j <= b.length; j++)
+            matrix[j][0] = j;
+        for (let j = 1; j <= b.length; j++) {
+            for (let i = 1; i <= a.length; i++) {
+                const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+                matrix[j][i] = Math.min(matrix[j][i - 1] + 1, matrix[j - 1][i] + 1, matrix[j - 1][i - 1] + cost);
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+    // -------------------------------------------------------------------------
+    // #region Helper / lookahead methods
+    // -------------------------------------------------------------------------
+    consumeOneOf(types, message) {
+        const token = this.peek();
+        for (const t of types) {
+            if (token && token.code === t) {
+                return this.advance();
+            }
+        }
+        const expected = types.map(t => t).join(', ');
+        const actual = token ? token.value : AbilityDSLToken_1.AbilityDSLToken.EOF;
+        const suggestion = this.suggest(actual, types);
+        const details = `${message}\nDetails: Unexpected token \`${actual}\`, expected one of: ${expected}.`;
+        const finalMsg = suggestion ? `${details} Did you mean \`${suggestion}\`?` : details;
+        this.syntaxError(finalMsg, token ?? this.tokens[this.tokens.length - 1]);
+    }
+    consume(type, message) {
+        const token = this.peek();
+        if (token && token.code === type) {
+            return this.advance();
+        }
+        const expected = type;
+        const actual = token ? token.value : AbilityDSLToken_1.AbilityDSLToken.EOF;
+        const suggestion = this.suggest(actual, [type]);
+        const details = `${message}\nDetails: Unexpected token \`${actual}\`, expected "${expected}".`;
+        const finalMsg = suggestion ? `${details} Did you mean \`${suggestion}\`?` : details;
+        this.syntaxError(finalMsg, token ?? this.tokens[this.tokens.length - 1]);
+    }
+    check(type) {
+        if (this.isAtEnd())
+            return false;
+        return this.peek().code === type;
+    }
+    isStartOfPolicy() {
+        return this.check(AbilityDSLToken_1.AbilityDSLToken.EFFECT);
+    }
+    isStartOfGroup() {
+        return this.check(AbilityDSLToken_1.AbilityDSLToken.ALL) || this.check(AbilityDSLToken_1.AbilityDSLToken.ANY);
+    }
+    advance() {
+        return this.tokens[this.pos++];
+    }
+    peek() {
+        return this.tokens[this.pos];
+    }
+    isAtEnd() {
+        return this.peek().code === AbilityDSLToken_1.AbilityDSLToken.EOF;
+    }
+}
+exports.AbilityDSLParser = AbilityDSLParser;
+
+
+/***/ }),
+
+/***/ 883:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityDSLSyntaxError = void 0;
+class AbilityDSLSyntaxError extends Error {
+    line;
+    column;
+    context;
+    details;
+    _formattedMessage;
+    _originalStack;
+    constructor(line, column, context, // строка DSL + ^ + соседние строки
+    details) {
+        super(details.split('\n')[0]); // message = только первая строка
+        this.line = line;
+        this.column = column;
+        this.context = context;
+        this.details = details;
+        this.name = 'AbilityDSLSyntaxError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, AbilityDSLSyntaxError);
+        }
+        this._originalStack = this.stack;
+        this._formattedMessage = this.formatMessage();
+        Object.defineProperty(this, 'stack', {
+            get: () => this._formattedMessage,
+            configurable: true,
+        });
+    }
+    static supportsColor() {
+        return typeof process !== 'undefined' && process.stdout?.isTTY;
+    }
+    formatMessage() {
+        const useColor = AbilityDSLSyntaxError.supportsColor();
+        const BOLD = useColor ? '\x1b[1m' : '';
+        const RED = useColor ? '\x1b[31m' : '';
+        const ORANGE = useColor ? '\x1b[33;1m' : '';
+        const GRAY = useColor ? '\x1b[90m' : '';
+        const RESET = useColor ? '\x1b[0m' : '';
+        const lines = this.context.split('\n');
+        // Find line with ^
+        const pointerIndex = lines.findIndex(l => l.includes('^') || l.includes('~'));
+        const commentIndex = lines.findIndex(l => l.trim().includes('#'));
+        const formattedLines = lines.map((line, idx) => {
+            if (idx === pointerIndex - 1) {
+                // Error line
+                return `${BOLD}${ORANGE}${line}${RESET}`;
+            }
+            if (idx === pointerIndex) {
+                // Error with ~~~~~
+                return `${RED}${line}${RESET}`;
+            }
+            // Comments # ...
+            if (idx === commentIndex) {
+                return `${GRAY}${line}${RESET}`;
+            }
+            return line;
+        });
+        const contextBlock = formattedLines.join('\n');
+        return `${BOLD}${RED}${this.name}: ${this.details}${RESET}\n\n` + contextBlock;
+    }
+    toString() {
+        return this._formattedMessage;
+    }
+}
+exports.AbilityDSLSyntaxError = AbilityDSLSyntaxError;
+
+
+/***/ }),
+
+/***/ 325:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityDSLToken = void 0;
+const AbilityCode_1 = __importDefault(__webpack_require__(301));
+/**
+ * Represents a single token produced by the Ability DSL lexer.
+ * Each token carries a type (e.g., EFFECT, IDENTIFIER, STRING) and its raw string value.
+ */
+class AbilityDSLToken extends AbilityCode_1.default {
+    /** The literal text of the token as it appeared in the input (e.g., "permit", "user.roles", "admin"). */
+    value = '';
+    /** The line number in DSL */
+    line = 1;
+    /** The column in dsl */
+    column = 1;
+    constructor(type, value, line, column) {
+        super(type);
+        this.value = value;
+        this.line = line;
+        this.column = column;
+    }
+    /**
+     * Returns a human-readable representation of the token, useful for debugging.
+     * Example output: "AbilityDSLToken([EFFECT] permit"
+     */
+    toString() {
+        return `AbilityDSLToken([${this.code}] "${this.value}" at ${this.line}:${this.column})`;
+    }
+    static EFFECT = 'EFFECT';
+    static IF = 'IF';
+    static PERMISSION = 'PERMISSION';
+    static IDENTIFIER = 'IDENTIFIER';
+    static COLON = 'COLON';
+    static COMMA = 'COMMA';
+    static DOT = 'DOT';
+    static LBRACKET = 'LBRACKET';
+    static RBRACKET = 'RBRACKET';
+    static ALL = 'ALL';
+    static ANY = 'ANY';
+    static OF = 'OF';
+    static EOF = 'EOF';
+    static COMMENT = 'COMMENT';
+    static EQ = 'EQ';
+    static CONTAINS = 'CONTAINS';
+    static IN = 'IN';
+    static NOT_IN = 'NOT_IN';
+    static NOT_CONTAINS = 'NOT_CONTAINS';
+    static GT = 'GT';
+    static GTE = 'GTE';
+    static LT = 'LT';
+    static LTE = 'LTE';
+    static NULL = 'NULL';
+    static EQ_NULL = 'EQ_NULL';
+    static NOT_EQ_NULL = 'NOT_EQ_NULL';
+    static LEN_GT = 'LEN_GT';
+    static LEN_LT = 'LEN_LT';
+    static LEN_EQ = 'LEN_EQ';
+    static NOT_EQ = 'NOT_EQ';
+    static STRING = 'STRING';
+    static NUMBER = 'NUMBER';
+    static BOOLEAN = 'BOOLEAN';
+    static SYMBOL = 'SYMBOL';
+    static KEYWORD = 'KEYWORD';
+}
+exports.AbilityDSLToken = AbilityDSLToken;
+
+
+/***/ }),
+
+/***/ 909:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.AbilityJSONParser = void 0;
+const AbilityCondition_1 = __importDefault(__webpack_require__(167));
+const AbilityRule_1 = __webpack_require__(306);
+const AbilityRuleSet_1 = __webpack_require__(56);
+const AbilityCompare_1 = __importDefault(__webpack_require__(413));
+const AbilityPolicyEffect_1 = __importDefault(__webpack_require__(179));
+const AbilityPolicy_1 = __webpack_require__(278);
+class AbilityJSONParser {
+    /**
+     * Parses an array of policy configurations into an array of AbilityPolicy instances.
+     * @param configs - Array of policy configurations
+     * @returns Array of AbilityPolicy instances
+     */
+    static parse(configs) {
+        return configs.map(config => AbilityJSONParser.parsePolicy(config));
+    }
+    static parsePolicy(config) {
+        const { id, name, ruleSet, compareMethod, permission, effect } = config;
+        // Create the empty policy
+        const policy = new AbilityPolicy_1.AbilityPolicy({
+            name,
+            id,
+            permission: permission,
+            effect: new AbilityPolicyEffect_1.default(effect),
+        });
+        policy.compareMethod = new AbilityCompare_1.default(compareMethod);
+        ruleSet.forEach(ruleSetConfig => {
+            policy.addRuleSet(AbilityRuleSet_1.AbilityRuleSet.fromJSON(ruleSetConfig));
+        });
+        return policy;
+    }
+    static parseRule(config) {
+        const { id, name, subject, resource, condition } = config;
+        return new AbilityRule_1.AbilityRule({
+            id,
+            name,
+            subject,
+            resource,
+            condition: new AbilityCondition_1.default(condition),
+        });
+    }
+    /**
+     * Parse the config JSON format to Group class instance
+     */
+    static parseRuleSet(config) {
+        const { id, name, rules, compareMethod } = config;
+        const ruleSet = new AbilityRuleSet_1.AbilityRuleSet({
+            compareMethod: new AbilityCompare_1.default(compareMethod),
+            name,
+            id,
+        });
+        // Adding rules if exists
+        if (rules && rules.length > 0) {
+            const abilityRules = rules.map(ruleConfig => AbilityRule_1.AbilityRule.fromJSON(ruleConfig));
+            ruleSet.addRules(abilityRules);
+        }
+        return ruleSet;
+    }
+    static ruleToJSON(rule) {
+        return {
+            id: rule.id,
+            name: rule.name,
+            subject: rule.subject,
+            resource: rule.resource,
+            condition: rule.condition.code,
+        };
+    }
+    static ruleSetToJSON(ruleSet) {
+        return {
+            id: ruleSet.id.toString(),
+            name: ruleSet.name.toString(),
+            compareMethod: ruleSet.compareMethod.code.toString(),
+            rules: ruleSet.rules.map(rule => AbilityJSONParser.ruleToJSON(rule)),
+        };
+    }
+    static policyToJSON(policy) {
+        return {
+            id: policy.id.toString(),
+            name: policy.name.toString(),
+            compareMethod: policy.compareMethod.code.toString(),
+            ruleSet: policy.ruleSet.map(ruleSet => AbilityJSONParser.ruleSetToJSON(ruleSet)),
+            permission: policy.permission,
+            effect: policy.effect.code,
+        };
+    }
+    static toJSON(policies) {
+        return policies.map(policy => AbilityJSONParser.policyToJSON(policy));
+    }
+}
+exports.AbilityJSONParser = AbilityJSONParser;
 
 
 /***/ })