@flusys/nestjs-entity-builder 9.1.1 → 9.1.2

package/fesm/{582.js → 857.js}

@@ -1,24 +1,79 @@
-import { RE2JS } from "re2js";
 import * as __rspack_external__flusys_nestjs_shared_interfaces_413f2706 from "@flusys/nestjs-shared/interfaces";
 import * as __rspack_external__flusys_nestjs_shared_modules_24702bee from "@flusys/nestjs-shared/modules";
 import * as __rspack_external__flusys_nestjs_shared_utils_9125c1f1 from "@flusys/nestjs-shared/utils";
 import * as __rspack_external__nestjs_common_a04939da from "@nestjs/common";
 import * as __rspack_external_node_net_5ed819e1 from "node:net";
-export const __rspack_esm_id = 582;
-export const __rspack_esm_ids = [582];
+export const __rspack_esm_id = 857;
+export const __rspack_esm_ids = [857];
 export const __webpack_modules__ = {
 3372(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 const RECORD_FILTER_OPS = [
     'eq',
     'ne',
+    'ieq',
     'gt',
     'gte',
     'lt',
     'lte',
+    'between',
+    'not_between',
     'in',
+    'not_in',
+    'contains',
+    'not_contains',
+    'starts_with',
+    'ends_with',
+    'has_any',
+    'has_all',
+    'has_none',
+    'is_empty',
+    'not_empty',
     'is_null',
     'not_null'
 ];
+const FILTER_OP_VALUE_KIND = {
+    eq: 'single',
+    ne: 'single',
+    ieq: 'single',
+    gt: 'single',
+    gte: 'single',
+    lt: 'single',
+    lte: 'single',
+    between: 'range',
+    not_between: 'range',
+    in: 'list',
+    not_in: 'list',
+    contains: 'single',
+    not_contains: 'single',
+    starts_with: 'single',
+    ends_with: 'single',
+    has_any: 'list',
+    has_all: 'list',
+    has_none: 'list',
+    is_empty: 'none',
+    not_empty: 'none',
+    is_null: 'none',
+    not_null: 'none'
+};
+/** Case-insensitive text operators: text, long text, email and single-select fields only. */ const TEXT_FILTER_OPS = [
+    'ieq',
+    'contains',
+    'not_contains',
+    'starts_with',
+    'ends_with'
+];
+/** Multi-select operators: whether the stored list holds any / all / none of the given values. */ const LIST_FIELD_FILTER_OPS = [
+    'has_any',
+    'has_all',
+    'has_none'
+];
+/** Blank checks: no value, an empty text or an empty multi-select. */ const EMPTY_FILTER_OPS = [
+    'is_empty',
+    'not_empty'
+];
+function isFilterRange(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value) && 'from' in value && 'to' in value && Object.keys(value).length === 2;
+}
 const RECORD_FILTER_LIMITS = {
     MAX_IN_VALUES: 100
 };
@@ -37,15 +92,20 @@ const FILTER_CONDITION_KEYS = new Set([
 }
 
 __webpack_require__.d(__webpack_exports__, {
+  iA: () => (isFilterRange),
   t1: () => (isRecordFilterCondition)
 }, {
   M5: RECORD_FILTER_LIMITS,
-  ox: RECORD_FILTER_OPS
+  Oh: EMPTY_FILTER_OPS,
+  ox: RECORD_FILTER_OPS,
+  w9: FILTER_OP_VALUE_KIND,
+  wk: TEXT_FILTER_OPS,
+  yV: LIST_FIELD_FILTER_OPS
 });
 
 
 },
-8429(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+8552(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -74,14 +134,87 @@ var common_ = __webpack_require__(6157);
 var external_node_crypto_ = __webpack_require__(2561);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
 var message_keys = __webpack_require__(5732);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/interfaces/generic-record.interface.ts
-var generic_record_interface = __webpack_require__(3372);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-ip.ts
 var rule_ip = __webpack_require__(809);
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-permission.ts
 var rule_permission = __webpack_require__(5191);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-regex.ts + 1 modules
-var rule_regex = __webpack_require__(6308);
+;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-regex.ts
+
+
+
+
+/** RE2 (linear-time) search: true when the pattern matches anywhere in the input. */ function matchesPattern(input, pattern) {
+    const prepared = prepare(input, pattern);
+    return prepared ? prepared.regex.matcher(prepared.text).find() : false;
+}
+/**
+ * The first match's capture `group` (default: the first group when the pattern has one, else the
+ * whole match); null when nothing matches or the group does not exist.
+ */ function extractPattern(input, pattern, group) {
+    const prepared = prepare(input, pattern);
+    if (!prepared) return null;
+    const index = group === undefined || group === null || group === '' ? prepared.regex.groupCount() > 0 ? 1 : 0 : Number(group);
+    if (!Number.isInteger(index) || index < 0 || index > prepared.regex.groupCount()) return null;
+    const matcher = prepared.regex.matcher(prepared.text);
+    return matcher.find() ? matcher.group(index) ?? null : null;
+}
+function prepare(input, pattern) {
+    if (typeof pattern !== 'string') {
+        throw new common_.BadRequestException({
+            message: 'A regular expression pattern must be text.',
+            messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INVALID */.x3.REGEX_INVALID,
+            messageVariables: {
+                pattern: JSON.stringify(pattern ?? null)
+            }
+        });
+    }
+    const problem = (0,utils_.safeRegexProblem)(pattern);
+    if (problem) throw patternError(problem, pattern);
+    const text = typeof input === 'string' ? input : typeof input === 'number' || typeof input === 'boolean' ? String(input) : null;
+    if (text === null) return null;
+    if (text.length > rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH) {
+        throw new common_.BadRequestException({
+            message: `Text matched against a regular expression can be at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH} characters.`,
+            messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INPUT_TOO_LONG */.x3.REGEX_INPUT_TOO_LONG,
+            messageVariables: {
+                max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH
+            }
+        });
+    }
+    return {
+        regex: (0,utils_.compileSafeRegex)(pattern),
+        text
+    };
+}
+function patternError(problem, pattern) {
+    switch(problem){
+        case 'too_long':
+            return new common_.BadRequestException({
+                message: `A regular expression pattern can be at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH} characters.`,
+                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_PATTERN_TOO_LONG */.x3.REGEX_PATTERN_TOO_LONG,
+                messageVariables: {
+                    max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH
+                }
+            });
+        case 'too_complex':
+            return new common_.BadRequestException({
+                message: `A regular expression can repeat a part at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_REPEAT */.bw.MAX_REGEX_REPEAT} times, nested repeats included.`,
+                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_TOO_COMPLEX */.x3.REGEX_TOO_COMPLEX,
+                messageVariables: {
+                    max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_REPEAT */.bw.MAX_REGEX_REPEAT
+                }
+            });
+        case 'invalid':
+            return new common_.BadRequestException({
+                message: `'${pattern}' is not a valid regular expression.`,
+                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INVALID */.x3.REGEX_INVALID,
+                messageVariables: {
+                    pattern
+                }
+            });
+    }
+}
+
 // EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-values.ts
 var rule_values = __webpack_require__(6622);
 ;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-engine.service.ts
@@ -119,7 +252,6 @@ function _ts_param(paramIndex, decorator) {
 
 
 
-
 const FORBIDDEN_PATH_KEYS = new Set([
     '__proto__',
     'constructor',
@@ -145,6 +277,12 @@ class RuleEngineService {
             cache: this.permissionCache
         });
     }
+    /** Any user's codes in any company / branch - another user, or the caller outside their current scope. */ permissionCodes(scope) {
+        return (0,utils_.loadPermissionCodes)(scope, {
+            resolver: this.permissionResolver,
+            cache: this.permissionCache
+        });
+    }
     async evaluateGroup(group, ctx, depth = 0, budget = {}) {
         this.assertWithinLimits(group, depth);
         const evaluate = (node)=>(0,rule_interface/* .isRuleGroup */.GD)(node) ? this.evaluateGroup(node, ctx, depth + 1, budget) : this.evaluateCondition(node, ctx, budget);
@@ -221,9 +359,9 @@ class RuleEngineService {
             case 'is_false':
                 return actual === false;
             case 'matches':
-                return (0,rule_regex/* .matchesPattern */.MT)(actual, expected);
+                return matchesPattern(actual, expected);
             case 'not_matches':
-                return !(0,rule_regex/* .matchesPattern */.MT)(actual, expected);
+                return !matchesPattern(actual, expected);
         }
     }
     async resolveConditionLeft(condition, ctx, budget) {
@@ -290,17 +428,7 @@ class RuleEngineService {
         }
         const filter = {};
         for (const [key, item] of Object.entries(expression.filter ?? {})){
-            if ((0,generic_record_interface/* .isRecordFilterCondition */.t1)(item)) {
-                const value = item.value === undefined ? undefined : await this.resolveExpression(item.value, ctx, budget);
-                filter[key] = value === undefined ? {
-                    op: item.op
-                } : {
-                    op: item.op,
-                    value
-                };
-            } else {
-                filter[key] = (0,rule_values/* .equalsOperand */.$b)(await this.resolveExpression(item, ctx, budget));
-            }
+            filter[key] = await (0,rule_values/* .resolveFilterEntry */.vY)(item, (value)=>this.resolveExpression(value, ctx, budget));
         }
         const { rows, total } = await ctx.lookupResolver.find(expression.entity, {
             filter,
@@ -469,7 +597,7 @@ class RuleEngineService {
                     return part === undefined ? null : part.trim();
                 }
             case 'REGEX_EXTRACT':
-                return (0,rule_regex/* .extractPattern */.Ax)(resolvedArgs[0], resolvedArgs[1], resolvedArgs[2]);
+                return extractPattern(resolvedArgs[0], resolvedArgs[1], resolvedArgs[2]);
             case 'REPLACE':
                 {
                     const [value, search, replacement] = resolvedArgs;
@@ -824,235 +952,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
-},
-6308(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  Ax: () => (/* binding */ extractPattern),
-  MT: () => (/* binding */ matchesPattern),
-  _V: () => (/* binding */ rulePatternProblem)
-});
-
-// EXTERNAL MODULE: external "@nestjs/common"
-var common_ = __webpack_require__(6157);
-;// CONCATENATED MODULE: external "re2js"
-
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/config/message-keys.ts
-var message_keys = __webpack_require__(5732);
-// EXTERNAL MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule.interface.ts
-var rule_interface = __webpack_require__(2354);
-;// CONCATENATED MODULE: ./projects/nestjs-entity-builder/src/rule-engine/rule-regex.ts
-
-
-
-
-const MAX_CACHED_PATTERNS = 200;
-const compiled = new Map();
-const tooComplex = new Map();
-function remember(cache, pattern, make) {
-    if (cache.has(pattern)) return cache.get(pattern);
-    const value = make(pattern);
-    if (cache.size >= MAX_CACHED_PATTERNS) cache.delete(cache.keys().next().value);
-    cache.set(pattern, value);
-    return value;
-}
-/** Why a pattern cannot be used, or null when it compiles within the limits. */ function rulePatternProblem(pattern) {
-    if (pattern.length > rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH) return 'too_long';
-    if (remember(tooComplex, pattern, isTooComplex)) return 'too_complex';
-    try {
-        compile(pattern);
-        return null;
-    } catch  {
-        return 'invalid';
-    }
-}
-const newFrame = ()=>({
-        size: 0,
-        last: 0,
-        lastProduct: 1,
-        maxProduct: 1
-    });
-/**
- * RE2 unrolls counted repeats (`x{2,50}` becomes 50 copies of x), so match time grows with the
- * product of nested counts. Rejects a count above MAX_REGEX_REPEAT, nested counts whose product
- * is above it, and a pattern whose unrolled size grows by more than MAX_REGEX_REPEAT_EXPANSION.
- * `*`, `+` and `?` do not unroll and stay allowed, nested or not.
- */ function isTooComplex(pattern) {
-    const { MAX_REGEX_REPEAT, MAX_REGEX_REPEAT_EXPANSION } = rule_interface/* .RULE_ENGINE_LIMITS */.bw;
-    const stack = [
-        newFrame()
-    ];
-    const top = ()=>stack[stack.length - 1];
-    let atoms = 0;
-    const atom = (size, product)=>{
-        const frame = top();
-        frame.size += size;
-        frame.last = size;
-        frame.lastProduct = product;
-        frame.maxProduct = Math.max(frame.maxProduct, product);
-    };
-    let i = 0;
-    while(i < pattern.length){
-        const c = pattern[i];
-        if (c === '\\') {
-            const next = pattern[i + 1];
-            i += 2;
-            if ((next === 'p' || next === 'P' || next === 'x') && pattern[i] === '{') i = closing(pattern, i, '}');
-            atoms++;
-            atom(1, 1);
-        } else if (c === '[') {
-            i = classEnd(pattern, i);
-            atoms++;
-            atom(1, 1);
-        } else if (c === '(') {
-            i++;
-            if (pattern[i] === '?') {
-                const flagsOnly = /^\?[a-zA-Z-]*\)/.exec(pattern.slice(i));
-                if (flagsOnly) {
-                    i += flagsOnly[0].length;
-                    continue;
-                }
-                const marker = /^\?(?:P?<[^>]*>|[a-zA-Z-]*:)/.exec(pattern.slice(i));
-                i += marker ? marker[0].length : 1;
-            }
-            stack.push(newFrame());
-        } else if (c === ')') {
-            i++;
-            if (stack.length === 1) continue;
-            const group = stack.pop();
-            atom(group.size, group.maxProduct);
-        } else if (c === '|') {
-            i++;
-            top().last = 0;
-            top().lastProduct = 1;
-        } else if (c === '{') {
-            const repeat = /^\{(\d+)(,(\d*))?\}\??/.exec(pattern.slice(i));
-            if (!repeat) {
-                i++;
-                atoms++;
-                atom(1, 1);
-                continue;
-            }
-            i += repeat[0].length;
-            const min = Number(repeat[1]);
-            const max = repeat[2] === undefined ? min : repeat[3] ? Number(repeat[3]) : min + 1;
-            if (min > MAX_REGEX_REPEAT || max > MAX_REGEX_REPEAT) return true;
-            const frame = top();
-            const product = frame.lastProduct * Math.max(max, 1);
-            if (product > MAX_REGEX_REPEAT) return true;
-            const extra = frame.last * (Math.max(max, 1) - 1);
-            frame.size += extra;
-            frame.last += extra;
-            frame.lastProduct = product;
-            frame.maxProduct = Math.max(frame.maxProduct, product);
-        } else {
-            i++;
-            if (c !== '*' && c !== '+' && c !== '?') {
-                atoms++;
-                atom(1, 1);
-            }
-        }
-    }
-    while(stack.length > 1){
-        const group = stack.pop();
-        atom(group.size, group.maxProduct);
-    }
-    return stack[0].size - atoms > MAX_REGEX_REPEAT_EXPANSION;
-}
-function closing(pattern, from, char) {
-    const end = pattern.indexOf(char, from);
-    return end < 0 ? pattern.length : end + 1;
-}
-function classEnd(pattern, start) {
-    let j = start + 1;
-    if (pattern[j] === '^') j++;
-    if (pattern[j] === ']') j++;
-    while(j < pattern.length && pattern[j] !== ']'){
-        if (pattern[j] === '\\') j += 2;
-        else if (pattern.startsWith('[:', j)) j = closing(pattern, j + 2, ']');
-        else j++;
-    }
-    return j + 1;
-}
-/** RE2 (linear-time) search: true when the pattern matches anywhere in the input. */ function matchesPattern(input, pattern) {
-    const prepared = prepare(input, pattern);
-    return prepared ? prepared.regex.matcher(prepared.text).find() : false;
-}
-/**
- * The first match's capture `group` (default: the first group when the pattern has one, else the
- * whole match); null when nothing matches or the group does not exist.
- */ function extractPattern(input, pattern, group) {
-    const prepared = prepare(input, pattern);
-    if (!prepared) return null;
-    const index = group === undefined || group === null || group === '' ? prepared.regex.groupCount() > 0 ? 1 : 0 : Number(group);
-    if (!Number.isInteger(index) || index < 0 || index > prepared.regex.groupCount()) return null;
-    const matcher = prepared.regex.matcher(prepared.text);
-    return matcher.find() ? matcher.group(index) ?? null : null;
-}
-function prepare(input, pattern) {
-    if (typeof pattern !== 'string') {
-        throw new common_.BadRequestException({
-            message: 'A regular expression pattern must be text.',
-            messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INVALID */.x3.REGEX_INVALID,
-            messageVariables: {
-                pattern: JSON.stringify(pattern ?? null)
-            }
-        });
-    }
-    const problem = rulePatternProblem(pattern);
-    if (problem) throw patternError(problem, pattern);
-    const text = typeof input === 'string' ? input : typeof input === 'number' || typeof input === 'boolean' ? String(input) : null;
-    if (text === null) return null;
-    if (text.length > rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH) {
-        throw new common_.BadRequestException({
-            message: `Text matched against a regular expression can be at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH} characters.`,
-            messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INPUT_TOO_LONG */.x3.REGEX_INPUT_TOO_LONG,
-            messageVariables: {
-                max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_INPUT_LENGTH */.bw.MAX_REGEX_INPUT_LENGTH
-            }
-        });
-    }
-    return {
-        regex: compile(pattern),
-        text
-    };
-}
-function patternError(problem, pattern) {
-    switch(problem){
-        case 'too_long':
-            return new common_.BadRequestException({
-                message: `A regular expression pattern can be at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH} characters.`,
-                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_PATTERN_TOO_LONG */.x3.REGEX_PATTERN_TOO_LONG,
-                messageVariables: {
-                    max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_PATTERN_LENGTH */.bw.MAX_REGEX_PATTERN_LENGTH
-                }
-            });
-        case 'too_complex':
-            return new common_.BadRequestException({
-                message: `A regular expression can repeat a part at most ${rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_REPEAT */.bw.MAX_REGEX_REPEAT} times, nested repeats included.`,
-                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_TOO_COMPLEX */.x3.REGEX_TOO_COMPLEX,
-                messageVariables: {
-                    max: rule_interface/* .RULE_ENGINE_LIMITS.MAX_REGEX_REPEAT */.bw.MAX_REGEX_REPEAT
-                }
-            });
-        case 'invalid':
-            return new common_.BadRequestException({
-                message: `'${pattern}' is not a valid regular expression.`,
-                messageKey: message_keys/* .RULE_ENGINE_MESSAGES.REGEX_INVALID */.x3.REGEX_INVALID,
-                messageVariables: {
-                    pattern
-                }
-            });
-    }
-}
-function compile(pattern) {
-    return remember(compiled, pattern, (p)=>RE2JS.compile(p));
-}
-
-
 },
 6622(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _interfaces_generic_record_interface_js__rspack_import_0 = __webpack_require__(3372);
+
 const ISO_DATE_PREFIX = /^\s*\d{4}-\d{2}-\d{2}/;
 const ISO_DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:[.,](\d{1,9}))?)?)?\s*(Z|[+-]\d{2}(?::?\d{2})?)?$/i;
 const EXPLICIT_ZONE = /(?:\bZ|\bGMT|\bUTC|[+-]\d{2}:?\d{2})$/i;
@@ -1103,21 +1006,54 @@ function instant(value) {
 }
 const includesValue = (list, value)=>list.some((item)=>valuesEqual(item, value));
 /**
- * A resolved filter value is only ever an operand: an object or a list (e.g. `{ "op": "not_null" }`
- * sent as input) is wrapped as the operand of `eq`, which the entity service refuses as not a single
- * value, so it never becomes an operator. Only authored `{ op, value }` entries are operators.
- */ const equalsOperand = (value)=>value !== null && typeof value === 'object' ? {
+ * A filter entry with its expressions resolved, as the entity service takes it: a plain expression
+ * is `eq`, a `range` becomes `[from, to]`. `value` is undefined when a value it needs resolves to
+ * undefined. A resolved value is only ever an operand, so an object or list sent as input (e.g.
+ * `{ "op": "not_null" }`) never becomes an operator: the entity service refuses it as not a value.
+ */ async function resolveFilterEntry(item, resolve) {
+    if (!(0,_interfaces_generic_record_interface_js__rspack_import_0/* .isRecordFilterCondition */.t1)(item)) return {
         op: 'eq',
-        value
-    } : value;
+        value: await resolve(item)
+    };
+    const { op, value } = item;
+    switch(_interfaces_generic_record_interface_js__rspack_import_0/* .FILTER_OP_VALUE_KIND */.w9[op]){
+        case 'none':
+            return {
+                op
+            };
+        case 'range':
+            {
+                if (!(0,_interfaces_generic_record_interface_js__rspack_import_0/* .isFilterRange */.iA)(value)) return {
+                    op,
+                    value: undefined
+                };
+                const from = await resolve(value.from);
+                const to = await resolve(value.to);
+                return {
+                    op,
+                    value: from === undefined || to === undefined ? undefined : [
+                        from,
+                        to
+                    ]
+                };
+            }
+        default:
+            return {
+                op,
+                value: value === undefined ? undefined : await resolve(value)
+            };
+    }
+}
+/** Whether a resolved entry is missing the value its operator needs. */ const isFilterValueMissing = (entry)=>_interfaces_generic_record_interface_js__rspack_import_0/* .FILTER_OP_VALUE_KIND */.w9[entry.op] !== 'none' && entry.value === undefined;
 
 __webpack_require__.d(__webpack_exports__, {
   hz: () => (parseDateText),
-  lu: () => (valuesEqual)
+  lu: () => (valuesEqual),
+  vY: () => (resolveFilterEntry)
 }, {
-  $b: equalsOperand,
   XL: includesValue,
-  YN: ISO_DATE_PREFIX
+  YN: ISO_DATE_PREFIX,
+  kp: isFilterValueMissing
 });
 
 
@@ -1174,10 +1110,9 @@ const RULE_ENGINE_LIMITS = {
     MAX_GROUP_DEPTH: 8,
     MAX_CONDITIONS_PER_GROUP: 100,
     MAX_LOOKUPS: 10,
-    MAX_REGEX_PATTERN_LENGTH: 500,
-    MAX_REGEX_INPUT_LENGTH: 10_000,
-    /** Largest `{n,m}` count, also for the product of nested counts. */ MAX_REGEX_REPEAT: 100,
-    /** How much larger counted repeats may make the unrolled pattern than the pattern itself. */ MAX_REGEX_REPEAT_EXPANSION: 300,
+    MAX_REGEX_PATTERN_LENGTH: _flusys_nestjs_shared_utils__rspack_import_0.SAFE_REGEX_LIMITS.MAX_PATTERN_LENGTH,
+    MAX_REGEX_INPUT_LENGTH: _flusys_nestjs_shared_utils__rspack_import_0.SAFE_REGEX_LIMITS.MAX_INPUT_LENGTH,
+    /** Largest `{n,m}` count, also for the product of nested counts. */ MAX_REGEX_REPEAT: _flusys_nestjs_shared_utils__rspack_import_0.SAFE_REGEX_LIMITS.MAX_REPEAT,
     /** Largest `offsetMinutes` accepted by START_OF_DAY / END_OF_DAY (UTC+14 / UTC-12). */ MAX_UTC_OFFSET_MINUTES: 840,
     MAX_PERMISSION_CODES: _flusys_nestjs_shared_utils__rspack_import_0.MAX_PERMISSION_LOGIC_CODES,
     MAX_IP_RANGES: 100

package/fesm/controllers/index.js

@@ -7,7 +7,7 @@ import * as __rspack_chunk_1 from '../21.js';
 __webpack_require__.C(__rspack_chunk_1);
 import * as __rspack_chunk_2 from '../897.js';
 __webpack_require__.C(__rspack_chunk_2);
-import * as __rspack_chunk_3 from '../582.js';
+import * as __rspack_chunk_3 from '../857.js';
 __webpack_require__.C(__rspack_chunk_3);
 import * as __rspack_chunk_4 from '../794.js';
 __webpack_require__.C(__rspack_chunk_4);

package/fesm/guards/index.js

@@ -298,7 +298,7 @@ import * as __rspack_chunk_1 from '../21.js';
 __webpack_require__.C(__rspack_chunk_1);
 import * as __rspack_chunk_2 from '../897.js';
 __webpack_require__.C(__rspack_chunk_2);
-import * as __rspack_chunk_3 from '../582.js';
+import * as __rspack_chunk_3 from '../857.js';
 __webpack_require__.C(__rspack_chunk_3);
 import * as __rspack_chunk_4 from '../794.js';
 __webpack_require__.C(__rspack_chunk_4);