@rsconcept/domain 1.0.0 → 1.1.0

package/dist/rslang/parser/expression-generator.js

@@ -1,451 +1,253 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-function getNodeText(node) {
-  if (node.data.dataType === "string" && typeof node.data.value === "string") {
-    return node.data.value;
-  }
-  return `NO DATA NODE: ${node.typeID}`;
-}
-function getNodeIndices(node) {
-  if (node.data.dataType === "string[]" && Array.isArray(node.data.value)) {
-    return node.data.value.map((s) => parseInt(s, 10)).filter((n) => !isNaN(n));
-  }
-  return [];
-}
-
-// 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/expression-generator.ts
+import { getNodeIndices, getNodeText } from "../../parsing/ast.js";
+import "../../parsing/index.js";
+import { TokenID } from "./token.js";
+//#region src/rslang/parser/expression-generator.ts
+/** Generates Math-syntax RS expression from AST, with optional identifier normalization. */
 function generateExpressionFromAst(ast, options = {}) {
-  return new ExpressionGenerator(options).run(ast);
+	return new ExpressionGenerator(options).run(ast);
 }
+/** Generates Math-syntax RS expression from AST, with optional identifier normalization. */
 var ExpressionGenerator = class {
-  options;
-  freeLocals = /* @__PURE__ */ new Map();
-  radicals = /* @__PURE__ */ new Map();
-  scopes = [];
-  localCounter = 0;
-  radicalCounter = 0;
-  constructor(options) {
-    this.options = options;
-  }
-  /** Run generator. Requires that the AST has no syntax errors. */
-  run(ast) {
-    if (ast.hasError) {
-      throw new Error("Cannot generate expression: AST has error");
-    }
-    return this.visit(ast, { localDeclaration: false });
-  }
-  visit(node, context) {
-    const shouldScope = this.shouldStartScope(node.typeID);
-    if (shouldScope) {
-      this.startScope();
-    }
-    const result = this.renderNode(node, context);
-    if (shouldScope) {
-      this.endScope();
-    }
-    return result;
-  }
-  renderNode(node, context) {
-    switch (node.typeID) {
-      case TokenID.ID_LOCAL: {
-        const alias = getNodeText(node);
-        return this.options.normalize ? context.localDeclaration ? this.declareLocal(alias) : this.resolveLocal(alias) : alias;
-      }
-      case TokenID.ID_GLOBAL:
-      case TokenID.ID_FUNCTION:
-      case TokenID.ID_PREDICATE:
-        return getNodeText(node);
-      case TokenID.ID_RADICAL: {
-        const alias = getNodeText(node);
-        return this.options.normalize ? this.resolveRadical(alias) : alias;
-      }
-      case TokenID.LIT_INTEGER:
-        return String(node.data.value);
-      case TokenID.LIT_WHOLE_NUMBERS:
-        return "Z";
-      case TokenID.LIT_EMPTYSET:
-        return "\u2205";
-      case TokenID.BIGPR:
-        return `Pr${this.formatIndices(node)}(${this.visitChild(node, 0, context)})`;
-      case TokenID.SMALLPR:
-        return `pr${this.formatIndices(node)}(${this.visitChild(node, 0, context)})`;
-      case TokenID.FILTER: {
-        const args = node.children.slice(0, -1).map((child) => this.visit(child, context)).join(", ");
-        const body = this.visitChild(node, node.children.length - 1, context);
-        return `Fi${this.formatIndices(node)}[${args}](${body})`;
-      }
-      case TokenID.CARD:
-        return `card(${this.visitChild(node, 0, context)})`;
-      case TokenID.BOOL:
-        return `bool(${this.visitChild(node, 0, context)})`;
-      case TokenID.DEBOOL:
-        return `debool(${this.visitChild(node, 0, context)})`;
-      case TokenID.REDUCE:
-        return `red(${this.visitChild(node, 0, context)})`;
-      case TokenID.BOOLEAN:
-        return this.renderBoolean(node, context);
-      case TokenID.NT_FUNC_CALL: {
-        const callee = this.visitChild(node, 0, context);
-        const args = node.children.slice(1).map((child) => this.visit(child, context)).join(", ");
-        return `${callee}[${args}]`;
-      }
-      case TokenID.NT_TUPLE:
-        return `(${node.children.map((child) => this.visit(child, context)).join(", ")})`;
-      case TokenID.NT_ENUMERATION:
-        return `{${node.children.map((child) => this.visit(child, context)).join(", ")}}`;
-      case TokenID.NT_ARGUMENTS:
-      case TokenID.NT_ENUM_DECL:
-        return node.children.map((child, index) => this.visit(child, this.childContext(node.typeID, index, context))).join(", ");
-      case TokenID.NT_TUPLE_DECL:
-        return `(${node.children.map((child, index) => this.visit(child, this.childContext(node.typeID, index, context))).join(", ")})`;
-      case TokenID.NT_ARG_DECL:
-        return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}\u2208${this.visitChild(node, 1, context)}`;
-      case TokenID.QUANTOR_UNIVERSAL:
-        return this.renderQuantifier("\u2200", node, context);
-      case TokenID.QUANTOR_EXISTS:
-        return this.renderQuantifier("\u2203", node, context);
-      case TokenID.NT_DECLARATIVE_EXPR:
-        return `D{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}\u2208${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)}}`;
-      case TokenID.NT_FUNC_DEFINITION:
-        return `[${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}] ${this.visitChild(node, 1, context)}`;
-      case TokenID.ITERATE:
-        return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:\u2208${this.visitChild(node, 1, context)}`;
-      case TokenID.ASSIGN:
-        return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)}`;
-      case TokenID.NT_IMPERATIVE_EXPR: {
-        const statements = node.children.slice(1).map((child, index) => this.visit(child, this.childContext(node.typeID, index + 1, context)));
-        const target = this.visitChild(node, 0, context);
-        return `I{${target} | ${statements.join("; ")}}`;
-      }
-      case TokenID.NT_RECURSIVE_SHORT:
-        return `R{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)}}`;
-      case TokenID.NT_RECURSIVE_FULL:
-        return `R{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)} | ${this.visitChild(node, 3, context)}}`;
-      case TokenID.PLUS:
-        return this.renderInfix("+", node, context);
-      case TokenID.MINUS:
-        return this.renderInfix("-", node, context);
-      case TokenID.MULTIPLY:
-        return this.renderInfix("*", node, context);
-      case TokenID.GREATER:
-        return this.renderInfix(">", node, context);
-      case TokenID.LESSER:
-        return this.renderInfix("<", node, context);
-      case TokenID.GREATER_OR_EQ:
-        return this.renderInfix("\u2265", node, context);
-      case TokenID.LESSER_OR_EQ:
-        return this.renderInfix("\u2264", node, context);
-      case TokenID.EQUAL:
-        return this.renderInfix("=", node, context);
-      case TokenID.NOTEQUAL:
-        return this.renderInfix("\u2260", node, context);
-      case TokenID.LOGIC_AND:
-        return this.renderInfix("&", node, context);
-      case TokenID.LOGIC_OR:
-        return this.renderInfix("\u2228", node, context);
-      case TokenID.LOGIC_IMPLICATION:
-        return this.renderInfix("\u21D2", node, context);
-      case TokenID.LOGIC_EQUIVALENT:
-        return this.renderInfix("\u21D4", node, context);
-      case TokenID.SET_IN:
-        return this.renderInfix("\u2208", node, context);
-      case TokenID.SET_NOT_IN:
-        return this.renderInfix("\u2209", node, context);
-      case TokenID.SUBSET:
-        return this.renderInfix("\u2282", node, context);
-      case TokenID.SUBSET_OR_EQ:
-        return this.renderInfix("\u2286", node, context);
-      case TokenID.NOT_SUBSET:
-        return this.renderInfix("\u2284", node, context);
-      case TokenID.DECART:
-        return this.renderInfix("\xD7", node, context);
-      case TokenID.SET_UNION:
-        return this.renderInfix("\u222A", node, context);
-      case TokenID.SET_INTERSECTION:
-        return this.renderInfix("\u2229", node, context);
-      case TokenID.SET_MINUS:
-        return this.renderInfix("\\", node, context);
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return this.renderInfix("\u2206", node, context);
-      case TokenID.LOGIC_NOT:
-        return `\xAC${this.wrapIfNeeded(this.visitChild(node, 0, context), node.children[0])}`;
-      default:
-        return node.children.map((child) => this.visit(child, context)).join("");
-    }
-  }
-  visitChild(node, index, context) {
-    const child = node.children[index];
-    if (!child) {
-      return "";
-    }
-    return this.visit(child, this.childContext(node.typeID, index, context));
-  }
-  renderQuantifier(symbol, node, context) {
-    const declaration = this.visitChild(node, 0, this.childContext(node.typeID, 0, context));
-    const domain = this.visitChild(node, 1, context);
-    const bodyNode = node.children[2];
-    const bodyText = this.visitChild(node, 2, context);
-    const body = bodyNode && this.shouldWrapQuantifierBody(bodyNode) ? `(${bodyText})` : bodyText;
-    return `${symbol}${declaration}\u2208${domain} ${body}`;
-  }
-  shouldWrapQuantifierBody(node) {
-    const quantifierPrecedence = this.getPrecedence(TokenID.QUANTOR_UNIVERSAL);
-    const bodyPrecedence = this.getPrecedence(node.typeID);
-    if (quantifierPrecedence === null || bodyPrecedence === null) {
-      return false;
-    }
-    return bodyPrecedence < quantifierPrecedence;
-  }
-  renderInfix(symbol, node, context) {
-    if (this.isLogicBinary(node.typeID)) {
-      const parts2 = node.children.map((child, index) => {
-        const text = this.visit(child, context);
-        return this.needParen(node, child, index) ? `(${text})` : text;
-      });
-      return parts2.join(` ${symbol} `);
-    }
-    const parts = node.children.map((child) => this.wrapIfNeeded(this.visit(child, context), child));
-    return parts.join(symbol);
-  }
-  needParen(parent, child, childIndex) {
-    if (this.isAtomic(child.typeID)) {
-      return false;
-    }
-    const parentPrecedence = this.getPrecedence(parent.typeID);
-    const childPrecedence = this.getPrecedence(child.typeID);
-    if (parentPrecedence === null || childPrecedence === null) {
-      return true;
-    }
-    if (childPrecedence > parentPrecedence) {
-      return false;
-    }
-    if (childPrecedence < parentPrecedence) {
-      return true;
-    }
-    if (this.isAssociative(parent.typeID) && child.typeID === parent.typeID) {
-      return false;
-    }
-    if (this.isLeftAssociative(parent.typeID)) {
-      return childIndex > 0;
-    }
-    return true;
-  }
-  getPrecedence(typeID) {
-    switch (typeID) {
-      case TokenID.LOGIC_EQUIVALENT:
-        return 1;
-      case TokenID.LOGIC_IMPLICATION:
-        return 2;
-      case TokenID.LOGIC_OR:
-        return 3;
-      case TokenID.LOGIC_AND:
-        return 4;
-      case TokenID.QUANTOR_UNIVERSAL:
-      case TokenID.QUANTOR_EXISTS:
-        return 5;
-      case TokenID.EQUAL:
-      case TokenID.NOTEQUAL:
-      case TokenID.GREATER:
-      case TokenID.LESSER:
-      case TokenID.GREATER_OR_EQ:
-      case TokenID.LESSER_OR_EQ:
-      case TokenID.SET_IN:
-      case TokenID.SET_NOT_IN:
-      case TokenID.SUBSET:
-      case TokenID.SUBSET_OR_EQ:
-      case TokenID.NOT_SUBSET:
-        return 6;
-      case TokenID.PLUS:
-      case TokenID.MINUS:
-      case TokenID.SET_UNION:
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return 7;
-      case TokenID.MULTIPLY:
-      case TokenID.DECART:
-      case TokenID.SET_INTERSECTION:
-      case TokenID.SET_MINUS:
-        return 8;
-      default:
-        return null;
-    }
-  }
-  isAssociative(typeID) {
-    return typeID === TokenID.PLUS || typeID === TokenID.MULTIPLY || typeID === TokenID.LOGIC_AND || typeID === TokenID.LOGIC_OR || typeID === TokenID.LOGIC_EQUIVALENT || typeID === TokenID.SET_UNION || typeID === TokenID.SET_INTERSECTION || typeID === TokenID.DECART;
-  }
-  isLeftAssociative(typeID) {
-    return typeID === TokenID.LOGIC_IMPLICATION || typeID === TokenID.MINUS || typeID === TokenID.SET_MINUS || typeID === TokenID.SET_SYMMETRIC_MINUS;
-  }
-  renderBoolean(node, context) {
-    let current = node;
-    let depth = 0;
-    while (current.typeID === TokenID.BOOLEAN && current.children.length === 1) {
-      depth += 1;
-      current = current.children[0];
-    }
-    return `${"\u212C".repeat(depth)}(${this.visit(current, context)})`;
-  }
-  wrapIfNeeded(text, node) {
-    if (this.isAtomic(node.typeID)) {
-      return text;
-    }
-    return `(${text})`;
-  }
-  isAtomic(typeID) {
-    return typeID === TokenID.ID_LOCAL || typeID === TokenID.ID_GLOBAL || typeID === TokenID.ID_FUNCTION || typeID === TokenID.ID_PREDICATE || typeID === TokenID.ID_RADICAL || typeID === TokenID.LIT_INTEGER || typeID === TokenID.LIT_WHOLE_NUMBERS || typeID === TokenID.LIT_EMPTYSET || typeID === TokenID.NT_FUNC_CALL || typeID === TokenID.NT_TUPLE || typeID === TokenID.NT_ENUMERATION || typeID === TokenID.BIGPR || typeID === TokenID.SMALLPR || typeID === TokenID.FILTER || typeID === TokenID.REDUCE || typeID === TokenID.BOOL || typeID === TokenID.DEBOOL || typeID === TokenID.CARD || typeID === TokenID.BOOLEAN;
-  }
-  isLogicBinary(typeID) {
-    return typeID === TokenID.LOGIC_AND || typeID === TokenID.LOGIC_OR || typeID === TokenID.LOGIC_IMPLICATION || typeID === TokenID.LOGIC_EQUIVALENT;
-  }
-  formatIndices(node) {
-    return getNodeIndices(node).join(",");
-  }
-  shouldStartScope(typeID) {
-    return typeID === TokenID.QUANTOR_UNIVERSAL || typeID === TokenID.QUANTOR_EXISTS || typeID === TokenID.NT_DECLARATIVE_EXPR || typeID === TokenID.NT_FUNC_DEFINITION || typeID === TokenID.NT_IMPERATIVE_EXPR || typeID === TokenID.NT_RECURSIVE_SHORT || typeID === TokenID.NT_RECURSIVE_FULL;
-  }
-  childContext(typeID, index, parent) {
-    if (!this.options.normalize) {
-      return parent;
-    }
-    const isDeclaration = (typeID === TokenID.QUANTOR_UNIVERSAL || typeID === TokenID.QUANTOR_EXISTS || typeID === TokenID.NT_DECLARATIVE_EXPR || typeID === TokenID.ITERATE || typeID === TokenID.ASSIGN || typeID === TokenID.NT_RECURSIVE_SHORT || typeID === TokenID.NT_RECURSIVE_FULL) && index === 0 || typeID === TokenID.NT_FUNC_DEFINITION && index === 0 || typeID === TokenID.NT_ARG_DECL && index === 0 || typeID === TokenID.NT_TUPLE_DECL || typeID === TokenID.NT_ENUM_DECL;
-    return { localDeclaration: isDeclaration };
-  }
-  declareLocal(alias) {
-    const scope = this.currentScope();
-    const local = this.nextLocal();
-    scope.set(alias, local);
-    return local;
-  }
-  resolveLocal(alias) {
-    for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
-      const local2 = this.scopes[index].get(alias);
-      if (local2) {
-        return local2;
-      }
-    }
-    let local = this.freeLocals.get(alias);
-    if (!local) {
-      local = this.nextLocal();
-      this.freeLocals.set(alias, local);
-    }
-    return local;
-  }
-  resolveRadical(alias) {
-    let radical = this.radicals.get(alias);
-    if (!radical) {
-      this.radicalCounter += 1;
-      radical = `R${this.radicalCounter}`;
-      this.radicals.set(alias, radical);
-    }
-    return radical;
-  }
-  startScope() {
-    this.scopes.push(/* @__PURE__ */ new Map());
-  }
-  endScope() {
-    this.scopes.pop();
-  }
-  currentScope() {
-    const scope = this.scopes.at(-1);
-    if (!scope) {
-      throw new Error("Attempted to declare local outside of scope");
-    }
-    return scope;
-  }
-  nextLocal() {
-    this.localCounter += 1;
-    return `a${this.localCounter}`;
-  }
-};
-export {
-  generateExpressionFromAst
+	options;
+	freeLocals = /* @__PURE__ */ new Map();
+	radicals = /* @__PURE__ */ new Map();
+	scopes = [];
+	localCounter = 0;
+	radicalCounter = 0;
+	constructor(options) {
+		this.options = options;
+	}
+	/** Run generator. Requires that the AST has no syntax errors. */
+	run(ast) {
+		if (ast.hasError) throw new Error("Cannot generate expression: AST has error");
+		return this.visit(ast, { localDeclaration: false });
+	}
+	visit(node, context) {
+		const shouldScope = this.shouldStartScope(node.typeID);
+		if (shouldScope) this.startScope();
+		const result = this.renderNode(node, context);
+		if (shouldScope) this.endScope();
+		return result;
+	}
+	renderNode(node, context) {
+		switch (node.typeID) {
+			case TokenID.ID_LOCAL: {
+				const alias = getNodeText(node);
+				return this.options.normalize ? context.localDeclaration ? this.declareLocal(alias) : this.resolveLocal(alias) : alias;
+			}
+			case TokenID.ID_GLOBAL:
+			case TokenID.ID_FUNCTION:
+			case TokenID.ID_PREDICATE: return getNodeText(node);
+			case TokenID.ID_RADICAL: {
+				const alias = getNodeText(node);
+				return this.options.normalize ? this.resolveRadical(alias) : alias;
+			}
+			case TokenID.LIT_INTEGER: return String(node.data.value);
+			case TokenID.LIT_WHOLE_NUMBERS: return "Z";
+			case TokenID.LIT_EMPTYSET: return "∅";
+			case TokenID.BIGPR: return `Pr${this.formatIndices(node)}(${this.visitChild(node, 0, context)})`;
+			case TokenID.SMALLPR: return `pr${this.formatIndices(node)}(${this.visitChild(node, 0, context)})`;
+			case TokenID.FILTER: {
+				const args = node.children.slice(0, -1).map((child) => this.visit(child, context)).join(", ");
+				const body = this.visitChild(node, node.children.length - 1, context);
+				return `Fi${this.formatIndices(node)}[${args}](${body})`;
+			}
+			case TokenID.CARD: return `card(${this.visitChild(node, 0, context)})`;
+			case TokenID.BOOL: return `bool(${this.visitChild(node, 0, context)})`;
+			case TokenID.DEBOOL: return `debool(${this.visitChild(node, 0, context)})`;
+			case TokenID.REDUCE: return `red(${this.visitChild(node, 0, context)})`;
+			case TokenID.BOOLEAN: return this.renderBoolean(node, context);
+			case TokenID.NT_FUNC_CALL: return `${this.visitChild(node, 0, context)}[${node.children.slice(1).map((child) => this.visit(child, context)).join(", ")}]`;
+			case TokenID.NT_TUPLE: return `(${node.children.map((child) => this.visit(child, context)).join(", ")})`;
+			case TokenID.NT_ENUMERATION: return `{${node.children.map((child) => this.visit(child, context)).join(", ")}}`;
+			case TokenID.NT_ARGUMENTS:
+			case TokenID.NT_ENUM_DECL: return node.children.map((child, index) => this.visit(child, this.childContext(node.typeID, index, context))).join(", ");
+			case TokenID.NT_TUPLE_DECL: return `(${node.children.map((child, index) => this.visit(child, this.childContext(node.typeID, index, context))).join(", ")})`;
+			case TokenID.NT_ARG_DECL: return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}∈${this.visitChild(node, 1, context)}`;
+			case TokenID.QUANTOR_UNIVERSAL: return this.renderQuantifier("∀", node, context);
+			case TokenID.QUANTOR_EXISTS: return this.renderQuantifier("∃", node, context);
+			case TokenID.NT_DECLARATIVE_EXPR: return `D{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}∈${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)}}`;
+			case TokenID.NT_FUNC_DEFINITION: return `[${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}] ${this.visitChild(node, 1, context)}`;
+			case TokenID.ITERATE: return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:∈${this.visitChild(node, 1, context)}`;
+			case TokenID.ASSIGN: return `${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)}`;
+			case TokenID.NT_IMPERATIVE_EXPR: {
+				const statements = node.children.slice(1).map((child, index) => this.visit(child, this.childContext(node.typeID, index + 1, context)));
+				return `I{${this.visitChild(node, 0, context)} | ${statements.join("; ")}}`;
+			}
+			case TokenID.NT_RECURSIVE_SHORT: return `R{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)}}`;
+			case TokenID.NT_RECURSIVE_FULL: return `R{${this.visitChild(node, 0, this.childContext(node.typeID, 0, context))}:=${this.visitChild(node, 1, context)} | ${this.visitChild(node, 2, context)} | ${this.visitChild(node, 3, context)}}`;
+			case TokenID.PLUS: return this.renderInfix("+", node, context);
+			case TokenID.MINUS: return this.renderInfix("-", node, context);
+			case TokenID.MULTIPLY: return this.renderInfix("*", node, context);
+			case TokenID.GREATER: return this.renderInfix(">", node, context);
+			case TokenID.LESSER: return this.renderInfix("<", node, context);
+			case TokenID.GREATER_OR_EQ: return this.renderInfix("≥", node, context);
+			case TokenID.LESSER_OR_EQ: return this.renderInfix("≤", node, context);
+			case TokenID.EQUAL: return this.renderInfix("=", node, context);
+			case TokenID.NOTEQUAL: return this.renderInfix("≠", node, context);
+			case TokenID.LOGIC_AND: return this.renderInfix("&", node, context);
+			case TokenID.LOGIC_OR: return this.renderInfix("∨", node, context);
+			case TokenID.LOGIC_IMPLICATION: return this.renderInfix("⇒", node, context);
+			case TokenID.LOGIC_EQUIVALENT: return this.renderInfix("⇔", node, context);
+			case TokenID.SET_IN: return this.renderInfix("∈", node, context);
+			case TokenID.SET_NOT_IN: return this.renderInfix("∉", node, context);
+			case TokenID.SUBSET: return this.renderInfix("⊂", node, context);
+			case TokenID.SUBSET_OR_EQ: return this.renderInfix("⊆", node, context);
+			case TokenID.NOT_SUBSET: return this.renderInfix("⊄", node, context);
+			case TokenID.DECART: return this.renderInfix("×", node, context);
+			case TokenID.SET_UNION: return this.renderInfix("∪", node, context);
+			case TokenID.SET_INTERSECTION: return this.renderInfix("∩", node, context);
+			case TokenID.SET_MINUS: return this.renderInfix("\\", node, context);
+			case TokenID.SET_SYMMETRIC_MINUS: return this.renderInfix("∆", node, context);
+			case TokenID.LOGIC_NOT: return `¬${this.wrapIfNeeded(this.visitChild(node, 0, context), node.children[0])}`;
+			default: return node.children.map((child) => this.visit(child, context)).join("");
+		}
+	}
+	visitChild(node, index, context) {
+		const child = node.children[index];
+		if (!child) return "";
+		return this.visit(child, this.childContext(node.typeID, index, context));
+	}
+	renderQuantifier(symbol, node, context) {
+		const declaration = this.visitChild(node, 0, this.childContext(node.typeID, 0, context));
+		const domain = this.visitChild(node, 1, context);
+		const bodyNode = node.children[2];
+		const bodyText = this.visitChild(node, 2, context);
+		return `${symbol}${declaration}∈${domain} ${bodyNode && this.shouldWrapQuantifierBody(bodyNode) ? `(${bodyText})` : bodyText}`;
+	}
+	shouldWrapQuantifierBody(node) {
+		const quantifierPrecedence = this.getPrecedence(TokenID.QUANTOR_UNIVERSAL);
+		const bodyPrecedence = this.getPrecedence(node.typeID);
+		if (quantifierPrecedence === null || bodyPrecedence === null) return false;
+		return bodyPrecedence < quantifierPrecedence;
+	}
+	renderInfix(symbol, node, context) {
+		if (this.isLogicBinary(node.typeID)) return node.children.map((child, index) => {
+			const text = this.visit(child, context);
+			return this.needParen(node, child, index) ? `(${text})` : text;
+		}).join(` ${symbol} `);
+		return node.children.map((child) => this.wrapIfNeeded(this.visit(child, context), child)).join(symbol);
+	}
+	needParen(parent, child, childIndex) {
+		if (this.isAtomic(child.typeID)) return false;
+		const parentPrecedence = this.getPrecedence(parent.typeID);
+		const childPrecedence = this.getPrecedence(child.typeID);
+		if (parentPrecedence === null || childPrecedence === null) return true;
+		if (childPrecedence > parentPrecedence) return false;
+		if (childPrecedence < parentPrecedence) return true;
+		if (this.isAssociative(parent.typeID) && child.typeID === parent.typeID) return false;
+		if (this.isLeftAssociative(parent.typeID)) return childIndex > 0;
+		return true;
+	}
+	getPrecedence(typeID) {
+		switch (typeID) {
+			case TokenID.LOGIC_EQUIVALENT: return 1;
+			case TokenID.LOGIC_IMPLICATION: return 2;
+			case TokenID.LOGIC_OR: return 3;
+			case TokenID.LOGIC_AND: return 4;
+			case TokenID.QUANTOR_UNIVERSAL:
+			case TokenID.QUANTOR_EXISTS: return 5;
+			case TokenID.EQUAL:
+			case TokenID.NOTEQUAL:
+			case TokenID.GREATER:
+			case TokenID.LESSER:
+			case TokenID.GREATER_OR_EQ:
+			case TokenID.LESSER_OR_EQ:
+			case TokenID.SET_IN:
+			case TokenID.SET_NOT_IN:
+			case TokenID.SUBSET:
+			case TokenID.SUBSET_OR_EQ:
+			case TokenID.NOT_SUBSET: return 6;
+			case TokenID.PLUS:
+			case TokenID.MINUS:
+			case TokenID.SET_UNION:
+			case TokenID.SET_SYMMETRIC_MINUS: return 7;
+			case TokenID.MULTIPLY:
+			case TokenID.DECART:
+			case TokenID.SET_INTERSECTION:
+			case TokenID.SET_MINUS: return 8;
+			default: return null;
+		}
+	}
+	isAssociative(typeID) {
+		return typeID === TokenID.PLUS || typeID === TokenID.MULTIPLY || typeID === TokenID.LOGIC_AND || typeID === TokenID.LOGIC_OR || typeID === TokenID.LOGIC_EQUIVALENT || typeID === TokenID.SET_UNION || typeID === TokenID.SET_INTERSECTION || typeID === TokenID.DECART;
+	}
+	isLeftAssociative(typeID) {
+		return typeID === TokenID.LOGIC_IMPLICATION || typeID === TokenID.MINUS || typeID === TokenID.SET_MINUS || typeID === TokenID.SET_SYMMETRIC_MINUS;
+	}
+	renderBoolean(node, context) {
+		let current = node;
+		let depth = 0;
+		while (current.typeID === TokenID.BOOLEAN && current.children.length === 1) {
+			depth += 1;
+			current = current.children[0];
+		}
+		return `${"ℬ".repeat(depth)}(${this.visit(current, context)})`;
+	}
+	wrapIfNeeded(text, node) {
+		if (this.isAtomic(node.typeID)) return text;
+		return `(${text})`;
+	}
+	isAtomic(typeID) {
+		return typeID === TokenID.ID_LOCAL || typeID === TokenID.ID_GLOBAL || typeID === TokenID.ID_FUNCTION || typeID === TokenID.ID_PREDICATE || typeID === TokenID.ID_RADICAL || typeID === TokenID.LIT_INTEGER || typeID === TokenID.LIT_WHOLE_NUMBERS || typeID === TokenID.LIT_EMPTYSET || typeID === TokenID.NT_FUNC_CALL || typeID === TokenID.NT_TUPLE || typeID === TokenID.NT_ENUMERATION || typeID === TokenID.BIGPR || typeID === TokenID.SMALLPR || typeID === TokenID.FILTER || typeID === TokenID.REDUCE || typeID === TokenID.BOOL || typeID === TokenID.DEBOOL || typeID === TokenID.CARD || typeID === TokenID.BOOLEAN;
+	}
+	isLogicBinary(typeID) {
+		return typeID === TokenID.LOGIC_AND || typeID === TokenID.LOGIC_OR || typeID === TokenID.LOGIC_IMPLICATION || typeID === TokenID.LOGIC_EQUIVALENT;
+	}
+	formatIndices(node) {
+		return getNodeIndices(node).join(",");
+	}
+	shouldStartScope(typeID) {
+		return typeID === TokenID.QUANTOR_UNIVERSAL || typeID === TokenID.QUANTOR_EXISTS || typeID === TokenID.NT_DECLARATIVE_EXPR || typeID === TokenID.NT_FUNC_DEFINITION || typeID === TokenID.NT_IMPERATIVE_EXPR || typeID === TokenID.NT_RECURSIVE_SHORT || typeID === TokenID.NT_RECURSIVE_FULL;
+	}
+	childContext(typeID, index, parent) {
+		if (!this.options.normalize) return parent;
+		return { localDeclaration: (typeID === TokenID.QUANTOR_UNIVERSAL || typeID === TokenID.QUANTOR_EXISTS || typeID === TokenID.NT_DECLARATIVE_EXPR || typeID === TokenID.ITERATE || typeID === TokenID.ASSIGN || typeID === TokenID.NT_RECURSIVE_SHORT || typeID === TokenID.NT_RECURSIVE_FULL) && index === 0 || typeID === TokenID.NT_FUNC_DEFINITION && index === 0 || typeID === TokenID.NT_ARG_DECL && index === 0 || typeID === TokenID.NT_TUPLE_DECL || typeID === TokenID.NT_ENUM_DECL };
+	}
+	declareLocal(alias) {
+		const scope = this.currentScope();
+		const local = this.nextLocal();
+		scope.set(alias, local);
+		return local;
+	}
+	resolveLocal(alias) {
+		for (let index = this.scopes.length - 1; index >= 0; index -= 1) {
+			const local = this.scopes[index].get(alias);
+			if (local) return local;
+		}
+		let local = this.freeLocals.get(alias);
+		if (!local) {
+			local = this.nextLocal();
+			this.freeLocals.set(alias, local);
+		}
+		return local;
+	}
+	resolveRadical(alias) {
+		let radical = this.radicals.get(alias);
+		if (!radical) {
+			this.radicalCounter += 1;
+			radical = `R${this.radicalCounter}`;
+			this.radicals.set(alias, radical);
+		}
+		return radical;
+	}
+	startScope() {
+		this.scopes.push(/* @__PURE__ */ new Map());
+	}
+	endScope() {
+		this.scopes.pop();
+	}
+	currentScope() {
+		const scope = this.scopes.at(-1);
+		if (!scope) throw new Error("Attempted to declare local outside of scope");
+		return scope;
+	}
+	nextLocal() {
+		this.localCounter += 1;
+		return `a${this.localCounter}`;
+	}
 };
+//#endregion
+export { generateExpressionFromAst };
+
 //# sourceMappingURL=expression-generator.js.map