@rsconcept/domain 1.0.0 → 1.1.0

package/dist/rslang/parser/normalize.js

@@ -1,507 +1,312 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-function visitAstDFS(node, callback) {
-  for (const child of node.children) {
-    visitAstDFS(child, callback);
-  }
-  callback(node);
-}
-
-// src/rslang/parser/parser.terms.ts
-var Expression = 1;
-var Logic = 2;
-var Logic_predicates = 3;
-var Variable = 4;
-var Local = 5;
-var Tuple = 8;
-var Expr_enum_min2 = 9;
-var Logic_unary = 24;
-var Predicate = 26;
-var Logic_quantor = 29;
-var Variable_pack = 31;
-var Logic_binary = 33;
-var Setexpr = 38;
-var Integer = 39;
-var EmptySet = 40;
-var IntegerSet = 41;
-var Global = 42;
-var Radical = 43;
-var Setexpr_binary = 44;
-var Enumeration = 55;
-var Boolean = 56;
-var Filter_expression = 58;
-var Filter = 59;
-var Declarative = 60;
-var PrefixD = 62;
-var Imperative = 64;
-var Imp_blocks = 65;
-var Recursion = 68;
-var Function = 69;
-var BigPr = 70;
-var SmallPr = 71;
-var Card = 72;
-var Bool = 73;
-var Debool = 74;
-var Red = 75;
-var Function_decl = 76;
-var Arguments = 77;
-var Declaration = 78;
-
-// src/rslang/parser/token.ts
-var TokenID = {
-  // Global, local IDs and literals
-  ERROR: TOKEN_ERROR,
-  ID_LOCAL: 258,
-  ID_GLOBAL: 259,
-  ID_FUNCTION: 260,
-  ID_PREDICATE: 261,
-  ID_RADICAL: 262,
-  LIT_INTEGER: 263,
-  LIT_WHOLE_NUMBERS: 264,
-  LIT_EMPTYSET: 265,
-  // Arithmetic
-  PLUS: 266,
-  MINUS: 267,
-  MULTIPLY: 268,
-  // Integer predicate symbols
-  GREATER: 269,
-  LESSER: 270,
-  GREATER_OR_EQ: 271,
-  LESSER_OR_EQ: 272,
-  // Equality comparison
-  EQUAL: 273,
-  NOTEQUAL: 274,
-  // Logic predicate symbols
-  QUANTOR_UNIVERSAL: 275,
-  QUANTOR_EXISTS: 276,
-  LOGIC_NOT: 277,
-  LOGIC_EQUIVALENT: 278,
-  LOGIC_IMPLICATION: 279,
-  LOGIC_OR: 280,
-  LOGIC_AND: 281,
-  // Set theory predicate symbols
-  SET_IN: 282,
-  SET_NOT_IN: 283,
-  SUBSET: 284,
-  SUBSET_OR_EQ: 285,
-  NOT_SUBSET: 286,
-  // Set theory operators
-  DECART: 287,
-  SET_UNION: 288,
-  SET_INTERSECTION: 289,
-  SET_MINUS: 290,
-  SET_SYMMETRIC_MINUS: 291,
-  BOOLEAN: 292,
-  // Structure operations
-  BIGPR: 293,
-  SMALLPR: 294,
-  FILTER: 295,
-  CARD: 296,
-  BOOL: 297,
-  DEBOOL: 298,
-  REDUCE: 299,
-  // Term constructions prefixes
-  DECLARATIVE: 300,
-  RECURSIVE: 301,
-  IMPERATIVE: 302,
-  ITERATE: 303,
-  ASSIGN: 304,
-  // Punctuation
-  PUNCTUATION_DEFINE: 305,
-  PUNCTUATION_STRUCT: 306,
-  PUNCTUATION_PL: 307,
-  PUNCTUATION_PR: 308,
-  PUNCTUATION_CL: 309,
-  PUNCTUATION_CR: 310,
-  PUNCTUATION_SL: 311,
-  PUNCTUATION_SR: 312,
-  PUNCTUATION_BAR: 313,
-  PUNCTUATION_COMMA: 314,
-  PUNCTUATION_SEMICOLON: 315,
-  // ======= Non-terminal tokens =========
-  NT_ENUM_DECL: 316,
-  NT_TUPLE: 317,
-  NT_ENUMERATION: 318,
-  NT_TUPLE_DECL: 319,
-  NT_ARG_DECL: 320,
-  NT_FUNC_DEFINITION: 321,
-  NT_ARGUMENTS: 322,
-  NT_FUNC_CALL: 323,
-  NT_DECLARATIVE_EXPR: 324,
-  NT_IMPERATIVE_EXPR: 325,
-  NT_RECURSIVE_FULL: 326,
-  NT_RECURSIVE_SHORT: 327,
-  // ======= Helper tokens ========
-  INTERRUPT: 328,
-  END: 329
-};
-
-// src/rslang/parser/normalize.ts
+import { visitAstDFS } from "../../parsing/ast.js";
+import "../../parsing/index.js";
+import { TokenID } from "./token.js";
+import "./parser.terms.js";
+//#region src/rslang/parser/normalize.ts
+/**
+* Module: Transforming AST to a simple form.
+*/
+/** Normalizes AST to a simple form. */
 function normalizeAST(ast, input) {
-  visitAstDFS(ast, (node) => normalizeNode(node, input));
+	visitAstDFS(ast, (node) => normalizeNode(node, input));
 }
-var idRecord = {
-  [Global]: TokenID.ID_GLOBAL,
-  [Local]: TokenID.ID_LOCAL,
-  [Radical]: TokenID.ID_RADICAL,
-  [Function]: TokenID.ID_FUNCTION,
-  [Predicate]: TokenID.ID_PREDICATE,
-  [Integer]: TokenID.LIT_INTEGER,
-  [EmptySet]: TokenID.LIT_EMPTYSET,
-  [IntegerSet]: TokenID.LIT_WHOLE_NUMBERS,
-  [Boolean]: TokenID.BOOLEAN,
-  [BigPr]: TokenID.BIGPR,
-  [SmallPr]: TokenID.SMALLPR,
-  [Filter]: TokenID.FILTER,
-  [Bool]: TokenID.BOOL,
-  [Debool]: TokenID.DEBOOL,
-  [Red]: TokenID.REDUCE,
-  [Card]: TokenID.CARD,
-  [Enumeration]: TokenID.NT_ENUMERATION,
-  [Tuple]: TokenID.NT_TUPLE,
-  [Arguments]: TokenID.NT_ARGUMENTS,
-  [Declaration]: TokenID.NT_ARG_DECL,
-  [Function_decl]: TokenID.NT_FUNC_DEFINITION,
-  [Variable_pack]: TokenID.NT_ENUM_DECL,
-  [Declarative]: TokenID.NT_DECLARATIVE_EXPR,
-  [Imperative]: TokenID.NT_IMPERATIVE_EXPR
+const idRecord = {
+	[42]: TokenID.ID_GLOBAL,
+	[5]: TokenID.ID_LOCAL,
+	[43]: TokenID.ID_RADICAL,
+	[69]: TokenID.ID_FUNCTION,
+	[26]: TokenID.ID_PREDICATE,
+	[39]: TokenID.LIT_INTEGER,
+	[40]: TokenID.LIT_EMPTYSET,
+	[41]: TokenID.LIT_WHOLE_NUMBERS,
+	[56]: TokenID.BOOLEAN,
+	[70]: TokenID.BIGPR,
+	[71]: TokenID.SMALLPR,
+	[59]: TokenID.FILTER,
+	[73]: TokenID.BOOL,
+	[74]: TokenID.DEBOOL,
+	[75]: TokenID.REDUCE,
+	[72]: TokenID.CARD,
+	[55]: TokenID.NT_ENUMERATION,
+	[8]: TokenID.NT_TUPLE,
+	[77]: TokenID.NT_ARGUMENTS,
+	[78]: TokenID.NT_ARG_DECL,
+	[76]: TokenID.NT_FUNC_DEFINITION,
+	[31]: TokenID.NT_ENUM_DECL,
+	[60]: TokenID.NT_DECLARATIVE_EXPR,
+	[64]: TokenID.NT_IMPERATIVE_EXPR
 };
 function normalizeNode(node, input) {
-  if (node.hasError) {
-    return;
-  }
-  switch (node.typeID) {
-    case 0:
-      return;
-    case Expression:
-      promoteSingleChild(node);
-      return;
-    case EmptySet:
-    case IntegerSet:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      return;
-    case Integer:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "number";
-      node.data.value = Number(input.slice(node.from, node.to));
-      return;
-    case Function:
-    case Predicate:
-    case Global:
-    case Local:
-    case Radical:
-    case Integer:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "string";
-      node.data.value = input.slice(node.from, node.to);
-      return;
-    case Boolean:
-      node.typeID = idRecord[node.typeID];
-      if (node.children.length === 4) {
-        node.children = [node.children[2]];
-      } else {
-        node.children = [node.children[1]];
-      }
-      clearData(node);
-      return;
-    case Filter:
-    case BigPr:
-    case SmallPr:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "string[]";
-      node.data.value = parseIndex(input.slice(node.from + 2, node.to));
-      return;
-    case Red:
-    case Debool:
-    case Bool:
-    case Card:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      return;
-    case Function_decl:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      node.children = [node.children[1], node.children[3]];
-      return;
-    case Declaration:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      node.children = [node.children[0], node.children[2]];
-      return;
-    case Arguments:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children.length === 3) {
-        processLeftEnum(node);
-      }
-      return;
-    case Expr_enum_min2:
-      processLeftEnum(node);
-      return;
-    case Setexpr:
-      if (node.children.length === 1) {
-        promoteSingleChild(node);
-      } else if (node.children.length === 4) {
-        processTextFunction(node);
-      }
-      return;
-    case Tuple:
-    case Enumeration:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children[1].typeID === Expr_enum_min2) {
-        for (const child of node.children[1].children) {
-          child.parent = node;
-        }
-        node.children = node.children[1].children;
-      } else {
-        node.children = [node.children[1]];
-      }
-      return;
-    case Logic_binary:
-    case Logic_predicates:
-    case Setexpr_binary:
-      if (node.children[0].data.value === "(") {
-        processParenthesis(node);
-      } else {
-        clearData(node);
-        node.typeID = symbolToToken(node.children[1].data.value);
-        if (node.typeID === TokenID.DECART) {
-          processDecartChildren(node);
-        } else {
-          node.children = [node.children[0], node.children[2]];
-        }
-      }
-      return;
-    case Filter_expression:
-      processFilter(node);
-      return;
-    case Logic:
-      if (node.children[0].data.value === "(") {
-        processParenthesis(node);
-      } else {
-        promoteSingleChild(node);
-      }
-      return;
-    case Logic_unary:
-      if (node.children[0].data.value === "\xAC") {
-        clearData(node);
-        node.typeID = TokenID.LOGIC_NOT;
-        node.children = [node.children[1]];
-      } else if (node.children[0].typeID === TokenID.ID_PREDICATE) {
-        processTextFunction(node);
-      } else {
-        promoteSingleChild(node);
-      }
-      return;
-    case Logic_quantor:
-      clearData(node);
-      node.typeID = symbolToToken(node.children[0].data.value);
-      node.children = [node.children[1], node.children[3], node.children[4]];
-      return;
-    case Variable:
-      convertTupleDeclaration(node.children[0]);
-      promoteSingleChild(node);
-      return;
-    case Variable_pack:
-      if (node.children.length === 1) {
-        promoteSingleChild(node);
-      } else {
-        node.typeID = idRecord[node.typeID];
-        processLeftEnum(node);
-      }
-      return;
-    case Declarative:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children[0].typeID === PrefixD) {
-        node.children = [node.children[2], node.children[4], node.children[6]];
-      } else {
-        node.children = [node.children[1], node.children[3], node.children[5]];
-      }
-      return;
-    case Imp_blocks:
-      if (node.children.length === 1) {
-        if (node.parent?.typeID === Imp_blocks) {
-          promoteSingleChild(node);
-        }
-      } else {
-        processLeftEnum(node);
-      }
-      return;
-    case Imperative:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      for (const child of node.children[4].children) {
-        child.parent = node;
-      }
-      node.children = [node.children[2], ...node.children[4].children];
-      return;
-    case Recursion:
-      if (node.children.length > 9) {
-        node.typeID = TokenID.NT_RECURSIVE_FULL;
-        node.children = [node.children[2], node.children[4], node.children[6], node.children[8]];
-      } else {
-        node.typeID = TokenID.NT_RECURSIVE_SHORT;
-        node.children = [node.children[2], node.children[4], node.children[6]];
-      }
-      return;
-  }
+	if (node.hasError) return;
+	switch (node.typeID) {
+		case 0: return;
+		case 1:
+			promoteSingleChild(node);
+			return;
+		case 40:
+		case 41:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			return;
+		case 39:
+			node.typeID = idRecord[node.typeID];
+			node.data.dataType = "number";
+			node.data.value = Number(input.slice(node.from, node.to));
+			return;
+		case 69:
+		case 26:
+		case 42:
+		case 5:
+		case 43:
+		case 39:
+			node.typeID = idRecord[node.typeID];
+			node.data.dataType = "string";
+			node.data.value = input.slice(node.from, node.to);
+			return;
+		case 56:
+			node.typeID = idRecord[node.typeID];
+			if (node.children.length === 4) node.children = [node.children[2]];
+			else node.children = [node.children[1]];
+			clearData(node);
+			return;
+		case 59:
+		case 70:
+		case 71:
+			node.typeID = idRecord[node.typeID];
+			node.data.dataType = "string[]";
+			node.data.value = parseIndex(input.slice(node.from + 2, node.to));
+			return;
+		case 75:
+		case 74:
+		case 73:
+		case 72:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			return;
+		case 76:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			node.children = [node.children[1], node.children[3]];
+			return;
+		case 78:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			node.children = [node.children[0], node.children[2]];
+			return;
+		case 77:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			if (node.children.length === 3) processLeftEnum(node);
+			return;
+		case 9:
+			processLeftEnum(node);
+			return;
+		case 38:
+			if (node.children.length === 1) promoteSingleChild(node);
+			else if (node.children.length === 4) processTextFunction(node);
+			return;
+		case 8:
+		case 55:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			if (node.children[1].typeID === 9) {
+				for (const child of node.children[1].children) child.parent = node;
+				node.children = node.children[1].children;
+			} else node.children = [node.children[1]];
+			return;
+		case 33:
+		case 3:
+		case 44:
+			if (node.children[0].data.value === "(") processParenthesis(node);
+			else {
+				clearData(node);
+				node.typeID = symbolToToken(node.children[1].data.value);
+				if (node.typeID === TokenID.DECART) processDecartChildren(node);
+				else node.children = [node.children[0], node.children[2]];
+			}
+			return;
+		case 58:
+			processFilter(node);
+			return;
+		case 2:
+			if (node.children[0].data.value === "(") processParenthesis(node);
+			else promoteSingleChild(node);
+			return;
+		case 24:
+			if (node.children[0].data.value === "¬") {
+				clearData(node);
+				node.typeID = TokenID.LOGIC_NOT;
+				node.children = [node.children[1]];
+			} else if (node.children[0].typeID === TokenID.ID_PREDICATE) processTextFunction(node);
+			else promoteSingleChild(node);
+			return;
+		case 29:
+			clearData(node);
+			node.typeID = symbolToToken(node.children[0].data.value);
+			node.children = [
+				node.children[1],
+				node.children[3],
+				node.children[4]
+			];
+			return;
+		case 4:
+			convertTupleDeclaration(node.children[0]);
+			promoteSingleChild(node);
+			return;
+		case 31:
+			if (node.children.length === 1) promoteSingleChild(node);
+			else {
+				node.typeID = idRecord[node.typeID];
+				processLeftEnum(node);
+			}
+			return;
+		case 60:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			if (node.children[0].typeID === 62) node.children = [
+				node.children[2],
+				node.children[4],
+				node.children[6]
+			];
+			else node.children = [
+				node.children[1],
+				node.children[3],
+				node.children[5]
+			];
+			return;
+		case 65:
+			if (node.children.length === 1) {
+				if (node.parent?.typeID === 65) promoteSingleChild(node);
+			} else processLeftEnum(node);
+			return;
+		case 64:
+			node.typeID = idRecord[node.typeID];
+			clearData(node);
+			for (const child of node.children[4].children) child.parent = node;
+			node.children = [node.children[2], ...node.children[4].children];
+			return;
+		case 68:
+			if (node.children.length > 9) {
+				node.typeID = TokenID.NT_RECURSIVE_FULL;
+				node.children = [
+					node.children[2],
+					node.children[4],
+					node.children[6],
+					node.children[8]
+				];
+			} else {
+				node.typeID = TokenID.NT_RECURSIVE_SHORT;
+				node.children = [
+					node.children[2],
+					node.children[4],
+					node.children[6]
+				];
+			}
+			return;
+	}
 }
 function convertTupleDeclaration(node) {
-  if (node.typeID !== TokenID.NT_TUPLE) {
-    return;
-  }
-  node.typeID = TokenID.NT_TUPLE_DECL;
-  for (const child of node.children) {
-    convertTupleDeclaration(child);
-  }
+	if (node.typeID !== TokenID.NT_TUPLE) return;
+	node.typeID = TokenID.NT_TUPLE_DECL;
+	for (const child of node.children) convertTupleDeclaration(child);
 }
 function clearData(node) {
-  node.data.value = null;
-  node.data.dataType = "null";
+	node.data.value = null;
+	node.data.dataType = "null";
 }
 function promoteSingleChild(node, index = 0) {
-  for (const child of node.children[index].children) {
-    child.parent = node;
-  }
-  node.typeID = node.children[index].typeID;
-  node.data = node.children[index].data;
-  node.parenthesis = node.children[index].parenthesis;
-  node.children = node.children[index].children;
+	for (const child of node.children[index].children) child.parent = node;
+	node.typeID = node.children[index].typeID;
+	node.data = node.children[index].data;
+	node.parenthesis = node.children[index].parenthesis;
+	node.children = node.children[index].children;
 }
 function parseIndex(text) {
-  return text.split(",");
+	return text.split(",");
 }
 function symbolToToken(symbol) {
-  switch (symbol) {
-    case "+":
-      return TokenID.PLUS;
-    case "-":
-      return TokenID.MINUS;
-    case "*":
-      return TokenID.MULTIPLY;
-    case "\u222A":
-      return TokenID.SET_UNION;
-    case "\\":
-      return TokenID.SET_MINUS;
-    case "\u2206":
-      return TokenID.SET_SYMMETRIC_MINUS;
-    case "\u2229":
-      return TokenID.SET_INTERSECTION;
-    case "\xD7":
-      return TokenID.DECART;
-    case "\u2208":
-      return TokenID.SET_IN;
-    case "\u2209":
-      return TokenID.SET_NOT_IN;
-    case "\u2286":
-      return TokenID.SUBSET_OR_EQ;
-    case "\u2284":
-      return TokenID.NOT_SUBSET;
-    case "\u2282":
-      return TokenID.SUBSET;
-    case ">":
-      return TokenID.GREATER;
-    case "\u2265":
-      return TokenID.GREATER_OR_EQ;
-    case "<":
-      return TokenID.LESSER;
-    case "\u2264":
-      return TokenID.LESSER_OR_EQ;
-    case "\u2260":
-      return TokenID.NOTEQUAL;
-    case "=":
-      return TokenID.EQUAL;
-    case ":\u2208":
-      return TokenID.ITERATE;
-    case ":=":
-      return TokenID.ASSIGN;
-    case "\xAC":
-      return TokenID.LOGIC_NOT;
-    case "\u21D4":
-      return TokenID.LOGIC_EQUIVALENT;
-    case "\u21D2":
-      return TokenID.LOGIC_IMPLICATION;
-    case "\u2228":
-      return TokenID.LOGIC_OR;
-    case "&":
-      return TokenID.LOGIC_AND;
-    case "\u2200":
-      return TokenID.QUANTOR_UNIVERSAL;
-    case "\u2203":
-      return TokenID.QUANTOR_EXISTS;
-  }
-  return TokenID.ERROR;
+	switch (symbol) {
+		case "+": return TokenID.PLUS;
+		case "-": return TokenID.MINUS;
+		case "*": return TokenID.MULTIPLY;
+		case "∪": return TokenID.SET_UNION;
+		case "\\": return TokenID.SET_MINUS;
+		case "∆": return TokenID.SET_SYMMETRIC_MINUS;
+		case "∩": return TokenID.SET_INTERSECTION;
+		case "×": return TokenID.DECART;
+		case "∈": return TokenID.SET_IN;
+		case "∉": return TokenID.SET_NOT_IN;
+		case "⊆": return TokenID.SUBSET_OR_EQ;
+		case "⊄": return TokenID.NOT_SUBSET;
+		case "⊂": return TokenID.SUBSET;
+		case ">": return TokenID.GREATER;
+		case "≥": return TokenID.GREATER_OR_EQ;
+		case "<": return TokenID.LESSER;
+		case "≤": return TokenID.LESSER_OR_EQ;
+		case "≠": return TokenID.NOTEQUAL;
+		case "=": return TokenID.EQUAL;
+		case ":∈": return TokenID.ITERATE;
+		case ":=": return TokenID.ASSIGN;
+		case "¬": return TokenID.LOGIC_NOT;
+		case "⇔": return TokenID.LOGIC_EQUIVALENT;
+		case "⇒": return TokenID.LOGIC_IMPLICATION;
+		case "∨": return TokenID.LOGIC_OR;
+		case "&": return TokenID.LOGIC_AND;
+		case "∀": return TokenID.QUANTOR_UNIVERSAL;
+		case "∃": return TokenID.QUANTOR_EXISTS;
+	}
+	return TokenID.ERROR;
 }
 function processParenthesis(node) {
-  promoteSingleChild(node, 1);
-  node.parenthesis = true;
+	promoteSingleChild(node, 1);
+	node.parenthesis = true;
 }
 function processLeftEnum(node) {
-  if (node.children[0].typeID === node.typeID) {
-    for (const child of node.children[0].children) {
-      child.parent = node;
-    }
-    node.children = [...node.children[0].children, node.children[2]];
-  } else {
-    node.children = [node.children[0], node.children[2]];
-  }
+	if (node.children[0].typeID === node.typeID) {
+		for (const child of node.children[0].children) child.parent = node;
+		node.children = [...node.children[0].children, node.children[2]];
+	} else node.children = [node.children[0], node.children[2]];
 }
 function processDecartChildren(node) {
-  const newChildren = [];
-  if (node.children[0].typeID === TokenID.DECART && !node.children[0].parenthesis) {
-    for (const child of node.children[0].children) {
-      child.parent = node;
-      newChildren.push(child);
-    }
-  } else {
-    newChildren.push(node.children[0]);
-  }
-  if (node.children[2].typeID === TokenID.DECART && !node.children[2].parenthesis) {
-    for (const child of node.children[2].children) {
-      child.parent = node;
-      newChildren.push(child);
-    }
-  } else {
-    newChildren.push(node.children[2]);
-  }
-  node.children = newChildren;
+	const newChildren = [];
+	if (node.children[0].typeID === TokenID.DECART && !node.children[0].parenthesis) for (const child of node.children[0].children) {
+		child.parent = node;
+		newChildren.push(child);
+	}
+	else newChildren.push(node.children[0]);
+	if (node.children[2].typeID === TokenID.DECART && !node.children[2].parenthesis) for (const child of node.children[2].children) {
+		child.parent = node;
+		newChildren.push(child);
+	}
+	else newChildren.push(node.children[2]);
+	node.children = newChildren;
 }
 function processTextFunction(node) {
-  if (node.children[0].typeID === TokenID.ID_FUNCTION || node.children[0].typeID === TokenID.ID_PREDICATE) {
-    node.typeID = TokenID.NT_FUNC_CALL;
-    clearData(node);
-    if (node.children[2].typeID === Expr_enum_min2) {
-      for (const child of node.children[2].children) {
-        child.parent = node;
-      }
-      node.children = [node.children[0], ...node.children[2].children];
-    } else {
-      node.children = [node.children[0], node.children[2]];
-    }
-  } else {
-    node.typeID = node.children[0].typeID;
-    node.data = node.children[0].data;
-    node.children = [node.children[2]];
-  }
+	if (node.children[0].typeID === TokenID.ID_FUNCTION || node.children[0].typeID === TokenID.ID_PREDICATE) {
+		node.typeID = TokenID.NT_FUNC_CALL;
+		clearData(node);
+		if (node.children[2].typeID === 9) {
+			for (const child of node.children[2].children) child.parent = node;
+			node.children = [node.children[0], ...node.children[2].children];
+		} else node.children = [node.children[0], node.children[2]];
+	} else {
+		node.typeID = node.children[0].typeID;
+		node.data = node.children[0].data;
+		node.children = [node.children[2]];
+	}
 }
 function processFilter(node) {
-  const children = [];
-  if (node.children[2].typeID === Expr_enum_min2) {
-    for (const child of node.children[2].children) {
-      child.parent = node;
-      children.push(child);
-    }
-  } else {
-    children.push(node.children[2]);
-  }
-  children.push(node.children[5]);
-  promoteSingleChild(node);
-  node.children = children;
+	const children = [];
+	if (node.children[2].typeID === 9) for (const child of node.children[2].children) {
+		child.parent = node;
+		children.push(child);
+	}
+	else children.push(node.children[2]);
+	children.push(node.children[5]);
+	promoteSingleChild(node);
+	node.children = children;
 }
-export {
-  normalizeAST
-};
+//#endregion
+export { normalizeAST };
+
 //# sourceMappingURL=normalize.js.map