@react-querybuilder/core 8.11.1 → 8.12.0

package/dist/{import-Dvayhrgj.d.ts → import-BSWb9Vgd.d.ts}

@@ -1,4 +1,4 @@
-import { o as ValueSources, t as FullField, x as OptionList } from "./basic-BeKPP0_1.js";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-o1-sYjK6.js";
 
 //#region src/types/import.d.ts
 
@@ -25,4 +25,4 @@ interface ParserCommonOptions {
 }
 //#endregion
 export { ParserCommonOptions as t };
-//# sourceMappingURL=import-Dvayhrgj.d.ts.map
+//# sourceMappingURL=import-BSWb9Vgd.d.ts.map

package/dist/{import-Bc_p8ls9.d.mts → import-CLyHpgk8.d.mts}

@@ -1,4 +1,4 @@
-import { o as ValueSources, t as FullField, x as OptionList } from "./basic-B4vXboTG.mjs";
+import { o as ValueSources, t as FullField, x as OptionList } from "./basic-DbvrfPNz.mjs";
 
 //#region src/types/import.d.ts
 
@@ -25,4 +25,4 @@ interface ParserCommonOptions {
 }
 //#endregion
 export { ParserCommonOptions as t };
-//# sourceMappingURL=import-Bc_p8ls9.d.mts.map
+//# sourceMappingURL=import-CLyHpgk8.d.mts.map

package/dist/{isRuleGroup-CYcfPgbg.mjs → isRuleGroup-BcfwGaIN.mjs}

@@ -37,4 +37,4 @@ const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 
 //#endregion
 export { lc as a, isPojo as i, isRuleGroupType as n, nullOrUndefinedOrEmpty as o, isRuleGroupTypeIC as r, numericRegex$1 as s, isRuleGroup as t };
-//# sourceMappingURL=isRuleGroup-CYcfPgbg.mjs.map
+//# sourceMappingURL=isRuleGroup-BcfwGaIN.mjs.map

package/dist/{isRuleGroup-CYcfPgbg.mjs.map → isRuleGroup-BcfwGaIN.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"isRuleGroup-CYcfPgbg.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}
+{"version":3,"file":"isRuleGroup-BcfwGaIN.mjs","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,iBAAuB,IAAI,OACtCC,aAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/{isRuleGroup-DqAs2x4E.js → isRuleGroup-Do9KKsmt.js}

@@ -1,31 +1,5 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function() {
-	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
+const require_chunk = require('./chunk-BxBTb9qk.js');
 let numeric_quantity = require("numeric-quantity");
-numeric_quantity = __toESM(numeric_quantity);
 
 //#region src/utils/misc.ts
 /**
@@ -63,18 +37,6 @@ const isRuleGroupType = (rg) => isRuleGroup(rg) && typeof rg.combinator === "str
 const isRuleGroupTypeIC = (rg) => isRuleGroup(rg) && rg.combinator === void 0;
 
 //#endregion
-Object.defineProperty(exports, '__commonJS', {
-  enumerable: true,
-  get: function () {
-    return __commonJS;
-  }
-});
-Object.defineProperty(exports, '__toESM', {
-  enumerable: true,
-  get: function () {
-    return __toESM;
-  }
-});
 Object.defineProperty(exports, 'isPojo', {
   enumerable: true,
   get: function () {
@@ -117,4 +79,4 @@ Object.defineProperty(exports, 'numericRegex', {
     return numericRegex;
   }
 });
-//# sourceMappingURL=isRuleGroup-DqAs2x4E.js.map
+//# sourceMappingURL=isRuleGroup-Do9KKsmt.js.map

package/dist/{isRuleGroup-DqAs2x4E.js.map → isRuleGroup-Do9KKsmt.js.map}

@@ -1 +1 @@
-{"version":3,"file":"isRuleGroup-DqAs2x4E.js","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,eAAuB,IAAI,OACtCC,8BAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}
+{"version":3,"file":"isRuleGroup-Do9KKsmt.js","names":["numericRegex: RegExp","numericQuantityRegex"],"sources":["../src/utils/misc.ts","../src/utils/isRuleGroup.ts"],"sourcesContent":["import { numericRegex as numericQuantityRegex } from 'numeric-quantity';\n\n/**\n * Converts a value to lowercase if it's a string, otherwise returns the value as is.\n */\n// istanbul ignore next\nexport const lc = <T>(v: T): T => (typeof v === 'string' ? (v.toLowerCase() as T) : v);\n\n/**\n * Regex matching numeric strings. Passes for positive/negative integers, decimals,\n * and E notation, with optional surrounding whitespace.\n */\nexport const numericRegex: RegExp = new RegExp(\n  numericQuantityRegex.source.replace(/^\\^/, String.raw`^\\s*`).replace(/\\$$/, String.raw`\\s*$`)\n);\n\n/**\n * Determines if a variable is a plain old JavaScript object, aka POJO.\n */\n// oxlint-disable-next-line typescript/no-explicit-any\nexport const isPojo = (obj: any): obj is Record<string, any> =>\n  obj === null || typeof obj !== 'object' ? false : Object.getPrototypeOf(obj) === Object.prototype;\n\n/**\n * Simple helper to determine whether a value is null, undefined, or an empty string.\n */\nexport const nullOrUndefinedOrEmpty = (value: unknown): value is null | undefined | '' =>\n  value === null || value === undefined || value === '';\n","import type { RuleGroupType, RuleGroupTypeAny, RuleGroupTypeIC, RuleType } from '../types';\nimport { isPojo } from './misc';\n\n/**\n * Determines if an object is a {@link RuleType} (only checks for a `field` property).\n */\nexport const isRuleType = (s: unknown): s is RuleType =>\n  isPojo(s) && 'field' in s && typeof s.field === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupType} or {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroup = (rg: unknown): rg is RuleGroupTypeAny =>\n  isPojo(rg) && Array.isArray(rg.rules);\n\n/**\n * Determines if an object is a {@link RuleGroupType}.\n */\nexport const isRuleGroupType = (rg: unknown): rg is RuleGroupType =>\n  isRuleGroup(rg) && typeof rg.combinator === 'string';\n\n/**\n * Determines if an object is a {@link RuleGroupTypeIC}.\n */\nexport const isRuleGroupTypeIC = (rg: unknown): rg is RuleGroupTypeIC =>\n  isRuleGroup(rg) && rg.combinator === undefined;\n"],"mappings":";;;;;;;;AAMA,MAAa,MAAS,MAAa,OAAO,MAAM,WAAY,EAAE,aAAa,GAAS;;;;;AAMpF,MAAaA,eAAuB,IAAI,OACtCC,8BAAqB,OAAO,QAAQ,OAAO,OAAO,GAAG,OAAO,CAAC,QAAQ,OAAO,OAAO,GAAG,OAAO,CAC9F;;;;AAMD,MAAa,UAAU,QACrB,QAAQ,QAAQ,OAAO,QAAQ,WAAW,QAAQ,OAAO,eAAe,IAAI,KAAK,OAAO;;;;AAK1F,MAAa,0BAA0B,UACrC,UAAU,QAAQ,UAAU,UAAa,UAAU;;;;;;;ACfrD,MAAa,eAAe,OAC1B,OAAO,GAAG,IAAI,MAAM,QAAQ,GAAG,MAAM;;;;AAKvC,MAAa,mBAAmB,OAC9B,YAAY,GAAG,IAAI,OAAO,GAAG,eAAe;;;;AAK9C,MAAa,qBAAqB,OAChC,YAAY,GAAG,IAAI,GAAG,eAAe"}

package/dist/parseCEL.d.mts

@@ -1,8 +1,8 @@
-import { C as Except, _ as RuleGroupType, d as DefaultRuleGroupTypeIC, g as DefaultRuleGroupType, h as DefaultOperatorName, m as DefaultCombinatorName, p as RuleGroupTypeIC, v as RuleType } from "./basic-B4vXboTG.mjs";
-import { t as ParserCommonOptions } from "./import-Bc_p8ls9.mjs";
+import { C as Except, _ as RuleGroupType, d as DefaultRuleGroupTypeIC, g as DefaultRuleGroupType, h as DefaultOperatorName, m as DefaultCombinatorName, p as RuleGroupTypeIC, v as RuleType } from "./basic-DbvrfPNz.mjs";
+import { t as ParserCommonOptions } from "./import-CLyHpgk8.mjs";
 
 //#region src/utils/parseCEL/types.d.ts
-type CELExpressionType = "Addition" | "BooleanLiteral" | "BytesLiteral" | "ConditionalAnd" | "ConditionalExpr" | "ConditionalOr" | "Division" | "DynamicPropertyAccessor" | "ExpressionGroup" | "ExpressionList" | "FieldInit" | "FieldInits" | "FieldsObject" | "FloatLiteral" | "FunctionCall" | "Identifier" | "IntegerLiteral" | "List" | "Map" | "MapInit" | "MapInits" | "Member" | "Modulo" | "Multiplication" | "Negation" | "Negative" | "NullLiteral" | "Property" | "Relation" | "StringLiteral" | "Subtraction" | "Unary" | "UnsignedIntegerLiteral" | "LikeExpression";
+type CELExpressionType = "Addition" | "BooleanLiteral" | "BytesLiteral" | "ConditionalAnd" | "ConditionalExpr" | "ConditionalOr" | "Division" | "DynamicPropertyAccessor" | "ExpressionGroup" | "ExpressionList" | "FieldInit" | "FieldInits" | "FieldsObject" | "FloatLiteral" | "FunctionCall" | "Identifier" | "IntegerLiteral" | "List" | "Map" | "MapInit" | "MapInits" | "Member" | "Modulo" | "Multiplication" | "Negation" | "Negative" | "NullLiteral" | "Property" | "Relation" | "StringLiteral" | "Subtraction" | "Unary" | "UnsignedIntegerLiteral" | "LikeExpression" | "SubqueryExpression";
 type CELRelop = "==" | ">=" | ">" | "<=" | "<" | "!=" | "in";
 interface CELExpression {
   type: CELExpressionType;
@@ -64,7 +64,7 @@ interface CELNegative extends CELExpression {
 interface CELMember extends CELExpression {
   type: "Member";
   value?: CELPrimary;
-  left?: CELPrimary | CELMember;
+  left?: CELPrimary | CELMember | CELNegation;
   right?: CELIdentifier;
   list?: CELExpressionList;
 }
@@ -194,6 +194,22 @@ interface CELNegatedLikeExpression extends CELExpression {
     value: [CELStringLiteral | CELIdentifier];
   };
 }
+interface CELSubqueryExpression extends CELExpression {
+  type: "Member";
+  left: CELIdentifier | CELMemberIdentifierChain;
+  right: CELIdentifier<"all" | "exists">;
+  list: CELExpressionList & {
+    value: [CELIdentifier, CELExpression];
+  };
+}
+interface CELNegatedSubqueryExpression extends CELExpression {
+  type: "Member";
+  left: CELMemberNegatedIdentifier | CELMemberNegatedIdentifierChain;
+  right: CELIdentifier<"all" | "exists">;
+  list: CELExpressionList & {
+    value: [CELIdentifier, CELExpression];
+  };
+}
 type CELNumericLiteral = CELIntegerLiteral | CELUnsignedIntegerLiteral | CELFloatLiteral;
 type CELLiteral = CELStringLiteral | CELBytesLiteral | CELNumericLiteral | CELBooleanLiteral | CELNullLiteral;
 type CELPrimary = CELProperty | CELIdentifier | CELExpressionGroup | CELFunctionCall | CELLiteral | CELList | CELMap;
@@ -292,12 +308,20 @@ declare const isCELNullLiteral: (expr: CELExpression) => expr is CELNullLiteral;
 declare const isCELProperty: (expr: CELExpression) => expr is CELProperty;
 declare const isCELSubtraction: (expr: CELExpression) => expr is CELSubtraction;
 declare const isCELUnsignedIntegerLiteral: (expr: CELExpression) => expr is CELUnsignedIntegerLiteral;
-declare const isCELIdentifierOrChain: (expr: CELExpression) => expr is CELMemberIdentifierChain | CELIdentifier;
+declare const isCELIdentifierOrChain: (expr: CELExpression) => expr is CELMemberIdentifierChain | CELIdentifier | CELDynamicPropertyAccessor;
 declare const isCELNegatedIdentifier: (expr: CELExpression) => expr is CELMemberNegatedIdentifier;
 declare const isCELNegatedIdentifierOrChain: (expr: CELExpression) => expr is CELMemberNegatedIdentifierChain | CELMemberNegatedIdentifier;
 declare const isCELLikeExpression: (expr: CELExpression) => expr is CELLikeExpression;
 declare const isCELNegatedLikeExpression: (expr: CELExpression) => expr is CELNegatedLikeExpression;
-declare const getCELIdentifierFromChain: (expr: CELIdentifier | CELMemberIdentifierChain) => string;
+declare const isCELSubqueryExpression: (expr: CELExpression) => expr is CELSubqueryExpression;
+declare const isCELNegatedSubqueryExpression: (expr: CELExpression) => expr is CELNegatedSubqueryExpression;
+declare const extractSubqueryComponents: (expr: CELMember) => {
+  field: string;
+  method: "all" | "exists";
+  alias: string | null;
+  condition: CELExpression;
+} | null;
+declare const getCELIdentifierFromChain: (expr: CELIdentifier | CELMemberIdentifierChain | CELDynamicPropertyAccessor | CELMember) => string;
 declare const getCELIdentifierFromNegatedChain: (expr: CELMemberNegatedIdentifier | CELMemberNegatedIdentifierChain) => string;
 declare function evalCELLiteralValue(literal: CELStringLiteral): string;
 declare function evalCELLiteralValue(literal: CELBooleanLiteral): boolean;
@@ -309,6 +333,7 @@ declare const celNormalizeCombinator: (c: "&&" | "||") => DefaultCombinatorName;
 declare const celNormalizeOperator: (op: CELRelop, flip?: boolean) => DefaultOperatorName;
 declare const celGenerateFlatAndOrList: (expr: CELConditionalAnd | CELConditionalOr) => (DefaultCombinatorName | CELExpression)[];
 declare const celGenerateMixedAndOrList: (expr: CELConditionalAnd | CELConditionalOr) => (DefaultCombinatorName | CELExpression | ("and" | CELExpression)[])[];
+declare const transformAliasInExpression: (expr: CELExpression, alias: string | null) => CELExpression;
 //#endregion
-export { CELAddition, CELBooleanLiteral, CELBytesLiteral, CELConditionalAnd, CELConditionalExpr, CELConditionalOr, CELDivision, CELDynamicPropertyAccessor, CELExpression, CELExpressionGroup, CELExpressionList, CELExpressionType, CELFieldInit, CELFieldInits, CELFieldsObject, CELFloatLiteral, CELFunctionCall, CELIdentifier, CELIntegerLiteral, CELLikeExpression, CELList, CELLiteral, CELMap, CELMapInit, CELMapInits, CELMathOperation, CELMember, CELMemberIdentifierChain, CELMemberNegatedIdentifier, CELMemberNegatedIdentifierChain, CELModulo, CELMultiplication, CELNegatedLikeExpression, CELNegation, CELNegative, CELNullLiteral, CELNumericLiteral, CELPrimary, CELProperty, CELRelation, CELRelop, CELStringLiteral, CELSubtraction, CELUnsignedIntegerLiteral, ParseCELOptions, ParseCELOptionsIC, ParseCELOptionsStandard, ParsedCEL, celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL };
+export { CELAddition, CELBooleanLiteral, CELBytesLiteral, CELConditionalAnd, CELConditionalExpr, CELConditionalOr, CELDivision, CELDynamicPropertyAccessor, CELExpression, CELExpressionGroup, CELExpressionList, CELExpressionType, CELFieldInit, CELFieldInits, CELFieldsObject, CELFloatLiteral, CELFunctionCall, CELIdentifier, CELIntegerLiteral, CELLikeExpression, CELList, CELLiteral, CELMap, CELMapInit, CELMapInits, CELMathOperation, CELMember, CELMemberIdentifierChain, CELMemberNegatedIdentifier, CELMemberNegatedIdentifierChain, CELModulo, CELMultiplication, CELNegatedLikeExpression, CELNegatedSubqueryExpression, CELNegation, CELNegative, CELNullLiteral, CELNumericLiteral, CELPrimary, CELProperty, CELRelation, CELRelop, CELStringLiteral, CELSubqueryExpression, CELSubtraction, CELUnsignedIntegerLiteral, ParseCELOptions, ParseCELOptionsIC, ParseCELOptionsStandard, ParsedCEL, celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, extractSubqueryComponents, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegatedSubqueryExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubqueryExpression, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL, transformAliasInExpression };
 //# sourceMappingURL=parseCEL.d.mts.map

package/dist/parseCEL.d.ts

@@ -1,8 +1,8 @@
-import { C as Except, _ as RuleGroupType, d as DefaultRuleGroupTypeIC, g as DefaultRuleGroupType, h as DefaultOperatorName, m as DefaultCombinatorName, p as RuleGroupTypeIC, v as RuleType } from "./basic-BeKPP0_1.js";
-import { t as ParserCommonOptions } from "./import-Dvayhrgj.js";
+import { C as Except, _ as RuleGroupType, d as DefaultRuleGroupTypeIC, g as DefaultRuleGroupType, h as DefaultOperatorName, m as DefaultCombinatorName, p as RuleGroupTypeIC, v as RuleType } from "./basic-o1-sYjK6.js";
+import { t as ParserCommonOptions } from "./import-BSWb9Vgd.js";
 
 //#region src/utils/parseCEL/types.d.ts
-type CELExpressionType = "Addition" | "BooleanLiteral" | "BytesLiteral" | "ConditionalAnd" | "ConditionalExpr" | "ConditionalOr" | "Division" | "DynamicPropertyAccessor" | "ExpressionGroup" | "ExpressionList" | "FieldInit" | "FieldInits" | "FieldsObject" | "FloatLiteral" | "FunctionCall" | "Identifier" | "IntegerLiteral" | "List" | "Map" | "MapInit" | "MapInits" | "Member" | "Modulo" | "Multiplication" | "Negation" | "Negative" | "NullLiteral" | "Property" | "Relation" | "StringLiteral" | "Subtraction" | "Unary" | "UnsignedIntegerLiteral" | "LikeExpression";
+type CELExpressionType = "Addition" | "BooleanLiteral" | "BytesLiteral" | "ConditionalAnd" | "ConditionalExpr" | "ConditionalOr" | "Division" | "DynamicPropertyAccessor" | "ExpressionGroup" | "ExpressionList" | "FieldInit" | "FieldInits" | "FieldsObject" | "FloatLiteral" | "FunctionCall" | "Identifier" | "IntegerLiteral" | "List" | "Map" | "MapInit" | "MapInits" | "Member" | "Modulo" | "Multiplication" | "Negation" | "Negative" | "NullLiteral" | "Property" | "Relation" | "StringLiteral" | "Subtraction" | "Unary" | "UnsignedIntegerLiteral" | "LikeExpression" | "SubqueryExpression";
 type CELRelop = "==" | ">=" | ">" | "<=" | "<" | "!=" | "in";
 interface CELExpression {
   type: CELExpressionType;
@@ -64,7 +64,7 @@ interface CELNegative extends CELExpression {
 interface CELMember extends CELExpression {
   type: "Member";
   value?: CELPrimary;
-  left?: CELPrimary | CELMember;
+  left?: CELPrimary | CELMember | CELNegation;
   right?: CELIdentifier;
   list?: CELExpressionList;
 }
@@ -194,6 +194,22 @@ interface CELNegatedLikeExpression extends CELExpression {
     value: [CELStringLiteral | CELIdentifier];
   };
 }
+interface CELSubqueryExpression extends CELExpression {
+  type: "Member";
+  left: CELIdentifier | CELMemberIdentifierChain;
+  right: CELIdentifier<"all" | "exists">;
+  list: CELExpressionList & {
+    value: [CELIdentifier, CELExpression];
+  };
+}
+interface CELNegatedSubqueryExpression extends CELExpression {
+  type: "Member";
+  left: CELMemberNegatedIdentifier | CELMemberNegatedIdentifierChain;
+  right: CELIdentifier<"all" | "exists">;
+  list: CELExpressionList & {
+    value: [CELIdentifier, CELExpression];
+  };
+}
 type CELNumericLiteral = CELIntegerLiteral | CELUnsignedIntegerLiteral | CELFloatLiteral;
 type CELLiteral = CELStringLiteral | CELBytesLiteral | CELNumericLiteral | CELBooleanLiteral | CELNullLiteral;
 type CELPrimary = CELProperty | CELIdentifier | CELExpressionGroup | CELFunctionCall | CELLiteral | CELList | CELMap;
@@ -292,12 +308,20 @@ declare const isCELNullLiteral: (expr: CELExpression) => expr is CELNullLiteral;
 declare const isCELProperty: (expr: CELExpression) => expr is CELProperty;
 declare const isCELSubtraction: (expr: CELExpression) => expr is CELSubtraction;
 declare const isCELUnsignedIntegerLiteral: (expr: CELExpression) => expr is CELUnsignedIntegerLiteral;
-declare const isCELIdentifierOrChain: (expr: CELExpression) => expr is CELMemberIdentifierChain | CELIdentifier;
+declare const isCELIdentifierOrChain: (expr: CELExpression) => expr is CELMemberIdentifierChain | CELIdentifier | CELDynamicPropertyAccessor;
 declare const isCELNegatedIdentifier: (expr: CELExpression) => expr is CELMemberNegatedIdentifier;
 declare const isCELNegatedIdentifierOrChain: (expr: CELExpression) => expr is CELMemberNegatedIdentifierChain | CELMemberNegatedIdentifier;
 declare const isCELLikeExpression: (expr: CELExpression) => expr is CELLikeExpression;
 declare const isCELNegatedLikeExpression: (expr: CELExpression) => expr is CELNegatedLikeExpression;
-declare const getCELIdentifierFromChain: (expr: CELIdentifier | CELMemberIdentifierChain) => string;
+declare const isCELSubqueryExpression: (expr: CELExpression) => expr is CELSubqueryExpression;
+declare const isCELNegatedSubqueryExpression: (expr: CELExpression) => expr is CELNegatedSubqueryExpression;
+declare const extractSubqueryComponents: (expr: CELMember) => {
+  field: string;
+  method: "all" | "exists";
+  alias: string | null;
+  condition: CELExpression;
+} | null;
+declare const getCELIdentifierFromChain: (expr: CELIdentifier | CELMemberIdentifierChain | CELDynamicPropertyAccessor | CELMember) => string;
 declare const getCELIdentifierFromNegatedChain: (expr: CELMemberNegatedIdentifier | CELMemberNegatedIdentifierChain) => string;
 declare function evalCELLiteralValue(literal: CELStringLiteral): string;
 declare function evalCELLiteralValue(literal: CELBooleanLiteral): boolean;
@@ -309,6 +333,7 @@ declare const celNormalizeCombinator: (c: "&&" | "||") => DefaultCombinatorName;
 declare const celNormalizeOperator: (op: CELRelop, flip?: boolean) => DefaultOperatorName;
 declare const celGenerateFlatAndOrList: (expr: CELConditionalAnd | CELConditionalOr) => (DefaultCombinatorName | CELExpression)[];
 declare const celGenerateMixedAndOrList: (expr: CELConditionalAnd | CELConditionalOr) => (DefaultCombinatorName | CELExpression | ("and" | CELExpression)[])[];
+declare const transformAliasInExpression: (expr: CELExpression, alias: string | null) => CELExpression;
 //#endregion
-export { CELAddition, CELBooleanLiteral, CELBytesLiteral, CELConditionalAnd, CELConditionalExpr, CELConditionalOr, CELDivision, CELDynamicPropertyAccessor, CELExpression, CELExpressionGroup, CELExpressionList, CELExpressionType, CELFieldInit, CELFieldInits, CELFieldsObject, CELFloatLiteral, CELFunctionCall, CELIdentifier, CELIntegerLiteral, CELLikeExpression, CELList, CELLiteral, CELMap, CELMapInit, CELMapInits, CELMathOperation, CELMember, CELMemberIdentifierChain, CELMemberNegatedIdentifier, CELMemberNegatedIdentifierChain, CELModulo, CELMultiplication, CELNegatedLikeExpression, CELNegation, CELNegative, CELNullLiteral, CELNumericLiteral, CELPrimary, CELProperty, CELRelation, CELRelop, CELStringLiteral, CELSubtraction, CELUnsignedIntegerLiteral, ParseCELOptions, ParseCELOptionsIC, ParseCELOptionsStandard, ParsedCEL, celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL };
+export { CELAddition, CELBooleanLiteral, CELBytesLiteral, CELConditionalAnd, CELConditionalExpr, CELConditionalOr, CELDivision, CELDynamicPropertyAccessor, CELExpression, CELExpressionGroup, CELExpressionList, CELExpressionType, CELFieldInit, CELFieldInits, CELFieldsObject, CELFloatLiteral, CELFunctionCall, CELIdentifier, CELIntegerLiteral, CELLikeExpression, CELList, CELLiteral, CELMap, CELMapInit, CELMapInits, CELMathOperation, CELMember, CELMemberIdentifierChain, CELMemberNegatedIdentifier, CELMemberNegatedIdentifierChain, CELModulo, CELMultiplication, CELNegatedLikeExpression, CELNegatedSubqueryExpression, CELNegation, CELNegative, CELNullLiteral, CELNumericLiteral, CELPrimary, CELProperty, CELRelation, CELRelop, CELStringLiteral, CELSubqueryExpression, CELSubtraction, CELUnsignedIntegerLiteral, ParseCELOptions, ParseCELOptionsIC, ParseCELOptionsStandard, ParsedCEL, celGenerateFlatAndOrList, celGenerateMixedAndOrList, celNormalizeCombinator, celNormalizeOperator, evalCELLiteralValue, extractSubqueryComponents, getCELIdentifierFromChain, getCELIdentifierFromNegatedChain, isCELAddition, isCELBooleanLiteral, isCELBytesLiteral, isCELConditionalAnd, isCELConditionalExpr, isCELConditionalOr, isCELDivision, isCELDynamicPropertyAccessor, isCELExpressionGroup, isCELExpressionList, isCELFieldInit, isCELFieldInits, isCELFieldsObject, isCELFloatLiteral, isCELFunctionCall, isCELIdentifier, isCELIdentifierOrChain, isCELIntegerLiteral, isCELLikeExpression, isCELList, isCELLiteral, isCELMap, isCELMapInit, isCELMapInits, isCELMember, isCELModulo, isCELMultiplication, isCELNegatedIdentifier, isCELNegatedIdentifierOrChain, isCELNegatedLikeExpression, isCELNegatedSubqueryExpression, isCELNegation, isCELNegative, isCELNullLiteral, isCELNumericLiteral, isCELProperty, isCELRelation, isCELStringLiteral, isCELSubqueryExpression, isCELSubtraction, isCELUnsignedIntegerLiteral, parseCEL, transformAliasInExpression };
 //# sourceMappingURL=parseCEL.d.ts.map

package/dist/parseCEL.js

@@ -1,11 +1,9 @@
-const require_isRuleGroup = require('./isRuleGroup-DqAs2x4E.js');
-const require_optGroupUtils = require('./optGroupUtils-B0hTpodo.js');
-const require_arrayUtils = require('./arrayUtils-QxZOZTf6.js');
-const require_prepareQueryObjects = require('./prepareQueryObjects-BOUWfel5.js');
+const require_chunk = require('./chunk-BxBTb9qk.js');
+const require_utils = require('./utils-CoYbYnVo.js');
+const require_isRuleGroup = require('./isRuleGroup-Do9KKsmt.js');
+const require_prepareQueryObjects = require('./prepareQueryObjects-DCtJJrF5.js');
 let __ts_jison_parser = require("@ts-jison/parser");
-__ts_jison_parser = require_isRuleGroup.__toESM(__ts_jison_parser);
 let __ts_jison_lexer = require("@ts-jison/lexer");
-__ts_jison_lexer = require_isRuleGroup.__toESM(__ts_jison_lexer);
 
 //#region src/utils/parseCEL/celParser.ts
 /**
@@ -2060,14 +2058,39 @@ const isCELProperty = (expr) => expr.type === "Property";
 // istanbul ignore next
 const isCELSubtraction = (expr) => expr.type === "Subtraction";
 const isCELUnsignedIntegerLiteral = (expr) => expr.type === "UnsignedIntegerLiteral";
-const isCELIdentifierOrChain = (expr) => isCELIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right);
+const isCELIdentifierOrChain = (expr) => isCELIdentifier(expr) || isCELDynamicPropertyAccessor(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right);
 const isCELNegatedIdentifier = (expr) => isCELNegation(expr) && isCELIdentifier(expr.value);
 const isCELNegatedIdentifierOrChain = (expr) => isCELNegatedIdentifier(expr) || isCELMember(expr) && !!expr.left && !!expr.right && !expr.list && !expr.value && isCELIdentifierOrChain(expr.right) && isCELNegatedIdentifier(expr.left);
 const isCELLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
 const isCELNegatedLikeExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELNegatedIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "contains" || expr.right.value === "startsWith" || expr.right.value === "endsWith") && expr.list.value.length === 1 && (isCELStringLiteral(expr.list.value[0]) || isCELIdentifier(expr.list.value[0]));
+const isCELSubqueryExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "all" || expr.right.value === "exists") && expr.list.value.length >= 2;
+const isCELNegatedSubqueryExpression = (expr) => isCELMember(expr) && !!expr.left && !!expr.right && !!expr.list && isCELNegatedIdentifierOrChain(expr.left) && isCELIdentifier(expr.right) && (expr.right.value === "all" || expr.right.value === "exists") && expr.list.value.length >= 2;
+const extractSubqueryComponents = (expr) => {
+	// istanbul ignore next
+	if (!isCELSubqueryExpression(expr)) return null;
+	const field = getCELIdentifierFromChain(expr.left);
+	const method = expr.right.value;
+	const [aliasExpr, conditionExpr] = expr.list.value;
+	return {
+		field,
+		method,
+		alias: isCELIdentifier(aliasExpr) ? aliasExpr.value : null,
+		condition: conditionExpr
+	};
+};
 const getCELIdentifierFromChain = (expr) => {
 	if (isCELIdentifier(expr)) return expr.value;
-	return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	if (isCELDynamicPropertyAccessor(expr)) {
+		const leftField = getCELIdentifierFromChain(expr.left);
+		// istanbul ignore else
+		if (isCELStringLiteral(expr.right)) return `${leftField}["${evalCELLiteralValue(expr.right)}"]`;
+		// istanbul ignore next
+		return `${leftField}[${expr.right.type}]`;
+	}
+	// istanbul ignore else
+	if (expr.left && expr.right && isCELIdentifier(expr.right) && (isCELIdentifier(expr.left) || isCELMember(expr.left) || isCELDynamicPropertyAccessor(expr.left))) return `${getCELIdentifierFromChain(expr.left)}.${expr.right.value}`;
+	// istanbul ignore next
+	return expr.type;
 };
 const getCELIdentifierFromNegatedChain = (expr) => {
 	if (isCELNegatedIdentifier(expr)) return `${``.padStart(expr.negations, `!`)}${expr.value.value}`;
@@ -2130,6 +2153,102 @@ const celGenerateMixedAndOrList = (expr) => {
 	if (returnArray.length === 1 && Array.isArray(returnArray[0])) return returnArray[0];
 	return returnArray;
 };
+const isPrimitiveArrayUsage = (expr, alias) => {
+	// istanbul ignore next
+	if (!alias) return false;
+	if (isCELIdentifier(expr) && expr.value === alias) return true;
+	if (isCELLikeExpression(expr) && isCELIdentifier(expr.left) && expr.left.value === alias) return true;
+	if (isCELRelation(expr) || isCELConditionalAnd(expr) || isCELConditionalOr(expr)) return isPrimitiveArrayUsage(expr.left, alias) || isPrimitiveArrayUsage(expr.right, alias);
+	// istanbul ignore next
+	if (isCELExpressionGroup(expr) || isCELNegation(expr)) return isPrimitiveArrayUsage(expr.value, alias);
+	return false;
+};
+const transformAliasInExpressionInternal = (expr, alias, isPrimitive) => {
+	// istanbul ignore next
+	if (!alias) return expr;
+	if (isCELIdentifier(expr) && expr.value === alias) return {
+		type: "Identifier",
+		value: ""
+	};
+	if (isCELMember(expr) && expr.left && isCELIdentifier(expr.left) && expr.left.value === alias) {
+		if (expr.right && isCELIdentifier(expr.right) && !isPrimitive) {
+			if (expr.list) return {
+				type: "Member",
+				left: {
+					type: "Identifier",
+					value: ""
+				},
+				right: expr.right,
+				list: expr.list
+			};
+			return expr.right;
+		}
+	}
+	if (isCELLikeExpression(expr) && isCELIdentifier(expr.left) && expr.left.value === alias) return {
+		type: "Member",
+		left: {
+			type: "Identifier",
+			value: ""
+		},
+		right: expr.right,
+		list: expr.list
+	};
+	if (isCELNegatedLikeExpression(expr) && expr.left && isCELNegatedIdentifier(expr.left) && expr.left.value.value === alias) return {
+		type: "Member",
+		left: {
+			type: "Negation",
+			negations: expr.left.negations,
+			value: {
+				type: "Identifier",
+				value: ""
+			}
+		},
+		right: expr.right,
+		list: expr.list
+	};
+	if (isCELMember(expr) && expr.left && expr.right) {
+		const transformedLeft = transformAliasInExpressionInternal(expr.left, alias, isPrimitive);
+		// istanbul ignore else
+		if (transformedLeft !== expr.left) return {
+			type: "Member",
+			left: transformedLeft,
+			right: expr.right,
+			list: expr.list,
+			value: expr.value
+		};
+	}
+	if (isCELRelation(expr)) return {
+		type: "Relation",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive),
+		operator: expr.operator
+	};
+	if (isCELConditionalAnd(expr)) return {
+		type: "ConditionalAnd",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive)
+	};
+	if (isCELConditionalOr(expr)) return {
+		type: "ConditionalOr",
+		left: transformAliasInExpressionInternal(expr.left, alias, isPrimitive),
+		right: transformAliasInExpressionInternal(expr.right, alias, isPrimitive)
+	};
+	if (isCELExpressionGroup(expr)) return {
+		type: "ExpressionGroup",
+		value: transformAliasInExpressionInternal(expr.value, alias, isPrimitive)
+	};
+	if (isCELNegation(expr)) return {
+		type: "Negation",
+		negations: expr.negations,
+		value: transformAliasInExpressionInternal(expr.value, alias, isPrimitive)
+	};
+	return expr;
+};
+const transformAliasInExpression = (expr, alias) => {
+	// istanbul ignore next
+	if (!alias) return expr;
+	return transformAliasInExpressionInternal(expr, alias, isPrimitiveArrayUsage(expr, alias));
+};
 
 //#endregion
 //#region src/utils/parseCEL/parseCEL.ts
@@ -2228,6 +2347,52 @@ function parseCEL(cel, options = {}) {
 				operator,
 				value
 			};
+		} else if (isCELSubqueryExpression(expr)) {
+			const components = extractSubqueryComponents(expr);
+			// istanbul ignore else
+			if (components) {
+				const { field, method, alias, condition } = components;
+				const matchMode = method === "all" ? "all" : "some";
+				const subqueryValue = processCELExpression(transformAliasInExpression(condition, alias));
+				if (subqueryValue && fieldIsValid(field, "=")) {
+					const ruleGroupValue = require_isRuleGroup.isRuleGroup(subqueryValue) ? subqueryValue : ic ? { rules: [subqueryValue] } : {
+						combinator: "and",
+						rules: [subqueryValue]
+					};
+					return {
+						field,
+						operator: "=",
+						match: { mode: matchMode },
+						value: ruleGroupValue
+					};
+				}
+			}
+		} else if (isCELNegatedSubqueryExpression(expr)) {
+			const field = getCELIdentifierFromNegatedChain(expr.left).replace(/^!+/, "");
+			const method = expr.right.value;
+			const [aliasExpr, conditionExpr] = expr.list.value;
+			const subqueryValue = processCELExpression(transformAliasInExpression(conditionExpr, isCELIdentifier(aliasExpr) ? aliasExpr.value : null));
+			// istanbul ignore else
+			if (subqueryValue && fieldIsValid(field, "=")) {
+				const ruleGroupValue = require_isRuleGroup.isRuleGroup(subqueryValue) ? subqueryValue : ic ? { rules: [subqueryValue] } : {
+					combinator: "and",
+					rules: [subqueryValue]
+				};
+				const subqueryRule = {
+					field,
+					operator: "=",
+					match: { mode: method === "all" ? "all" : "some" },
+					value: ruleGroupValue
+				};
+				return ic ? {
+					not: true,
+					rules: [subqueryRule]
+				} : {
+					combinator: "and",
+					not: true,
+					rules: [subqueryRule]
+				};
+			}
 		} else if (isCELRelation(expr)) {
 			let field = null;
 			let value = void 0;
@@ -2246,7 +2411,7 @@ function parseCEL(cel, options = {}) {
 				value = evalCELLiteralValue(left);
 			}
 			let operator = celNormalizeOperator(expr.operator, flip);
-			if (forwardedNegation) operator = require_optGroupUtils.defaultOperatorNegationMap[operator];
+			if (forwardedNegation) operator = require_utils.defaultOperatorNegationMap[operator];
 			if (value === null && (operator === "=" || operator === "!=")) operator = operator === "=" ? "null" : "notNull";
 			else if ((operator === "in" || operator === "notIn") && isCELList(right)) {
 				if (right.value.value.every((v) => isCELLiteral(v))) value = right.value.value.map((v) => evalCELLiteralValue(v));
@@ -2254,13 +2419,13 @@ function parseCEL(cel, options = {}) {
 					valueSource = "field";
 					value = right.value.value.map((id) => getCELIdentifierFromChain(id));
 				}
-				if (value && !listsAsArrays) value = require_arrayUtils.joinWith(value.map((v) => `${v}`), ",");
+				if (value && !listsAsArrays) value = require_utils.joinWith(value.map((v) => `${v}`), ",");
 			} else if ((operator === "in" || operator === "notIn") && isCELMap(right)) {
 				const keys = right.value.value.map((v) => v.left);
 				if (keys.every((k) => isCELLiteral(k) || isCELIdentifierOrChain(k))) value = keys.map((k) => isCELLiteral(k) ? evalCELLiteralValue(k) : getCELIdentifierFromChain(k));
-				if (value && !listsAsArrays) value = require_arrayUtils.joinWith(value.map((v) => `${v}`), ",");
+				if (value && !listsAsArrays) value = require_utils.joinWith(value.map((v) => `${v}`), ",");
 			}
-			if (field && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
+			if (field !== null && fieldIsValid(field, operator, valueSource === "field" ? value : void 0) && value !== void 0) return valueSource ? {
 				field,
 				operator,
 				value,
@@ -2298,6 +2463,7 @@ exports.celGenerateMixedAndOrList = celGenerateMixedAndOrList;
 exports.celNormalizeCombinator = celNormalizeCombinator;
 exports.celNormalizeOperator = celNormalizeOperator;
 exports.evalCELLiteralValue = evalCELLiteralValue;
+exports.extractSubqueryComponents = extractSubqueryComponents;
 exports.getCELIdentifierFromChain = getCELIdentifierFromChain;
 exports.getCELIdentifierFromNegatedChain = getCELIdentifierFromNegatedChain;
 exports.isCELAddition = isCELAddition;
@@ -2330,6 +2496,7 @@ exports.isCELMultiplication = isCELMultiplication;
 exports.isCELNegatedIdentifier = isCELNegatedIdentifier;
 exports.isCELNegatedIdentifierOrChain = isCELNegatedIdentifierOrChain;
 exports.isCELNegatedLikeExpression = isCELNegatedLikeExpression;
+exports.isCELNegatedSubqueryExpression = isCELNegatedSubqueryExpression;
 exports.isCELNegation = isCELNegation;
 exports.isCELNegative = isCELNegative;
 exports.isCELNullLiteral = isCELNullLiteral;
@@ -2337,7 +2504,9 @@ exports.isCELNumericLiteral = isCELNumericLiteral;
 exports.isCELProperty = isCELProperty;
 exports.isCELRelation = isCELRelation;
 exports.isCELStringLiteral = isCELStringLiteral;
+exports.isCELSubqueryExpression = isCELSubqueryExpression;
 exports.isCELSubtraction = isCELSubtraction;
 exports.isCELUnsignedIntegerLiteral = isCELUnsignedIntegerLiteral;
 exports.parseCEL = parseCEL;
+exports.transformAliasInExpression = transformAliasInExpression;
 //# sourceMappingURL=parseCEL.js.map