@rsconcept/domain 1.0.0 → 1.2.0

package/dist/rslang/labels.d.ts

@@ -1,9 +1,8 @@
-import { AstNodeBase } from '../parsing/ast.js';
-import { TokenID } from './parser/token.js';
-import { ExpressionType } from './semantic/typification.js';
-import '@lezer/common';
-import '../shared/branded.js';
+import { n as AstNodeBase } from "../ast-C8sIpKdL.js";
+import { f as ExpressionType } from "../typification-Dk-fisgO.js";
+import { t as TokenID } from "../token-DeXAmzwr.js";
 
+//#region src/rslang/labels.d.ts
 /** Retrieves label for {@link TokenID}. */
 declare function labelToken(id: TokenID): string;
 /** Generates label for {@link AstNodeBase}. */
@@ -12,5 +11,6 @@ declare function labelRSLangNode(node: AstNodeBase): string;
 declare function labelType(type: ExpressionType | null): string;
 /** Converts expression type to normalized string. */
 declare function normalizeType(type: ExpressionType | null): string;
-
+//#endregion
 export { labelRSLangNode, labelToken, labelType, normalizeType };
+//# sourceMappingURL=labels.d.ts.map

package/dist/rslang/labels.js

@@ -1,315 +1,149 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-
-// 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/typification.ts
-var TypeID = {
-  anyTypification: 1,
-  integer: 2,
-  basic: 3,
-  tuple: 4,
-  collection: 5,
-  logic: 6,
-  function: 7,
-  predicate: 8
-};
-var LogicT = { typeID: TypeID.logic };
-var IntegerT = {
-  typeID: TypeID.integer,
-  isOrdered: true,
-  isArithmetic: true,
-  isIntegerCompatible: true
-};
-var AnyTypificationT = { typeID: TypeID.anyTypification };
-var EmptySetT = bool(AnyTypificationT);
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-
-// src/rslang/labels.ts
-var INTEGER_TYPE_NAME = "Z";
-var ANY_TYPE_NAME = "R0";
-var LOGIC_TYPE_NAME = "Logic";
-var labelTokenRecord = {
-  [TokenID.DECART]: "\xD7",
-  [TokenID.PUNCTUATION_PL]: "( )",
-  [TokenID.PUNCTUATION_SL]: "[ ]",
-  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
-  [TokenID.QUANTOR_EXISTS]: "\u2203",
-  [TokenID.LOGIC_NOT]: "\xAC",
-  [TokenID.LOGIC_AND]: "&",
-  [TokenID.LOGIC_OR]: "\u2228",
-  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
-  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
-  [TokenID.LIT_EMPTYSET]: "\u2205",
-  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
-  [TokenID.MULTIPLY]: "*",
-  [TokenID.EQUAL]: "=",
-  [TokenID.NOTEQUAL]: "\u2260",
-  [TokenID.GREATER_OR_EQ]: "\u2265",
-  [TokenID.LESSER_OR_EQ]: "\u2264",
-  [TokenID.SET_IN]: "\u2208",
-  [TokenID.SET_NOT_IN]: "\u2209",
-  [TokenID.SUBSET_OR_EQ]: "\u2286",
-  [TokenID.SUBSET]: "\u2282",
-  [TokenID.NOT_SUBSET]: "\u2284",
-  [TokenID.SET_INTERSECTION]: "\u2229",
-  [TokenID.SET_UNION]: "\u222A",
-  [TokenID.SET_MINUS]: "\\",
-  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
-  [TokenID.BOOLEAN]: "\u212C()",
-  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
-  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
-  [TokenID.NT_RECURSIVE_FULL]: "R{}",
-  [TokenID.BIGPR]: "Pr1()",
-  [TokenID.SMALLPR]: "pr1()",
-  [TokenID.FILTER]: "Fi1[]()",
-  [TokenID.REDUCE]: "red()",
-  [TokenID.CARD]: "card()",
-  [TokenID.BOOL]: "bool()",
-  [TokenID.DEBOOL]: "debool()",
-  [TokenID.ASSIGN]: ":=",
-  [TokenID.ITERATE]: ":\u2208"
+import { TokenID } from "./parser/token.js";
+import { TypeID } from "./semantic/typification.js";
+//#region src/rslang/labels.ts
+const INTEGER_TYPE_NAME = "Z";
+const ANY_TYPE_NAME = "R0";
+const LOGIC_TYPE_NAME = "Logic";
+const labelTokenRecord = {
+	[TokenID.DECART]: "×",
+	[TokenID.PUNCTUATION_PL]: "( )",
+	[TokenID.PUNCTUATION_SL]: "[ ]",
+	[TokenID.QUANTOR_UNIVERSAL]: "∀",
+	[TokenID.QUANTOR_EXISTS]: "∃",
+	[TokenID.LOGIC_NOT]: "¬",
+	[TokenID.LOGIC_AND]: "&",
+	[TokenID.LOGIC_OR]: "∨",
+	[TokenID.LOGIC_IMPLICATION]: "⇒",
+	[TokenID.LOGIC_EQUIVALENT]: "⇔",
+	[TokenID.LIT_EMPTYSET]: "∅",
+	[TokenID.LIT_WHOLE_NUMBERS]: "Z",
+	[TokenID.MULTIPLY]: "*",
+	[TokenID.EQUAL]: "=",
+	[TokenID.NOTEQUAL]: "≠",
+	[TokenID.GREATER_OR_EQ]: "≥",
+	[TokenID.LESSER_OR_EQ]: "≤",
+	[TokenID.SET_IN]: "∈",
+	[TokenID.SET_NOT_IN]: "∉",
+	[TokenID.SUBSET_OR_EQ]: "⊆",
+	[TokenID.SUBSET]: "⊂",
+	[TokenID.NOT_SUBSET]: "⊄",
+	[TokenID.SET_INTERSECTION]: "∩",
+	[TokenID.SET_UNION]: "∪",
+	[TokenID.SET_MINUS]: "\\",
+	[TokenID.SET_SYMMETRIC_MINUS]: "∆",
+	[TokenID.BOOLEAN]: "ℬ()",
+	[TokenID.NT_DECLARATIVE_EXPR]: "D{}",
+	[TokenID.NT_IMPERATIVE_EXPR]: "I{}",
+	[TokenID.NT_RECURSIVE_FULL]: "R{}",
+	[TokenID.BIGPR]: "Pr1()",
+	[TokenID.SMALLPR]: "pr1()",
+	[TokenID.FILTER]: "Fi1[]()",
+	[TokenID.REDUCE]: "red()",
+	[TokenID.CARD]: "card()",
+	[TokenID.BOOL]: "bool()",
+	[TokenID.DEBOOL]: "debool()",
+	[TokenID.ASSIGN]: ":=",
+	[TokenID.ITERATE]: ":∈"
 };
+/** Retrieves label for {@link TokenID}. */
 function labelToken(id) {
-  const text = labelTokenRecord[id];
-  return text ?? "UNKNOWN TOKEN: " + String(id);
+	return labelTokenRecord[id] ?? "UNKNOWN TOKEN: " + String(id);
 }
+/** Generates label for {@link AstNodeBase}. */
 function labelRSLangNode(node) {
-  switch (node.typeID) {
-    case TokenID.ERROR:
-      return "[ERROR]";
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_GLOBAL:
-    case TokenID.ID_FUNCTION:
-    case TokenID.ID_PREDICATE:
-    case TokenID.ID_RADICAL:
-      return node.data.value;
-    case TokenID.LIT_INTEGER:
-      return String(node.data.value);
-    case TokenID.BIGPR:
-      return "Pr" + node.data.value.toString();
-    case TokenID.SMALLPR:
-      return "pr" + node.data.value.toString();
-    case TokenID.FILTER:
-      return "Fi" + node.data.value.toString();
-    case TokenID.NT_DECLARATIVE_EXPR:
-      return "DECLARATIVE";
-    case TokenID.NT_IMPERATIVE_EXPR:
-      return "IMPERATIVE";
-    case TokenID.NT_RECURSIVE_FULL:
-      return "RECURSIVE";
-    case TokenID.NT_RECURSIVE_SHORT:
-      return "RECURSIVE";
-    case TokenID.BOOLEAN:
-      return "\u212C";
-    case TokenID.REDUCE:
-      return "red";
-    case TokenID.CARD:
-      return "card";
-    case TokenID.BOOL:
-      return "bool";
-    case TokenID.DEBOOL:
-      return "debool";
-    case TokenID.PLUS:
-      return "+";
-    case TokenID.MINUS:
-      return "-";
-    case TokenID.MULTIPLY:
-      return "*";
-    case TokenID.GREATER:
-      return ">";
-    case TokenID.LESSER:
-      return "<";
-    case TokenID.NT_TUPLE:
-      return "TUPLE";
-    case TokenID.NT_ENUMERATION:
-      return "ENUM";
-    case TokenID.NT_ENUM_DECL:
-      return "ENUM_DECLARE";
-    case TokenID.NT_TUPLE_DECL:
-      return "TUPLE_DECLARE";
-    case TokenID.PUNCTUATION_DEFINE:
-      return "DEFINITION";
-    case TokenID.PUNCTUATION_STRUCT:
-      return "STRUCTURE_DEFINE";
-    case TokenID.NT_ARG_DECL:
-      return "ARG";
-    case TokenID.NT_FUNC_CALL:
-      return "CALL";
-    case TokenID.NT_ARGUMENTS:
-      return "ARGS";
-    case TokenID.NT_FUNC_DEFINITION:
-      return "FUNCTION_DEFINE";
-    case TokenID.DECART:
-    case TokenID.QUANTOR_UNIVERSAL:
-    case TokenID.QUANTOR_EXISTS:
-    case TokenID.LOGIC_NOT:
-    case TokenID.LOGIC_AND:
-    case TokenID.LOGIC_OR:
-    case TokenID.LOGIC_IMPLICATION:
-    case TokenID.LOGIC_EQUIVALENT:
-    case TokenID.LIT_EMPTYSET:
-    case TokenID.LIT_WHOLE_NUMBERS:
-    case TokenID.EQUAL:
-    case TokenID.NOTEQUAL:
-    case TokenID.GREATER_OR_EQ:
-    case TokenID.LESSER_OR_EQ:
-    case TokenID.SET_IN:
-    case TokenID.SET_NOT_IN:
-    case TokenID.SUBSET_OR_EQ:
-    case TokenID.SUBSET:
-    case TokenID.NOT_SUBSET:
-    case TokenID.SET_INTERSECTION:
-    case TokenID.SET_UNION:
-    case TokenID.SET_MINUS:
-    case TokenID.SET_SYMMETRIC_MINUS:
-    case TokenID.ASSIGN:
-    case TokenID.ITERATE:
-      return labelToken(node.typeID);
-  }
-  if (node.data.value) {
-    return node.data.value;
-  }
-  return "UNKNOWN NODE: " + String(node.typeID);
+	switch (node.typeID) {
+		case TokenID.ERROR: return "[ERROR]";
+		case TokenID.ID_LOCAL:
+		case TokenID.ID_GLOBAL:
+		case TokenID.ID_FUNCTION:
+		case TokenID.ID_PREDICATE:
+		case TokenID.ID_RADICAL: return node.data.value;
+		case TokenID.LIT_INTEGER: return String(node.data.value);
+		case TokenID.BIGPR: return "Pr" + node.data.value.toString();
+		case TokenID.SMALLPR: return "pr" + node.data.value.toString();
+		case TokenID.FILTER: return "Fi" + node.data.value.toString();
+		case TokenID.NT_DECLARATIVE_EXPR: return "DECLARATIVE";
+		case TokenID.NT_IMPERATIVE_EXPR: return "IMPERATIVE";
+		case TokenID.NT_RECURSIVE_FULL: return "RECURSIVE";
+		case TokenID.NT_RECURSIVE_SHORT: return "RECURSIVE";
+		case TokenID.BOOLEAN: return "ℬ";
+		case TokenID.REDUCE: return "red";
+		case TokenID.CARD: return "card";
+		case TokenID.BOOL: return "bool";
+		case TokenID.DEBOOL: return "debool";
+		case TokenID.PLUS: return "+";
+		case TokenID.MINUS: return "-";
+		case TokenID.MULTIPLY: return "*";
+		case TokenID.GREATER: return ">";
+		case TokenID.LESSER: return "<";
+		case TokenID.NT_TUPLE: return "TUPLE";
+		case TokenID.NT_ENUMERATION: return "ENUM";
+		case TokenID.NT_ENUM_DECL: return "ENUM_DECLARE";
+		case TokenID.NT_TUPLE_DECL: return "TUPLE_DECLARE";
+		case TokenID.PUNCTUATION_DEFINE: return "DEFINITION";
+		case TokenID.PUNCTUATION_STRUCT: return "STRUCTURE_DEFINE";
+		case TokenID.NT_ARG_DECL: return "ARG";
+		case TokenID.NT_FUNC_CALL: return "CALL";
+		case TokenID.NT_ARGUMENTS: return "ARGS";
+		case TokenID.NT_FUNC_DEFINITION: return "FUNCTION_DEFINE";
+		case TokenID.DECART:
+		case TokenID.QUANTOR_UNIVERSAL:
+		case TokenID.QUANTOR_EXISTS:
+		case TokenID.LOGIC_NOT:
+		case TokenID.LOGIC_AND:
+		case TokenID.LOGIC_OR:
+		case TokenID.LOGIC_IMPLICATION:
+		case TokenID.LOGIC_EQUIVALENT:
+		case TokenID.LIT_EMPTYSET:
+		case TokenID.LIT_WHOLE_NUMBERS:
+		case TokenID.EQUAL:
+		case TokenID.NOTEQUAL:
+		case TokenID.GREATER_OR_EQ:
+		case TokenID.LESSER_OR_EQ:
+		case TokenID.SET_IN:
+		case TokenID.SET_NOT_IN:
+		case TokenID.SUBSET_OR_EQ:
+		case TokenID.SUBSET:
+		case TokenID.NOT_SUBSET:
+		case TokenID.SET_INTERSECTION:
+		case TokenID.SET_UNION:
+		case TokenID.SET_MINUS:
+		case TokenID.SET_SYMMETRIC_MINUS:
+		case TokenID.ASSIGN:
+		case TokenID.ITERATE: return labelToken(node.typeID);
+	}
+	if (node.data.value) return node.data.value;
+	return "UNKNOWN NODE: " + String(node.typeID);
 }
+/** Converts expression type to string. */
 function labelType(type) {
-  if (!type) {
-    return "N/A";
-  }
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-      return ANY_TYPE_NAME;
-    case TypeID.integer:
-      return INTEGER_TYPE_NAME;
-    case TypeID.basic:
-      return type.baseID;
-    case TypeID.tuple:
-      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
-    case TypeID.collection:
-      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
-    case TypeID.logic:
-      return LOGIC_TYPE_NAME;
-    case TypeID.predicate:
-    case TypeID.function:
-      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
-      return `[${argsText}] \u2192 ${labelType(type.result)}`;
-  }
+	if (!type) return "N/A";
+	switch (type.typeID) {
+		case TypeID.anyTypification: return ANY_TYPE_NAME;
+		case TypeID.integer: return INTEGER_TYPE_NAME;
+		case TypeID.basic: return type.baseID;
+		case TypeID.tuple: return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("×");
+		case TypeID.collection: return type.base.typeID === TypeID.collection ? `ℬ${labelType(type.base)}` : `ℬ(${labelType(type.base)})`;
+		case TypeID.logic: return LOGIC_TYPE_NAME;
+		case TypeID.predicate:
+		case TypeID.function: return `[${type.args.map((arg) => labelType(arg.type)).join(", ")}] → ${labelType(type.result)}`;
+	}
 }
+/** Converts expression type to normalized string. */
 function normalizeType(type) {
-  if (!type) {
-    return "N/A";
-  }
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-      return ANY_TYPE_NAME;
-    case TypeID.integer:
-    case TypeID.basic:
-      return "X1";
-    case TypeID.tuple:
-      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)).join("\xD7");
-    case TypeID.collection:
-      return type.base.typeID === TypeID.collection ? `\u212C${normalizeType(type.base)}` : `\u212C(${normalizeType(type.base)})`;
-    case TypeID.logic:
-      return LOGIC_TYPE_NAME;
-    case TypeID.predicate:
-    case TypeID.function:
-      const argsText = type.args.map((arg) => normalizeType(arg.type)).join(", ");
-      return `[${argsText}] \u2192 ${normalizeType(type.result)}`;
-  }
+	if (!type) return "N/A";
+	switch (type.typeID) {
+		case TypeID.anyTypification: return ANY_TYPE_NAME;
+		case TypeID.integer:
+		case TypeID.basic: return "X1";
+		case TypeID.tuple: return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)).join("×");
+		case TypeID.collection: return type.base.typeID === TypeID.collection ? `ℬ${normalizeType(type.base)}` : `ℬ(${normalizeType(type.base)})`;
+		case TypeID.logic: return LOGIC_TYPE_NAME;
+		case TypeID.predicate:
+		case TypeID.function: return `[${type.args.map((arg) => normalizeType(arg.type)).join(", ")}] → ${normalizeType(type.result)}`;
+	}
 }
-export {
-  labelRSLangNode,
-  labelToken,
-  labelType,
-  normalizeType
-};
+//#endregion
+export { labelRSLangNode, labelToken, labelType, normalizeType };
+
 //# sourceMappingURL=labels.js.map

package/dist/rslang/labels.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/parsing/ast.ts","../../src/rslang/parser/token.ts","../../src/rslang/semantic/typification.ts","../../src/rslang/labels.ts"],"sourcesContent":["import { type TreeCursor } from './lezer-tree';\n\nexport const TOKEN_ERROR = 0;\n\n/** Represents AST node data. */\ninterface AstNodeData extends Record<string, unknown> {\n  dataType: string;\n  value: unknown;\n}\n\n/** Represents AST structured node base. */\nexport interface AstNodeBase {\n  typeID: number;\n  data: AstNodeData;\n  annotation?: Record<string, unknown>;\n}\n\n/** Represents AST structured node. */\nexport interface AstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  from: number;\n  to: number;\n  hasError: boolean;\n  parenthesis?: boolean;\n  parent: AstNode | null;\n  children: AstNode[];\n}\n\n/** Represents AST node. */\nexport interface FlatAstNode extends Record<string, unknown>, AstNodeBase {\n  uid: number;\n  parent: number | null;\n  from: number;\n  to: number;\n}\n\n/** Represents Syntax tree flat representation. */\nexport type FlatAST = FlatAstNode[];\n\n/** Builds AST tree from a given tree cursor, generating unique uids for each node. */\nexport function buildTree(cursor: TreeCursor): AstNode {\n  let nextUid = 1;\n  function genUid() {\n    return nextUid++;\n  }\n  return buildTreeInternal(cursor, null, genUid);\n}\n\n/** Flattens AST tree to a array form. */\nexport function flattenAst(node: AstNode, parent: number | null = null, out: FlatAST = []): FlatAST {\n  out.push({\n    uid: node.uid,\n    parent: parent,\n    typeID: node.typeID,\n    from: node.from,\n    to: node.to,\n    data: node.data,\n    annotation: node.annotation\n  });\n  for (const child of node.children) {\n    flattenAst(child, node.uid, out);\n  }\n  return out;\n}\n\n/** Visits AST tree in depth-first order. */\nexport function visitAstDFS(node: AstNode, callback: (node: AstNode) => void) {\n  for (const child of node.children) {\n    visitAstDFS(child, callback);\n  }\n  callback(node);\n}\n\n/** Finds and returns the AstNode with the given ui. */\nexport function findByUid(root: AstNode, uid: number): AstNode | null {\n  let found: AstNode | null = null;\n  visitAstDFS(root, node => {\n    if (node.uid === uid && !found) {\n      found = node;\n    }\n  });\n  return found;\n}\n\n/** Prints AST tree. */\nexport function printAst(node: AstNode, printNode: (node: AstNode) => string): string {\n  let children: string = '';\n  for (const child of node.children) {\n    children += `${printAst(child, printNode)}`;\n  }\n  return `[${printNode(node)}${children}]`;\n}\n\n/** Extracts node text. */\nexport function getNodeText(node: AstNode): string {\n  if (node.data.dataType === 'string' && typeof node.data.value === 'string') {\n    return node.data.value;\n  }\n  return `NO DATA NODE: ${node.typeID}`;\n}\n\n/** Extracts node indices. */\nexport function getNodeIndices(node: AstNode): number[] {\n  if (node.data.dataType === 'string[]' && Array.isArray(node.data.value)) {\n    return (node.data.value as string[]).map(s => parseInt(s, 10)).filter(n => !isNaN(n));\n  }\n  return [];\n}\n\n// ======== Internals ========\nfunction buildTreeInternal(cursor: TreeCursor, parent: AstNode | null = null, genUid: () => number): AstNode {\n  const node = cursor.node;\n\n  const result: AstNode = {\n    uid: genUid(),\n    typeID: node.type.isError ? 0 : node.type.id,\n    from: node.from,\n    to: node.to,\n    hasError: node.type.isError,\n    data: node.type.isError ? { dataType: 'null', value: null } : { dataType: 'string', value: node.type.name },\n    parent,\n    children: []\n  };\n\n  if (cursor.firstChild()) {\n    do {\n      const child = buildTreeInternal(cursor, result, genUid);\n      if (child.hasError) {\n        result.hasError = true;\n      }\n      result.children.push(child);\n    } while (cursor.nextSibling());\n    cursor.parent();\n  }\n  return result;\n}\n","import { TOKEN_ERROR } from '../../parsing';\n\n/** Represents RSLang token types. */\nexport const TokenID = {\n  // Global, local IDs and literals\n  ERROR: TOKEN_ERROR,\n\n  ID_LOCAL: 258,\n  ID_GLOBAL: 259,\n  ID_FUNCTION: 260,\n  ID_PREDICATE: 261,\n  ID_RADICAL: 262,\n  LIT_INTEGER: 263,\n  LIT_WHOLE_NUMBERS: 264,\n  LIT_EMPTYSET: 265,\n\n  // Arithmetic\n  PLUS: 266,\n  MINUS: 267,\n  MULTIPLY: 268,\n\n  // Integer predicate symbols\n  GREATER: 269,\n  LESSER: 270,\n  GREATER_OR_EQ: 271,\n  LESSER_OR_EQ: 272,\n\n  // Equality comparison\n  EQUAL: 273,\n  NOTEQUAL: 274,\n\n  // Logic predicate symbols\n  QUANTOR_UNIVERSAL: 275,\n  QUANTOR_EXISTS: 276,\n  LOGIC_NOT: 277,\n  LOGIC_EQUIVALENT: 278,\n  LOGIC_IMPLICATION: 279,\n  LOGIC_OR: 280,\n  LOGIC_AND: 281,\n\n  // Set theory predicate symbols\n  SET_IN: 282,\n  SET_NOT_IN: 283,\n  SUBSET: 284,\n  SUBSET_OR_EQ: 285,\n  NOT_SUBSET: 286,\n\n  // Set theory operators\n  DECART: 287,\n  SET_UNION: 288,\n  SET_INTERSECTION: 289,\n  SET_MINUS: 290,\n  SET_SYMMETRIC_MINUS: 291,\n  BOOLEAN: 292,\n\n  // Structure operations\n  BIGPR: 293,\n  SMALLPR: 294,\n  FILTER: 295,\n  CARD: 296,\n  BOOL: 297,\n  DEBOOL: 298,\n  REDUCE: 299,\n\n  // Term constructions prefixes\n  DECLARATIVE: 300,\n  RECURSIVE: 301,\n  IMPERATIVE: 302,\n\n  ITERATE: 303,\n  ASSIGN: 304,\n\n  // Punctuation\n  PUNCTUATION_DEFINE: 305,\n  PUNCTUATION_STRUCT: 306,\n  PUNCTUATION_PL: 307,\n  PUNCTUATION_PR: 308,\n  PUNCTUATION_CL: 309,\n  PUNCTUATION_CR: 310,\n  PUNCTUATION_SL: 311,\n  PUNCTUATION_SR: 312,\n  PUNCTUATION_BAR: 313,\n  PUNCTUATION_COMMA: 314,\n  PUNCTUATION_SEMICOLON: 315,\n\n  // ======= Non-terminal tokens =========\n  NT_ENUM_DECL: 316,\n  NT_TUPLE: 317,\n  NT_ENUMERATION: 318,\n  NT_TUPLE_DECL: 319,\n  NT_ARG_DECL: 320,\n\n  NT_FUNC_DEFINITION: 321,\n  NT_ARGUMENTS: 322,\n  NT_FUNC_CALL: 323,\n\n  NT_DECLARATIVE_EXPR: 324,\n  NT_IMPERATIVE_EXPR: 325,\n  NT_RECURSIVE_FULL: 326,\n  NT_RECURSIVE_SHORT: 327,\n\n  // ======= Helper tokens ========\n  INTERRUPT: 328,\n  END: 329\n} as const;\nexport type TokenID = (typeof TokenID)[keyof typeof TokenID];\n","/*\n * Module: Typification for RSLang.\n */\n\nimport { type Branded } from '../../shared';\n\n/** Typification structure enumeration. */\nexport const TypeID = {\n  anyTypification: 1,\n  integer: 2,\n  basic: 3,\n  tuple: 4,\n  collection: 5,\n  logic: 6,\n  function: 7,\n  predicate: 8\n} as const;\nexport type TypeID = (typeof TypeID)[keyof typeof TypeID];\n\n/** Represents type class. */\nexport const TypeClass = {\n  logic: 1,\n  typification: 2,\n  function: 3,\n  predicate: 4\n} as const;\nexport type TypeClass = (typeof TypeClass)[keyof typeof TypeClass];\n\n/** Logic type object. */\nexport const LogicT = { typeID: TypeID.logic } as const;\n\n/** Integer type object. */\nexport const IntegerT = {\n  typeID: TypeID.integer,\n  isOrdered: true,\n  isArithmetic: true,\n  isIntegerCompatible: true\n} as const;\n\n/** Type transformation path. */\nexport type TypePath = Branded<number[], 'TypePath'>;\n\n/** Creates type path. */\nexport function makeTypePath(path: number[]): TypePath {\n  return path as TypePath;\n}\n\n/** AnyTyped type object. */\nexport const AnyTypificationT = { typeID: TypeID.anyTypification } as const;\n\n/** Empty set typification. */\nexport const EmptySetT = bool(AnyTypificationT);\n\n/** Parametrized typification. */\nexport type Parametrized = EchelonFunctional | EchelonPredicate;\n\n/** General expression types. */\nexport type ExpressionType =\n  | EchelonLogic\n  | EchelonBase\n  | EchelonTuple\n  | EchelonCollection\n  | EchelonFunctional\n  | EchelonPredicate\n  | EchelonAnyTyped\n  | EchelonInteger;\n\n/** Setexpr type. */\nexport type Typification = EchelonBase | EchelonAnyTyped | EchelonInteger | EchelonCollection | EchelonTuple;\n\n/** Typification context. */\nexport type TypeContext = Map<string, ExpressionType>;\n\n/** Functional argument. */\nexport interface Argument {\n  readonly alias: string;\n  readonly type: Typification;\n}\n\n/** Type: Logic. */\nexport interface EchelonLogic {\n  readonly typeID: typeof TypeID.logic;\n}\n\n/** Type: AnyTyped. */\nexport interface EchelonAnyTyped {\n  readonly typeID: typeof TypeID.anyTypification;\n}\n\n/** Type: Integer. */\nexport interface EchelonInteger {\n  readonly typeID: typeof TypeID.integer;\n  readonly isOrdered: true;\n  readonly isArithmetic: true;\n  readonly isIntegerCompatible: true;\n}\n\n/** Type: Element of basic set. */\nexport interface EchelonBase {\n  readonly typeID: typeof TypeID.basic;\n  readonly baseID: string;\n  readonly isOrdered?: boolean;\n  readonly isArithmetic?: boolean;\n  readonly isIntegerCompatible?: boolean;\n}\n\n/** Type: Tuple. */\nexport interface EchelonTuple {\n  readonly typeID: typeof TypeID.tuple;\n  readonly factors: readonly Typification[];\n}\n\n/** Type: Collection. */\nexport interface EchelonCollection {\n  readonly typeID: typeof TypeID.collection;\n  readonly base: Typification;\n}\n\n/** Type: Functional. */\nexport interface EchelonFunctional {\n  readonly typeID: typeof TypeID.function;\n  readonly result: Typification;\n  readonly args: readonly Argument[];\n}\n\n/** Type: Predicate. */\nexport interface EchelonPredicate {\n  readonly typeID: typeof TypeID.predicate;\n  readonly result: EchelonLogic;\n  readonly args: readonly Argument[];\n}\n\n/** Create basic element typification. */\nexport function basic(alias: string): EchelonBase {\n  return { typeID: TypeID.basic, baseID: alias };\n}\n\n/** Create constant element typification. */\nexport function constant(alias: string): EchelonBase {\n  return { typeID: TypeID.basic, baseID: alias, isOrdered: true, isArithmetic: true, isIntegerCompatible: true };\n}\n\n/** Create boolean typification. */\nexport function bool(base: Typification): EchelonCollection {\n  return { typeID: TypeID.collection, base };\n}\n\n/** Create tuple typification. */\nexport function tuple(factors: Typification[]): EchelonTuple {\n  if (factors.length < 2) {\n    throw new Error('Tuple with less than two factors is not allowed');\n  }\n  return { typeID: TypeID.tuple, factors };\n}\n\n/** Remove boolean from typification. */\nexport function debool(target: EchelonCollection): Typification {\n  return target.base;\n}\n\n/** Extract component from tuple. */\nexport function component(target: EchelonTuple, index: number): Typification | null {\n  return target.factors[index - 1] ?? null;\n}\n\n/** Checks if given type is typification. */\nexport function isTypification(type: ExpressionType | null): boolean {\n  return (\n    type?.typeID === TypeID.basic ||\n    type?.typeID === TypeID.anyTypification ||\n    type?.typeID === TypeID.integer ||\n    type?.typeID === TypeID.collection ||\n    type?.typeID === TypeID.tuple\n  );\n}\n\n/** Checks if given type is radical. */\nexport function isRadical(alias: string): boolean {\n  return alias.length > 0 && alias.startsWith('R') && alias[1] !== '0';\n}\n","import { type AstNodeBase } from '../parsing';\n\nimport { TokenID } from './parser/token';\nimport { type ExpressionType, TypeID } from './semantic/typification';\n\nconst INTEGER_TYPE_NAME = 'Z';\nconst ANY_TYPE_NAME = 'R0';\nconst LOGIC_TYPE_NAME = 'Logic';\n\nconst labelTokenRecord: Partial<Record<TokenID, string>> = {\n  [TokenID.DECART]: '×',\n  [TokenID.PUNCTUATION_PL]: '( )',\n  [TokenID.PUNCTUATION_SL]: '[ ]',\n  [TokenID.QUANTOR_UNIVERSAL]: '∀',\n  [TokenID.QUANTOR_EXISTS]: '∃',\n  [TokenID.LOGIC_NOT]: '¬',\n  [TokenID.LOGIC_AND]: '&',\n  [TokenID.LOGIC_OR]: '∨',\n  [TokenID.LOGIC_IMPLICATION]: '⇒',\n  [TokenID.LOGIC_EQUIVALENT]: '⇔',\n  [TokenID.LIT_EMPTYSET]: '∅',\n  [TokenID.LIT_WHOLE_NUMBERS]: 'Z',\n  [TokenID.MULTIPLY]: '*',\n  [TokenID.EQUAL]: '=',\n  [TokenID.NOTEQUAL]: '≠',\n  [TokenID.GREATER_OR_EQ]: '≥',\n  [TokenID.LESSER_OR_EQ]: '≤',\n  [TokenID.SET_IN]: '∈',\n  [TokenID.SET_NOT_IN]: '∉',\n  [TokenID.SUBSET_OR_EQ]: '⊆',\n  [TokenID.SUBSET]: '⊂',\n  [TokenID.NOT_SUBSET]: '⊄',\n  [TokenID.SET_INTERSECTION]: '∩',\n  [TokenID.SET_UNION]: '∪',\n  [TokenID.SET_MINUS]: '\\\\',\n  [TokenID.SET_SYMMETRIC_MINUS]: '∆',\n  [TokenID.BOOLEAN]: 'ℬ()',\n  [TokenID.NT_DECLARATIVE_EXPR]: 'D{}',\n  [TokenID.NT_IMPERATIVE_EXPR]: 'I{}',\n  [TokenID.NT_RECURSIVE_FULL]: 'R{}',\n  [TokenID.BIGPR]: 'Pr1()',\n  [TokenID.SMALLPR]: 'pr1()',\n  [TokenID.FILTER]: 'Fi1[]()',\n  [TokenID.REDUCE]: 'red()',\n  [TokenID.CARD]: 'card()',\n  [TokenID.BOOL]: 'bool()',\n  [TokenID.DEBOOL]: 'debool()',\n  [TokenID.ASSIGN]: ':=',\n  [TokenID.ITERATE]: ':∈'\n};\n\n/** Retrieves label for {@link TokenID}. */\nexport function labelToken(id: TokenID): string {\n  const text = labelTokenRecord[id];\n  return text ?? 'UNKNOWN TOKEN: ' + String(id);\n}\n\n/** Generates label for {@link AstNodeBase}. */\nexport function labelRSLangNode(node: AstNodeBase): string {\n  // prettier-ignore\n  switch (node.typeID) {\n    case TokenID.ERROR: return '[ERROR]';\n    case TokenID.ID_LOCAL:\n    case TokenID.ID_GLOBAL:\n    case TokenID.ID_FUNCTION:\n    case TokenID.ID_PREDICATE:\n    case TokenID.ID_RADICAL:\n      return node.data.value as string;\n\n    case TokenID.LIT_INTEGER: return String(node.data.value);\n\n    case TokenID.BIGPR: return 'Pr' + (node.data.value as string[]).toString();\n    case TokenID.SMALLPR: return 'pr' + (node.data.value as string[]).toString();\n    case TokenID.FILTER: return 'Fi' + (node.data.value as string[]).toString();\n\n    case TokenID.NT_DECLARATIVE_EXPR: return 'DECLARATIVE';\n    case TokenID.NT_IMPERATIVE_EXPR: return 'IMPERATIVE';\n    case TokenID.NT_RECURSIVE_FULL: return 'RECURSIVE';\n    case TokenID.NT_RECURSIVE_SHORT: return 'RECURSIVE';\n\n    case TokenID.BOOLEAN: return 'ℬ';\n    case TokenID.REDUCE: return 'red';\n    case TokenID.CARD: return 'card';\n    case TokenID.BOOL: return 'bool';\n    case TokenID.DEBOOL: return 'debool';\n\n    case TokenID.PLUS: return '+';\n    case TokenID.MINUS: return '-';\n    case TokenID.MULTIPLY: return '*';\n    case TokenID.GREATER: return '>';\n    case TokenID.LESSER: return '<';\n\n    case TokenID.NT_TUPLE: return 'TUPLE';\n    case TokenID.NT_ENUMERATION: return 'ENUM';\n\n    case TokenID.NT_ENUM_DECL: return 'ENUM_DECLARE';\n    case TokenID.NT_TUPLE_DECL: return 'TUPLE_DECLARE';\n    case TokenID.PUNCTUATION_DEFINE: return 'DEFINITION';\n    case TokenID.PUNCTUATION_STRUCT: return 'STRUCTURE_DEFINE';\n\n    case TokenID.NT_ARG_DECL: return 'ARG';\n    case TokenID.NT_FUNC_CALL: return 'CALL';\n    case TokenID.NT_ARGUMENTS: return 'ARGS';\n\n    case TokenID.NT_FUNC_DEFINITION: return 'FUNCTION_DEFINE';\n\n    case TokenID.DECART:\n    case TokenID.QUANTOR_UNIVERSAL:\n    case TokenID.QUANTOR_EXISTS:\n    case TokenID.LOGIC_NOT:\n    case TokenID.LOGIC_AND:\n    case TokenID.LOGIC_OR:\n    case TokenID.LOGIC_IMPLICATION:\n    case TokenID.LOGIC_EQUIVALENT:\n    case TokenID.LIT_EMPTYSET:\n    case TokenID.LIT_WHOLE_NUMBERS:\n    case TokenID.EQUAL:\n    case TokenID.NOTEQUAL:\n    case TokenID.GREATER_OR_EQ:\n    case TokenID.LESSER_OR_EQ:\n    case TokenID.SET_IN:\n    case TokenID.SET_NOT_IN:\n    case TokenID.SUBSET_OR_EQ:\n    case TokenID.SUBSET:\n    case TokenID.NOT_SUBSET:\n    case TokenID.SET_INTERSECTION:\n    case TokenID.SET_UNION:\n    case TokenID.SET_MINUS:\n    case TokenID.SET_SYMMETRIC_MINUS:\n    case TokenID.ASSIGN:\n    case TokenID.ITERATE:\n      return labelToken(node.typeID);\n  }\n  if (node.data.value) {\n    return node.data.value as string;\n  }\n  return 'UNKNOWN NODE: ' + String(node.typeID);\n}\n\n/** Converts expression type to string. */\nexport function labelType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n      return INTEGER_TYPE_NAME;\n    case TypeID.basic:\n      return type.baseID;\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${labelType(type.base)}` : `ℬ(${labelType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => labelType(arg.type)).join(', ');\n      return `[${argsText}] → ${labelType(type.result)}`;\n  }\n}\n\n/** Converts expression type to normalized string. */\nexport function normalizeType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n    case TypeID.basic:\n      return 'X1';\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${normalizeType(type.base)}` : `ℬ(${normalizeType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => normalizeType(arg.type)).join(', ');\n      return `[${argsText}] → ${normalizeType(type.result)}`;\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"file":"labels.js","names":[],"sources":["../../src/rslang/labels.ts"],"sourcesContent":["import { type AstNodeBase } from '../parsing';\n\nimport { TokenID } from './parser/token';\nimport { type ExpressionType, TypeID } from './semantic/typification';\n\nconst INTEGER_TYPE_NAME = 'Z';\nconst ANY_TYPE_NAME = 'R0';\nconst LOGIC_TYPE_NAME = 'Logic';\n\nconst labelTokenRecord: Partial<Record<TokenID, string>> = {\n  [TokenID.DECART]: '×',\n  [TokenID.PUNCTUATION_PL]: '( )',\n  [TokenID.PUNCTUATION_SL]: '[ ]',\n  [TokenID.QUANTOR_UNIVERSAL]: '∀',\n  [TokenID.QUANTOR_EXISTS]: '∃',\n  [TokenID.LOGIC_NOT]: '¬',\n  [TokenID.LOGIC_AND]: '&',\n  [TokenID.LOGIC_OR]: '∨',\n  [TokenID.LOGIC_IMPLICATION]: '⇒',\n  [TokenID.LOGIC_EQUIVALENT]: '⇔',\n  [TokenID.LIT_EMPTYSET]: '∅',\n  [TokenID.LIT_WHOLE_NUMBERS]: 'Z',\n  [TokenID.MULTIPLY]: '*',\n  [TokenID.EQUAL]: '=',\n  [TokenID.NOTEQUAL]: '≠',\n  [TokenID.GREATER_OR_EQ]: '≥',\n  [TokenID.LESSER_OR_EQ]: '≤',\n  [TokenID.SET_IN]: '∈',\n  [TokenID.SET_NOT_IN]: '∉',\n  [TokenID.SUBSET_OR_EQ]: '⊆',\n  [TokenID.SUBSET]: '⊂',\n  [TokenID.NOT_SUBSET]: '⊄',\n  [TokenID.SET_INTERSECTION]: '∩',\n  [TokenID.SET_UNION]: '∪',\n  [TokenID.SET_MINUS]: '\\\\',\n  [TokenID.SET_SYMMETRIC_MINUS]: '∆',\n  [TokenID.BOOLEAN]: 'ℬ()',\n  [TokenID.NT_DECLARATIVE_EXPR]: 'D{}',\n  [TokenID.NT_IMPERATIVE_EXPR]: 'I{}',\n  [TokenID.NT_RECURSIVE_FULL]: 'R{}',\n  [TokenID.BIGPR]: 'Pr1()',\n  [TokenID.SMALLPR]: 'pr1()',\n  [TokenID.FILTER]: 'Fi1[]()',\n  [TokenID.REDUCE]: 'red()',\n  [TokenID.CARD]: 'card()',\n  [TokenID.BOOL]: 'bool()',\n  [TokenID.DEBOOL]: 'debool()',\n  [TokenID.ASSIGN]: ':=',\n  [TokenID.ITERATE]: ':∈'\n};\n\n/** Retrieves label for {@link TokenID}. */\nexport function labelToken(id: TokenID): string {\n  const text = labelTokenRecord[id];\n  return text ?? 'UNKNOWN TOKEN: ' + String(id);\n}\n\n/** Generates label for {@link AstNodeBase}. */\nexport function labelRSLangNode(node: AstNodeBase): string {\n  // prettier-ignore\n  switch (node.typeID) {\n    case TokenID.ERROR: return '[ERROR]';\n    case TokenID.ID_LOCAL:\n    case TokenID.ID_GLOBAL:\n    case TokenID.ID_FUNCTION:\n    case TokenID.ID_PREDICATE:\n    case TokenID.ID_RADICAL:\n      return node.data.value as string;\n\n    case TokenID.LIT_INTEGER: return String(node.data.value);\n\n    case TokenID.BIGPR: return 'Pr' + (node.data.value as string[]).toString();\n    case TokenID.SMALLPR: return 'pr' + (node.data.value as string[]).toString();\n    case TokenID.FILTER: return 'Fi' + (node.data.value as string[]).toString();\n\n    case TokenID.NT_DECLARATIVE_EXPR: return 'DECLARATIVE';\n    case TokenID.NT_IMPERATIVE_EXPR: return 'IMPERATIVE';\n    case TokenID.NT_RECURSIVE_FULL: return 'RECURSIVE';\n    case TokenID.NT_RECURSIVE_SHORT: return 'RECURSIVE';\n\n    case TokenID.BOOLEAN: return 'ℬ';\n    case TokenID.REDUCE: return 'red';\n    case TokenID.CARD: return 'card';\n    case TokenID.BOOL: return 'bool';\n    case TokenID.DEBOOL: return 'debool';\n\n    case TokenID.PLUS: return '+';\n    case TokenID.MINUS: return '-';\n    case TokenID.MULTIPLY: return '*';\n    case TokenID.GREATER: return '>';\n    case TokenID.LESSER: return '<';\n\n    case TokenID.NT_TUPLE: return 'TUPLE';\n    case TokenID.NT_ENUMERATION: return 'ENUM';\n\n    case TokenID.NT_ENUM_DECL: return 'ENUM_DECLARE';\n    case TokenID.NT_TUPLE_DECL: return 'TUPLE_DECLARE';\n    case TokenID.PUNCTUATION_DEFINE: return 'DEFINITION';\n    case TokenID.PUNCTUATION_STRUCT: return 'STRUCTURE_DEFINE';\n\n    case TokenID.NT_ARG_DECL: return 'ARG';\n    case TokenID.NT_FUNC_CALL: return 'CALL';\n    case TokenID.NT_ARGUMENTS: return 'ARGS';\n\n    case TokenID.NT_FUNC_DEFINITION: return 'FUNCTION_DEFINE';\n\n    case TokenID.DECART:\n    case TokenID.QUANTOR_UNIVERSAL:\n    case TokenID.QUANTOR_EXISTS:\n    case TokenID.LOGIC_NOT:\n    case TokenID.LOGIC_AND:\n    case TokenID.LOGIC_OR:\n    case TokenID.LOGIC_IMPLICATION:\n    case TokenID.LOGIC_EQUIVALENT:\n    case TokenID.LIT_EMPTYSET:\n    case TokenID.LIT_WHOLE_NUMBERS:\n    case TokenID.EQUAL:\n    case TokenID.NOTEQUAL:\n    case TokenID.GREATER_OR_EQ:\n    case TokenID.LESSER_OR_EQ:\n    case TokenID.SET_IN:\n    case TokenID.SET_NOT_IN:\n    case TokenID.SUBSET_OR_EQ:\n    case TokenID.SUBSET:\n    case TokenID.NOT_SUBSET:\n    case TokenID.SET_INTERSECTION:\n    case TokenID.SET_UNION:\n    case TokenID.SET_MINUS:\n    case TokenID.SET_SYMMETRIC_MINUS:\n    case TokenID.ASSIGN:\n    case TokenID.ITERATE:\n      return labelToken(node.typeID);\n  }\n  if (node.data.value) {\n    return node.data.value as string;\n  }\n  return 'UNKNOWN NODE: ' + String(node.typeID);\n}\n\n/** Converts expression type to string. */\nexport function labelType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n      return INTEGER_TYPE_NAME;\n    case TypeID.basic:\n      return type.baseID;\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${labelType(type.base)}` : `ℬ(${labelType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => labelType(arg.type)).join(', ');\n      return `[${argsText}] → ${labelType(type.result)}`;\n  }\n}\n\n/** Converts expression type to normalized string. */\nexport function normalizeType(type: ExpressionType | null): string {\n  if (!type) {\n    return 'N/A';\n  }\n  switch (type.typeID) {\n    case TypeID.anyTypification:\n      return ANY_TYPE_NAME;\n    case TypeID.integer:\n    case TypeID.basic:\n      return 'X1';\n    case TypeID.tuple:\n      return type.factors\n        .map(factor => (factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)))\n        .join('×');\n    case TypeID.collection:\n      return type.base.typeID === TypeID.collection ? `ℬ${normalizeType(type.base)}` : `ℬ(${normalizeType(type.base)})`;\n    case TypeID.logic:\n      return LOGIC_TYPE_NAME;\n    case TypeID.predicate:\n    case TypeID.function:\n      const argsText = type.args.map(arg => normalizeType(arg.type)).join(', ');\n      return `[${argsText}] → ${normalizeType(type.result)}`;\n  }\n}\n"],"mappings":"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"}

package/dist/rslang/parser/expression-generator.d.ts

@@ -1,10 +1,10 @@
-import { AstNode } from '../../parsing/ast.js';
-import '@lezer/common';
-
+import { t as AstNode } from "../../ast-C8sIpKdL.js";
+//#region src/rslang/parser/expression-generator.d.ts
 interface ExpressionGeneratorOptions {
-    normalize?: boolean;
+  normalize?: boolean;
 }
 /** Generates Math-syntax RS expression from AST, with optional identifier normalization. */
 declare function generateExpressionFromAst(ast: AstNode, options?: ExpressionGeneratorOptions): string;
-
+//#endregion
 export { generateExpressionFromAst };
+//# sourceMappingURL=expression-generator.d.ts.map