@rsconcept/domain 1.0.0

package/dist/library/rsmodel-api.js

@@ -0,0 +1,836 @@
+// 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 bool(base) {
+  return { typeID: TypeID.collection, base };
+}
+
+// src/rslang/eval/value-api.ts
+function printValue(data) {
+  if (!Array.isArray(data)) {
+    return String(data);
+  }
+  const len = data.length;
+  if (data.length === 0) {
+    return "{}";
+  }
+  const isTuple = data[0] === TUPLE_ID;
+  const start = isTuple ? 1 : 0;
+  let result = isTuple ? "(" : "{";
+  for (let i = start; i < len; i++) {
+    if (i > start) result += ", ";
+    result += printValue(data[i]);
+  }
+  result += isTuple ? ")" : "}";
+  return result;
+}
+function isTupleValue(data) {
+  return Array.isArray(data) && data.length > 1 && data[0] === TUPLE_ID;
+}
+function extractValue(target, path) {
+  let current = target;
+  let i = 0;
+  while (i < path.length) {
+    if (!Array.isArray(current) || current.length <= path[i]) {
+      return null;
+    }
+    current = current[path[i]];
+    i++;
+  }
+  return current;
+}
+function makeDefaultValue(type) {
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+    case TypeID.integer:
+    case TypeID.basic:
+      return INVALID_ELEMENT;
+    case TypeID.collection:
+      return [];
+    case TypeID.tuple:
+      return tuple(type.factors.map((item) => makeDefaultValue(item)));
+  }
+}
+function setNestedValue(target, path, newVal) {
+  if (path.length === 0) {
+    return newVal;
+  }
+  const [head, ...rest] = path;
+  const arr = Array.isArray(target) ? [...target] : [];
+  arr[head] = setNestedValue(arr[head], makeValuePath(rest), newVal);
+  return arr;
+}
+
+// src/rslang/eval/value.ts
+var TUPLE_ID = -111;
+var INVALID_ELEMENT = -1;
+var VALUE_TRUE = 1;
+function makeValuePath(path) {
+  return path;
+}
+function compare(v1, v2) {
+  const stack1 = [v1];
+  const stack2 = [v2];
+  while (stack1.length > 0 && stack2.length > 0) {
+    const el1 = stack1.pop();
+    const el2 = stack2.pop();
+    if (el1 === el2) {
+      continue;
+    }
+    const type1 = typeof el1;
+    const type2 = typeof el2;
+    if (type1 === "number" && type2 === "number") {
+      const numDiff = el1 - el2;
+      if (numDiff !== 0) return numDiff;
+      continue;
+    }
+    const isArray1 = Array.isArray(el1);
+    const isArray2 = Array.isArray(el2);
+    if (!isArray1 || !isArray2) {
+      throw new Error(`Cannot compare different types ${printValue(el1)} and ${printValue(el2)}`);
+    }
+    const arr1 = el1;
+    const arr2 = el2;
+    const len1 = arr1.length;
+    const len2 = arr2.length;
+    if (len1 !== len2) {
+      return len1 - len2;
+    }
+    for (let i = len1 - 1; i >= 0; i--) {
+      stack1.push(arr1[i]);
+      stack2.push(arr2[i]);
+    }
+  }
+  return 0;
+}
+function tuple(components) {
+  return [TUPLE_ID, ...components];
+}
+
+// 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
+};
+
+// 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 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 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 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 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;
+}
+
+// src/library/rsmodel.ts
+var EvalStatus = {
+  NO_EVAL: 1,
+  // не вычисляется
+  NOT_PROCESSED: 2,
+  // Интерпретация не вычислялась
+  INVALID_DATA: 3,
+  // Неверные данные
+  EVAL_FAIL: 4,
+  // Ошибка при вычислении
+  AXIOM_FALSE: 5,
+  // Значение аксиомы = FALSE
+  EMPTY: 6,
+  // Значение пусто
+  HAS_DATA: 7
+  // Интерпретация вычислена и не пуста
+};
+
+// src/library/rsmodel-api.ts
+var RANDOM_INTEGER_MIN = -100;
+var RANDOM_INTEGER_MAX = 100;
+var DEFAULT_RANDOM_SET_ELEMENTS_COUNT = 5;
+function validateBasicBindingData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    return false;
+  }
+  return Object.entries(data).every(([key, value]) => typeof value === "string" && Number.isInteger(Number(key)));
+}
+function toBasicBinding(data) {
+  const result = {};
+  for (const [k, v] of Object.entries(data)) {
+    result[Number(k)] = v;
+  }
+  return result;
+}
+function validateValueData(data) {
+  if (typeof data === "number") {
+    return Number.isFinite(data);
+  }
+  if (!Array.isArray(data)) {
+    return false;
+  }
+  return data.every((item) => validateValueData(item));
+}
+function generateRandomValue(type, basics, cstByAlias, setElementsCount = DEFAULT_RANDOM_SET_ELEMENTS_COUNT) {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return Math.floor(Math.random() * (RANDOM_INTEGER_MAX - RANDOM_INTEGER_MIN + 1)) + RANDOM_INTEGER_MIN;
+    case TypeID.basic: {
+      const cst = cstByAlias.get(type.baseID);
+      const binding = cst ? basics.get(cst.id) : void 0;
+      const ids = Object.keys(binding ?? {}).map(Number);
+      if (ids.length === 0) {
+        return null;
+      }
+      return ids[Math.floor(Math.random() * ids.length)];
+    }
+    case TypeID.tuple: {
+      const factors = [];
+      for (const factor of type.factors) {
+        const sample = generateRandomValue(factor, basics, cstByAlias, setElementsCount);
+        if (sample === null) {
+          return null;
+        }
+        factors.push(sample);
+      }
+      return tuple(factors);
+    }
+    case TypeID.collection: {
+      const result = [];
+      const randomElementsCount = Math.floor(Math.random() * (setElementsCount + 1));
+      for (let i = 0; i < randomElementsCount; i++) {
+        const sample = generateRandomValue(type.base, basics, cstByAlias, setElementsCount);
+        if (sample === null) {
+          return null;
+        }
+        result.push(sample);
+      }
+      return result;
+    }
+    case TypeID.anyTypification:
+      return null;
+  }
+}
+function calculateModelStats(schema, engine, _engineGeneration) {
+  const items = schema.items;
+  const statusByID = /* @__PURE__ */ new Map();
+  for (const cst of items) {
+    statusByID.set(cst.id, engine.getCstStatus(cst.id));
+  }
+  return {
+    ...calculateSchemaStats(schema),
+    base_elements: items.reduce((sum, cst) => sum + countBaseElements(cst, engine), 0),
+    count_missing_base: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.EMPTY && isBasicConcept(cst.cst_type) ? 1 : 0),
+      0
+    ),
+    count_false_axioms: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.AXIOM_FALSE ? 1 : 0),
+      0
+    ),
+    count_invalid_data: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.INVALID_DATA ? 1 : 0),
+      0
+    ),
+    count_invalid_calculations: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.EVAL_FAIL || statusByID.get(cst.id) === EvalStatus.NOT_PROCESSED ? 1 : 0),
+      0
+    ),
+    count_empty_terms: items.reduce(
+      (sum, cst) => sum + (statusByID.get(cst.id) === EvalStatus.EMPTY && cst.cst_type === CstType.TERM ? 1 : 0),
+      0
+    )
+  };
+}
+function isModelIssue(engine, cst) {
+  const status = engine.getCstStatus(cst.id);
+  const isBasic = isBasicConcept(cst.cst_type);
+  return status === EvalStatus.EVAL_FAIL || status === EvalStatus.AXIOM_FALSE || status === EvalStatus.INVALID_DATA || isBasic && status === EvalStatus.EMPTY;
+}
+function isInterpretable(type) {
+  switch (type) {
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.STATEMENT:
+      return true;
+    case CstType.NOMINAL:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+function isInferrable(type) {
+  switch (type) {
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+    case CstType.TERM:
+      return true;
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+function inferEvalStatus(value, cstType, wasCalculated = true, isInvalid = false) {
+  if (isBaseSet(cstType) || cstType === CstType.STRUCTURED) {
+    if (isInvalid) {
+      return EvalStatus.INVALID_DATA;
+    }
+    if (value === null || Array.isArray(value) && value.length === 0) {
+      return EvalStatus.EMPTY;
+    }
+    return EvalStatus.HAS_DATA;
+  }
+  if (!isInferrable(cstType)) {
+    return EvalStatus.NO_EVAL;
+  }
+  if (!wasCalculated) {
+    return EvalStatus.NOT_PROCESSED;
+  }
+  if (value === null) {
+    return EvalStatus.EVAL_FAIL;
+  }
+  if (cstType === CstType.AXIOM && value !== VALUE_TRUE) {
+    return EvalStatus.AXIOM_FALSE;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return EvalStatus.EMPTY;
+  }
+  return EvalStatus.HAS_DATA;
+}
+function tryFixValue(value, type, targetAlias, targetValue) {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return false;
+    case TypeID.basic:
+      if (type.baseID !== targetAlias) {
+        return false;
+      }
+      if (typeof value !== "number") {
+        return null;
+      }
+      if (!targetValue.includes(value)) {
+        return null;
+      }
+      return false;
+    case TypeID.tuple: {
+      if (!isTupleValue(value)) {
+        return null;
+      }
+      let wasChanged2 = false;
+      for (let i = 0; i < type.factors.length; i++) {
+        const componentChanged = tryFixValue(value[i + 1], type.factors[i], targetAlias, targetValue);
+        if (componentChanged === null) {
+          return null;
+        }
+        if (componentChanged) {
+          wasChanged2 = true;
+        }
+      }
+      return wasChanged2;
+    }
+    case TypeID.collection:
+      if (!Array.isArray(value) || value.length > 1 && value[0] === TUPLE_ID) {
+        return null;
+      }
+      let wasChanged = false;
+      const removeElements = [];
+      for (const item of value) {
+        const elementChanged = tryFixValue(item, type.base, targetAlias, targetValue);
+        if (elementChanged === null || elementChanged === true) {
+          wasChanged = true;
+          if (elementChanged === null) {
+            removeElements.push(item);
+          }
+        }
+      }
+      for (const item of removeElements) {
+        const index = value.indexOf(item);
+        if (index !== -1) {
+          value.splice(index, 1);
+        }
+      }
+      if (wasChanged) {
+        value.sort((a, b) => compare(a, b));
+        let i = 1;
+        while (i < value.length) {
+          if (compare(value[i], value[i - 1]) === 0) {
+            value.splice(i, 1);
+          } else {
+            i++;
+          }
+        }
+      }
+      return wasChanged;
+    case TypeID.logic:
+    case TypeID.anyTypification:
+    case TypeID.predicate:
+    case TypeID.function:
+      return null;
+  }
+}
+function updateValueElement(value, path, newValue) {
+  return setNestedValue(value, path, newValue);
+}
+function deleteValueElement(value, path, type, target) {
+  if (path.length === 0 && type.typeID !== TypeID.collection) {
+    return null;
+  }
+  const arrayValue = extractValue(value, path);
+  const updatedArray = [...arrayValue.slice(0, target), ...arrayValue.slice(target + 1)];
+  return setNestedValue(value, path, updatedArray);
+}
+function addValueElement(value, path, type, currentType) {
+  if (path.length === 0 && type.typeID !== TypeID.collection) {
+    return makeDefaultValue(type);
+  }
+  const newElem = makeDefaultValue(currentType.base);
+  const arrayValue = extractValue(value, path) ?? [];
+  const updatedArray = [newElem, ...arrayValue];
+  return setNestedValue(value, path, updatedArray);
+}
+function countBaseElements(cst, engine) {
+  if (!isBasicConcept(cst.cst_type)) {
+    return 0;
+  }
+  const value = engine.getCstValue(cst.id);
+  if (value === null) {
+    return 0;
+  }
+  if (!Array.isArray(value) || value[0] === TUPLE_ID) {
+    return 1;
+  }
+  return value.length;
+}
+export {
+  addValueElement,
+  calculateModelStats,
+  deleteValueElement,
+  generateRandomValue,
+  inferEvalStatus,
+  isInferrable,
+  isInterpretable,
+  isModelIssue,
+  toBasicBinding,
+  tryFixValue,
+  updateValueElement,
+  validateBasicBindingData,
+  validateValueData
+};
+//# sourceMappingURL=rsmodel-api.js.map