@rsconcept/domain 1.0.0 → 1.2.0

package/dist/library/rsform-api.js

@@ -1,879 +1,367 @@
-// src/rslang/error.ts
-var RSErrorCode = {
-  unknownSyntax: 33792,
-  // 33792
-  missingParenthesis: 33798,
-  // 33798
-  missingCurlyBrace: 33799,
-  // 33799
-  missingSquareBracket: 33800,
-  // 33800
-  bracketMismatch: 33801,
-  // 33801
-  doubleParenthesis: 33802,
-  // 33802
-  missingOpenBracket: 33803,
-  // 33803
-  expectedLocal: 33813,
-  // 33813
-  expectedType: 33814,
-  // 33814
-  localDoubleDeclare: 10241,
-  // 10241
-  localNotUsed: 10242,
-  // 10242
-  localUndeclared: 34817,
-  // 34817
-  localShadowing: 34818,
-  // 34818
-  typesNotEqual: 34819,
-  // 34819
-  globalNotTyped: 34820,
-  // 34820
-  invalidDecart: 34821,
-  // 34821
-  invalidBoolean: 34822,
-  // 34822
-  invalidTypeOperation: 34823,
-  // 34823
-  invalidCard: 34824,
-  // 34824
-  invalidDebool: 34825,
-  // 34825
-  globalFuncWithoutArgs: 34827,
-  // 34827
-  invalidReduce: 34832,
-  // 34832
-  invalidProjectionTuple: 34833,
-  // 34833
-  invalidProjectionSet: 34834,
-  // 34834
-  invalidEnumeration: 34835,
-  // 34835
-  invalidCortegeDeclare: 34836,
-  // 34836
-  localOutOfScope: 34837,
-  // 34837
-  invalidElementPredicate: 34838,
-  // 34838
-  invalidEmptySetUsage: 34839,
-  // 34839
-  invalidArgsArity: 34840,
-  // 34840
-  invalidArgumentType: 34841,
-  // 34841
-  globalStructure: 34844,
-  // 34844
-  radicalUsage: 34849,
-  // 34849
-  invalidFilterArgumentType: 34850,
-  // 34850
-  invalidFilterArity: 34851,
-  // 34851
-  arithmeticNotSupported: 34852,
-  // 34852
-  typesNotCompatible: 34853,
-  // 34853
-  orderingNotSupported: 34854,
-  // 34854
-  expectedLogic: 34855,
-  // 34855
-  expectedSetexpr: 34856,
-  // 34856
-  invalidArgumentCortegeDeclare: 34857,
-  // 34857
-  globalNoValue: 34880,
-  // 34880
-  invalidPropertyUsage: 34881,
-  // 34881
-  // Value evaluation (runtime)
-  calcUnknownError: 33024,
-  // 35328
-  setOverflow: 33025,
-  // 35329
-  booleanBaseLimit: 33026,
-  // 35330
-  calcGlobalMissing: 33027,
-  // 35331
-  iterationsLimit: 33028,
-  // 35332
-  calcInvalidDebool: 33029,
-  // 35333
-  iterateInfinity: 33030,
-  // 35334
-  calculationNotSupported: 33031,
-  // 35335
-  cstEmptyDerived: 34913,
-  // 34913
-  definitionNotAllowed: 34914
-  // 34914
+import { RSErrorCode } from "../rslang/error.js";
+import { TypeClass, TypeID, basic, bool, constant, isTypification } from "../rslang/semantic/typification.js";
+import { applyPath } from "../rslang/semantic/typification-api.js";
+import { ValueClass } from "../rslang/semantic/value-class.js";
+import "../rslang/index.js";
+import { CstClass, CstStatus, CstType } from "./rsform.js";
+//#region src/library/rsform-api.ts
+/**
+* Module: API for formal representation for systems of concepts.
+*/
+/** Record of {@link CstType} prefixes. */
+const CST_TYPE_PREFIX = {
+	[CstType.NOMINAL]: "N",
+	[CstType.BASE]: "X",
+	[CstType.CONSTANT]: "C",
+	[CstType.STRUCTURED]: "S",
+	[CstType.AXIOM]: "A",
+	[CstType.TERM]: "D",
+	[CstType.FUNCTION]: "F",
+	[CstType.PREDICATE]: "P",
+	[CstType.STATEMENT]: "T"
 };
-
-// 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 TypeClass = {
-  logic: 1,
-  typification: 2,
-  function: 3,
-  predicate: 4
-};
-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 basic(alias) {
-  return { typeID: TypeID.basic, baseID: alias };
-}
-function constant(alias) {
-  return { typeID: TypeID.basic, baseID: alias, isOrdered: true, isArithmetic: true, isIntegerCompatible: true };
-}
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-function component(target, index) {
-  return target.factors[index - 1] ?? null;
-}
-function isTypification(type) {
-  return type?.typeID === TypeID.basic || type?.typeID === TypeID.anyTypification || type?.typeID === TypeID.integer || type?.typeID === TypeID.collection || type?.typeID === TypeID.tuple;
-}
-
-// src/rslang/parser/parser.ts
-import { LRParser } from "@lezer/lr";
-var parser = LRParser.deserialize({
-  version: 14,
-  states: "2lO!sQPOOOVQPO'#CdO$qQPO'#C`O&pQPO'#C`O*bQPO'#C_Q*jQPOOO,TQPO'#CyOVQPO'#CtO,]QPO'#CtOOQO'#Ct'#CtOOQO'#C^'#C^OOQO'#ES'#ESOOQO'#ET'#ETO,bQPO'#DeO,iQPO'#DfO,qQPO'#DhO,vQPO'#DjO,{QPO'#DnO-QQPO'#DrOOQO'#EU'#EUOOQO'#EV'#EVOOQO'#DS'#DSO-VQPO'#DSO-[QPO'#DSOOQO'#EQ'#EQO,TQPO'#DzQOQPOOO-aQPO'#ERO-nQPO,59OO-vQPO'#CeO-{QPO,58xO/lQPO,59tOVQPO,58yOVQPO,58yOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO'#CdOOQO'#C`'#C`OOQO'#C{'#C{O1]QPO,59eO2rQPO,59`OVQPO,59`OOQO'#ER'#ERO5TQPO,5:PO5]QPO,5:UOVQPO,5:QOOQO,5:Q,5:QOVQPO,5:SO,TQPO,5:UOVQPO,5:YO,TQPO,5:^OVQPO,59nOVQPO,59nO5dQPO'#D|OOQO'#D{'#D{O5iQPO,5:fOOQO1G.j1G.jOVQPO,59POOQO1G.d1G.dOOQO1G/`1G/`O5qQPO1G.eO7vQPO1G.eO:zQPO1G/TO=]QPO1G/TO?nQPO1G/TOBPQPO1G/TOGyQPO1G/`OHQQPO1G/`OKpQPO1G/`O! `QPO1G/`O! gQPO1G/`O! nQPO1G/`O! uQPO1G/`O,TQPO,59gOVQPO1G/PO!%aQPO1G.zOOQO1G/k1G/kOVQPO1G/pO!%iQPO1G/lO!%pQPO1G/nO!%xQPO1G/pO!%}QPO1G/tO!&UQPO1G/xO!&ZQPO1G/YO!&cQPO1G/YOVQPO,5:hO,TQPO,5:gOVQPO1G0QO!&jQPO1G.kOOQO1G/R1G/RO!&zQPO7+$kOOQO7+$f7+$fO!(gQPO7+%[OOQO7+%W7+%WO!(nQPO7+%YOVQPO7+%[OVQPO7+%`OVQPO7+%dOOQO7+$t7+$tO!(sQPO1G0SOOQO1G0R1G0RO!(}QPO7+%lO!)UQPO<<HVOVQPO<<HvOVQPO<<HtO!+gQPO<<HvO!+nQPO'#DoO!+xQPO<<HzO!,QQPO<<IOO!,XQPOAN>bO!,`QPOAN>`OVQPOAN>bOVQPO,5:ZOOQOAN>fAN>fOVQPOAN>jOOQOG23|G23|OOQOG23zG23zO!,gQPOG23|O!,nQPO1G/uO!,xQPOG24UOOQOLD)hLD)hOOQOLD)pLD)pOVQPOLD)pO!-SQPO!$'M[OOQO!)9Bv!)9Bv",
-  stateData: "!-l~O!sOS~OTQOVPOiVOjWOnUOpUOwZOxZOyZOz[O{[O!W]O!Z^O!]_O!``O!aaO!ebO!gfO!hdO!idO!jdO!kdO!ldO!mdO~OkiO~PVOZSX[SX]!wX^!wX_!wX`!wXa!wXb!wXc!wXd!wXe!wXf!wXg!wXr!wXs!wXt!wXu!wX}!wX!O!wX!P!wX!Q!wX!R!wX!S!wX!T!wX!U!wXY!wX!V!wX~O!q!wXU!wXl!wX!_!wXT!wXV!wXi!wXj!wXn!wXp!wXw!wXx!wXy!wXz!wX{!wX!W!wX!Z!wX!]!wX!`!wX!a!wX!e!wX!g!wX!h!wX!i!wX!j!wX!k!wX!l!wX!m!wX!d!wX~P!zOZSX[SX]!xX^!xX_!xX`!xXa!xXb!xXc!xXd!xXe!xXf!xXg!xXr!xXs!xXt!xXu!xX}!xX!O!xX!P!xX!Q!xX!R!xX!S!xX!T!xX!U!xX!q!xXY!xX!V!xXU!xXl!xX!_!xXT!xXV!xXi!xXj!xXn!xXp!xXw!xXx!xXy!xXz!xX{!xX!W!xX!Z!xX!]!xX!`!xX!a!xX!e!xX!g!xX!h!xX!i!xX!j!xX!k!xX!l!xX!m!xX!d!xX~OZpO[pO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~OT!POV!OO~Ok!TO~OT!WO~PYOV!XO!Z^O~Ok!ZO~O!W![O~O!W!]O~O!W!^O~Ok!_O~OV!`O~OY!uX!V!uXl!uX~P*jOU!dOY!uX~OY!eO~OU!fOY!tX]!tX^!tX_!tX`!tXa!tXb!tXc!tXd!tXe!tXf!tXg!tXr!tXs!tXt!tXu!tX}!tX!O!tX!P!tX!Q!tX!R!tX!S!tX!T!tX!U!tX~OU!gOYvX]vX^vX_vX`vXavXbvXcvXdvXevXfvXgvXrvXsvXtvXuvX}vX!OvX!PvX!QvX!RvX!SvX!TvX!UvX~OY!uO]!vO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~Orhashathauha!qhaUhaYha!Vhalha!_haThaVhaihajhanhaphawhaxhayhazha{ha!Wha!Zha!]ha!`ha!aha!eha!gha!hha!iha!jha!kha!lha!mha!dha~P1eOY!eO!V!xO~O]!yO~P!zO]#RO~OY#SOl#TO~O!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P*jO]Ri^Ri_Ri`RiaRibRicRidRieRifRigRirRisRitRiuRi!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P+iOssOttOuuOrqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOttOuuOrqisqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOuuOrqisqitqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOrqisqitqiuqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eO}vO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!P|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!O|i~PDbO!OwO~PDbO}vO!OwO!PxO!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!R|i!S|i!T|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!Q|i~PHXO}vO!OwO!PxO!QyO!T|O!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!S|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!R|i~PKwO!RzO~PKwO!QyO~PHXO}vO!OwO!PxO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~OY!eOl#XO~OU#ZO~P*jOY!eOl#[O~O]#]O~O!_#^O~P*jO[#_O~OY!eOl#`O~OU#`O~P*jOUXiYXi!VXilXi~P*jO]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~PVO!_#eO~P*jOV#fO~OY!pil!pi~P*jO!q!nq~P*jOrmysmytmyumy!qmyUmyYmy!Vmylmy!_myTmyVmyimyjmynmypmywmyxmyymyzmy{my!Wmy!Zmy!]my!`my!amy!emy!gmy!hmy!imy!jmy!kmy!lmy!mmy!dmy~P1eO!_#mO~P*jO!V!cX!d!cX~P*jO!V#oO!d#nO~O!_#pO~P*jO!V#qO~P*jOU#rO~P*jO!V#vO~P*jO!V!ci!d!ci~P*jO!V#wO!_#xO~P*jO!V#zO~P*jO!]!hj!gz{!j!k!l!m!iT!e!a!`!a~",
-  goto: "1O!zPP!{#y$uPPP&R'VPPPPPPPPPPPPPP#yPPPP'aP(]P#yPPPP(`PPPPP)[PPPPPPPPPP*Y+UP*YP*YPPP*Y,TPP*YPPPPPPP,W,Z,^PPP,d.v/W/W/W0S!phOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRnP!sYOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rSOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xQ!QUS!ai#SQ!|![Q#O!^R#V!u!rROPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x]!PUi![!^!u#SSlP!OX!U]!T!Z!_!sXOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!RU!shOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!peOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRoP!scOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rcOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!Y^R#i#^RjOR!ciQ!biR#b#SQTO[kP]!O!T!Z!_Q!SVQ!gvQ!hpQ!iqQ!jrQ!ksQ!ltQ!muQ!nwQ!oxQ!pyQ!qzQ!r{Q!s|Q!t}Q!z!XQ!}!]Q#Q!`Q#U!eQ#W!vQ#Y!yQ#a#RQ#c#TQ#d#WQ#g#]Q#h#^Q#j#_Q#k#eQ#l#fQ#s#mQ#t#nQ#u#pR#y#xSmP!OQ!V]Q!w!TQ!{!ZR#P!_!seOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!sgOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x",
-  nodeNames: "\u26A0 Expression Logic Logic_predicates Variable Local ) ( Tuple Expr_enum_min2 , :\u2208 := \u2208 \u2209 \u2286 \u2284 \u2282 > \u2265 < \u2264 \u2260 = Logic_unary \xAC Predicate [ ] Logic_quantor \u2200 Variable_pack \u2203 Logic_binary \u21D4 \u21D2 \u2228 & Setexpr Integer EmptySet IntegerSet Global Radical Setexpr_binary * + - \u222A \\ \u2206 \u2229 \xD7 } { Enumeration Boolean \u212C Filter_expression Filter Declarative | PrefixD PrefixI Imperative Imp_blocks ; PrefixR Recursion Function BigPr SmallPr Card Bool Debool Red Function_decl Arguments Declaration",
-  maxTerm: 87,
-  nodeProps: [
-    ["openedBy", 6, "(", 53, "{"],
-    ["closedBy", 7, ")", 54, "}"]
-  ],
-  skippedNodes: [0],
-  repeatNodeCount: 0,
-  tokenData: "6j~R!jX^%spq%svw&hxy&myz&rz{&w{|&||}'R}!O'W!Q![']![!]'e!]!^'x!^!_'}!_!`(S!`!a(X!c!d(^!e!f(^!f!g(l!h!i(t!k!l)h!p!q(^!r!s)m!t!u*a!u!v(^!v!w(^!z!{(^!|!}*q!}#O*v#O#P*{#P#Q+Q#R#S+V#T#U+V#U#V+m#V#W-]#W#X.x#X#d+V#d#e1b#e#f+V#f#g2w#g#o+V#o#p4R#p#q4W#q#r4]#y#z%s$f$g%s$r$s4b%o%p4g5i6S+V#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s% l% m4l%%Y%%Z4q%%[%%]4v%&Y%&Z4{%&]%&^5Q%&_%&`5V%&`%&a5[%&b%&c5a%&c%&d5f%'S%'T5k%'T%'U5p%'U%'V5u%(^%(_5z%(b%(c6P%(c%(d6U%)Q%)R6Z%)S%)T6`%)U%)V6e&FU&FV%s~%xY!s~X^%spq%s#y#z%s$f$g%s#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s&FU&FV%s~&mOu~~&rOV~~&wOU~~&|O}~~'RO!O~~'WOY~~']O!P~~'bPw~!Q![']~'hQ!_!`'n%&b%&c's~'sO[~~'xOZ~~'}O!d~~(SOd~~(XOg~~(^Ob~~(aP!Q![(d~(iPz~!Q![(d~(qP!`~!Q![(d~(wQ!Q![(}#]#^)V~)SP!g~!Q![(}~)YP!R![)]~)bQ!]~|})V!Q![)]~)mO!a~~)pQ!Q![)v#f#g*O~){Pj~!Q![)v~*RP!R![*U~*ZQ!h~|}*O!Q![*U~*fP!e~!Q![*i~*nP{~!Q![*i~*vOy~~*{Ok~~+QO!R~~+VOl~~+[RT~!Q![+e#T#o+V5i6S+V~+jPT~!Q![+e~+rTT~!Q![+e#T#c+V#c#d,R#d#o+V5i6S+V~,WTT~!Q![+e#T#c+V#c#d,g#d#o+V5i6S+V~,lTT~!Q![+e#T#`+V#`#a,{#a#o+V5i6S+V~-SR!k~T~!Q![+e#T#o+V5i6S+V~-bST~!Q![+e#T#U-n#U#o+V5i6S+V~-sTT~!Q![+e#T#f+V#f#g.S#g#o+V5i6S+V~.XTT~!Q![+e#T#W+V#W#X.h#X#o+V5i6S+V~.oR!j~T~!Q![+e#T#o+V5i6S+V~.}TT~!Q![+e#T#X+V#X#Y/^#Y#o+V5i6S+V~/cTT~!Q![+e#T#U+V#U#V/r#V#o+V5i6S+V~/wTT~!Q![+e#T#c+V#c#d0W#d#o+V5i6S+V~0]TT~!Q![+e#T#c+V#c#d0l#d#o+V5i6S+V~0qTT~!Q![+e#T#`+V#`#a1Q#a#o+V5i6S+V~1XR!l~T~!Q![+e#T#o+V5i6S+V~1gTT~!Q![+e#T#f+V#f#g1v#g#o+V5i6S+V~1{ST~!Q!R+e!R![2X#T#o+V5i6S+V~2`Q!i~T~|}2f!Q![2X~2iP!R![2l~2qQ!i~|}2f!Q![2l~2|TT~!Q![+e#T#X+V#X#Y3]#Y#o+V5i6S+V~3bTT~!Q![+e#T#W+V#W#X3q#X#o+V5i6S+V~3xR!m~T~!Q![+e#T#o+V5i6S+V~4WO!W~~4]O!_~~4bO!V~~4gOi~~4lO!U~~4qO!Z~~4vOs~~4{Or~~5QOn~~5VOp~~5[Ox~~5aO!S~~5fO]~~5kO^~~5pOt~~5uO!T~~5zO!Q~~6POf~~6UOe~~6ZOc~~6`Oa~~6eO`~~6jO_~",
-  tokenizers: [0],
-  topRules: { "Expression": [0, 1] },
-  tokenPrec: 2679
-});
-
-// src/rslang/parser/parser.terms.ts
-var Local = 5;
-var Tuple = 8;
-var Predicate = 26;
-var Variable_pack = 31;
-var Integer = 39;
-var EmptySet = 40;
-var IntegerSet = 41;
-var Global = 42;
-var Radical = 43;
-var Enumeration = 55;
-var Boolean = 56;
-var Filter = 59;
-var Declarative = 60;
-var Imperative = 64;
-var Function = 69;
-var BigPr = 70;
-var SmallPr = 71;
-var Card = 72;
-var Bool = 73;
-var Debool = 74;
-var Red = 75;
-var Function_decl = 76;
-var Arguments = 77;
-var Declaration = 78;
-
-// src/rslang/parser/normalize.ts
-var idRecord = {
-  [Global]: TokenID.ID_GLOBAL,
-  [Local]: TokenID.ID_LOCAL,
-  [Radical]: TokenID.ID_RADICAL,
-  [Function]: TokenID.ID_FUNCTION,
-  [Predicate]: TokenID.ID_PREDICATE,
-  [Integer]: TokenID.LIT_INTEGER,
-  [EmptySet]: TokenID.LIT_EMPTYSET,
-  [IntegerSet]: TokenID.LIT_WHOLE_NUMBERS,
-  [Boolean]: TokenID.BOOLEAN,
-  [BigPr]: TokenID.BIGPR,
-  [SmallPr]: TokenID.SMALLPR,
-  [Filter]: TokenID.FILTER,
-  [Bool]: TokenID.BOOL,
-  [Debool]: TokenID.DEBOOL,
-  [Red]: TokenID.REDUCE,
-  [Card]: TokenID.CARD,
-  [Enumeration]: TokenID.NT_ENUMERATION,
-  [Tuple]: TokenID.NT_TUPLE,
-  [Arguments]: TokenID.NT_ARGUMENTS,
-  [Declaration]: TokenID.NT_ARG_DECL,
-  [Function_decl]: TokenID.NT_FUNC_DEFINITION,
-  [Variable_pack]: TokenID.NT_ENUM_DECL,
-  [Declarative]: TokenID.NT_DECLARATIVE_EXPR,
-  [Imperative]: TokenID.NT_IMPERATIVE_EXPR
-};
-
-// src/rslang/labels.ts
-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"
-};
-
-// src/rslang/semantic/typification-api.ts
-var TypeIDToClass = {
-  [TypeID.anyTypification]: TypeClass.typification,
-  [TypeID.integer]: TypeClass.typification,
-  [TypeID.basic]: TypeClass.typification,
-  [TypeID.tuple]: TypeClass.typification,
-  [TypeID.collection]: TypeClass.typification,
-  [TypeID.logic]: TypeClass.logic,
-  [TypeID.function]: TypeClass.function,
-  [TypeID.predicate]: TypeClass.predicate
-};
-function applyPath(target, path, index = 0) {
-  let current = target;
-  let i = index;
-  while (i < path.length && current) {
-    switch (current.typeID) {
-      case TypeID.anyTypification:
-      case TypeID.integer:
-      case TypeID.basic:
-        return null;
-      case TypeID.collection:
-        current = current.base;
-        i++;
-        break;
-      case TypeID.tuple:
-        current = component(current, path[i]);
-        if (current === null) {
-          return null;
-        }
-        i++;
-        break;
-    }
-  }
-  return current;
-}
-
-// src/rslang/semantic/value-class.ts
-var ValueClass = {
-  VALUE: "value",
-  PROPERTY: "property"
-};
-
-// src/library/rsform.ts
-var CstType = {
-  NOMINAL: "nominal",
-  BASE: "basic",
-  STRUCTURED: "structure",
-  TERM: "term",
-  AXIOM: "axiom",
-  FUNCTION: "function",
-  PREDICATE: "predicate",
-  CONSTANT: "constant",
-  STATEMENT: "statement"
-};
-var CstClass = {
-  NOMINAL: "nominal",
-  BASIC: "basic",
-  DERIVED: "derived",
-  STATEMENT: "statement",
-  TEMPLATE: "template"
-};
-var CstStatus = {
-  VERIFIED: "verified",
-  INCORRECT: "incorrect",
-  INCALCULABLE: "incalculable",
-  PROPERTY: "property",
-  UNKNOWN: "unknown"
-};
-
-// src/library/rsform-api.ts
-var CST_TYPE_PREFIX = {
-  [CstType.NOMINAL]: "N",
-  [CstType.BASE]: "X",
-  [CstType.CONSTANT]: "C",
-  [CstType.STRUCTURED]: "S",
-  [CstType.AXIOM]: "A",
-  [CstType.TERM]: "D",
-  [CstType.FUNCTION]: "F",
-  [CstType.PREDICATE]: "P",
-  [CstType.STATEMENT]: "T"
-};
-var CST_TYPE_TO_CLASS = {
-  [CstType.NOMINAL]: CstClass.NOMINAL,
-  [CstType.BASE]: CstClass.BASIC,
-  [CstType.CONSTANT]: CstClass.BASIC,
-  [CstType.STRUCTURED]: CstClass.BASIC,
-  [CstType.TERM]: CstClass.DERIVED,
-  [CstType.FUNCTION]: CstClass.DERIVED,
-  [CstType.AXIOM]: CstClass.STATEMENT,
-  [CstType.PREDICATE]: CstClass.DERIVED,
-  [CstType.STATEMENT]: CstClass.STATEMENT
+/** Record of {@link CstType} to {@link CstClass} mapping. */
+const CST_TYPE_TO_CLASS = {
+	[CstType.NOMINAL]: CstClass.NOMINAL,
+	[CstType.BASE]: CstClass.BASIC,
+	[CstType.CONSTANT]: CstClass.BASIC,
+	[CstType.STRUCTURED]: CstClass.BASIC,
+	[CstType.TERM]: CstClass.DERIVED,
+	[CstType.FUNCTION]: CstClass.DERIVED,
+	[CstType.AXIOM]: CstClass.STATEMENT,
+	[CstType.PREDICATE]: CstClass.DERIVED,
+	[CstType.STATEMENT]: CstClass.STATEMENT
 };
+/** Checks if {@link Constituenta} is a schema issue. */
 function isSchemaIssue(cst) {
-  if (cst.homonyms.length > 0 || cst.formalDuplicates.length > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE || cst.is_type_mismatch) {
-    return true;
-  }
-  if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-    if (!cst.convention || !cst.term_resolved) {
-      return true;
-    }
-  }
-  return false;
+	if (cst.homonyms.length > 0 || cst.formalDuplicates.length > 0 || cst.status === CstStatus.INCORRECT || cst.status === CstStatus.INCALCULABLE || cst.is_type_mismatch) return true;
+	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
+		if (!cst.convention || !cst.term_resolved) return true;
+	}
+	return false;
 }
+/** Infers the status of an expression based on parsing and value information. */
 function inferStatus(parse, value) {
-  if (!parse) {
-    return CstStatus.INCORRECT;
-  }
-  if (value === null) {
-    return CstStatus.INCALCULABLE;
-  }
-  if (value === ValueClass.PROPERTY) {
-    return CstStatus.PROPERTY;
-  }
-  return CstStatus.VERIFIED;
+	if (!parse) return CstStatus.INCORRECT;
+	if (value === null) return CstStatus.INCALCULABLE;
+	if (value === ValueClass.PROPERTY) return CstStatus.PROPERTY;
+	return CstStatus.VERIFIED;
 }
+/** Infers type of constituent for a given template and arguments. */
 function inferTemplatedType(templateType, args) {
-  if (args.length === 0 || args.some((arg) => !arg.value)) {
-    return templateType;
-  } else if (templateType === CstType.PREDICATE) {
-    return CstType.AXIOM;
-  } else {
-    return CstType.TERM;
-  }
+	if (args.length === 0 || args.some((arg) => !arg.value)) return templateType;
+	else if (templateType === CstType.PREDICATE) return CstType.AXIOM;
+	else return CstType.TERM;
 }
+/** Checks if given expression is a template. */
 function inferTemplate(expression) {
-  const match = expression.match(/R\d+/g);
-  return (match && match?.length > 0) ?? false;
+	const match = expression.match(/R\d+/g);
+	return (match && match?.length > 0) ?? false;
 }
+/** Infers the {@link CstClass} based on the provided {@link CstType} and template status. */
 function inferClass(type, isTemplate = false) {
-  if (isTemplate) {
-    return CstClass.TEMPLATE;
-  }
-  return CST_TYPE_TO_CLASS[type];
+	if (isTemplate) return CstClass.TEMPLATE;
+	return CST_TYPE_TO_CLASS[type];
 }
+/** Check if {@link Constituenta} is a template or a category. */
 function isTemplateCst(cst) {
-  return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
+	return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
 }
+/** Apply filter based on start {@link Constituenta} type. */
 function applyFilterCategory(start, items) {
-  const startIndex = items.indexOf(start);
-  if (startIndex === -1) {
-    return [];
-  }
-  const nextCategoryIndex = items.findIndex((cst, index) => index > startIndex && cst.cst_type === CstType.STATEMENT);
-  return items.filter((_, index) => index >= startIndex && (nextCategoryIndex === -1 || index < nextCategoryIndex));
+	const startIndex = items.indexOf(start);
+	if (startIndex === -1) return [];
+	const nextCategoryIndex = items.findIndex((cst, index) => index > startIndex && cst.cst_type === CstType.STATEMENT);
+	return items.filter((_, index) => index >= startIndex && (nextCategoryIndex === -1 || index < nextCategoryIndex));
 }
+/** Prefix for alias indicating {@link CstType}. */
 function getCstTypePrefix(type) {
-  return CST_TYPE_PREFIX[type];
+	return CST_TYPE_PREFIX[type];
 }
+/** Guess {@link CstType} from user input hint. */
 function guessCstType(hint) {
-  if (hint.length !== 1) {
-    return null;
-  }
-  for (const [type, prefix] of Object.entries(CST_TYPE_PREFIX)) {
-    if (hint === prefix) {
-      return type;
-    }
-  }
-  return null;
+	if (hint.length !== 1) return null;
+	for (const [type, prefix] of Object.entries(CST_TYPE_PREFIX)) if (hint === prefix) return type;
+	return null;
 }
+/** Evaluate if {@link CstType} is basic concept. */
 function isBasicConcept(type) {
-  switch (type) {
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.STRUCTURED:
-    case CstType.AXIOM:
-      return true;
-    case CstType.TERM:
-    case CstType.FUNCTION:
-    case CstType.PREDICATE:
-    case CstType.STATEMENT:
-      return false;
-  }
-}
+	switch (type) {
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.STRUCTURED:
+		case CstType.AXIOM: return true;
+		case CstType.TERM:
+		case CstType.FUNCTION:
+		case CstType.PREDICATE:
+		case CstType.STATEMENT: return false;
+	}
+}
+/** Evaluate if {@link CstType} is base set or constant set. */
 function isBaseSet(type) {
-  switch (type) {
-    case CstType.BASE:
-    case CstType.CONSTANT:
-      return true;
-    case CstType.NOMINAL:
-    case CstType.STRUCTURED:
-    case CstType.AXIOM:
-    case CstType.TERM:
-    case CstType.FUNCTION:
-    case CstType.PREDICATE:
-    case CstType.STATEMENT:
-      return false;
-  }
-}
+	switch (type) {
+		case CstType.BASE:
+		case CstType.CONSTANT: return true;
+		case CstType.NOMINAL:
+		case CstType.STRUCTURED:
+		case CstType.AXIOM:
+		case CstType.TERM:
+		case CstType.FUNCTION:
+		case CstType.PREDICATE:
+		case CstType.STATEMENT: return false;
+	}
+}
+/** Evaluate if {@link CstType} is a function. */
 function isFunctional(type) {
-  switch (type) {
-    case CstType.FUNCTION:
-    case CstType.PREDICATE:
-      return true;
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.STRUCTURED:
-    case CstType.AXIOM:
-    case CstType.TERM:
-    case CstType.STATEMENT:
-      return false;
-  }
-}
+	switch (type) {
+		case CstType.FUNCTION:
+		case CstType.PREDICATE: return true;
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.STRUCTURED:
+		case CstType.AXIOM:
+		case CstType.TERM:
+		case CstType.STATEMENT: return false;
+	}
+}
+/** Evaluate if {@link CstType} is logical. */
 function isLogical(type) {
-  switch (type) {
-    case CstType.AXIOM:
-    case CstType.STATEMENT:
-      return true;
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.STRUCTURED:
-    case CstType.TERM:
-    case CstType.FUNCTION:
-    case CstType.PREDICATE:
-      return false;
-  }
-}
+	switch (type) {
+		case CstType.AXIOM:
+		case CstType.STATEMENT: return true;
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.STRUCTURED:
+		case CstType.TERM:
+		case CstType.FUNCTION:
+		case CstType.PREDICATE: return false;
+	}
+}
+/** Evaluate if {@link Constituenta} can be used produce structure. */
 function canProduceStructure(cst) {
-  switch (cst.cst_type) {
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.AXIOM:
-    case CstType.STATEMENT:
-    case CstType.PREDICATE:
-      return false;
-  }
-  if (!cst.effectiveType) {
-    return false;
-  }
-  if (cst.cst_type === CstType.FUNCTION) {
-    const result = cst.effectiveType.result;
-    return typeCanProduceStructure(result);
-  }
-  if (!isTypification(cst.effectiveType)) {
-    return false;
-  }
-  return typeCanProduceStructure(cst.effectiveType);
-}
+	switch (cst.cst_type) {
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.AXIOM:
+		case CstType.STATEMENT:
+		case CstType.PREDICATE: return false;
+	}
+	if (!cst.effectiveType) return false;
+	if (cst.cst_type === CstType.FUNCTION) {
+		const result = cst.effectiveType.result;
+		return typeCanProduceStructure(result);
+	}
+	if (!isTypification(cst.effectiveType)) return false;
+	return typeCanProduceStructure(cst.effectiveType);
+}
+/** Evaluate if {@link CstType} can have manual typification. */
 function canHaveManualTypification(type) {
-  switch (type) {
-    case CstType.STRUCTURED:
-    case CstType.TERM:
-    case CstType.FUNCTION:
-    case CstType.PREDICATE:
-      return true;
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.AXIOM:
-    case CstType.STATEMENT:
-      return false;
-  }
-}
+	switch (type) {
+		case CstType.STRUCTURED:
+		case CstType.TERM:
+		case CstType.FUNCTION:
+		case CstType.PREDICATE: return true;
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.AXIOM:
+		case CstType.STATEMENT: return false;
+	}
+}
+/** Validate alias format for a given {@link CstType} (prefix + digits, min length 2). */
+function validateAliasFormat(alias, type) {
+	if (alias.length < 2) return false;
+	const prefix = getCstTypePrefix(type);
+	if (!alias.startsWith(prefix)) return false;
+	if (!/^\d+$/.exec(alias.substring(prefix.length))) return false;
+	return true;
+}
+/** Validate new alias against {@link CstType} and {@link RSForm}. */
 function validateNewAlias(alias, type, schema) {
-  if (alias.length < 2) {
-    return false;
-  }
-  const prefix = getCstTypePrefix(type);
-  if (!alias.startsWith(prefix)) {
-    return false;
-  }
-  if (schema.cstByAlias.has(alias)) {
-    return false;
-  }
-  if (!/^\d+$/.exec(alias.substring(prefix.length))) {
-    return false;
-  }
-  return true;
+	if (!validateAliasFormat(alias, type)) return false;
+	if (schema.cstByAlias.has(alias)) return false;
+	return true;
 }
+/** Generate alias for new {@link Constituenta} of a given {@link CstType} for current {@link RSForm}. */
 function generateAlias(type, schema, takenAliases = []) {
-  const prefix = getCstTypePrefix(type);
-  if (schema.items.length <= 0) {
-    return `${prefix}1`;
-  }
-  let index = schema.items.reduce((prev, cst, index2) => {
-    if (cst.cst_type !== type) {
-      return prev;
-    }
-    index2 = Number(cst.alias.slice(1 - cst.alias.length)) + 1;
-    return Math.max(prev, index2);
-  }, 1);
-  let alias = `${prefix}${index}`;
-  while (takenAliases.includes(alias)) {
-    index = index + 1;
-    alias = `${prefix}${index}`;
-  }
-  return alias;
-}
+	const prefix = getCstTypePrefix(type);
+	if (schema.items.length <= 0) return `${prefix}1`;
+	let index = schema.items.reduce((prev, cst, index) => {
+		if (cst.cst_type !== type) return prev;
+		index = Number(cst.alias.slice(1 - cst.alias.length)) + 1;
+		return Math.max(prev, index);
+	}, 1);
+	let alias = `${prefix}${index}`;
+	while (takenAliases.includes(alias)) {
+		index = index + 1;
+		alias = `${prefix}${index}`;
+	}
+	return alias;
+}
+/**
+* Id to pass as `insert_after` when creating a new {@link Constituenta} spawned by `targetId`:
+* after the last existing child of that spawner, or after the spawner itself if none.
+*/
 function inferNewSpawnPosition(schema, targetId) {
-  let last = null;
-  for (const cst of schema.items) {
-    if (cst.spawner === targetId) {
-      last = cst.id;
-    }
-  }
-  return last ?? targetId;
+	let last = null;
+	for (const cst of schema.items) if (cst.spawner === targetId) last = cst.id;
+	return last ?? targetId;
 }
+/** Sorts library items relevant for InlineSynthesis with specified {@link RSForm}. */
 function sortItemsForInlineSynthesis(receiver, items) {
-  const result = items.filter((item) => item.location === receiver.location);
-  for (const item of items) {
-    if (item.visible && item.owner === item.owner && !result.includes(item)) {
-      result.push(item);
-    }
-  }
-  for (const item of items) {
-    if (item.visible && !result.includes(item)) {
-      result.push(item);
-    }
-  }
-  for (const item of items) {
-    if (!result.includes(item)) {
-      result.push(item);
-    }
-  }
-  return result;
+	const result = items.filter((item) => item.location === receiver.location);
+	for (const item of items) if (item.visible && item.owner === item.owner && !result.includes(item)) result.push(item);
+	for (const item of items) if (item.visible && !result.includes(item)) result.push(item);
+	for (const item of items) if (!result.includes(item)) result.push(item);
+	return result;
 }
+/** Remove alias from expression. */
 function removeAliasReference(expression, alias) {
-  const result = expression.replaceAll(new RegExp(`\\b${alias}\\b`, "g"), "DEL");
-  return result === "DEL" ? "" : result;
+	const result = expression.replaceAll(new RegExp(`\\b${alias}\\b`, "g"), "DEL");
+	return result === "DEL" ? "" : result;
 }
+/** Add alias to expression. */
 function addAliasReference(expression, alias) {
-  return expression + " " + alias;
+	return expression + " " + alias;
 }
+/** Returns expected {@link TypeClass} of formal definition for {@link CstType}. */
 function typeClassForCstType(cstType) {
-  switch (cstType) {
-    case CstType.NOMINAL:
-    case CstType.BASE:
-    case CstType.CONSTANT:
-    case CstType.STRUCTURED:
-    case CstType.TERM:
-      return TypeClass.typification;
-    case CstType.FUNCTION:
-      return TypeClass.function;
-    case CstType.PREDICATE:
-      return TypeClass.predicate;
-    case CstType.AXIOM:
-    case CstType.STATEMENT:
-      return TypeClass.logic;
-  }
-}
+	switch (cstType) {
+		case CstType.NOMINAL:
+		case CstType.BASE:
+		case CstType.CONSTANT:
+		case CstType.STRUCTURED:
+		case CstType.TERM: return TypeClass.typification;
+		case CstType.FUNCTION: return TypeClass.function;
+		case CstType.PREDICATE: return TypeClass.predicate;
+		case CstType.AXIOM:
+		case CstType.STATEMENT: return TypeClass.logic;
+	}
+}
+/** Checks whether a constituenta type supports formal definitions. */
 function canHaveFormalDefinition(cstType) {
-  return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
+	return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
 }
+/** Analyze expression for {@link RSForm}. */
 function getAnalysisFor(expression, cstType, schema, alias) {
-  if (!canHaveFormalDefinition(cstType)) {
-    if (expression.trim().length === 0) {
-      const fallbackAlias = alias && alias.length > 0 ? alias : "X0";
-      const type = cstType === CstType.BASE ? bool(basic(fallbackAlias)) : bool(constant(fallbackAlias));
-      return {
-        success: true,
-        type,
-        valueClass: ValueClass.VALUE,
-        errors: [],
-        ast: null
-      };
-    }
-    return {
-      success: false,
-      type: null,
-      valueClass: null,
-      errors: [
-        {
-          code: RSErrorCode.definitionNotAllowed,
-          from: 0,
-          to: Math.max(0, expression.length - 1)
-        }
-      ],
-      ast: null
-    };
-  }
-  return schema.analyzer.checkFull(expression, {
-    expected: typeClassForCstType(cstType),
-    isDomain: cstType === CstType.STRUCTURED
-  });
-}
+	if (!canHaveFormalDefinition(cstType)) {
+		if (expression.trim().length === 0) {
+			const fallbackAlias = alias && alias.length > 0 ? alias : "X0";
+			return {
+				success: true,
+				type: cstType === CstType.BASE ? bool(basic(fallbackAlias)) : bool(constant(fallbackAlias)),
+				valueClass: ValueClass.VALUE,
+				errors: [],
+				ast: null
+			};
+		}
+		return {
+			success: false,
+			type: null,
+			valueClass: null,
+			errors: [{
+				code: RSErrorCode.definitionNotAllowed,
+				from: 0,
+				to: Math.max(0, expression.length - 1)
+			}],
+			ast: null
+		};
+	}
+	return schema.analyzer.checkFull(expression, {
+		expected: typeClassForCstType(cstType),
+		isDomain: cstType === CstType.STRUCTURED
+	});
+}
+/** Calculate statistics for {@link RSForm}. */
 function calculateSchemaStats(target) {
-  const items = target.items;
-  return {
-    count_all: items.length,
-    count_crucial: items.reduce((sum, cst) => sum + (cst.crucial ? 1 : 0), 0),
-    step_complexity: items.reduce((sum, cst) => sum + calculateStepComplexity(cst), 0),
-    count_problematic: items.reduce((sum, cst) => sum + (isSchemaIssue(cst) ? 1 : 0), 0),
-    count_homonyms: items.reduce((sum, cst) => sum + (cst.homonyms.length > 0 ? 1 : 0), 0),
-    count_formal_duplicates: items.reduce((sum, cst) => sum + (cst.formalDuplicates.length > 0 ? 1 : 0), 0),
-    count_missing_convention: items.reduce((sum, cst) => sum + (isMissingConvention(cst) ? 1 : 0), 0),
-    count_type_mismatch: items.reduce((sum, cst) => sum + (cst.is_type_mismatch ? 1 : 0), 0),
-    count_incorrect: items.reduce((sum, cst) => sum + (cst.status === CstStatus.INCORRECT ? 1 : 0), 0),
-    count_property: items.reduce((sum, cst) => sum + (cst.analysis?.valueClass === ValueClass.PROPERTY ? 1 : 0), 0),
-    count_incalculable: items.reduce(
-      (sum, cst) => sum + (cst.analysis?.success && cst.analysis.valueClass === null ? 1 : 0),
-      0
-    ),
-    count_inherited: items.reduce((sum, cst) => sum + (cst.is_inherited ? 1 : 0), 0),
-    count_text_term: items.reduce((sum, cst) => sum + (cst.term_raw ? 1 : 0), 0),
-    count_definition: items.reduce((sum, cst) => sum + (cst.definition_raw ? 1 : 0), 0),
-    count_convention: items.reduce((sum, cst) => sum + (isBasicConcept(cst.cst_type) && cst.convention ? 1 : 0), 0),
-    count_comment: items.reduce((sum, cst) => sum + (!isBasicConcept(cst.cst_type) && !cst.convention ? 1 : 0), 0),
-    count_base: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.BASE ? 1 : 0), 0),
-    count_constant: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.CONSTANT ? 1 : 0), 0),
-    count_structured: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STRUCTURED ? 1 : 0), 0),
-    count_axiom: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.AXIOM ? 1 : 0), 0),
-    count_term: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.TERM ? 1 : 0), 0),
-    count_function: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.FUNCTION ? 1 : 0), 0),
-    count_predicate: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.PREDICATE ? 1 : 0), 0),
-    count_statement: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STATEMENT ? 1 : 0), 0),
-    count_nominal: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.NOMINAL ? 1 : 0), 0)
-  };
-}
+	const items = target.items;
+	return {
+		count_all: items.length,
+		count_crucial: items.reduce((sum, cst) => sum + (cst.crucial ? 1 : 0), 0),
+		step_complexity: items.reduce((sum, cst) => sum + calculateStepComplexity(cst), 0),
+		count_problematic: items.reduce((sum, cst) => sum + (isSchemaIssue(cst) ? 1 : 0), 0),
+		count_homonyms: items.reduce((sum, cst) => sum + (cst.homonyms.length > 0 ? 1 : 0), 0),
+		count_formal_duplicates: items.reduce((sum, cst) => sum + (cst.formalDuplicates.length > 0 ? 1 : 0), 0),
+		count_missing_convention: items.reduce((sum, cst) => sum + (isMissingConvention(cst) ? 1 : 0), 0),
+		count_type_mismatch: items.reduce((sum, cst) => sum + (cst.is_type_mismatch ? 1 : 0), 0),
+		count_incorrect: items.reduce((sum, cst) => sum + (cst.status === CstStatus.INCORRECT ? 1 : 0), 0),
+		count_property: items.reduce((sum, cst) => sum + (cst.analysis?.valueClass === ValueClass.PROPERTY ? 1 : 0), 0),
+		count_incalculable: items.reduce((sum, cst) => sum + (cst.analysis?.success && cst.analysis.valueClass === null ? 1 : 0), 0),
+		count_inherited: items.reduce((sum, cst) => sum + (cst.is_inherited ? 1 : 0), 0),
+		count_text_term: items.reduce((sum, cst) => sum + (cst.term_raw ? 1 : 0), 0),
+		count_definition: items.reduce((sum, cst) => sum + (cst.definition_raw ? 1 : 0), 0),
+		count_convention: items.reduce((sum, cst) => sum + (isBasicConcept(cst.cst_type) && cst.convention ? 1 : 0), 0),
+		count_comment: items.reduce((sum, cst) => sum + (!isBasicConcept(cst.cst_type) && !cst.convention ? 1 : 0), 0),
+		count_base: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.BASE ? 1 : 0), 0),
+		count_constant: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.CONSTANT ? 1 : 0), 0),
+		count_structured: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STRUCTURED ? 1 : 0), 0),
+		count_axiom: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.AXIOM ? 1 : 0), 0),
+		count_term: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.TERM ? 1 : 0), 0),
+		count_function: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.FUNCTION ? 1 : 0), 0),
+		count_predicate: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.PREDICATE ? 1 : 0), 0),
+		count_statement: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.STATEMENT ? 1 : 0), 0),
+		count_nominal: items.reduce((sum, cst) => sum + (cst.cst_type === CstType.NOMINAL ? 1 : 0), 0)
+	};
+}
+/** Finds {@link Constituenta} by structure path. */
 function findCstByStructure(schema, target, path) {
-  for (const cst of schema.items) {
-    if (cst.spawner === target.id && cst.spawner_path) {
-      if (cst.spawner_path.length === path.length && cst.spawner_path.every((v, i) => v === path[i])) {
-        return cst;
-      }
-    }
-  }
-  return null;
+	for (const cst of schema.items) if (cst.spawner === target.id && cst.spawner_path) {
+		if (cst.spawner_path.length === path.length && cst.spawner_path.every((v, i) => v === path[i])) return cst;
+	}
+	return null;
 }
+/** Retrieves name for piece of target {@link Constituenta} structure. */
 function getStructureName(schema, target, path) {
-  const representation = findCstByStructure(schema, target, path);
-  if (representation) {
-    return `${representation.alias}: ${representation.term_resolved}`;
-  }
-  if (!isTypification(target.effectiveType)) {
-    return "";
-  }
-  const type = applyPath(target.effectiveType, path);
-  if (type?.typeID === TypeID.basic) {
-    const cst = schema.cstByAlias.get(type.baseID);
-    if (cst?.term_resolved) {
-      return `${cst.alias}: ${cst.term_resolved}`;
-    }
-  }
-  return "";
+	const representation = findCstByStructure(schema, target, path);
+	if (representation) return `${representation.alias}: ${representation.term_resolved}`;
+	if (!isTypification(target.effectiveType)) return "";
+	const type = applyPath(target.effectiveType, path);
+	if (type?.typeID === TypeID.basic) {
+		const cst = schema.cstByAlias.get(type.baseID);
+		if (cst?.term_resolved) return `${cst.alias}: ${cst.term_resolved}`;
+	}
+	return "";
 }
 function calculateStepComplexity(cst) {
-  if (cst.cst_type === CstType.AXIOM || cst.cst_type === CstType.NOMINAL || !isBasicConcept(cst.cst_type)) {
-    return 0;
-  }
-  if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT || !cst.effectiveType) {
-    return 1;
-  }
-  const type = cst.effectiveType;
-  return calculateTypificationComplexity(type) + 1;
+	if (cst.cst_type === CstType.AXIOM || cst.cst_type === CstType.NOMINAL || !isBasicConcept(cst.cst_type)) return 0;
+	if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT || !cst.effectiveType) return 1;
+	const type = cst.effectiveType;
+	return calculateTypificationComplexity(type) + 1;
 }
 function calculateTypificationComplexity(type) {
-  switch (type.typeID) {
-    case TypeID.basic:
-    case TypeID.integer:
-    case TypeID.anyTypification:
-      return 0;
-    case TypeID.tuple:
-      return type.factors.length + type.factors.reduce((sum, factor) => sum + calculateTypificationComplexity(factor), 0);
-    case TypeID.collection:
-      if (type.base.typeID === TypeID.tuple) {
-        let sum = 0;
-        type.base.factors.forEach((factor) => {
-          sum += calculateTypificationComplexity(factor);
-        });
-        return sum + type.base.factors.length;
-      } else if (type.base.typeID === TypeID.collection) {
-        return calculateTypificationComplexity(type.base) + 1;
-      }
-      return 0;
-  }
+	switch (type.typeID) {
+		case TypeID.basic:
+		case TypeID.integer:
+		case TypeID.anyTypification: return 0;
+		case TypeID.tuple: return type.factors.length + type.factors.reduce((sum, factor) => sum + calculateTypificationComplexity(factor), 0);
+		case TypeID.collection:
+			if (type.base.typeID === TypeID.tuple) {
+				let sum = 0;
+				type.base.factors.forEach((factor) => {
+					sum += calculateTypificationComplexity(factor);
+				});
+				return sum + type.base.factors.length;
+			} else if (type.base.typeID === TypeID.collection) return calculateTypificationComplexity(type.base) + 1;
+			return 0;
+	}
 }
 function isMissingConvention(cst) {
-  if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
-    if (!cst.convention || !cst.term_resolved) {
-      return true;
-    }
-  }
-  return false;
+	if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
+		if (!cst.convention || !cst.term_resolved) return true;
+	}
+	return false;
 }
+/** Evaluate if {@link Typification} can be used to produce structure. */
 function typeCanProduceStructure(type) {
-  if (type.typeID === TypeID.basic || type.typeID === TypeID.integer || type.typeID === TypeID.anyTypification) {
-    return false;
-  } else if (type.typeID === TypeID.tuple) {
-    return true;
-  } else {
-    return type.base.typeID !== TypeID.basic && type.base.typeID !== TypeID.integer && type.base.typeID !== TypeID.anyTypification;
-  }
-}
-export {
-  addAliasReference,
-  applyFilterCategory,
-  calculateSchemaStats,
-  canHaveFormalDefinition,
-  canHaveManualTypification,
-  canProduceStructure,
-  findCstByStructure,
-  generateAlias,
-  getAnalysisFor,
-  getCstTypePrefix,
-  getStructureName,
-  guessCstType,
-  inferClass,
-  inferNewSpawnPosition,
-  inferStatus,
-  inferTemplate,
-  inferTemplatedType,
-  isBaseSet,
-  isBasicConcept,
-  isFunctional,
-  isLogical,
-  isSchemaIssue,
-  isTemplateCst,
-  removeAliasReference,
-  sortItemsForInlineSynthesis,
-  typeClassForCstType,
-  validateNewAlias
-};
+	if (type.typeID === TypeID.basic || type.typeID === TypeID.integer || type.typeID === TypeID.anyTypification) return false;
+	else if (type.typeID === TypeID.tuple) return true;
+	else return type.base.typeID !== TypeID.basic && type.base.typeID !== TypeID.integer && type.base.typeID !== TypeID.anyTypification;
+}
+//#endregion
+export { addAliasReference, applyFilterCategory, calculateSchemaStats, canHaveFormalDefinition, canHaveManualTypification, canProduceStructure, findCstByStructure, generateAlias, getAnalysisFor, getCstTypePrefix, getStructureName, guessCstType, inferClass, inferNewSpawnPosition, inferStatus, inferTemplate, inferTemplatedType, isBaseSet, isBasicConcept, isFunctional, isLogical, isSchemaIssue, isTemplateCst, removeAliasReference, sortItemsForInlineSynthesis, typeClassForCstType, validateAliasFormat, validateNewAlias };
+
 //# sourceMappingURL=rsform-api.js.map