@platforma-sdk/workflow-tengo 5.3.3 → 5.3.4

package/dist/tengo/lib/pt.expression.lib.tengo

@@ -3,11 +3,15 @@ maps := import("@platforma-sdk/workflow-tengo:maps")
 slices := import("@platforma-sdk/workflow-tengo:slices")
 validation := import("@platforma-sdk/workflow-tengo:validation")
 fmt := import("fmt")
+objects := import("@platforma-sdk/workflow-tengo:objects")
+oop := import("@platforma-sdk/workflow-tengo:oop")
+pframesSpec := import("@platforma-sdk/workflow-tengo:pframes.spec")
 
 
 
 _newExpression := undefined
 _newWindowExpression := undefined
+axis := undefined
 col := undefined
 lit := undefined
 allHorizontal := undefined
@@ -37,16 +41,16 @@ _validateOptions := func(options, schema, functionName) {
 
 
 _isExpression := func(item) {
-	return ll.isMap(item) && ll.methodExists(item, "getExpression")
+	return ll.isMap(item) && ll.methodExists(item, "_getExpression")
 }
 
 
 _isAggregation := func(item) {
-	return ll.isMap(item) && ll.methodExists(item, "getAggregation")
+	return ll.isMap(item) && ll.methodExists(item, "_getAggregation")
 }
 
 
-_mapToExpressionStructList := func(itemsList, stringInterpretation) {
+_mapToExpressionStructList := func(itemsList, stringInterpretation, ctx) {
 	if !is_array(itemsList) {
 		itemsList = [itemsList] // Allow single item to be passed
 	}
@@ -57,12 +61,12 @@ _mapToExpressionStructList := func(itemsList, stringInterpretation) {
 	return slices.map(itemsList, func(item) {
 		if is_string(item) {
 			if stringInterpretation == "col" {
-				return col(item).getExpression()
+				return col(item)._getExpression(ctx)
 			} else { // Must be "lit" due to the check above
-				return lit(item).getExpression()
+				return lit(item)._getExpression(ctx)
 			}
 		} else if _isExpression(item) {
-			return item.getExpression()
+			return item._getExpression(ctx)
 		} else {
 			ll.panic("Invalid item type in list: %T. Must be a string (interpreted as '%s') or an expression object.", item, stringInterpretation)
 			return undefined // Unreachable
@@ -70,16 +74,16 @@ _mapToExpressionStructList := func(itemsList, stringInterpretation) {
 	})
 }
 
-_mapToSingleExpressionStruct := func(item, stringInterpretation) {
+_mapToSingleExpressionStruct := func(item, stringInterpretation, ctx) {
 	if _isExpression(item) {
-		return item.getExpression()
+		return item._getExpression(ctx)
 	} else if is_int(item) || is_float(item) || is_bool(item) { // These are always literals
-		return lit(item).getExpression()
+		return lit(item)._getExpression(ctx)
 	} else if is_string(item) {
 		if stringInterpretation == "col" {
-			return col(item).getExpression()
+			return col(item)._getExpression(ctx)
 		} else if stringInterpretation == "lit" {
-			return lit(item).getExpression()
+			return lit(item)._getExpression(ctx)
 		} else { // stringInterpretation is undefined or an invalid value
 			ll.panic("String item '%v' provided, but its interpretation as 'col' or 'lit' was not specified or is not applicable in this context. (stringInterpretation: '%v')", item, stringInterpretation)
 			return undefined
@@ -99,26 +103,28 @@ _mapToSingleExpressionStruct := func(item, stringInterpretation) {
 _newWindowExpression = func(expression, aggregation, currentAlias) {
 	self := undefined
 	self = ll.toStrict({
-		
-		getExpression: func() {
-			if expression == undefined {
-				ll.panic("Using this operation as a window expression is not allowed. Use it as a group by expression instead. %v", aggregation)
-			}
-			return expression
+
+
+
+
+		_getExpression: func(ctx) {
+			ll.assert(is_map(ctx), "ctx must be a map")
+			ll.assert(!is_undefined(expression), "Using this operation as a window expression is not allowed. Use it as a group by expression instead. %v", aggregation)
+			ll.assert(!is_undefined(currentAlias), "Alias is not defined for this window expression.")
+
+			valueExpr := expression(ctx)
+			return {type: "alias", value: valueExpr, name: currentAlias}
 		},
 		
-		getAggregation: func() {
+		_getAggregation: func(ctx) {
 			if aggregation == undefined {
 				ll.panic("Using this operation as a group by expression is not allowed, most probably because you applied .over() to it. %v", expression)
 			}
-			return maps.deepMerge(aggregation, {name: self.getAlias()})
-		},
-		
-		getAlias: func() {
 			if currentAlias == undefined {
 				ll.panic("Alias is not defined for this window expression.")
 			}
-			return currentAlias
+			aggStruct := aggregation(ctx)
+			return maps.deepMerge(aggStruct, {name: currentAlias})
 		},
 
 
@@ -128,6 +134,7 @@ _newWindowExpression = func(expression, aggregation, currentAlias) {
 
 
 		alias: func(newAlias) {
+			ll.assert(is_string(newAlias), "alias must be a string")
 			return _newWindowExpression(expression, aggregation, newAlias)
 		},
 
@@ -139,15 +146,20 @@ _newWindowExpression = func(expression, aggregation, currentAlias) {
 		over: func(partitionBy) {
 			ll.assert(is_array(partitionBy) || is_string(partitionBy) || _isExpression(partitionBy), "partitionBy must be an array of strings/expressions or a single string/expression")
 
-			if len(expression.partitionBy) > 0 {
-				ll.warn("partitionBy already set on this window expression, overriding.")
-			}
 
-			newExpression := maps.deepMerge(expression, {
-				partitionBy: _mapToExpressionStructList(partitionBy, "col")
-			})
+			newExpr := func(ctx) {
+				baseExpr := expression(ctx)
 
-			return _newWindowExpression(newExpression, undefined, currentAlias)
+				if len(baseExpr.partitionBy) > 0 {
+					ll.warn("partitionBy already set on this window expression, overriding.")
+				}
+
+				return maps.deepMerge(baseExpr, {
+					partitionBy: _mapToExpressionStructList(partitionBy, "col", ctx)
+				})
+			}
+
+			return _newWindowExpression(newExpr, undefined, currentAlias)
 		}
 	})
 	return self
@@ -157,48 +169,58 @@ _newWindowExpression = func(expression, aggregation, currentAlias) {
 
 
 
-
-_newExpression = func(expression, currentAlias) {
+_newExpression = func(expression) {
 	self := undefined // forward declaration
 
 
 	binaryOp := func(opType, other) {
-		rhsExprStruct := undefined
-		if _isExpression(other) {
-			rhsExprStruct = other.getExpression()
-		} else if is_int(other) || is_float(other) || is_bool(other) || is_string(other) {
-			rhsExprStruct = lit(other).getExpression()
-		} else {
-			ll.panic(opType + " expects an expression object or a literal (number, boolean, null) as argument. Got type: %T", other)
-		}
-
 		return _newExpression(
-			{type: opType, lhs: expression, rhs: rhsExprStruct},
-			undefined // Result of operation typically doesn't carry forward alias
+			func(ctx) {
+				lhsExpr := self._getExpression(ctx)
+				rhsExpr := undefined
+				if _isExpression(other) {
+					rhsExpr = other._getExpression(ctx)
+				} else if is_int(other) || is_float(other) || is_bool(other) || is_string(other) {
+					rhsExpr = lit(other)._getExpression(ctx)
+				} else {
+					ll.panic(opType + " expects an expression object or a literal (number, boolean, null) as argument. Got type: %T", other)
+				}
+				return {type: opType, lhs: lhsExpr, rhs: rhsExpr}
+			}
 		)
 	}
 
 
 	unaryOp := func(opType) {
 		return _newExpression(
-			{type: opType, value: expression},
-			undefined
+			func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {type: opType, value: valueExpr}
+			}
 		)
 	}
 
 
 	unaryStrOp := func(opType) {
 		return _newExpression(
-			{type: opType, value: expression},
-			undefined
+			func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {type: opType, value: valueExpr}
+			}
 		)
 	}
 
 
 	aggOp := func(aggType) {
 		return _newWindowExpression(
-			{type: "aggregate", aggregation: aggType, value: expression, partitionBy: []},
-			{aggregation: aggType, expression: expression},
+			func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {type: "aggregate", aggregation: aggType, value: valueExpr, partitionBy: []}
+			},
+			func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {aggregation: aggType, expression: valueExpr}
+			},
 			undefined // Alias of underlying col, window expression itself is typically aliased later
 		)
 	}
@@ -206,20 +228,19 @@ _newExpression = func(expression, currentAlias) {
 	aggOpBy := func(aggType, by) {
 		return _newWindowExpression(
 			undefined,
-			{aggregation: aggType, expression: expression, by: _mapToExpressionStructList(by, "col")},
+			func(ctx) {
+				baseExpr := self._getExpression(ctx)
+				return {aggregation: aggType, expression: baseExpr, by: _mapToExpressionStructList(by, "col", {})}
+			},
 			undefined // Alias of underlying col, window expression itself is typically aliased later
 		)
 	}
 
 	self = ll.toStrict({
 		
-		getExpression: func() { return expression },
-		
-		getAlias: func() {
-			if currentAlias == undefined {
-				ll.panic("Alias is not defined for this expression.")
-			}
-			return currentAlias
+		_getExpression: func(ctx) {
+			ll.assert(is_map(ctx), "ctx must be a map")
+			return expression(ctx)
 		},
 
 
@@ -228,7 +249,10 @@ _newExpression = func(expression, currentAlias) {
 
 
 		alias: func(newAlias) {
-			return _newExpression(expression, newAlias)
+			return _newExpression(func (ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {type: "alias", value: valueExpr, name: newAlias}
+			})
 		},
 
 
@@ -294,10 +318,10 @@ _newExpression = func(expression, currentAlias) {
 			if !is_undefined(ops.strict) {
 				strictVal = ops.strict
 			}
-			return _newExpression(
-				{type: "cast", value: expression, dtype: dtype, strict: strictVal},
-				undefined
-			)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {type: "cast", value: valueExpr, dtype: dtype, strict: strictVal}
+			})
 		},
 
 
@@ -382,21 +406,23 @@ _newExpression = func(expression, currentAlias) {
 			}, "structField")
 
 
-			structExpr := {
-				type: "struct_field",
-				struct: expression,
-				fields: fields
-			}
+			return _newExpression(func(ctx) {
+				structExpr := {
+					type: "struct_field",
+					struct: self._getExpression(ctx),
+					fields: fields
+				}
 
 
-			if !is_undefined(ops.default) {
-				structExpr.default = ops.default
-			}
-			if !is_undefined(ops.dtype) {
-				structExpr.dtype = ops.dtype
-			}
+				if !is_undefined(ops.default) {
+					structExpr.default = ops.default
+				}
+				if !is_undefined(ops.dtype) {
+					structExpr.dtype = ops.dtype
+				}
 
-			return _newExpression(structExpr, undefined)
+				return structExpr
+			})
 		},
 
 
@@ -420,12 +446,8 @@ _newExpression = func(expression, currentAlias) {
 		strSlice: func(start, ...args) {
 			ll.assert(len(args) <= 1, "strSlice expects at most one additional argument.")
 
-			expr := {
-				type: "substring",
-				value: expression,
-				start: _mapToSingleExpressionStruct(start, "col")
-			}
-
+			length := undefined
+			end := undefined
 			if len(args) > 0 {
 				arg := args[0]
 				if is_map(arg) {
@@ -438,17 +460,33 @@ _newExpression = func(expression, currentAlias) {
 						ll.panic("strSlice cannot have both 'length' and 'end' options.")
 					}
 					if !is_undefined(ops.length) {
-						expr.length = _mapToSingleExpressionStruct(ops.length, "col")
+						length = ops.length
 					}
 					if !is_undefined(ops.end) {
-						expr.end = _mapToSingleExpressionStruct(ops.end, "col")
+						end = ops.end
 					}
 				} else {
-					expr.length = _mapToSingleExpressionStruct(arg, "col")
+					length = arg
 				}
 			}
 
-			return _newExpression(expr, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				expr := {
+					type: "substring",
+					value: valueExpr,
+					start: _mapToSingleExpressionStruct(start, "col", ctx)
+				}
+
+				if !is_undefined(length) {
+					expr.length = _mapToSingleExpressionStruct(length, "col", ctx)
+				}
+				if !is_undefined(end) {
+					expr.end = _mapToSingleExpressionStruct(end, "col", ctx)
+				}
+
+				return expr
+			})
 		},
 
 
@@ -476,14 +514,17 @@ _newExpression = func(expression, currentAlias) {
 				literalVal = ops.literal
 			}
 
-			return _newExpression({
-				type: "str_replace",
-				value: expression,
-				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
-				replacement: _mapToSingleExpressionStruct(replacement, "lit"),
-				replaceAll: replaceAllVal,
-				literal: literalVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_replace",
+					value: valueExpr,
+					pattern: _mapToSingleExpressionStruct(pattern, "lit", ctx),
+					replacement: _mapToSingleExpressionStruct(replacement, "lit", ctx),
+					replaceAll: replaceAllVal,
+					literal: literalVal
+				}
+			})
 		},
 
 
@@ -527,13 +568,16 @@ _newExpression = func(expression, currentAlias) {
 				strictVal = ops.strict
 			}
 
-			return _newExpression({
-				type: "str_contains",
-				value: expression,
-				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
-				literal: literalVal,
-				strict: strictVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_contains",
+					value: valueExpr,
+					pattern: _mapToSingleExpressionStruct(pattern, "lit", ctx),
+					literal: literalVal,
+					strict: strictVal
+				}
+			})
 		},
 
 
@@ -558,12 +602,15 @@ _newExpression = func(expression, currentAlias) {
 				asciiCaseInsensitiveVal = ops.asciiCaseInsensitive
 			}
 
-			return _newExpression({
-				type: "str_contains_any",
-				value: expression,
-				patterns: patterns,
-				asciiCaseInsensitive: asciiCaseInsensitiveVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_contains_any",
+					value: valueExpr,
+					patterns: patterns,
+					asciiCaseInsensitive: asciiCaseInsensitiveVal
+				}
+			})
 		},
 
 
@@ -584,12 +631,15 @@ _newExpression = func(expression, currentAlias) {
 				literalVal = ops.literal
 			}
 
-			return _newExpression({
-				type: "str_count_matches",
-				value: expression,
-				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
-				literal: literalVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_count_matches",
+					value: valueExpr,
+					pattern: _mapToSingleExpressionStruct(pattern, "lit", ctx),
+					literal: literalVal
+				}
+			})
 		},
 
 
@@ -610,12 +660,15 @@ _newExpression = func(expression, currentAlias) {
 				groupIndexVal = ops.groupIndex
 			}
 
-			return _newExpression({
-				type: "str_extract",
-				value: expression,
-				pattern: _mapToSingleExpressionStruct(pattern, "lit"),
-				groupIndex: groupIndexVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_extract",
+					value: valueExpr,
+					pattern: _mapToSingleExpressionStruct(pattern, "lit", ctx),
+					groupIndex: groupIndexVal
+				}
+			})
 		},
 
 
@@ -624,11 +677,14 @@ _newExpression = func(expression, currentAlias) {
 
 
 		strStartsWith: func(prefix) {
-			return _newExpression({
-				type: "str_starts_with",
-				value: expression,
-				prefix: _mapToSingleExpressionStruct(prefix, "lit")
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_starts_with",
+					value: valueExpr,
+					prefix: _mapToSingleExpressionStruct(prefix, "lit", ctx)
+				}
+			})
 		},
 
 
@@ -637,11 +693,14 @@ _newExpression = func(expression, currentAlias) {
 
 
 		strEndsWith: func(suffix) {
-			return _newExpression({
-				type: "str_ends_with",
-				value: expression,
-				suffix: _mapToSingleExpressionStruct(suffix, "lit")
-			}, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "str_ends_with",
+					value: valueExpr,
+					suffix: _mapToSingleExpressionStruct(suffix, "lit", ctx)
+				}
+			})
 		},
 
 
@@ -662,13 +721,17 @@ _newExpression = func(expression, currentAlias) {
 				returnSimilarityVal = returnSimilarity
 			}
 
-			return _newExpression({
-				type: "string_distance",
-				string1: expression,
-				string2: string2.getExpression(),
-				metric: metric,
-				returnSimilarity: returnSimilarityVal
-			}, undefined)
+			return _newExpression(func(ctx) {
+				lhsExpr := self._getExpression(ctx)
+				rhsExpr := string2._getExpression(ctx)
+				return {
+					type: "string_distance",
+					string1: lhsExpr,
+					string2: rhsExpr,
+					metric: metric,
+					returnSimilarity: returnSimilarityVal
+				}
+			})
 		},
 
 
@@ -684,13 +747,17 @@ _newExpression = func(expression, currentAlias) {
 			ll.assert(is_string(metric), "metric must be a string")
 			ll.assert(is_int(bound) || is_float(bound), "bound must be a number")
 
-			return _newExpression({
-				type: "fuzzy_string_filter",
-				value: expression,
-				pattern: patternExpr.getExpression(),
-				metric: metric,
-				bound: bound
-			}, undefined)
+			return _newExpression(func(ctx) {
+				lhsExpr := self._getExpression(ctx)
+				rhsExpr := patternExpr._getExpression(ctx)
+				return {
+					type: "fuzzy_string_filter",
+					value: lhsExpr,
+					pattern: rhsExpr,
+					metric: metric,
+					bound: bound
+				}
+			})
 		},
 
 
@@ -708,16 +775,19 @@ _newExpression = func(expression, currentAlias) {
 				ll.assert(is_int(bits), "bits must be a number")
 			}
 
-			hashExpr := {
-				type: "hash",
-				value: expression,
-				hashType: hashType,
-				encoding: encoding
-			}
-			if bits != undefined {
-				hashExpr.bits = bits
-			}
-			return _newExpression(hashExpr, undefined)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				hashExpr := {
+					type: "hash",
+					value: valueExpr,
+					hashType: hashType,
+					encoding: encoding
+				}
+				if bits != undefined {
+					hashExpr.bits = bits
+				}
+				return hashExpr
+			})
 		},
 
 
@@ -727,10 +797,14 @@ _newExpression = func(expression, currentAlias) {
 
 
 		fillNull: func(fillValueExpr) {
-			return _newExpression(
-				{type: "fill_null", input: expression, fillValue: _mapToSingleExpressionStruct(fillValueExpr, "lit")},
-				undefined
-			)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "fill_null",
+					input: valueExpr,
+					fillValue: _mapToSingleExpressionStruct(fillValueExpr, "lit", ctx)
+				}
+			})
 		},
 
 
@@ -739,10 +813,14 @@ _newExpression = func(expression, currentAlias) {
 
 
 		fillNaN: func(fillValueExpr) {
-			return _newExpression(
-				{type: "fill_nan", input: expression, fillValue: _mapToSingleExpressionStruct(fillValueExpr, "lit")},
-				undefined
-			)
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "fill_nan",
+					input: valueExpr,
+					fillValue: _mapToSingleExpressionStruct(fillValueExpr, "lit", ctx)
+				}
+			})
 		},
 
 
@@ -787,11 +865,14 @@ _newExpression = func(expression, currentAlias) {
 				ll.assert(is_bool(descendingArgs[0]), "descending argument for rank must be a boolean")
 				descendingVal = descendingArgs[0]
 			}
-			return _newWindowExpression({
-				type: "rank",
-				orderBy: [expression],
-				partitionBy: [], // To be set by .over()
-				descending: descendingVal
+			return _newWindowExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "rank",
+					orderBy: [valueExpr],
+					partitionBy: [], // To be set by .over()
+					descending: descendingVal
+				}
 			}, undefined)
 		},
 
@@ -819,7 +900,11 @@ _newExpression = func(expression, currentAlias) {
 				}, "cumsum")
 				actualArgs = args[0:len(args)-1]
 				if !is_undefined(ops.orderBy) {
-					additionalOrderByVal = _mapToExpressionStructList(ops.orderBy, "col")
+					if is_array(ops.orderBy) {
+						additionalOrderByVal = ops.orderBy
+					} else {
+						additionalOrderByVal = [ops.orderBy]
+					}
 				}
 				if !is_undefined(ops.descending) {
 					descendingVal = ops.descending
@@ -829,7 +914,11 @@ _newExpression = func(expression, currentAlias) {
 
 			if len(additionalOrderByVal) == 0 && len(actualArgs) > 0 {
 				if is_array(actualArgs[0]) || is_string(actualArgs[0]) || _isExpression(actualArgs[0]) {
-					additionalOrderByVal = _mapToExpressionStructList(actualArgs[0], "col")
+					if is_array(actualArgs[0]) {
+						additionalOrderByVal = actualArgs[0]
+					} else {
+						additionalOrderByVal = [actualArgs[0]]
+					}
 					if len(actualArgs) > 1 && is_bool(actualArgs[1]) {
 						descendingVal = actualArgs[1]
 					}
@@ -840,20 +929,107 @@ _newExpression = func(expression, currentAlias) {
 				}
 			}
 
-			return _newWindowExpression({
-				type: "cumsum",
-				value: expression,
-				additionalOrderBy: additionalOrderByVal,
-				partitionBy: [],
-				descending: descendingVal
+			return _newWindowExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "cumsum",
+					value: valueExpr,
+					additionalOrderBy: _mapToExpressionStructList(additionalOrderByVal, "col", ctx),
+					partitionBy: [],
+					descending: descendingVal
+				}
 			}, undefined, undefined)
 		},
 
-
-
 		
 		toString: func() {
 			return self.cast("string")
+		},
+
+
+
+
+
+
+		inSet: func(...values) {
+			ll.assert(len(values) > 0, "inSet method requires at least one value.")
+
+			set := []
+			for v in values {
+				ll.assert(
+					is_undefined(v) || is_bool(v) || is_int(v) || is_float(v) || is_string(v),
+					"Invalid argument in inSet: Expected primitive value, got %T", v)
+				set = append(set, v)
+			}
+			uniqueSet := slices.sortUnique(set)
+
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "in_set",
+					value: valueExpr,
+					set: uniqueSet
+				}
+			})
+		},
+
+
+
+
+
+
+		matchesEcmaRegex: func(ecmaRegex) {
+			ll.assert(is_string(ecmaRegex) && len(ecmaRegex) > 0, "ecma_regex must be a non-empty string.")
+
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return {
+					type: "matches_ecma_regex",
+					value: valueExpr,
+					ecmaRegex: ecmaRegex
+				}
+			})
+		},
+
+
+
+
+
+
+
+
+
+
+		containsFuzzyMatch: func(reference, maxEdits, ...args) {
+			ll.assert(is_string(reference) && len(reference) > 0, "pattern must be a non-empty string.")
+			ll.assert(is_int(maxEdits) && maxEdits > 0, "maxEdits must be a positive integer.")
+
+			wildcard := undefined
+			substitutionsOnly := undefined
+			if len(args) > 0 {
+				ops := _validateOptions(args, {
+					"__options__,closed": "",
+					"wildcard,?": "string",
+					"substitutionsOnly,?": "bool"
+				}, "containsFuzzyMatch")
+				if !is_undefined(ops.wildcard) {
+					ll.assert(len(ops.wildcard) == 1, "wildcard must be a single character.")
+				}
+				wildcard = ops.wildcard
+				substitutionsOnly = ops.substitutionsOnly
+			}
+
+			return _newExpression(func(ctx) {
+				valueExpr := self._getExpression(ctx)
+				return objects.deleteUndefined({
+					type: "contains_fuzzy_match",
+					value: valueExpr,
+					reference: reference,
+					maxEdits: maxEdits,
+					wildcard: wildcard,
+					substitutionsOnly: substitutionsOnly
+				})
+			})
 		}
 	})
 	return self
@@ -868,12 +1044,71 @@ _newExpression = func(expression, currentAlias) {
 
 
 
+
+
+
+
+
+axis = func(matcher) {
+	processedMatcher := undefined
+	if is_string(matcher) {
+		processedMatcher = { name: matcher, domain: {} }
+	} else if is_map(matcher) {
+		processedMatcher = pframesSpec.axisSpecToMatcher(matcher)
+	} else {
+		ll.panic("Matcher for axis must be a string (axis name) or an AxisSpec-like map (with at least 'name' and 'type' fields).")
+	}
+	return _newExpression(func(ctx) {
+		ll.assert(!is_undefined(ctx.specDistiller), "specDistiller must be defined")
+		ll.assert(is_map(ctx.distilledAxesSpecs), "distilledAxesSpecs must be a map")
+
+		distilledMatcher := ctx.specDistiller.distill(processedMatcher)
+		discriminativeDomains := ctx.specDistiller.getDiscriminativeDomainsSet(distilledMatcher.name)
+        if ((!is_undefined(distilledMatcher.domain) && len(distilledMatcher.domain) > 0) != (!is_undefined(discriminativeDomains) && len(discriminativeDomains) > 0)) ||
+			(!is_undefined(distilledMatcher.domain) && !is_undefined(discriminativeDomains) && len(distilledMatcher.domain) != len(discriminativeDomains)) {
+            ll.panic("Axis matcher %v is not specific enough. Expected discriminative domains %v, got %v", distilledMatcher.name, discriminativeDomains, distilledMatcher.domain)
+        }
+		
+		axisSpec := undefined
+		for spec in ctx.distilledAxesSpecs[distilledMatcher.name] {
+			if !is_undefined(distilledMatcher.type) {
+				if distilledMatcher.type != spec.type {
+					continue
+				}
+			}
+			if !is_undefined(distilledMatcher.domain) {
+				if is_undefined(spec.domain) || len(spec.domain) < len(distilledMatcher.domain) {
+					continue
+				}
+				for domainKey, domainValue in distilledMatcher.domain {
+					if spec.domain[domainKey] != domainValue {
+						continue
+					}
+				}
+			}
+			axisSpec = spec
+			break
+		}
+		return {
+			type: "axis",
+			spec: axisSpec
+		}
+	})
+}
+
+
+
+
+
+
 col = func(name) {
 	ll.assert(is_string(name), "col name must be a string")
-	return _newExpression({
-		type: "col",
-		name: name
-	}, name)
+	return _newExpression(func(ctx) {
+		return {
+			type: "col",
+			name: name
+		}
+	})
 }
 
 
@@ -882,10 +1117,12 @@ col = func(name) {
 
 
 lit = func(value) {
-	return _newExpression({
-		type: "const",
-		value: value
-	}, undefined)
+	return _newExpression(func(ctx) {
+		return {
+			type: "const",
+			value: value
+		}
+	})
 }
 
 
@@ -908,11 +1145,13 @@ concatStr := func(expressions, ...options) {
 		delimiterVal = ops.delimiter
 	}
 
-	return _newExpression({
-		type: "str_join",
-		operands: _mapToExpressionStructList(expressions, "lit"),
-		delimiter: delimiterVal
-	}, undefined)
+	return _newExpression(func(ctx) {
+		return {
+			type: "str_join",
+			operands: _mapToExpressionStructList(expressions, "lit", ctx),
+			delimiter: delimiterVal
+		}
+	})
 }
 
 
@@ -923,10 +1162,12 @@ concatStr := func(expressions, ...options) {
 minHorizontal := func(expressions) {
 	ll.assert(is_array(expressions), "Argument to minHorizontal must be an array of expressions")
 	ll.assert(len(expressions) > 0, "Expression array for minHorizontal cannot be empty")
-	return _newExpression({
-		type: "min",
-		operands: _mapToExpressionStructList(expressions, "col")
-	}, undefined)
+	return _newExpression(func(ctx) {
+		return {
+			type: "min",
+			operands: _mapToExpressionStructList(expressions, "col", ctx)
+		}
+	})
 }
 
 
@@ -937,10 +1178,12 @@ minHorizontal := func(expressions) {
 maxHorizontal := func(expressions) {
 	ll.assert(is_array(expressions), "Argument to maxHorizontal must be an array of expressions")
 	ll.assert(len(expressions) > 0, "Expression array for maxHorizontal cannot be empty")
-	return _newExpression({
-		type: "max",
-		operands: _mapToExpressionStructList(expressions, "col")
-	}, undefined)
+	return _newExpression(func(ctx) {
+		return {
+			type: "max",
+			operands: _mapToExpressionStructList(expressions, "col", ctx)
+		}
+	})
 }
 
 
@@ -949,30 +1192,32 @@ maxHorizontal := func(expressions) {
 
 
 allHorizontal = func(...args){
-    processedOperands := []
-    for arg in args {
-        exprStruct := undefined
-        if _isExpression(arg) {
-            exprStruct = arg.getExpression()
-        } else if is_string(arg) {
-            exprStruct = col(arg).getExpression()
-        } else {
-            ll.panic("Invalid argument type for allHorizontal: %T. Must be an expression object or string.", arg)
+    return _newExpression(func(ctx) {
+        processedOperands := []
+        for arg in args {
+            exprStruct := undefined
+            if _isExpression(arg) {
+                exprStruct = arg._getExpression(ctx)
+            } else if is_string(arg) {
+                exprStruct = col(arg)._getExpression(ctx)
+            } else {
+                ll.panic("Invalid argument type for allHorizontal: %T. Must be an expression object or string.", arg)
+            }
+
+            if exprStruct.type == "and" && is_array(exprStruct.operands) {
+                processedOperands = append(processedOperands, exprStruct.operands...)
+            } else {
+                processedOperands = append(processedOperands, exprStruct)
+            }
         }
-
-        if exprStruct.type == "and" && is_array(exprStruct.operands) {
-            processedOperands = append(processedOperands, exprStruct.operands...)
-        } else {
-            processedOperands = append(processedOperands, exprStruct)
+        if len(processedOperands) == 0 {
+            ll.panic("allHorizontal requires at least one expression.")
+        }
+        return {
+            type: "and",
+            operands: processedOperands
         }
-    }
-    if len(processedOperands) == 0 {
-        ll.panic("allHorizontal requires at least one expression.")
-    }
-    return _newExpression({
-        type: "and",
-        operands: processedOperands
-    }, undefined)
+    })
 }
 
 
@@ -981,30 +1226,32 @@ allHorizontal = func(...args){
 
 
 anyHorizontal = func(...args){
-    processedOperands := []
-    for arg in args {
-        exprStruct := undefined
-        if _isExpression(arg) {
-            exprStruct = arg.getExpression()
-        } else if is_string(arg) {
-            exprStruct = col(arg).getExpression()
-        } else {
-            ll.panic("Invalid argument type for anyHorizontal: %T. Must be an expression object or string.", arg)
+    return _newExpression(func(ctx) {
+        processedOperands := []
+        for arg in args {
+            exprStruct := undefined
+            if _isExpression(arg) {
+                exprStruct = arg._getExpression(ctx)
+            } else if is_string(arg) {
+                exprStruct = col(arg)._getExpression(ctx)
+            } else {
+                ll.panic("Invalid argument type for anyHorizontal: %T. Must be an expression object or string.", arg)
+            }
+
+            if exprStruct.type == "or" && is_array(exprStruct.operands) {
+                processedOperands = append(processedOperands, exprStruct.operands...)
+            } else {
+                processedOperands = append(processedOperands, exprStruct)
+            }
         }
-
-        if exprStruct.type == "or" && is_array(exprStruct.operands) {
-            processedOperands = append(processedOperands, exprStruct.operands...)
-        } else {
-            processedOperands = append(processedOperands, exprStruct)
+        if len(processedOperands) == 0 {
+            ll.panic("anyHorizontal requires at least one expression.")
         }
-    }
-    if len(processedOperands) == 0 {
-        ll.panic("anyHorizontal requires at least one expression.")
-    }
-    return _newExpression({
-        type: "or",
-        operands: processedOperands
-    }, undefined)
+        return {
+            type: "or",
+            operands: processedOperands
+        }
+    })
 }
 
 
@@ -1049,8 +1296,6 @@ rank = func(orderByExpressions, ...options) {
 	descendingVal := false
 
 	ll.assert(orderByExpressions != undefined, "rank() requires orderByExpressions (single expression/string or array of them).")
-	orderByVal = _mapToExpressionStructList(orderByExpressions, "col")
-	ll.assert(len(orderByVal) > 0, "rank() 'orderBy' list cannot be empty after processing arguments.")
 
 	ops := _validateOptions(options, {
 		"__options__,closed": "",
@@ -1060,11 +1305,15 @@ rank = func(orderByExpressions, ...options) {
 		descendingVal = ops.descending
 	}
 
-	return _newWindowExpression({
-		type: "rank",
-		orderBy: orderByVal,
-		partitionBy: [],
-		descending: descendingVal
+	return _newWindowExpression(func(ctx) {
+		orderByVal := _mapToExpressionStructList(orderByExpressions, "col", ctx)
+		ll.assert(len(orderByVal) > 0, "rank() 'orderBy' list cannot be empty after processing arguments.")
+		return {
+			type: "rank",
+			orderBy: orderByVal,
+			partitionBy: [],
+			descending: descendingVal
+		}
 	}, undefined, undefined)
 }
 
@@ -1082,14 +1331,17 @@ _newWhenThenBuilder := func(currentClauses, currentWhenExprOrUndefined) {
 			ll.assert(_isExpression(thenExpr), ".then() expects an expression object argument.")
 
 
-			newClauses := maps.clone(currentClauses) // Deep copy existing clauses
-			newClauses = append(newClauses, {
-				when: currentWhenExprOrUndefined.getExpression(),
-				then: thenExpr.getExpression()
-			})
+			newClausesExpr := func(ctx) {
+				existingClauses := currentClauses(ctx)
+				newClauses := maps.clone(existingClauses) // Deep copy existing clauses
+				return append(newClauses, {
+					when: currentWhenExprOrUndefined._getExpression(ctx),
+					then: thenExpr._getExpression(ctx)
+				})
+			}
 
 
-			return _newWhenThenBuilder(newClauses, undefined)
+			return _newWhenThenBuilder(newClausesExpr, undefined)
 		},
 
 
@@ -1113,16 +1365,18 @@ _newWhenThenBuilder := func(currentClauses, currentWhenExprOrUndefined) {
 
 		otherwise: func(otherwiseExpr) {
 			ll.assert(currentWhenExprOrUndefined == undefined, ".otherwise() must follow a .then() call.")
-			ll.assert(len(currentClauses) > 0, "At least one .when().then() clause is required before .otherwise().")
 			ll.assert(_isExpression(otherwiseExpr), ".otherwise() expects an expression object argument.")
 
 
-			finalClauses := maps.clone(currentClauses)
-			return _newExpression({
-				type: "when_then_otherwise",
-				conditions: finalClauses,
-				otherwise: otherwiseExpr.getExpression()
-			}, undefined)
+			return _newExpression(func(ctx) {
+				finalClauses := maps.clone(currentClauses(ctx))
+				ll.assert(len(finalClauses) > 0, "At least one .when().then() clause is required before .otherwise().")
+				return {
+					type: "when_then_otherwise",
+					conditions: finalClauses,
+					otherwise: otherwiseExpr._getExpression(ctx)
+				}
+			})
 		}
 	})
 	return builderSelf
@@ -1140,7 +1394,7 @@ _newWhenThenBuilder := func(currentClauses, currentWhenExprOrUndefined) {
 
 when = func(conditionExpr) {
 	ll.assert(_isExpression(conditionExpr), "Initial when() expects an expression object argument.")
-	return _newWhenThenBuilder([], conditionExpr)
+	return _newWhenThenBuilder(func(ctx) { return [] }, conditionExpr)
 }
 
 
@@ -1153,18 +1407,322 @@ when = func(conditionExpr) {
 
 
 
-
-rawExp := func(expression, ...alias) {
-	ll.assert(len(alias) <= 1, "rawExpression expects at most one alias argument")
-	aliasVal := undefined
-	if len(alias) > 0 {
-		aliasVal = alias[0]
-	}
+rawExp := func(expression) {
 	ll.assert(is_map(expression), "rawExpression expects a map as argument")
-	return _newExpression(expression, aliasVal)
+	return _newExpression(func(ctx) { return expression })
+}
+
+_isSelector := func(expression) {
+	return _isExpression(expression) && ll.methodExists(expression, "complement")
 }
 
+_newSelectorExpression := func(expression) {
+	self := undefined
+	newExpression := _newExpression(expression)
+	self = ll.toStrict(oop.inherit(newExpression, {
+
+
+
+
+
+		complement: func() {
+			return _newSelectorExpression(func(ctx) {
+				return {
+					type: "selector_complement",
+					selector: self._getExpression(ctx)
+				}
+			})
+		},
+		
+
+
+
+
+
+
+		union: func(...others) {
+			ll.assert(len(others) > 0, "union requires at least one other selector")
+			return _newSelectorExpression(func(ctx) {
+				selectors := [self._getExpression(ctx)]
+				for other in others {
+					ll.assert(_isSelector(other), "union requires selector expressions, got: %T", other)
+					selectors = append(selectors, other._getExpression(ctx))
+				}
+				return {
+					type: "selector_union",
+					selectors: selectors
+				}
+			})
+		},
+		
+
+
+
+
+
+
+		intersection: func(...others) {
+			ll.assert(len(others) > 0, "intersection requires at least one other selector")
+			return _newSelectorExpression(func(ctx) {
+				selectors := [self._getExpression(ctx)]
+				for other in others {
+					ll.assert(_isSelector(other), "intersection requires selector expressions, got: %T", other)
+					selectors = append(selectors, other._getExpression(ctx))
+				}
+				return {
+					type: "selector_intersection",
+					selectors: selectors
+				}
+			})
+		},
+		
+
+
+
+
+
+
+		difference: func(...others) {
+			ll.assert(len(others) > 0, "difference requires at least one other selector")
+			return _newSelectorExpression(func(ctx) {
+				selectors := [self._getExpression(ctx)]
+				for other in others {
+					ll.assert(_isSelector(other), "difference requires selector expressions, got: %T", other)
+					selectors = append(selectors, other._getExpression(ctx))
+				}
+				return {
+					type: "selector_difference",
+					selectors: selectors
+				}
+			})
+		},
+		
+
+
+
+
+
+
+		symmetricDifference: func(...others) {
+			ll.assert(len(others) > 0, "symmetricDifference requires at least one other selector")
+			return _newSelectorExpression(func(ctx) {
+				selectors := [self._getExpression(ctx)]
+				for other in others {
+					ll.assert(_isSelector(other), "symmetricDifference requires selector expressions, got: %T", other)
+					selectors = append(selectors, other._getExpression(ctx))
+				}
+				return {
+					type: "selector_symmetric_difference",
+					selectors: selectors
+				}
+			})
+		}
+	}))
+	return self
+}
+
+
+
+
+
+sc := ll.toStrict({
+
+
+
+
+
+
+	all: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_all"}
+		})
+	},
+	
+
+
+
+
+
+
+	string: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_string"}
+		})
+	},
+	
+
+
+
+
+
+
+	numeric: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_numeric"}
+		})
+	},
+	
+
+
+
+
+
+
+	integer: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_integer"}
+		})
+	},
+	
+
+
+
+
+
+
+	float: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_float"}
+		})
+	},
+	
+
+
+
+
+
+
+
+	startsWith: func(prefix) {
+		ll.assert(is_string(prefix), "startsWith requires a string argument, got: %T", prefix)
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_starts_with",
+				prefix: prefix
+			}
+		})
+	},
+	
+
+
+
+
+
+
+
+	endsWith: func(suffix) {
+		ll.assert(is_string(suffix), "endsWith requires a string argument, got: %T", suffix)
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_ends_with",
+				suffix: suffix
+			}
+		})
+	},
+	
+
+
+
+
+
+
+
+	contains: func(substring) {
+		ll.assert(is_string(substring), "contains requires a string argument, got: %T", substring)
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_contains",
+				substring: substring
+			}
+		})
+	},
+	
+
+
+
+
+
+
+
+	matches: func(pattern) {
+		ll.assert(is_string(pattern), "matches requires a string argument, got: %T", pattern)
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_matches",
+				pattern: pattern
+			}
+		})
+	},
+	
+
+
+
+
+
+
+
+	exclude: func(...columns) {
+		ll.assert(len(columns) > 0, "exclude requires at least one column name")
+		for col in columns {
+			ll.assert(is_string(col), "exclude requires string arguments, got: %T", col)
+		}
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_exclude",
+				columns: columns
+			}
+		})
+	},
+	
+
+
+
+
+
+
+
+	byName: func(...names) {
+		ll.assert(len(names) > 0, "byName requires at least one column name")
+		for name in names {
+			ll.assert(is_string(name), "byName requires string arguments, got: %T", name)
+		}
+		return _newSelectorExpression(func(ctx) {
+			return {
+				type: "selector_by_name",
+				names: names
+			}
+		})
+	},
+
+
+
+
+
+
+
+
+	axis: func(spec) {
+		validation.assertType(spec, pframesSpec.P_AXIS_SPEC_SCHEMA)
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_axis", spec: spec}
+		})
+	},
+	
+
+
+
+
+
+
+	nested: func() {
+		return _newSelectorExpression(func(ctx) {
+			return {type: "selector_nested"}
+		})
+	}
+})
+
 export ll.toStrict({
+	axis: axis,
 	col: col,
 	lit: lit,
 	concatStr: concatStr,
@@ -1177,6 +1735,8 @@ export ll.toStrict({
 	rank: rank,
 	when: when,
 	rawExp: rawExp,
+	sc: sc,
+	_newExpression: _newExpression,
 	_isExpression: _isExpression,
 	_isAggregation: _isAggregation,
 	_mapToExpressionStructList: _mapToExpressionStructList,