@rsconcept/domain 1.0.0

package/dist/rslang/api.js

@@ -0,0 +1,846 @@
+// 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/ast-annotations.ts
+var AST_TYPE_KEY = "rsType";
+function readTypeAnnotation(node) {
+  if (node.annotation && AST_TYPE_KEY in node.annotation) {
+    return node.annotation[AST_TYPE_KEY];
+  }
+  return null;
+}
+
+// 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/semantic/arguments-extractor.ts
+var ArgumentsExtractor = class {
+  locals = new LocalContext();
+  result = [];
+  run(ast) {
+    if (ast.hasError) {
+      return [];
+    }
+    this.result = [];
+    this.locals.clear();
+    this.dispatchVisit(ast);
+    return this.result;
+  }
+  dispatchDeclare(node) {
+    return this.processDeclare(node);
+  }
+  processDeclare(node) {
+    switch (node.typeID) {
+      case TokenID.ID_LOCAL:
+        return this.declareLocal(node);
+      case TokenID.NT_TUPLE_DECL:
+        return this.declareTuple(node);
+      case TokenID.NT_ENUM_DECL:
+        return this.declareEnumeration(node);
+    }
+    return false;
+  }
+  declareLocal(node) {
+    this.locals.pushLocal(node);
+    return true;
+  }
+  declareTuple(node) {
+    for (let child = 0; child < node.children.length; child++) {
+      if (!this.visitChildDeclaration(node, child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  declareEnumeration(node) {
+    for (const child of node.children) {
+      if (!this.dispatchDeclare(child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  dispatchVisit(node) {
+    return this.processVisit(node);
+  }
+  processVisit(node) {
+    switch (node.typeID) {
+      case TokenID.ID_GLOBAL:
+      case TokenID.ID_FUNCTION:
+      case TokenID.ID_PREDICATE:
+      case TokenID.ID_RADICAL:
+      case TokenID.LIT_INTEGER:
+      case TokenID.LIT_WHOLE_NUMBERS:
+      case TokenID.LIT_EMPTYSET:
+        return true;
+      case TokenID.CARD:
+      case TokenID.FILTER:
+      case TokenID.PLUS:
+      case TokenID.MINUS:
+      case TokenID.MULTIPLY:
+      case TokenID.LOGIC_AND:
+      case TokenID.LOGIC_OR:
+      case TokenID.LOGIC_IMPLICATION:
+      case TokenID.LOGIC_EQUIVALENT:
+      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:
+      case TokenID.DECART:
+      case TokenID.BOOLEAN:
+      case TokenID.BIGPR:
+      case TokenID.SMALLPR:
+      case TokenID.REDUCE:
+      case TokenID.BOOL:
+      case TokenID.DEBOOL:
+      case TokenID.SET_UNION:
+      case TokenID.SET_INTERSECTION:
+      case TokenID.SET_MINUS:
+      case TokenID.SET_SYMMETRIC_MINUS:
+      case TokenID.LOGIC_NOT:
+      case TokenID.NT_TUPLE:
+      case TokenID.NT_ENUMERATION:
+      case TokenID.NT_ARGUMENTS:
+        return this.visitAllAndReturn(node);
+      case TokenID.ID_LOCAL:
+        return this.visitLocal(node);
+      case TokenID.NT_ARG_DECL:
+        return this.visitArgument(node);
+      case TokenID.QUANTOR_UNIVERSAL:
+      case TokenID.QUANTOR_EXISTS:
+      case TokenID.NT_DECLARATIVE_EXPR:
+        return this.visitQuantifier(node);
+      case TokenID.NT_FUNC_DEFINITION:
+        return this.visitFunctionDefinition(node);
+      case TokenID.NT_FUNC_CALL:
+        return this.visitFunctionCall(node);
+      case TokenID.ITERATE:
+      case TokenID.ASSIGN:
+        return this.visitIterate(node);
+      case TokenID.NT_IMPERATIVE_EXPR:
+        return this.visitImperative(node);
+      case TokenID.NT_RECURSIVE_FULL:
+      case TokenID.NT_RECURSIVE_SHORT:
+        return this.visitRecursion(node);
+    }
+    return false;
+  }
+  visitChild(node, index) {
+    return index < node.children.length && this.dispatchVisit(node.children[index]);
+  }
+  visitChildDeclaration(node, index) {
+    return index < node.children.length && this.dispatchDeclare(node.children[index]);
+  }
+  visitAllAndReturn(node) {
+    for (const child of node.children) {
+      if (!this.dispatchVisit(child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  visitLocal(node) {
+    const alias = getNodeText(node);
+    if (!this.locals.checkLocal(node) && this.result.find((arg) => arg.alias === alias) === void 0) {
+      this.result.push({ alias, type: readTypeAnnotation(node) });
+    }
+    return true;
+  }
+  visitFunctionDefinition(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 0)) {
+      return false;
+    }
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitFunctionCall(node) {
+    for (let child = 1; child < node.children.length; child++) {
+      if (!this.visitChild(node, child)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  visitArgument(node) {
+    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);
+  }
+  visitQuantifier(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    if (!this.visitChildDeclaration(node, 0)) {
+      return false;
+    }
+    if (!this.visitChild(node, 2)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitImperative(node) {
+    this.locals.startScope();
+    for (let child = 1; child < node.children.length; child++) {
+      if (!this.visitChild(node, child)) {
+        return false;
+      }
+    }
+    if (!this.visitChild(node, 0)) {
+      return false;
+    }
+    this.locals.endScope();
+    return true;
+  }
+  visitIterate(node) {
+    return this.visitChild(node, 1) && this.visitChildDeclaration(node, 0);
+  }
+  visitRecursion(node) {
+    this.locals.startScope();
+    if (!this.visitChild(node, 1)) {
+      return false;
+    }
+    if (!this.visitChildDeclaration(node, 0)) {
+      return false;
+    }
+    const isFull = node.typeID === TokenID.NT_RECURSIVE_FULL;
+    const iterationIndex = isFull ? 3 : 2;
+    if (!this.visitChild(node, iterationIndex)) {
+      return false;
+    }
+    if (isFull) {
+      if (!this.visitChild(node, 2)) {
+        return false;
+      }
+    }
+    this.locals.endScope();
+    return true;
+  }
+};
+var LocalContext = class {
+  data = [];
+  clear() {
+    this.data = [];
+  }
+  startScope() {
+    for (const local of this.data) {
+      if (local.level > 0) {
+        local.level = local.level + 1;
+      }
+    }
+  }
+  endScope() {
+    for (const local of this.data) {
+      local.level--;
+    }
+  }
+  clearUnused() {
+    this.data = this.data.filter((data) => data.level > 0);
+  }
+  pushLocal(node) {
+    const alias = getNodeText(node);
+    const existing = this.data.find((data) => data.alias === alias);
+    if (existing) {
+      if (existing.level > 0) {
+        return;
+      } else {
+        const index = this.data.indexOf(existing);
+        if (index !== -1) {
+          this.data.splice(index, 1);
+        }
+      }
+    }
+    this.data.push({ alias, level: 1 });
+  }
+  checkLocal(node) {
+    const alias = getNodeText(node);
+    const local = this.data.find((data) => data.alias === alias);
+    return local !== void 0;
+  }
+};
+
+// src/rslang/parser/expression-generator.ts
+function generateExpressionFromAst(ast, options = {}) {
+  return new ExpressionGenerator(options).run(ast);
+}
+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}`;
+  }
+};
+
+// src/rslang/api.ts
+var LOCALS_REGEXP = /[_a-zα-ω][a-zα-ω]*\d*/g;
+var GLOBALS_REGEXP = /[XCSADFPTN]\d+/g;
+var COMPLEX_SYMBOLS_REGEXP = /[∀∃×ℬ;|:]/g;
+var TYPIFICATION_SET = /^ℬ+\([ℬ\(((X|C)\d+|Z)\)×]*\)$/g;
+function extractArguments(ast) {
+  return new ArgumentsExtractor().run(ast);
+}
+function extractGlobals(expression) {
+  return new Set(expression.match(GLOBALS_REGEXP) ?? []);
+}
+function isSimpleExpression(text) {
+  return !text.match(COMPLEX_SYMBOLS_REGEXP);
+}
+function isSetTypification(text) {
+  return !!text.match(TYPIFICATION_SET);
+}
+function splitTemplateDefinition(target) {
+  let start = 0;
+  for (; start < target.length && target[start] !== "["; ++start) ;
+  if (start < target.length) {
+    for (let counter = 0, end = start + 1; end < target.length; ++end) {
+      if (target[end] === "[") {
+        ++counter;
+      } else if (target[end] === "]") {
+        if (counter !== 0) {
+          --counter;
+        } else {
+          return {
+            head: target.substring(start + 1, end).trim(),
+            body: target.substring(end + 1).trim()
+          };
+        }
+      }
+    }
+  }
+  return {
+    head: "",
+    body: target
+  };
+}
+function substituteTemplateArgs(expression, mapping) {
+  if (Object.keys(mapping).length === 0) {
+    return expression;
+  }
+  let { head, body } = splitTemplateDefinition(expression);
+  body = applyPattern(body, mapping, LOCALS_REGEXP);
+  const argTexts = head.split(",").map((text) => text.trim());
+  head = argTexts.filter((arg) => [...arg.matchAll(LOCALS_REGEXP)].every((local) => local.every((match) => !(match in mapping)))).join(", ");
+  if (!head) {
+    return body;
+  } else {
+    return `[${head}] ${body}`;
+  }
+}
+function applyAliasMapping(target, mapping) {
+  return applyPattern(target, mapping, GLOBALS_REGEXP);
+}
+function applyTypificationMapping(target, mapping) {
+  const modified = applyAliasMapping(target, mapping);
+  if (modified === target) {
+    return target;
+  }
+  const deleteBrackets = [];
+  const positions = [];
+  const booleans = [];
+  let boolCount = 0;
+  let stackSize = 0;
+  for (let i = 0; i < modified.length; i++) {
+    const char = modified[i];
+    if (char === "\u212C") {
+      boolCount++;
+      continue;
+    }
+    if (char === "(") {
+      stackSize++;
+      positions.push(i);
+      booleans.push(boolCount);
+    }
+    boolCount = 0;
+    if (char === ")") {
+      if (i < modified.length - 1 && modified[i + 1] === ")" && stackSize > 1 && positions[stackSize - 2] + booleans[stackSize - 1] + 1 === positions[stackSize - 1]) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[stackSize - 2]);
+      }
+      if (i === modified.length - 1 && stackSize === 1 && positions[0] === 0) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[0]);
+      }
+      stackSize--;
+      positions.pop();
+      booleans.pop();
+    }
+  }
+  let result = "";
+  for (let i = 0; i < modified.length; i++) {
+    if (!deleteBrackets.includes(i)) {
+      result += modified[i];
+    }
+  }
+  return result;
+}
+function applyPattern(text, mapping, pattern) {
+  if (text === "" || pattern === null) {
+    return text;
+  }
+  let posInput = 0;
+  let output = "";
+  const patternMatches = text.matchAll(pattern);
+  for (const segment of patternMatches) {
+    const entity = segment[0];
+    const start = segment.index ?? 0;
+    if (entity in mapping) {
+      output += text.substring(posInput, start);
+      output += mapping[entity];
+      posInput = start + segment[0].length;
+    }
+  }
+  output += text.substring(posInput);
+  return output;
+}
+export {
+  applyAliasMapping,
+  applyTypificationMapping,
+  extractArguments,
+  extractGlobals,
+  generateExpressionFromAst,
+  isSetTypification,
+  isSimpleExpression,
+  splitTemplateDefinition,
+  substituteTemplateArgs
+};
+//# sourceMappingURL=api.js.map