@rsconcept/domain 1.0.0 → 1.1.0

package/dist/rslang/typification-graph.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/rslang/semantic/typification.ts","../../src/parsing/ast.ts","../../src/rslang/parser/token.ts","../../src/rslang/labels.ts","../../src/rslang/typification-graph.ts"],"sourcesContent":["/*\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 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","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","/**\n * Module: Multi-graph for typifications.\n */\n\nimport {\n  bool,\n  type EchelonCollection,\n  type EchelonTuple,\n  type ExpressionType,\n  tuple,\n  TypeID,\n  type Typification\n} from './semantic/typification';\nimport { labelType } from './labels';\n\n/** Represents a single node of a {@link TypificationGraph}. */\nexport interface TypificationNodeData extends Record<string, unknown> {\n  id: number;\n  rank: number;\n  text: string;\n  parents: number[];\n  annotations: string[];\n}\n\n/** Represents a typification multi-graph. */\nexport class TypificationGraph {\n  /** List of nodes. */\n  nodes: TypificationNodeData[] = [];\n  /** Map of nodes by ID. */\n  nodeById = new Map<number, TypificationNodeData>();\n  /** Map of nodes by alias. */\n  nodeByAlias = new Map<string, TypificationNodeData>();\n\n  /** Adds an element to the graph. */\n  addElement(alias: string, type: ExpressionType): void {\n    const node = this.processType(type);\n    if (!node) {\n      return;\n    }\n    this.addAliasAnnotation(node.id, alias);\n  }\n\n  private processType(type: ExpressionType): TypificationNodeData | null {\n    switch (type.typeID) {\n      case TypeID.logic:\n        return null;\n\n      case TypeID.anyTypification:\n      case TypeID.integer:\n      case TypeID.basic:\n        return this.addBaseNode(type);\n\n      case TypeID.collection:\n        return this.addBooleanNode(type);\n      case TypeID.tuple:\n        return this.addCartesianNode(type);\n\n      case TypeID.function:\n      case TypeID.predicate:\n        const combined = convertFunctionToTypification(type);\n        if (!combined) {\n          return null;\n        }\n        return this.processType(combined);\n    }\n  }\n\n  private addBaseNode(type: Typification): TypificationNodeData {\n    const text = labelType(type);\n    const existingNode = this.nodes.find(node => node.text === text);\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      text: text,\n      rank: 0,\n      parents: [],\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addBooleanNode(type: EchelonCollection): TypificationNodeData | null {\n    const baseNode = this.processType(type.base);\n    if (!baseNode) {\n      return null;\n    }\n\n    const existingNode = this.nodes.find(node => node.parents.length === 1 && node.parents[0] === baseNode.id);\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      rank: baseNode.rank + 1,\n      text: labelType(type),\n      parents: [baseNode.id],\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addCartesianNode(type: EchelonTuple): TypificationNodeData | null {\n    const factors = type.factors.map(factor => this.processType(factor)).filter(factor => factor !== null);\n    if (factors.length !== type.factors.length) {\n      return null;\n    }\n\n    const existingNode = this.nodes.find(\n      node => node.parents.length === factors.length && node.parents.every((p, i) => p === factors[i].id)\n    );\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      text: labelType(type),\n      rank: Math.max(...factors.map(factor => factor.rank)) + 1,\n      parents: factors.map(factor => factor.id),\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addAliasAnnotation(node: number, alias: string): void {\n    const nodeToAnnotate = this.nodeById.get(node);\n    if (!nodeToAnnotate) {\n      throw new Error(`Node ${node} not found`);\n    }\n    nodeToAnnotate.annotations.push(alias);\n    this.nodeByAlias.set(alias, nodeToAnnotate);\n  }\n}\n\nfunction convertFunctionToTypification(type: ExpressionType): Typification | null {\n  if (!('args' in type) || type.args.length === 0) {\n    return null;\n  }\n  const args = type.args.length === 1 ? type.args[0].type : tuple(type.args.map(arg => arg.type));\n  if (type.result.typeID === TypeID.logic) {\n    return bool(args);\n  } else {\n    return bool(tuple([type.result, args]));\n  }\n}\n"],"mappings":"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","names":["node"]}
+{"version":3,"file":"typification-graph.js","names":[],"sources":["../../src/rslang/typification-graph.ts"],"sourcesContent":["/**\n * Module: Multi-graph for typifications.\n */\n\nimport {\n  bool,\n  type EchelonCollection,\n  type EchelonTuple,\n  type ExpressionType,\n  tuple,\n  TypeID,\n  type Typification\n} from './semantic/typification';\nimport { labelType } from './labels';\n\n/** Represents a single node of a {@link TypificationGraph}. */\nexport interface TypificationNodeData extends Record<string, unknown> {\n  id: number;\n  rank: number;\n  text: string;\n  parents: number[];\n  annotations: string[];\n}\n\n/** Represents a typification multi-graph. */\nexport class TypificationGraph {\n  /** List of nodes. */\n  nodes: TypificationNodeData[] = [];\n  /** Map of nodes by ID. */\n  nodeById = new Map<number, TypificationNodeData>();\n  /** Map of nodes by alias. */\n  nodeByAlias = new Map<string, TypificationNodeData>();\n\n  /** Adds an element to the graph. */\n  addElement(alias: string, type: ExpressionType): void {\n    const node = this.processType(type);\n    if (!node) {\n      return;\n    }\n    this.addAliasAnnotation(node.id, alias);\n  }\n\n  private processType(type: ExpressionType): TypificationNodeData | null {\n    switch (type.typeID) {\n      case TypeID.logic:\n        return null;\n\n      case TypeID.anyTypification:\n      case TypeID.integer:\n      case TypeID.basic:\n        return this.addBaseNode(type);\n\n      case TypeID.collection:\n        return this.addBooleanNode(type);\n      case TypeID.tuple:\n        return this.addCartesianNode(type);\n\n      case TypeID.function:\n      case TypeID.predicate:\n        const combined = convertFunctionToTypification(type);\n        if (!combined) {\n          return null;\n        }\n        return this.processType(combined);\n    }\n  }\n\n  private addBaseNode(type: Typification): TypificationNodeData {\n    const text = labelType(type);\n    const existingNode = this.nodes.find(node => node.text === text);\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      text: text,\n      rank: 0,\n      parents: [],\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addBooleanNode(type: EchelonCollection): TypificationNodeData | null {\n    const baseNode = this.processType(type.base);\n    if (!baseNode) {\n      return null;\n    }\n\n    const existingNode = this.nodes.find(node => node.parents.length === 1 && node.parents[0] === baseNode.id);\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      rank: baseNode.rank + 1,\n      text: labelType(type),\n      parents: [baseNode.id],\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addCartesianNode(type: EchelonTuple): TypificationNodeData | null {\n    const factors = type.factors.map(factor => this.processType(factor)).filter(factor => factor !== null);\n    if (factors.length !== type.factors.length) {\n      return null;\n    }\n\n    const existingNode = this.nodes.find(\n      node => node.parents.length === factors.length && node.parents.every((p, i) => p === factors[i].id)\n    );\n    if (existingNode) {\n      return existingNode;\n    }\n\n    const node: TypificationNodeData = {\n      id: this.nodes.length,\n      text: labelType(type),\n      rank: Math.max(...factors.map(factor => factor.rank)) + 1,\n      parents: factors.map(factor => factor.id),\n      annotations: []\n    };\n    this.nodes.push(node);\n    this.nodeById.set(node.id, node);\n    return node;\n  }\n\n  private addAliasAnnotation(node: number, alias: string): void {\n    const nodeToAnnotate = this.nodeById.get(node);\n    if (!nodeToAnnotate) {\n      throw new Error(`Node ${node} not found`);\n    }\n    nodeToAnnotate.annotations.push(alias);\n    this.nodeByAlias.set(alias, nodeToAnnotate);\n  }\n}\n\nfunction convertFunctionToTypification(type: ExpressionType): Typification | null {\n  if (!('args' in type) || type.args.length === 0) {\n    return null;\n  }\n  const args = type.args.length === 1 ? type.args[0].type : tuple(type.args.map(arg => arg.type));\n  if (type.result.typeID === TypeID.logic) {\n    return bool(args);\n  } else {\n    return bool(tuple([type.result, args]));\n  }\n}\n"],"mappings":"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"}

package/dist/shared/branded.d.ts

@@ -1,7 +1,2 @@
-declare const brand: unique symbol;
-/** Branded strict type. No runtime consequences. */
-type Branded<T, BrandT> = T & {
-    readonly [brand]: BrandT;
-};
-
-export type { Branded };
+import { t as Branded } from "../branded-ZlzIcxzu.js";
+export { Branded };

package/dist/shared/branded.js

@@ -1 +1 @@
-//# sourceMappingURL=branded.js.map
+export {};

package/dist/shared/hash.d.ts

@@ -1,6 +1,2 @@
-/** 32-bit FNV-1a hash */
-declare function applyHash_fnv1a(str: string): number;
-/** Generates stub ID for text. */
-declare function generateStub(text: string): string;
-
-export { applyHash_fnv1a, generateStub };
+import { n as generateStub, t as applyHash_fnv1a } from "../hash-Y8I4c6Al.js";
+export { applyHash_fnv1a, generateStub };

package/dist/shared/hash.js

@@ -1,18 +1,18 @@
-// src/shared/hash.ts
+//#region src/shared/hash.ts
+/** 32-bit FNV-1a hash */
 function applyHash_fnv1a(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
+	let hash = 2166136261;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
 }
+/** Generates stub ID for text. */
 function generateStub(text) {
-  const hash = applyHash_fnv1a(text);
-  return hash.toString(16).padStart(8, "0").slice(0, 8);
+	return applyHash_fnv1a(text).toString(16).padStart(8, "0").slice(0, 8);
 }
-export {
-  applyHash_fnv1a,
-  generateStub
-};
+//#endregion
+export { applyHash_fnv1a, generateStub };
+
 //# sourceMappingURL=hash.js.map

package/dist/shared/hash.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/shared/hash.ts"],"sourcesContent":["/** 32-bit FNV-1a hash */\nexport function applyHash_fnv1a(str: string): number {\n  let hash = 0x811c9dc5;\n\n  for (let i = 0; i < str.length; i++) {\n    hash ^= str.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n\n  return hash >>> 0;\n}\n\n/** Generates stub ID for text. */\nexport function generateStub(text: string): string {\n  const hash = applyHash_fnv1a(text);\n  return hash.toString(16).padStart(8, '0').slice(0, 8);\n}\n"],"mappings":";AACO,SAAS,gBAAgB,KAAqB;AACnD,MAAI,OAAO;AAEX,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,YAAQ,IAAI,WAAW,CAAC;AACxB,WAAO,KAAK,KAAK,MAAM,QAAU;AAAA,EACnC;AAEA,SAAO,SAAS;AAClB;AAGO,SAAS,aAAa,MAAsB;AACjD,QAAM,OAAO,gBAAgB,IAAI;AACjC,SAAO,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,EAAE,MAAM,GAAG,CAAC;AACtD;","names":[]}
+{"version":3,"file":"hash.js","names":[],"sources":["../../src/shared/hash.ts"],"sourcesContent":["/** 32-bit FNV-1a hash */\nexport function applyHash_fnv1a(str: string): number {\n  let hash = 0x811c9dc5;\n\n  for (let i = 0; i < str.length; i++) {\n    hash ^= str.charCodeAt(i);\n    hash = Math.imul(hash, 0x01000193);\n  }\n\n  return hash >>> 0;\n}\n\n/** Generates stub ID for text. */\nexport function generateStub(text: string): string {\n  const hash = applyHash_fnv1a(text);\n  return hash.toString(16).padStart(8, '0').slice(0, 8);\n}\n"],"mappings":";;AACA,SAAgB,gBAAgB,KAAqB;CACnD,IAAI,OAAO;CAEX,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;EACnC,QAAQ,IAAI,WAAW,CAAC;EACxB,OAAO,KAAK,KAAK,MAAM,QAAU;CACnC;CAEA,OAAO,SAAS;AAClB;;AAGA,SAAgB,aAAa,MAAsB;CAEjD,OADa,gBAAgB,IACtB,CAAA,CAAK,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC;AACtD"}

package/dist/shared/index.d.ts

@@ -1,2 +1,3 @@
-export { Branded } from './branded.js';
-export { applyHash_fnv1a, generateStub } from './hash.js';
+import { t as Branded } from "../branded-ZlzIcxzu.js";
+import { n as generateStub, t as applyHash_fnv1a } from "../hash-Y8I4c6Al.js";
+export { type Branded, applyHash_fnv1a, generateStub };

package/dist/shared/index.js

@@ -1,18 +1,2 @@
-// src/shared/hash.ts
-function applyHash_fnv1a(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function generateStub(text) {
-  const hash = applyHash_fnv1a(text);
-  return hash.toString(16).padStart(8, "0").slice(0, 8);
-}
-export {
-  applyHash_fnv1a,
-  generateStub
-};
-//# sourceMappingURL=index.js.map
+import { applyHash_fnv1a, generateStub } from "./hash.js";
+export { applyHash_fnv1a, generateStub };

package/dist/token-DeXAmzwr.d.ts

@@ -0,0 +1,81 @@
+//#region src/rslang/parser/token.d.ts
+/** Represents RSLang token types. */
+declare const TokenID: {
+  readonly ERROR: 0;
+  readonly ID_LOCAL: 258;
+  readonly ID_GLOBAL: 259;
+  readonly ID_FUNCTION: 260;
+  readonly ID_PREDICATE: 261;
+  readonly ID_RADICAL: 262;
+  readonly LIT_INTEGER: 263;
+  readonly LIT_WHOLE_NUMBERS: 264;
+  readonly LIT_EMPTYSET: 265;
+  readonly PLUS: 266;
+  readonly MINUS: 267;
+  readonly MULTIPLY: 268;
+  readonly GREATER: 269;
+  readonly LESSER: 270;
+  readonly GREATER_OR_EQ: 271;
+  readonly LESSER_OR_EQ: 272;
+  readonly EQUAL: 273;
+  readonly NOTEQUAL: 274;
+  readonly QUANTOR_UNIVERSAL: 275;
+  readonly QUANTOR_EXISTS: 276;
+  readonly LOGIC_NOT: 277;
+  readonly LOGIC_EQUIVALENT: 278;
+  readonly LOGIC_IMPLICATION: 279;
+  readonly LOGIC_OR: 280;
+  readonly LOGIC_AND: 281;
+  readonly SET_IN: 282;
+  readonly SET_NOT_IN: 283;
+  readonly SUBSET: 284;
+  readonly SUBSET_OR_EQ: 285;
+  readonly NOT_SUBSET: 286;
+  readonly DECART: 287;
+  readonly SET_UNION: 288;
+  readonly SET_INTERSECTION: 289;
+  readonly SET_MINUS: 290;
+  readonly SET_SYMMETRIC_MINUS: 291;
+  readonly BOOLEAN: 292;
+  readonly BIGPR: 293;
+  readonly SMALLPR: 294;
+  readonly FILTER: 295;
+  readonly CARD: 296;
+  readonly BOOL: 297;
+  readonly DEBOOL: 298;
+  readonly REDUCE: 299;
+  readonly DECLARATIVE: 300;
+  readonly RECURSIVE: 301;
+  readonly IMPERATIVE: 302;
+  readonly ITERATE: 303;
+  readonly ASSIGN: 304;
+  readonly PUNCTUATION_DEFINE: 305;
+  readonly PUNCTUATION_STRUCT: 306;
+  readonly PUNCTUATION_PL: 307;
+  readonly PUNCTUATION_PR: 308;
+  readonly PUNCTUATION_CL: 309;
+  readonly PUNCTUATION_CR: 310;
+  readonly PUNCTUATION_SL: 311;
+  readonly PUNCTUATION_SR: 312;
+  readonly PUNCTUATION_BAR: 313;
+  readonly PUNCTUATION_COMMA: 314;
+  readonly PUNCTUATION_SEMICOLON: 315;
+  readonly NT_ENUM_DECL: 316;
+  readonly NT_TUPLE: 317;
+  readonly NT_ENUMERATION: 318;
+  readonly NT_TUPLE_DECL: 319;
+  readonly NT_ARG_DECL: 320;
+  readonly NT_FUNC_DEFINITION: 321;
+  readonly NT_ARGUMENTS: 322;
+  readonly NT_FUNC_CALL: 323;
+  readonly NT_DECLARATIVE_EXPR: 324;
+  readonly NT_IMPERATIVE_EXPR: 325;
+  readonly NT_RECURSIVE_FULL: 326;
+  readonly NT_RECURSIVE_SHORT: 327;
+  readonly INTERRUPT: 328;
+  readonly END: 329;
+};
+type TokenID = (typeof TokenID)[keyof typeof TokenID];
+//#endregion
+export { TokenID as t };
+//# sourceMappingURL=token-DeXAmzwr.d.ts.map

package/dist/typification-Dk-fisgO.d.ts

@@ -0,0 +1,120 @@
+import { t as Branded } from "./branded-ZlzIcxzu.js";
+//#region src/rslang/semantic/typification.d.ts
+/** Typification structure enumeration. */
+declare const TypeID: {
+  readonly anyTypification: 1;
+  readonly integer: 2;
+  readonly basic: 3;
+  readonly tuple: 4;
+  readonly collection: 5;
+  readonly logic: 6;
+  readonly function: 7;
+  readonly predicate: 8;
+};
+type TypeID = (typeof TypeID)[keyof typeof TypeID];
+/** Represents type class. */
+declare const TypeClass: {
+  readonly logic: 1;
+  readonly typification: 2;
+  readonly function: 3;
+  readonly predicate: 4;
+};
+type TypeClass = (typeof TypeClass)[keyof typeof TypeClass];
+/** Logic type object. */
+declare const LogicT: {
+  readonly typeID: 6;
+};
+/** Integer type object. */
+declare const IntegerT: {
+  readonly typeID: 2;
+  readonly isOrdered: true;
+  readonly isArithmetic: true;
+  readonly isIntegerCompatible: true;
+};
+/** Type transformation path. */
+type TypePath = Branded<number[], 'TypePath'>;
+/** Creates type path. */
+declare function makeTypePath(path: number[]): TypePath;
+/** AnyTyped type object. */
+declare const AnyTypificationT: {
+  readonly typeID: 1;
+};
+/** Empty set typification. */
+declare const EmptySetT: EchelonCollection;
+/** Parametrized typification. */
+type Parametrized = EchelonFunctional | EchelonPredicate;
+/** General expression types. */
+type ExpressionType = EchelonLogic | EchelonBase | EchelonTuple | EchelonCollection | EchelonFunctional | EchelonPredicate | EchelonAnyTyped | EchelonInteger;
+/** Setexpr type. */
+type Typification = EchelonBase | EchelonAnyTyped | EchelonInteger | EchelonCollection | EchelonTuple;
+/** Typification context. */
+type TypeContext = Map<string, ExpressionType>;
+/** Functional argument. */
+interface Argument {
+  readonly alias: string;
+  readonly type: Typification;
+}
+/** Type: Logic. */
+interface EchelonLogic {
+  readonly typeID: typeof TypeID.logic;
+}
+/** Type: AnyTyped. */
+interface EchelonAnyTyped {
+  readonly typeID: typeof TypeID.anyTypification;
+}
+/** Type: Integer. */
+interface EchelonInteger {
+  readonly typeID: typeof TypeID.integer;
+  readonly isOrdered: true;
+  readonly isArithmetic: true;
+  readonly isIntegerCompatible: true;
+}
+/** Type: Element of basic set. */
+interface EchelonBase {
+  readonly typeID: typeof TypeID.basic;
+  readonly baseID: string;
+  readonly isOrdered?: boolean;
+  readonly isArithmetic?: boolean;
+  readonly isIntegerCompatible?: boolean;
+}
+/** Type: Tuple. */
+interface EchelonTuple {
+  readonly typeID: typeof TypeID.tuple;
+  readonly factors: readonly Typification[];
+}
+/** Type: Collection. */
+interface EchelonCollection {
+  readonly typeID: typeof TypeID.collection;
+  readonly base: Typification;
+}
+/** Type: Functional. */
+interface EchelonFunctional {
+  readonly typeID: typeof TypeID.function;
+  readonly result: Typification;
+  readonly args: readonly Argument[];
+}
+/** Type: Predicate. */
+interface EchelonPredicate {
+  readonly typeID: typeof TypeID.predicate;
+  readonly result: EchelonLogic;
+  readonly args: readonly Argument[];
+}
+/** Create basic element typification. */
+declare function basic(alias: string): EchelonBase;
+/** Create constant element typification. */
+declare function constant(alias: string): EchelonBase;
+/** Create boolean typification. */
+declare function bool(base: Typification): EchelonCollection;
+/** Create tuple typification. */
+declare function tuple(factors: Typification[]): EchelonTuple;
+/** Remove boolean from typification. */
+declare function debool(target: EchelonCollection): Typification;
+/** Extract component from tuple. */
+declare function component(target: EchelonTuple, index: number): Typification | null;
+/** Checks if given type is typification. */
+declare function isTypification(type: ExpressionType | null): boolean;
+/** Checks if given type is radical. */
+declare function isRadical(alias: string): boolean;
+//#endregion
+export { component as C, isTypification as D, isRadical as E, makeTypePath as O, bool as S, debool as T, TypeContext as _, EchelonCollection as a, Typification as b, EchelonLogic as c, EmptySetT as d, ExpressionType as f, TypeClass as g, Parametrized as h, EchelonBase as i, tuple as k, EchelonPredicate as l, LogicT as m, Argument as n, EchelonFunctional as o, IntegerT as p, EchelonAnyTyped as r, EchelonInteger as s, AnyTypificationT as t, EchelonTuple as u, TypeID as v, constant as w, basic as x, TypePath as y };
+//# sourceMappingURL=typification-Dk-fisgO.d.ts.map

package/dist/typification-graph-6HcZ-rKH.d.ts

@@ -0,0 +1,30 @@
+import { f as ExpressionType } from "./typification-Dk-fisgO.js";
+
+//#region src/rslang/typification-graph.d.ts
+/** Represents a single node of a {@link TypificationGraph}. */
+interface TypificationNodeData extends Record<string, unknown> {
+  id: number;
+  rank: number;
+  text: string;
+  parents: number[];
+  annotations: string[];
+}
+/** Represents a typification multi-graph. */
+declare class TypificationGraph {
+  /** List of nodes. */
+  nodes: TypificationNodeData[];
+  /** Map of nodes by ID. */
+  nodeById: Map<number, TypificationNodeData>;
+  /** Map of nodes by alias. */
+  nodeByAlias: Map<string, TypificationNodeData>;
+  /** Adds an element to the graph. */
+  addElement(alias: string, type: ExpressionType): void;
+  private processType;
+  private addBaseNode;
+  private addBooleanNode;
+  private addCartesianNode;
+  private addAliasAnnotation;
+}
+//#endregion
+export { TypificationNodeData as n, TypificationGraph as t };
+//# sourceMappingURL=typification-graph-6HcZ-rKH.d.ts.map

package/dist/typification-parser-BBVx1RxP.d.ts

@@ -0,0 +1,13 @@
+import { f as ExpressionType } from "./typification-Dk-fisgO.js";
+
+//#region src/rslang/semantic/typification-parser.d.ts
+interface TypificationParseResult {
+  type: ExpressionType | null;
+  error: string | null;
+}
+declare function parseTypeText(input: string): TypificationParseResult;
+/** ASCII substitutions while editing typification text */
+declare function applyAsciiTypeSubstitutions(raw: string): string;
+//#endregion
+export { applyAsciiTypeSubstitutions as n, parseTypeText as r, TypificationParseResult as t };
+//# sourceMappingURL=typification-parser-BBVx1RxP.d.ts.map