@rsconcept/domain 1.0.0

package/dist/library/rsform-api.js

@@ -0,0 +1,879 @@
+// 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
+};
+
+// 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
+};
+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;
+}
+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;
+}
+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;
+  }
+}
+function inferTemplate(expression) {
+  const match = expression.match(/R\d+/g);
+  return (match && match?.length > 0) ?? false;
+}
+function inferClass(type, isTemplate = false) {
+  if (isTemplate) {
+    return CstClass.TEMPLATE;
+  }
+  return CST_TYPE_TO_CLASS[type];
+}
+function isTemplateCst(cst) {
+  return cst.cst_type === CstType.FUNCTION || cst.cst_type === CstType.PREDICATE || cst.cst_type === CstType.STATEMENT;
+}
+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));
+}
+function getCstTypePrefix(type) {
+  return CST_TYPE_PREFIX[type];
+}
+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;
+}
+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;
+  }
+}
+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;
+  }
+}
+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;
+  }
+}
+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;
+  }
+}
+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);
+}
+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;
+  }
+}
+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;
+}
+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;
+}
+function inferNewSpawnPosition(schema, targetId) {
+  let last = null;
+  for (const cst of schema.items) {
+    if (cst.spawner === targetId) {
+      last = cst.id;
+    }
+  }
+  return last ?? targetId;
+}
+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;
+}
+function removeAliasReference(expression, alias) {
+  const result = expression.replaceAll(new RegExp(`\\b${alias}\\b`, "g"), "DEL");
+  return result === "DEL" ? "" : result;
+}
+function addAliasReference(expression, alias) {
+  return expression + " " + alias;
+}
+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;
+  }
+}
+function canHaveFormalDefinition(cstType) {
+  return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
+}
+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
+  });
+}
+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)
+  };
+}
+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;
+}
+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 "";
+}
+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;
+}
+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;
+  }
+}
+function isMissingConvention(cst) {
+  if (isBasicConcept(cst.cst_type) && !isLogical(cst.cst_type)) {
+    if (!cst.convention || !cst.term_resolved) {
+      return true;
+    }
+  }
+  return false;
+}
+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
+};
+//# sourceMappingURL=rsform-api.js.map