@rsconcept/domain 1.0.0

package/dist/library/oss-api.js

@@ -0,0 +1,1105 @@
+// src/graph/graph.ts
+var GraphNode = class _GraphNode {
+  /** Unique identifier of the node. */
+  id;
+  /** List of outgoing nodes. */
+  outputs;
+  /** List of incoming nodes. */
+  inputs;
+  constructor(id) {
+    this.id = id;
+    this.outputs = [];
+    this.inputs = [];
+  }
+  clone() {
+    const result = new _GraphNode(this.id);
+    result.outputs = [...this.outputs];
+    result.inputs = [...this.inputs];
+    return result;
+  }
+  addOutput(node) {
+    this.outputs.push(node);
+  }
+  addInput(node) {
+    this.inputs.push(node);
+  }
+  removeInput(target) {
+    const index = this.inputs.findIndex((node) => node === target);
+    return index > -1 ? this.inputs.splice(index, 1)[0] : null;
+  }
+  removeOutput(target) {
+    const index = this.outputs.findIndex((node) => node === target);
+    return index > -1 ? this.outputs.splice(index, 1)[0] : null;
+  }
+};
+var Graph = class _Graph {
+  /** Map of nodes. */
+  nodes = /* @__PURE__ */ new Map();
+  constructor(arr) {
+    if (!arr) {
+      return;
+    }
+    arr.forEach((edge) => {
+      if (edge.length === 1) {
+        this.addNode(edge[0]);
+      } else {
+        this.addEdge(edge[0], edge[1]);
+      }
+    });
+  }
+  clone() {
+    const result = new _Graph();
+    this.nodes.forEach((node) => result.nodes.set(node.id, node.clone()));
+    return result;
+  }
+  at(target) {
+    return this.nodes.get(target);
+  }
+  addNode(target) {
+    let node = this.nodes.get(target);
+    if (!node) {
+      node = new GraphNode(target);
+      this.nodes.set(target, node);
+    }
+    return node;
+  }
+  hasNode(target) {
+    return !!this.nodes.get(target);
+  }
+  removeNode(target) {
+    this.nodes.forEach((node) => {
+      node.removeInput(target);
+      node.removeOutput(target);
+    });
+    this.nodes.delete(target);
+  }
+  foldNode(target) {
+    const nodeToRemove = this.nodes.get(target);
+    if (!nodeToRemove) {
+      return;
+    }
+    nodeToRemove.inputs.forEach((input) => {
+      nodeToRemove.outputs.forEach((output) => {
+        this.addEdge(input, output);
+      });
+    });
+    this.removeNode(target);
+  }
+  removeIsolated() {
+    const result = [];
+    this.nodes.forEach((node) => {
+      if (node.outputs.length === 0 && node.inputs.length === 0) {
+        result.push(node);
+        this.nodes.delete(node.id);
+      }
+    });
+    return result;
+  }
+  addEdge(source, destination) {
+    if (this.hasEdge(source, destination)) {
+      return;
+    }
+    const sourceNode = this.addNode(source);
+    const destinationNode = this.addNode(destination);
+    sourceNode.addOutput(destinationNode.id);
+    destinationNode.addInput(sourceNode.id);
+  }
+  removeEdge(source, destination) {
+    const sourceNode = this.nodes.get(source);
+    const destinationNode = this.nodes.get(destination);
+    if (sourceNode && destinationNode) {
+      sourceNode.removeOutput(destination);
+      destinationNode.removeInput(source);
+    }
+  }
+  hasEdge(source, destination) {
+    const sourceNode = this.nodes.get(source);
+    if (!sourceNode) {
+      return false;
+    }
+    return !!sourceNode.outputs.find((id) => id === destination);
+  }
+  isReachable(source, destination) {
+    return this.expandAllOutputs([source]).includes(destination);
+  }
+  rootNodes() {
+    return [...this.nodes.keys()].filter((id) => !this.nodes.get(id)?.inputs.length);
+  }
+  expandOutputs(origin) {
+    const result = [];
+    origin.forEach((id) => {
+      const node = this.nodes.get(id);
+      if (node) {
+        node.outputs.forEach((child) => {
+          if (!origin.includes(child) && !result.includes(child)) {
+            result.push(child);
+          }
+        });
+      }
+    });
+    return result;
+  }
+  expandInputs(origin) {
+    const result = [];
+    origin.forEach((id) => {
+      const node = this.nodes.get(id);
+      if (node) {
+        node.inputs.forEach((child) => {
+          if (!origin.includes(child) && !result.includes(child)) {
+            result.push(child);
+          }
+        });
+      }
+    });
+    return result;
+  }
+  expandAllOutputs(origin) {
+    const result = this.expandOutputs(origin);
+    if (result.length === 0) {
+      return [];
+    }
+    const marked = /* @__PURE__ */ new Map();
+    origin.forEach((id) => marked.set(id, true));
+    let position = 0;
+    while (position < result.length) {
+      const node = this.nodes.get(result[position]);
+      if (node && !marked.get(node.id)) {
+        marked.set(node.id, true);
+        node.outputs.forEach((child) => {
+          if (!marked.get(child) && !result.find((id) => id === child)) {
+            result.push(child);
+          }
+        });
+      }
+      position += 1;
+    }
+    return result;
+  }
+  expandAllInputs(origin) {
+    const result = this.expandInputs(origin);
+    if (result.length === 0) {
+      return [];
+    }
+    const marked = /* @__PURE__ */ new Map();
+    origin.forEach((id) => marked.set(id, true));
+    let position = 0;
+    while (position < result.length) {
+      const node = this.nodes.get(result[position]);
+      if (node && !marked.get(node.id)) {
+        marked.set(node.id, true);
+        node.inputs.forEach((child) => {
+          if (!marked.get(child) && !result.find((id) => id === child)) {
+            result.push(child);
+          }
+        });
+      }
+      position += 1;
+    }
+    return result;
+  }
+  maximizePart(origin) {
+    const outputs = this.expandAllOutputs(origin);
+    const result = [...origin];
+    this.topologicalOrder().filter((id) => outputs.includes(id)).forEach((id) => {
+      const node = this.nodes.get(id);
+      if (node?.inputs.every((parent) => result.includes(parent))) {
+        result.push(id);
+      }
+    });
+    return result;
+  }
+  topologicalOrder() {
+    const result = [];
+    const marked = /* @__PURE__ */ new Set();
+    const nodeStack = [];
+    this.nodes.forEach((node) => {
+      if (marked.has(node.id)) {
+        return;
+      }
+      nodeStack.push(node.id);
+      while (nodeStack.length > 0) {
+        const item = nodeStack[nodeStack.length - 1];
+        if (marked.has(item)) {
+          if (!result.find((id) => id === item)) {
+            result.push(item);
+          }
+          nodeStack.pop();
+        } else {
+          marked.add(item);
+          const itemNode = this.nodes.get(item);
+          if (itemNode && itemNode.outputs.length > 0) {
+            itemNode.outputs.forEach((child) => {
+              if (!marked.has(child)) {
+                nodeStack.push(child);
+              }
+            });
+          }
+        }
+      }
+    });
+    return result.reverse();
+  }
+  /**
+   * Stably reorders the given node ids so that, for this DAG, no node appears before a transitive
+   * successor (edges: source → dependent; {@link GraphNode.outputs} lists dependents).
+   */
+  sortStable(target) {
+    if (target.length <= 1) {
+      return [...target];
+    }
+    const reachable = this.buildTransitiveClosureForSort();
+    const testSet = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const nodeId of [...target].reverse()) {
+      const nodeReachable = reachable.get(nodeId) ?? /* @__PURE__ */ new Set();
+      const needMove = testSet.has(nodeId);
+      for (const childId of nodeReachable) {
+        testSet.add(childId);
+      }
+      if (!needMove) {
+        result.push(nodeId);
+        continue;
+      }
+      let inserted = false;
+      for (let index = 0; index < result.length; index++) {
+        const parent = result[index];
+        const parentReachable = reachable.get(parent) ?? /* @__PURE__ */ new Set();
+        if (nodeReachable.has(parent)) {
+          if (parentReachable.has(nodeId)) {
+            result.push(nodeId);
+          } else {
+            result.splice(index, 0, nodeId);
+          }
+          inserted = true;
+          break;
+        }
+      }
+      if (!inserted) {
+        result.push(nodeId);
+      }
+    }
+    result.reverse();
+    return result;
+  }
+  buildTransitiveClosureForSort() {
+    const closure = /* @__PURE__ */ new Map();
+    for (const node of this.nodes.values()) {
+      closure.set(node.id, new Set(node.outputs));
+    }
+    const order = this.topologicalOrder();
+    for (const nodeId of [...order].reverse()) {
+      const node = this.at(nodeId);
+      if (!node) {
+        continue;
+      }
+      const nodeClosure = closure.get(nodeId) ?? /* @__PURE__ */ new Set();
+      for (const parentId of node.inputs) {
+        const parentClosure = closure.get(parentId) ?? /* @__PURE__ */ new Set();
+        for (const childId of nodeClosure) {
+          parentClosure.add(childId);
+        }
+        closure.set(parentId, parentClosure);
+      }
+    }
+    return closure;
+  }
+  transitiveReduction() {
+    const order = this.topologicalOrder();
+    const marked = /* @__PURE__ */ new Map();
+    order.forEach((nodeID) => {
+      if (marked.get(nodeID)) {
+        return;
+      }
+      const stack = [];
+      stack.push({ id: nodeID, parents: [] });
+      while (stack.length > 0) {
+        const item = stack.splice(0, 1)[0];
+        const node = this.nodes.get(item.id);
+        if (node) {
+          node.outputs.forEach((child) => {
+            item.parents.forEach((parent) => this.removeEdge(parent, child));
+            stack.push({ id: child, parents: [item.id, ...item.parents] });
+          });
+        }
+        marked.set(item.id, true);
+      }
+    });
+  }
+  /**
+   * Finds a cycle in the graph.
+   *
+   * @returns {NodeID[] | null} The cycle if found, otherwise `null`.
+   * Uses non-recursive DFS.
+   */
+  findCycle() {
+    const visited = /* @__PURE__ */ new Set();
+    const nodeStack = /* @__PURE__ */ new Set();
+    const parents = /* @__PURE__ */ new Map();
+    for (const nodeId of this.nodes.keys()) {
+      if (visited.has(nodeId)) {
+        continue;
+      }
+      const callStack = [];
+      callStack.push({ nodeId, parentId: null });
+      while (callStack.length > 0) {
+        const { nodeId: nodeId2, parentId } = callStack[callStack.length - 1];
+        if (visited.has(nodeId2)) {
+          nodeStack.delete(nodeId2);
+          callStack.pop();
+          continue;
+        }
+        visited.add(nodeId2);
+        nodeStack.add(nodeId2);
+        if (parentId !== null) {
+          parents.set(nodeId2, parentId);
+        }
+        const currentNode = this.nodes.get(nodeId2);
+        for (const child of currentNode.outputs) {
+          if (!visited.has(child)) {
+            callStack.push({ nodeId: child, parentId: nodeId2 });
+            continue;
+          }
+          if (!nodeStack.has(child)) {
+            continue;
+          }
+          const cycle = [];
+          let current = nodeId2;
+          cycle.push(child);
+          while (current !== child) {
+            cycle.push(current);
+            current = parents.get(current);
+          }
+          cycle.push(child);
+          cycle.reverse();
+          return cycle;
+        }
+      }
+    }
+    return null;
+  }
+};
+
+// 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/api.ts
+var GLOBALS_REGEXP = /[XCSADFPTN]\d+/g;
+var TYPIFICATION_SET = /^ℬ+\([ℬ\(((X|C)\d+|Z)\)×]*\)$/g;
+function isSetTypification(text) {
+  return !!text.match(TYPIFICATION_SET);
+}
+function applyAliasMapping(target, mapping) {
+  return applyPattern(target, mapping, GLOBALS_REGEXP);
+}
+function applyTypificationMapping(target, mapping) {
+  const modified = applyAliasMapping(target, mapping);
+  if (modified === target) {
+    return target;
+  }
+  const deleteBrackets = [];
+  const positions = [];
+  const booleans = [];
+  let boolCount = 0;
+  let stackSize = 0;
+  for (let i = 0; i < modified.length; i++) {
+    const char = modified[i];
+    if (char === "\u212C") {
+      boolCount++;
+      continue;
+    }
+    if (char === "(") {
+      stackSize++;
+      positions.push(i);
+      booleans.push(boolCount);
+    }
+    boolCount = 0;
+    if (char === ")") {
+      if (i < modified.length - 1 && modified[i + 1] === ")" && stackSize > 1 && positions[stackSize - 2] + booleans[stackSize - 1] + 1 === positions[stackSize - 1]) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[stackSize - 2]);
+      }
+      if (i === modified.length - 1 && stackSize === 1 && positions[0] === 0) {
+        deleteBrackets.push(i);
+        deleteBrackets.push(positions[0]);
+      }
+      stackSize--;
+      positions.pop();
+      booleans.pop();
+    }
+  }
+  let result = "";
+  for (let i = 0; i < modified.length; i++) {
+    if (!deleteBrackets.includes(i)) {
+      result += modified[i];
+    }
+  }
+  return result;
+}
+function applyPattern(text, mapping, pattern) {
+  if (text === "" || pattern === null) {
+    return text;
+  }
+  let posInput = 0;
+  let output = "";
+  const patternMatches = text.matchAll(pattern);
+  for (const segment of patternMatches) {
+    const entity = segment[0];
+    const start = segment.index ?? 0;
+    if (entity in mapping) {
+      output += text.substring(posInput, start);
+      output += mapping[entity];
+      posInput = start + segment[0].length;
+    }
+  }
+  output += text.substring(posInput);
+  return output;
+}
+
+// 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/labels.ts
+var INTEGER_TYPE_NAME = "Z";
+var ANY_TYPE_NAME = "R0";
+var LOGIC_TYPE_NAME = "Logic";
+var labelTokenRecord = {
+  [TokenID.DECART]: "\xD7",
+  [TokenID.PUNCTUATION_PL]: "( )",
+  [TokenID.PUNCTUATION_SL]: "[ ]",
+  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
+  [TokenID.QUANTOR_EXISTS]: "\u2203",
+  [TokenID.LOGIC_NOT]: "\xAC",
+  [TokenID.LOGIC_AND]: "&",
+  [TokenID.LOGIC_OR]: "\u2228",
+  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
+  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
+  [TokenID.LIT_EMPTYSET]: "\u2205",
+  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
+  [TokenID.MULTIPLY]: "*",
+  [TokenID.EQUAL]: "=",
+  [TokenID.NOTEQUAL]: "\u2260",
+  [TokenID.GREATER_OR_EQ]: "\u2265",
+  [TokenID.LESSER_OR_EQ]: "\u2264",
+  [TokenID.SET_IN]: "\u2208",
+  [TokenID.SET_NOT_IN]: "\u2209",
+  [TokenID.SUBSET_OR_EQ]: "\u2286",
+  [TokenID.SUBSET]: "\u2282",
+  [TokenID.NOT_SUBSET]: "\u2284",
+  [TokenID.SET_INTERSECTION]: "\u2229",
+  [TokenID.SET_UNION]: "\u222A",
+  [TokenID.SET_MINUS]: "\\",
+  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
+  [TokenID.BOOLEAN]: "\u212C()",
+  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
+  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
+  [TokenID.NT_RECURSIVE_FULL]: "R{}",
+  [TokenID.BIGPR]: "Pr1()",
+  [TokenID.SMALLPR]: "pr1()",
+  [TokenID.FILTER]: "Fi1[]()",
+  [TokenID.REDUCE]: "red()",
+  [TokenID.CARD]: "card()",
+  [TokenID.BOOL]: "bool()",
+  [TokenID.DEBOOL]: "debool()",
+  [TokenID.ASSIGN]: ":=",
+  [TokenID.ITERATE]: ":\u2208"
+};
+function labelType(type) {
+  if (!type) {
+    return "N/A";
+  }
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return ANY_TYPE_NAME;
+    case TypeID.integer:
+      return INTEGER_TYPE_NAME;
+    case TypeID.basic:
+      return type.baseID;
+    case TypeID.tuple:
+      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
+    case TypeID.logic:
+      return LOGIC_TYPE_NAME;
+    case TypeID.predicate:
+    case TypeID.function:
+      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
+      return `[${argsText}] \u2192 ${labelType(type.result)}`;
+  }
+}
+
+// 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 extractBases(target) {
+  return new Set(extractBasesImpl(target));
+}
+function extractBasesImpl(target) {
+  switch (target.typeID) {
+    case TypeID.basic:
+      return [target.baseID];
+    case TypeID.collection:
+      return extractBasesImpl(target.base);
+    case TypeID.tuple:
+      return target.factors.reduce((result2, factor) => result2.concat(extractBasesImpl(factor)), []);
+    case TypeID.function:
+      const result = extractBasesImpl(target.result);
+      return target.args.reduce((result2, arg) => result2.concat(extractBasesImpl(arg.type)), result);
+    case TypeID.predicate:
+      return target.args.reduce((result2, arg) => result2.concat(extractBasesImpl(arg.type)), []);
+    default:
+      return [];
+  }
+}
+
+// src/library/oss.ts
+var NodeType = {
+  OPERATION: 1,
+  BLOCK: 2
+};
+var SubstitutionErrorType = {
+  invalidIDs: 0,
+  incorrectCst: 1,
+  invalidClasses: 2,
+  invalidBasic: 3,
+  invalidConstant: 4,
+  typificationCycle: 5,
+  baseSubstitutionNotSet: 6,
+  unequalTypification: 7,
+  unequalExpressions: 8,
+  unequalArgsCount: 9,
+  unequalArgs: 10,
+  invalidNominal: 11
+};
+
+// 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"
+};
+
+// src/library/oss-api.ts
+var STARTING_SUB_INDEX = 900;
+function constructNodeID(type, itemID) {
+  return type === NodeType.OPERATION ? "o" + String(itemID) : "b" + String(itemID);
+}
+function sortItemsForOSS(oss, items) {
+  const result = items.filter((item) => item.location === oss.location);
+  for (const item of items) {
+    if (item.visible && item.owner === oss.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;
+}
+var SubstitutionValidator = class {
+  errors = [];
+  suggestions = [];
+  schemas;
+  substitutions;
+  constituents = /* @__PURE__ */ new Set();
+  originals = /* @__PURE__ */ new Set();
+  mapping = /* @__PURE__ */ new Map();
+  cstByID = /* @__PURE__ */ new Map();
+  schemaByID = /* @__PURE__ */ new Map();
+  schemaByCst = /* @__PURE__ */ new Map();
+  constructor(schemas, substitutions) {
+    this.schemas = schemas;
+    this.substitutions = substitutions;
+    if (schemas.length === 0 || substitutions.length === 0) {
+      return;
+    }
+    for (const schema of schemas) {
+      this.schemaByID.set(schema.id, schema);
+      this.mapping.set(schema.id, {});
+      for (const item of schema.items) {
+        this.cstByID.set(item.id, item);
+        this.schemaByCst.set(item.id, schema);
+      }
+    }
+    let index = STARTING_SUB_INDEX;
+    for (const item of substitutions) {
+      this.constituents.add(item.original);
+      this.constituents.add(item.substitution);
+      this.originals.add(item.original);
+      const original = this.cstByID.get(item.original);
+      const substitution = this.cstByID.get(item.substitution);
+      if (!original || !substitution) {
+        return;
+      }
+      index++;
+      const newAlias = `${substitution.alias[0]}${index}`;
+      this.mapping.get(original.schema)[original.alias] = newAlias;
+      this.mapping.get(substitution.schema)[substitution.alias] = newAlias;
+    }
+  }
+  validate() {
+    this.errors = [];
+    this.suggestions = [];
+    this.calculateSuggestions();
+    if (this.substitutions.length === 0) {
+      return true;
+    }
+    if (!this.checkTypes()) {
+      return false;
+    }
+    if (!this.checkCycles()) {
+      return false;
+    }
+    if (!this.checkSubstitutions()) {
+      return false;
+    }
+    return true;
+  }
+  calculateSuggestions() {
+    const candidates = /* @__PURE__ */ new Map();
+    const minors = /* @__PURE__ */ new Set();
+    const schemaByCst = /* @__PURE__ */ new Map();
+    for (const schema of this.schemas) {
+      for (const cst of schema.items) {
+        if (this.originals.has(cst.id)) {
+          continue;
+        }
+        if (cst.cst_class === CstClass.BASIC || cst.definition_formal.length === 0) {
+          continue;
+        }
+        const inputs = schema.graph.at(cst.id).inputs;
+        if (inputs.some((id) => !this.constituents.has(id))) {
+          continue;
+        }
+        if (inputs.some((id) => this.originals.has(id))) {
+          minors.add(cst.id);
+        }
+        candidates.set(cst.id, applyAliasMapping(cst.definition_formal, this.mapping.get(schema.id)).replace(" ", ""));
+        schemaByCst.set(cst.id, schema);
+      }
+    }
+    for (const [key1, value1] of candidates) {
+      for (const [key2, value2] of candidates) {
+        if (key1 >= key2) {
+          continue;
+        }
+        if (schemaByCst.get(key1) === schemaByCst.get(key2)) {
+          continue;
+        }
+        if (value1 != value2) {
+          continue;
+        }
+        if (minors.has(key2)) {
+          this.suggestions.push({
+            original: key2,
+            substitution: key1
+          });
+        } else {
+          this.suggestions.push({
+            original: key1,
+            substitution: key2
+          });
+        }
+      }
+    }
+  }
+  checkTypes() {
+    for (const item of this.substitutions) {
+      const original = this.cstByID.get(item.original);
+      const substitution = this.cstByID.get(item.substitution);
+      if (!original || !substitution) {
+        return this.reportError(SubstitutionErrorType.invalidIDs, []);
+      }
+      if (substitution.analysis && original.analysis && (!original.analysis.success || !substitution.analysis.success)) {
+        return this.reportError(SubstitutionErrorType.incorrectCst, [substitution.alias, original.alias]);
+      }
+      switch (substitution.cst_type) {
+        case CstType.NOMINAL: {
+          if (original.cst_type !== CstType.NOMINAL) {
+            return this.reportError(SubstitutionErrorType.invalidNominal, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.BASE: {
+          if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT && original.cst_type !== CstType.NOMINAL) {
+            return this.reportError(SubstitutionErrorType.invalidBasic, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.CONSTANT: {
+          if (original.cst_type !== CstType.CONSTANT) {
+            return this.reportError(SubstitutionErrorType.invalidConstant, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.AXIOM:
+        case CstType.STATEMENT: {
+          if (original.cst_type !== CstType.AXIOM && original.cst_type !== CstType.STATEMENT) {
+            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.FUNCTION: {
+          if (original.cst_type !== CstType.FUNCTION) {
+            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.PREDICATE: {
+          if (original.cst_type !== CstType.PREDICATE) {
+            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+        case CstType.TERM:
+        case CstType.STRUCTURED: {
+          if (original.cst_type !== CstType.TERM && original.cst_type !== CstType.STRUCTURED && original.cst_type !== CstType.BASE) {
+            return this.reportError(SubstitutionErrorType.invalidClasses, [substitution.alias, original.alias]);
+          }
+          break;
+        }
+      }
+    }
+    return true;
+  }
+  checkCycles() {
+    const graph = new Graph();
+    for (const schema of this.schemas) {
+      for (const cst of schema.items) {
+        if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) {
+          graph.addNode(cst.id);
+        }
+      }
+    }
+    for (const item of this.substitutions) {
+      const original = this.cstByID.get(item.original);
+      const substitution = this.cstByID.get(item.substitution);
+      for (const cst of [original, substitution]) {
+        if (cst.cst_type === CstType.BASE || cst.cst_type === CstType.CONSTANT) {
+          continue;
+        }
+        graph.addNode(cst.id);
+        if (cst.effectiveType === null) {
+          continue;
+        }
+        const parents = extractBases(cst.effectiveType);
+        if (parents.size === 0) {
+          continue;
+        }
+        const schema = this.schemaByID.get(cst.schema);
+        for (const alias of parents) {
+          const parent = schema.cstByAlias.get(alias);
+          if (parent) {
+            graph.addEdge(parent.id, cst.id);
+          }
+        }
+      }
+      graph.addEdge(substitution.id, original.id);
+    }
+    const cycle = graph.findCycle();
+    if (cycle !== null) {
+      const cycleMsg = cycle.map((id) => {
+        const cst = this.cstByID.get(id);
+        const schema = this.schemaByID.get(cst.schema);
+        return `[${schema.alias}]-${cst.alias}`;
+      }).join(", ");
+      return this.reportError(SubstitutionErrorType.typificationCycle, [cycleMsg]);
+    }
+    return true;
+  }
+  checkSubstitutions() {
+    const baseMappings = this.prepareBaseMappings();
+    const typeMappings = this.calculateSubstituteMappings(baseMappings);
+    if (typeMappings === null) {
+      return false;
+    }
+    for (const item of this.substitutions) {
+      const original = this.cstByID.get(item.original);
+      if (original.cst_type === CstType.BASE || original.cst_type === CstType.CONSTANT || original.cst_type === CstType.NOMINAL) {
+        continue;
+      }
+      const substitution = this.cstByID.get(item.substitution);
+      if (original.cst_type === substitution.cst_type && original.cst_class !== CstClass.BASIC) {
+        if (!this.checkEqual(original, substitution)) {
+          this.reportError(SubstitutionErrorType.unequalExpressions, [substitution.alias, original.alias]);
+        }
+      }
+      if (original.analysis.success !== substitution.analysis.success) {
+        return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
+      }
+      if (!original.analysis.success || !substitution.analysis.success) {
+        continue;
+      }
+      const originalType = applyTypificationMapping(
+        applyAliasMapping(labelType(original.effectiveType), baseMappings.get(original.schema)),
+        typeMappings
+      );
+      const substitutionType = applyTypificationMapping(
+        applyAliasMapping(labelType(substitution.effectiveType), baseMappings.get(substitution.schema)),
+        typeMappings
+      );
+      if (originalType !== substitutionType) {
+        return this.reportError(SubstitutionErrorType.unequalTypification, [substitution.alias, original.alias]);
+      }
+    }
+    return true;
+  }
+  prepareBaseMappings() {
+    const result = /* @__PURE__ */ new Map();
+    let baseCount = 0;
+    let constCount = 0;
+    for (const schema of this.schemas) {
+      const mapping = {};
+      for (const cst of schema.items) {
+        if (cst.cst_type === CstType.BASE) {
+          baseCount++;
+          mapping[cst.alias] = `X${baseCount}`;
+        } else if (cst.cst_type === CstType.CONSTANT) {
+          constCount++;
+          mapping[cst.alias] = `C${constCount}`;
+        }
+        result.set(schema.id, mapping);
+      }
+    }
+    return result;
+  }
+  calculateSubstituteMappings(baseMappings) {
+    const result = {};
+    const processed = /* @__PURE__ */ new Set();
+    for (const item of this.substitutions) {
+      const original = this.cstByID.get(item.original);
+      if (original.cst_type !== CstType.BASE && original.cst_type !== CstType.CONSTANT) {
+        continue;
+      }
+      const originalAlias = baseMappings.get(original.schema)[original.alias];
+      const substitution = this.cstByID.get(item.substitution);
+      let substitutionText = "";
+      if (substitution.cst_type === original.cst_type || !substitution.effectiveType) {
+        substitutionText = baseMappings.get(substitution.schema)[substitution.alias];
+      } else {
+        const typeText = labelType(substitution.effectiveType);
+        substitutionText = applyAliasMapping(typeText, baseMappings.get(substitution.schema));
+        substitutionText = applyTypificationMapping(substitutionText, result);
+        if (!isSetTypification(substitutionText)) {
+          this.reportError(SubstitutionErrorType.baseSubstitutionNotSet, [substitution.alias, typeText]);
+          return null;
+        }
+        if (substitutionText.includes("\xD7") || substitutionText.startsWith("\u212C\u212C")) {
+          substitutionText = substitutionText.slice(1);
+        } else {
+          substitutionText = substitutionText.slice(2, -1);
+        }
+      }
+      for (const prevAlias of processed) {
+        result[prevAlias] = applyTypificationMapping(result[prevAlias], { [originalAlias]: substitutionText });
+      }
+      result[originalAlias] = substitutionText;
+      processed.add(originalAlias);
+    }
+    return result;
+  }
+  checkEqual(left, right) {
+    const schema1 = this.schemaByID.get(left.schema);
+    const inputs1 = schema1.graph.at(left.id).inputs;
+    if (inputs1.some((id) => !this.constituents.has(id))) {
+      return false;
+    }
+    const schema2 = this.schemaByID.get(right.schema);
+    const inputs2 = schema2.graph.at(right.id).inputs;
+    if (inputs2.some((id) => !this.constituents.has(id))) {
+      return false;
+    }
+    const expression1 = applyAliasMapping(left.definition_formal, this.mapping.get(schema1.id));
+    const expression2 = applyAliasMapping(right.definition_formal, this.mapping.get(schema2.id));
+    return expression1.replace(" ", "") === expression2.replace(" ", "");
+  }
+  reportError(errorType, params) {
+    this.errors.push({
+      errorType,
+      params
+    });
+    return false;
+  }
+};
+function getRelocateCandidates(source, destination, schema, oss) {
+  const destinationSchema = oss.operationByID.get(destination)?.result;
+  if (!destinationSchema) {
+    return [];
+  }
+  const node = oss.graph.at(source);
+  if (!node) {
+    return [];
+  }
+  if (node.outputs.includes(destination)) {
+    return schema.items;
+  }
+  const addedCst = schema.items.filter((item) => !item.is_inherited).map((cst) => cst.id);
+  const unreachableBases = [];
+  for (const cst of schema.items.filter((item) => item.is_inherited)) {
+    if (cst.parent_schema == destinationSchema) {
+      continue;
+    }
+    const parent = schema.inheritance.find((item) => item.child === cst.id && item.child_source === cst.schema)?.parent;
+    if (parent) {
+      const original = oss.substitutions.find((sub) => sub.substitution === parent)?.original;
+      if (original) {
+        continue;
+      }
+    }
+    unreachableBases.push(cst.id);
+  }
+  const unreachable = schema.graph.expandAllOutputs(unreachableBases);
+  return schema.items.filter(
+    (cst) => cst.parent_schema === destinationSchema || addedCst.includes(cst.id) && !unreachable.includes(cst.id)
+  );
+}
+export {
+  SubstitutionValidator,
+  constructNodeID,
+  getRelocateCandidates,
+  sortItemsForOSS
+};
+//# sourceMappingURL=oss-api.js.map