@via-profit/ability 3.4.0 → 3.5.0

package/dist/index.js

@@ -22,75 +22,116 @@ class AbilityCompare extends AbilityCode {
 }
 
 class AbilityError extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'AbilityError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
     }
 }
 class AbilityParserError extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
+        this.name = 'AbilityParserError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
     }
 }
 
 class AbilityCondition extends AbilityCode {
-    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 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 always = new AbilityCondition('always');
-    static never = new AbilityCondition('never');
+    static equals;
+    static not_equals;
+    static greater_than;
+    static less_than;
+    static less_or_equal;
+    static greater_or_equal;
+    static in;
+    static not_in;
+    static contains;
+    static not_contains;
+    static length_greater_than;
+    static length_less_than;
+    static length_equals;
+    static always;
+    static never;
+    static {
+        this.equals = new AbilityCondition('=');
+        this.not_equals = new AbilityCondition('<>');
+        this.greater_than = new AbilityCondition('>');
+        this.less_than = new AbilityCondition('<');
+        this.less_or_equal = new AbilityCondition('<=');
+        this.greater_or_equal = new AbilityCondition('>=');
+        this.in = new AbilityCondition('in');
+        this.not_in = new AbilityCondition('not in');
+        this.contains = new AbilityCondition('contains');
+        this.not_contains = new AbilityCondition('not contains');
+        this.length_greater_than = new AbilityCondition('length greater than');
+        this.length_less_than = new AbilityCondition('length less than');
+        this.length_equals = new AbilityCondition('length equals');
+        this.always = new AbilityCondition('always');
+        this.never = new AbilityCondition('never');
+    }
     static fromLiteral(literal) {
-        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;
+        const map = {
+            equals: this.equals,
+            not_equals: this.not_equals,
+            greater_than: this.greater_than,
+            less_than: this.less_than,
+            less_or_equal: this.less_or_equal,
+            greater_or_equal: this.greater_or_equal,
+            in: this.in,
+            not_in: this.not_in,
+            contains: this.contains,
+            not_contains: this.not_contains,
+            length_greater_than: this.length_greater_than,
+            length_equals: this.length_equals,
+            always: this.always,
+            never: this.never,
+            length_less_than: this.length_less_than,
+        };
+        const condition = map[literal];
+        if (!condition) {
+            throw new AbilityParserError(`Literal "${literal}" does not found in AbilityCondition class`);
+        }
+        return condition;
+    }
+    get literal() {
+        switch (this.code) {
+            case '=':
+                return 'equals';
+            case '<>':
+                return 'not_equals';
+            case '>':
+                return 'greater_than';
+            case '<':
+                return 'less_than';
+            case '>=':
+                return 'greater_or_equal';
+            case '<=':
+                return 'less_or_equal';
             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;
+                return 'in';
+            case 'not in':
+                return 'not_in';
+            case 'contains':
+                return 'contains';
+            case 'not contains':
+                return 'not_contains';
+            case 'length greater than':
+                return 'length_greater_than';
+            case 'length less than':
+                return 'length_less_than';
+            case 'length equals':
+                return 'length_equals';
             case 'always':
-                return this.always;
+                return 'always';
             case 'never':
-                return this.never;
+                return 'never';
             default:
-                throw new AbilityParserError(`Literal ${literal} does not found in AbilityCondition class`);
-        }
-    }
-    get literal() {
-        const literal = Object.keys(AbilityCondition).find(member => {
-            const val = AbilityCondition[member];
-            return val.code === this.code;
-        });
-        if (typeof literal === 'undefined') {
-            throw new Error(`Literal value does not found in class AbilityCondition`);
+                throw new Error(`Unknown condition code: ${String(this.code)}`);
         }
-        return literal;
     }
 }
 
@@ -126,8 +167,11 @@ class AbilityTypeGenerator {
                     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 (!ruleType) {
+                        return;
+                    }
                     if (existingType && existingType !== ruleType) {
+                        // If a type already exists for this path, create a union
                         typeStructure[action][subjectPath] = `${existingType} | ${ruleType}`;
                     }
                     else {
@@ -146,6 +190,10 @@ class AbilityTypeGenerator {
      * @returns TypeScript type as string
      */
     determineTypeFromRule(rule) {
+        if (rule.condition.isEqual(AbilityCondition.never) ||
+            rule.condition.isEqual(AbilityCondition.always)) {
+            return null;
+        }
         // Numeric comparisons - always number
         if (rule.condition.isEqual(AbilityCondition.greater_than) ||
             rule.condition.isEqual(AbilityCondition.less_than) ||
@@ -172,8 +220,9 @@ class AbilityTypeGenerator {
      */
     getArrayType(resource) {
         if (Array.isArray(resource)) {
-            if (resource.length === 0)
+            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
@@ -191,10 +240,12 @@ class AbilityTypeGenerator {
      * @returns TypeScript primitive type as string
      */
     getPrimitiveType(value) {
-        if (value === null)
+        if (value === null) {
             return 'null';
-        if (value === undefined)
+        }
+        if (value === undefined) {
             return 'undefined';
+        }
         switch (typeof value) {
             case 'string':
                 return 'string';
@@ -253,12 +304,20 @@ class AbilityTypeGenerator {
         let output = '// Automatically generated by via-profit/ability\n';
         output += '// Do not edit manually\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';
+            const actionObj = structure[action];
+            const isEmpty = Object.keys(actionObj).length === 0;
+            if (isEmpty) {
+                // Пустой объект → undefined
+                output += `  ['${action}']: undefined;\n`;
+            }
+            else {
+                // Непустой объект → как раньше
+                output += `  ['${action}']: {\n`;
+                output += this.formatNestedObject(actionObj, 4);
+                output += '  };\n';
+            }
         });
         output += '}\n';
         return output;
@@ -403,14 +462,14 @@ class AbilityPolicy {
      * @param resource - The resource to check
      * @param environment - The user environment object
      */
-    async check(resource, environment) {
+    check(resource, environment) {
         this.matchState = AbilityMatch.mismatch;
         if (!this.ruleSet.length) {
             return this.matchState;
         }
         const rulesetCheckStates = [];
         for (const ruleSet of this.ruleSet) {
-            const state = await ruleSet.check(resource, environment);
+            const state = ruleSet.check(resource, environment);
             rulesetCheckStates.push(state);
             if (AbilityCompare.and.isEqual(this.compareMethod) && AbilityMatch.mismatch.isEqual(state)) {
                 return this.matchState; // mismatch
@@ -512,14 +571,11 @@ class AbilityResult {
 
 class AbilityResolver {
     policies;
-    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;
+    policyOrListOfPolicies) {
         this.policies = Array.isArray(policyOrListOfPolicies)
             ? policyOrListOfPolicies
             : [policyOrListOfPolicies];
@@ -531,30 +587,18 @@ class AbilityResolver {
      * @param resource - Resource
      * @param environment
      */
-    async resolve(permission, resource, environment) {
+    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);
+            const policyMatchState = policy.check(resource, environment);
             if (policyMatchState === AbilityMatch.pending) {
                 throw new 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(filteredPolicies);
     }
-    async enforce(permission, resource, environment) {
-        const result = await this.resolve(permission, resource, environment);
+    enforce(permission, resource, environment) {
+        const result = this.resolve(permission, resource, environment);
         if (result.isDenied()) {
             const lastPolicy = result.getLastMatchedPolicy();
             if (lastPolicy) {
@@ -577,18 +621,6 @@ class AbilityResolver {
             return chunk === '*' || longer[i] === '*' || chunk === longer[i];
         });
     }
-    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();
-    }
 }
 
 /**
@@ -624,149 +656,122 @@ class AbilityRule {
         this.resource = resource;
         this.condition = condition;
     }
-    /**
-     * Check if the rule is matched
-     * @param resource - The resource to check
-     * @param environment
-     */
-    async check(resource, environment) {
-        let is = false;
-        const [subjectValue, resourceValue] = this.extractValues(resource, environment);
-        const isValue = (v) => typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || v === null;
-        // always
-        if (AbilityCondition.always.isEqual(this.condition)) {
-            is = true;
-        }
-        // equals
-        if (AbilityCondition.equals.isEqual(this.condition)) {
-            is = subjectValue === resourceValue;
-        }
-        // not equals
-        if (AbilityCondition.not_equals.isEqual(this.condition)) {
-            is = subjectValue !== resourceValue;
-        }
-        // less than
-        if (AbilityCondition.less_than.isEqual(this.condition)) {
-            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
-                is = subjectValue < resourceValue;
-            }
-        }
-        // less or equal
-        if (AbilityCondition.less_or_equal.isEqual(this.condition)) {
-            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
-                is = subjectValue <= resourceValue;
-            }
-        }
-        // more than
-        if (AbilityCondition.greater_than.isEqual(this.condition)) {
-            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
-                is = subjectValue > resourceValue;
-            }
-        }
-        // more or equal
-        if (AbilityCondition.greater_or_equal.isEqual(this.condition)) {
-            if (typeof subjectValue === 'number' && typeof resourceValue === 'number') {
-                is = subjectValue >= resourceValue;
-            }
-        }
-        // in
-        if (AbilityCondition.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));
-            }
-        }
-        // not in
-        if (AbilityCondition.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));
-            }
-        }
-        // contains
-        if (AbilityCondition.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));
+    isPrimitive(v) {
+        return typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean' || v === null;
+    }
+    isNumber(v) {
+        return typeof v === 'number';
+    }
+    isString(v) {
+        return typeof v === 'string';
+    }
+    valueLen = (v) => this.isString(v) || Array.isArray(v) ? v.length : null;
+    operatorHandlers = {
+        [AbilityCondition.always.literal]: () => true,
+        [AbilityCondition.never.literal]: () => false,
+        [AbilityCondition.equals.literal]: (a, b) => a === b,
+        [AbilityCondition.not_equals.literal]: (a, b) => a !== b,
+        [AbilityCondition.contains.literal]: (a, b) => {
+            if (Array.isArray(a) && this.isPrimitive(b)) {
+                return a.includes(b);
             }
-        }
-        // not contains
-        if (AbilityCondition.not_contains.isEqual(this.condition)) {
-            if (Array.isArray(subjectValue) && isValue(resourceValue)) {
-                is = !subjectValue.includes(resourceValue);
+            if (Array.isArray(a) && Array.isArray(b)) {
+                return a.some(v => b.includes(v));
             }
-            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
-                is = !subjectValue.some(v => resourceValue.includes(v));
+            return false;
+        },
+        [AbilityCondition.not_contains.literal]: (a, b) => {
+            if (Array.isArray(a) && this.isPrimitive(b)) {
+                return !a.includes(b);
             }
-        }
-        // length equals
-        if (AbilityCondition.length_equals.isEqual(this.condition)) {
-            // foo.bar == n
-            if (isValue(subjectValue) && typeof resourceValue === 'number') {
-                is = String(subjectValue).length === resourceValue;
+            if (Array.isArray(a) && Array.isArray(b)) {
+                return !a.some(v => b.includes(v));
             }
-            // ['foo', 'bar'] = n
-            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
-                is = subjectValue.length === resourceValue;
+            return false;
+        },
+        [AbilityCondition.in.literal]: (a, b) => {
+            if (this.isPrimitive(a) && Array.isArray(b)) {
+                return b.includes(a);
             }
-            // ['foo', 'bar'] = ['baz', 'taz']
-            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
-                is = subjectValue.length === resourceValue.length;
+            if (Array.isArray(a) && Array.isArray(b)) {
+                return a.some(v => b.includes(v));
             }
-            // 'foo' = 'bar'
-            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
-                is = subjectValue.length === resourceValue.length;
+            return false;
+        },
+        [AbilityCondition.not_in.literal]: (a, b) => {
+            if (this.isPrimitive(a) && Array.isArray(b)) {
+                return !b.includes(a);
             }
-        }
-        // length greater than
-        if (AbilityCondition.length_greater_than.isEqual(this.condition)) {
-            // foo.bar > n
-            if (isValue(subjectValue) && typeof resourceValue === 'number') {
-                is = String(subjectValue).length > resourceValue;
+            if (Array.isArray(a) && Array.isArray(b)) {
+                return !a.some(v => b.includes(v));
             }
-            // ['foo', 'bar'] > n
-            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
-                is = subjectValue.length > resourceValue;
+            return false;
+        },
+        [AbilityCondition.greater_than.literal]: (a, b) => {
+            return this.isNumber(a) && this.isNumber(b) ? a > b : false;
+        },
+        [AbilityCondition.less_than.literal]: (a, b) => {
+            return this.isNumber(a) && this.isNumber(b) ? a < b : false;
+        },
+        [AbilityCondition.greater_or_equal.literal]: (a, b) => {
+            return this.isNumber(a) && this.isNumber(b) ? a >= b : false;
+        },
+        [AbilityCondition.less_or_equal.literal]: (a, b) => {
+            return this.isNumber(a) && this.isNumber(b) ? a <= b : false;
+        },
+        [AbilityCondition.length_greater_than.literal]: (a, b) => {
+            const alen = this.valueLen(a);
+            if (alen === null) {
+                return false;
+            }
+            if (this.isNumber(b)) {
+                return alen > b;
+            }
+            const bLen = this.valueLen(b);
+            if (bLen !== null) {
+                return alen > bLen;
             }
-            // ['foo', 'bar'] > ['baz', 'taz']
-            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
-                is = subjectValue.length > resourceValue.length;
+            return false;
+        },
+        [AbilityCondition.length_less_than.literal]: (a, b) => {
+            const alen = this.valueLen(a);
+            if (alen === null) {
+                return false;
             }
-            // 'foo' > 'bar'
-            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
-                is = subjectValue.length > resourceValue.length;
+            if (this.isNumber(b)) {
+                return alen < b;
             }
-        }
-        // length greater than
-        if (AbilityCondition.length_less_than.isEqual(this.condition)) {
-            // foo.bar < n
-            if (isValue(subjectValue) && typeof resourceValue === 'number') {
-                is = String(subjectValue).length < resourceValue;
+            const bLen = this.valueLen(b);
+            if (bLen !== null) {
+                return alen < bLen;
             }
-            // ['foo', 'bar'] < n
-            else if (Array.isArray(subjectValue) && typeof resourceValue === 'number') {
-                is = subjectValue.length < resourceValue;
+            return false;
+        },
+        [AbilityCondition.length_equals.literal]: (a, b) => {
+            const alen = this.valueLen(a);
+            if (alen === null) {
+                return false;
             }
-            // ['foo', 'bar'] < ['baz', 'taz']
-            else if (Array.isArray(subjectValue) && Array.isArray(resourceValue)) {
-                is = subjectValue.length < resourceValue.length;
+            if (this.isNumber(b)) {
+                return alen === b;
             }
-            // 'foo' < 'bar'
-            else if (typeof subjectValue === 'string' && typeof resourceValue === 'string') {
-                is = subjectValue.length < resourceValue.length;
+            const bLen = this.valueLen(b);
+            if (bLen !== null) {
+                return alen === bLen;
             }
-        }
-        this.state = is ? AbilityMatch.match : AbilityMatch.mismatch;
+            return false;
+        },
+    };
+    /**
+     * Check if the rule is matched
+     * @param resource - The resource to check
+     * @param environment
+     */
+    check(resource, environment) {
+        const [subjectValue, resourceValue] = this.extractValues(resource, environment);
+        const handler = this.operatorHandlers[this.condition.literal];
+        const result = handler(subjectValue, resourceValue);
+        this.state = result ? AbilityMatch.match : AbilityMatch.mismatch;
         return this.state;
     }
     /**
@@ -965,14 +970,14 @@ class AbilityRuleSet {
         rules.forEach(rule => this.addRule(rule));
         return this;
     }
-    async check(resources, environment) {
+    check(resources, environment) {
         this.state = AbilityMatch.mismatch;
         if (!this.rules.length) {
             return this.state;
         }
         const ruleCheckStates = [];
         for (const rule of this.rules) {
-            const state = await rule.check(resources, environment);
+            const state = rule.check(resources, environment);
             ruleCheckStates.push(state);
             if (AbilityCompare.and.isEqual(this.compareMethod) && AbilityMatch.mismatch.isEqual(state)) {
                 return this.state; // mismatch
@@ -1021,79 +1026,6 @@ class AbilityRuleSet {
     }
 }
 
-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 + '}';
-    }
-}
-
 class AbilityJSONParser {
     /**
      * Parses an array of policy configurations into an array of AbilityPolicy instances.
@@ -2171,9 +2103,7 @@ class AbilityDSLParser {
         return best;
     }
     levenshteinDistance(a, b) {
-        const matrix = Array(b.length + 1)
-            .fill(null)
-            .map(() => Array(a.length + 1).fill(null));
+        const matrix = Array.from({ length: b.length + 1 }, () => Array.from({ length: a.length + 1 }, () => 0));
         for (let i = 0; i <= a.length; i++)
             matrix[0][i] = i;
         for (let j = 0; j <= b.length; j++)
@@ -2248,7 +2178,6 @@ exports.AbilityExplain = AbilityExplain;
 exports.AbilityExplainPolicy = AbilityExplainPolicy;
 exports.AbilityExplainRule = AbilityExplainRule;
 exports.AbilityExplainRuleSet = AbilityExplainRuleSet;
-exports.AbilityInMemoryCache = AbilityInMemoryCache;
 exports.AbilityJSONParser = AbilityJSONParser;
 exports.AbilityMatch = AbilityMatch;
 exports.AbilityParserError = AbilityParserError;