drakongen 1.4.7 → 1.7.0

package/browser/drakongen.js

@@ -14,7 +14,7 @@ function htmlToString(html) {
 
     root.childNodes.forEach((node) => {
         if (node.tagName === 'P') {
-            output.push(node.textContent.trim());
+            output.push(node.textContent);
         } else if (node.tagName === 'UL') {
             node.childNodes.forEach((item) => {
                 if (item.tagName === 'LI') {
@@ -39,16 +39,17 @@ const {drakonToStruct} = require("./drakonToStruct");
 const {printPseudo, printWithIndent, makeIndent} = require('./printPseudo');
 const {addRange, sortByProperty} = require("./tools")
 
-function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate) {    
-    var diagram = drakonToStruct(drakonJson, name, filename, translate)
+function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate, options) {    
+    var diagram = drakonToStruct(drakonJson, name, filename, translate, htmlToString, options)
     var lines = []
 
     lines.push("## " + translate("Procedure") + " \"" + diagram.name + "\"")
+    lines.push("")
     if (diagram.params) {
         lines.push(translate("Parameters") + ":")
         addRange(lines, htmlToString(diagram.params))
+        lines.push("")
     }    
-    lines.push("")
     lines.push(translate("Algorithm") + ":")    
     
     if (diagram.branches.length === 0) {
@@ -153,13 +154,21 @@ function createMindNode(name) {
 }
 
 module.exports = { drakonToPseudocode, mindToTree };
-},{"./drakonToStruct":3,"./printPseudo":5,"./tools":8}],3:[function(require,module,exports){
+},{"./drakonToStruct":3,"./printPseudo":7,"./tools":10}],3:[function(require,module,exports){
 const { structFlow, redirectNode } = require("./structFlow");
 const { createError, remove } = require("./tools");
 
 var translate;
 
-function drakonToStruct(drakonJson, name, filename, translateFunction) {
+function drakonToStruct(
+  drakonJson,
+  name,
+  filename,
+  translateFunction,
+  htmlToString,
+  options,
+) {
+  options = options || {};
   translate = translateFunction;
   let drakonGraph;
   try {
@@ -186,23 +195,112 @@ function drakonToStruct(drakonJson, name, filename, translateFunction) {
     };
   }
 
-  buildTwoWayConnections(nodes, firstNodeId);
+  handleParallel(nodes, undefined, firstNodeId, {}, undefined);
+  buildTwoWayConnections(nodes, firstNodeId, htmlToString);
 
   rewireSelectsMarkLoops(nodes, filename);
   branches.forEach((branch) =>
-    checkBranchIsReferenced(branch, firstNodeId, filename),
+    checkBranchIsReferenced(
+      branch,
+      firstNodeId,
+      filename,
+      options,
+      htmlToString,
+    ),
   );
   rewireShortcircuit(nodes, filename);
   branches.forEach((branch) => cutOffBranch(nodes, branch));
-  var branchTrees = structFlow(nodes, branches, filename, translate);
+  var branchTrees = structFlow(nodes, branches, filename, translate, options);
   return {
     name: name,
     params: drakonGraph.params || "",
     description: drakonGraph.description || "",
     branches: branchTrees,
+    secondary: findSecondary(branchTrees, options, htmlToString),
   };
 }
 
+function findSecondary(branchTrees, options, htmlToString) {
+  if (!options || !options.secondary) {
+    return undefined;
+  }
+  var ordinal = 0;
+  for (var branch of branchTrees) {
+    var name = htmlToString(branch.name)[0];
+    if (name === options.secondary) {
+      return ordinal;
+    }
+    ordinal++;
+  }
+  return undefined;
+}
+
+function handleParallel(nodes, prevNode, nodeId, visited, proc) {
+  if (!nodeId) {
+    return;
+  }
+  var node = nodes[nodeId];
+  if (node.type === "parend") {
+    if (!proc) {
+      throw new Error("handleParallel: no proc for parend");
+    }
+    var endId = proc.end;
+    var end;
+    if (endId) {
+      end = nodes[endId];
+    } else {
+      end = {
+        type: "end",
+        id: proc.id + "-" + proc.ordinal + "-end",
+        prev: [],
+      };
+      nodes[end.id] = end;
+      proc.end = end.id;
+      proc.next = node.one;
+    }
+    redirectNode(nodes, prevNode, nodeId, end.id);
+    return;
+  }
+  if (nodeId in visited) {
+    return;
+  }
+  visited[nodeId] = true;
+  if (node.type === "parbegin") {
+    node.procs = [];
+    var ordinal = 0;
+    var current = node;
+    while (true) {
+      var start = {
+        id: nodeId + "-" + ordinal + "-start",
+        type: "action",
+        prev: [],
+        one: current.one,
+      };
+      nodes[start.id] = start;
+      var childProc = {
+        id: nodeId,
+        ordinal: ordinal,
+        start: start.id,
+      };
+      var next = current.two;
+      node.procs.push(childProc);
+      handleParallel(nodes, start, start.one, {}, childProc);
+      delete current.one;
+      delete current.two;
+      if (!next) {
+        break;
+      }
+      current = nodes[next];
+      ordinal++;
+    }
+    node.one = node.procs[0].next;
+    handleParallel(nodes, node, node.one, visited, proc);
+  } else {
+    handleParallel(nodes, node, node.one, visited, proc);
+    handleParallel(nodes, node, node.two, visited, proc);
+  }
+}
+
 function drakonToGraph(drakonJson, name, filename, translateFunction) {
   translate = translateFunction;
   let drakonGraph;
@@ -227,7 +325,13 @@ function drakonToGraph(drakonJson, name, filename, translateFunction) {
   rewireSelectsMarkLoops(nodes, filename);
   rewireShortcircuit(nodes, filename);
   branches.forEach((branch) =>
-    checkBranchIsReferenced(branch, firstNodeId, filename),
+    checkBranchIsReferenced(
+      branch,
+      firstNodeId,
+      filename,
+      undefined,
+      undefined,
+    ),
   );
   branches.forEach((branch) => cutOffBranch(nodes, branch));
 
@@ -241,16 +345,35 @@ function drakonToGraph(drakonJson, name, filename, translateFunction) {
   };
 }
 
-function checkBranchIsReferenced(branch, firstNodeId, filename) {
+function checkBranchIsReferenced(
+  branch,
+  firstNodeId,
+  filename,
+  options,
+  htmlToString,
+) {
   if (branch.id === firstNodeId) {
     return;
   }
-  if (branch.prev.length === 0) {
-    throw createError(
-      translate("A silhouette branch is not referenced"),
-      filename,
-      branch.id,
-    );
+  if (options && htmlToString) {
+    var branchName = htmlToString(branch.content)[0];
+    if (branchName === options.secondary) {
+      if (branch.prev.length > 0) {
+        throw createError(
+          translate("A secondary branch is referenced"),
+          filename,
+          branch.id,
+        );
+      }
+    } else {
+      if (branch.prev.length === 0) {
+        throw createError(
+          translate("A silhouette branch is not referenced"),
+          filename,
+          branch.id,
+        );
+      }
+    }
   }
 }
 
@@ -327,14 +450,18 @@ function addFakeEnd(nodes, prev, node, end, addresses) {
   node.prev = remove(node.prev, prev.id);
 }
 
-function buildTwoWayConnections(nodes, firstNodeId) {
+function buildTwoWayConnections(nodes, firstNodeId, htmlToString) {
   for (var id in nodes) {
     var node = nodes[id];
     node.id = id;
     node.prev = [];
   }
 
-  traverse(nodes, firstNodeId, {}, connectBack);
+  var visitor = function (nodes, node) {
+    return connectBack(nodes, node, htmlToString);
+  };
+
+  traverse(nodes, firstNodeId, {}, visitor);
 }
 
 function findStartNode(nodes, filename, branches) {
@@ -373,6 +500,9 @@ function findStartNode(nodes, filename, branches) {
           id,
         );
       }
+    } else if (node.final) {
+      delete node.one
+      delete node.two
     }
   }
 
@@ -395,6 +525,7 @@ function rewireSelectsMarkLoops(nodes, filename) {
 
 function rewireSelect(nodes, selectNode, filename) {
   var caseNodeId = selectNode.one;
+  var caseNode0 = nodes[caseNodeId];
   while (caseNodeId) {
     var caseNode = nodes[caseNodeId];
     caseNodeId = caseNode.two;
@@ -434,6 +565,7 @@ function rewireSelect(nodes, selectNode, filename) {
       removeNodeOne(nodes, caseNode.id);
     }
   }
+  caseNode0.side = selectNode.side;
   removeNodeOne(nodes, selectNode.id);
 }
 
@@ -608,9 +740,14 @@ function traverse(nodes, nodeId, visited, action) {
   action(nodes, node);
   traverse(nodes, node.one, visited, action);
   traverse(nodes, node.two, visited, action);
+  if (node.procs) {
+    for (var proc of node.procs) {
+      traverse(nodes, proc.start, visited, action);
+    }
+  }
 }
 
-function connectBack(nodes, node) {
+function connectBack(nodes, node, htmlToString) {
   if (node.one) {
     var one = nodes[node.one];
     one.prev.push(node.id);
@@ -619,6 +756,25 @@ function connectBack(nodes, node) {
     var two = nodes[node.two];
     two.prev.push(node.id);
   }
+
+  if (node.side) {
+    var side = nodes[node.side].content;
+    if (side) {
+      node.side = decodeSide(side, htmlToString);
+    } else {
+      delete node.side;
+    }
+  }
+}
+
+function decodeSide(content, htmlToString) {
+  var text = htmlToString(content);
+  var oneLine = text.join(" ");
+  if (oneLine.indexOf("=") === -1) {
+    return translate("Do for") + " " + oneLine;
+  } else {
+    return translate("Start at") + " " + oneLine;
+  }
 }
 
 function markLoopBody(nodes, start, filename) {
@@ -641,32 +797,310 @@ function markLoopBody(nodes, start, filename) {
 
 module.exports = { drakonToStruct, drakonToGraph };
 
-},{"./structFlow":6,"./tools":8}],4:[function(require,module,exports){
-const { drakonToPseudocode, mindToTree } = require('./drakonToPromptStruct');
-const { htmlToString } = require("./browserTools")
-const { setUpLanguage, translate } = require("./translate")
+},{"./structFlow":8,"./tools":10}],4:[function(require,module,exports){
+const { drakonToPseudocode, mindToTree } = require("./drakonToPromptStruct");
+const { htmlToString } = require("./browserTools");
+const { setUpLanguage, translate } = require("./translate");
 const { drakonToStruct } = require("./drakonToStruct");
-
+const { freeDiagramToText } = require("./free");
 
 window.drakongen = {
-    toPseudocode: function (drakonJson, name, filename, language) {
-        setUpLanguage(language)
-        return drakonToPseudocode(drakonJson, name, filename, htmlToString, translate).text
-    },
+  toPseudocode: function (drakonJson, name, filename, language) {
+    setUpLanguage(language);
+    return drakonToPseudocode(
+      drakonJson,
+      name,
+      filename,
+      htmlToString,
+      translate,
+    ).text;
+  },
+
+  toMindTree: function (mindJson, name, filename, language) {
+    setUpLanguage(language);
+    var result = mindToTree(mindJson, name, filename, htmlToString);
+    return result.text;
+  },
+
+  freeToText: function (freeJson, name, filename, language) {
+    setUpLanguage(language);
+    var result = freeDiagramToText(
+      freeJson,
+      name,
+      filename,
+      translate,
+      htmlToString,
+    );
+    return result.text;
+  },
+
+  toTree: function (drakonJson, name, filename, language, options) {
+    setUpLanguage(language);
+    var result = drakonToStruct(
+      drakonJson,
+      name,
+      filename,
+      translate,
+      htmlToString,
+      options,
+    );
+    return JSON.stringify(result, null, 4);
+  },
+};
+
+},{"./browserTools":1,"./drakonToPromptStruct":2,"./drakonToStruct":3,"./free":5,"./translate":11}],5:[function(require,module,exports){
+var {addRange} = require("./tools")
+const { createError } = require("./tools");
 
-    toMindTree: function (mindJson, name, filename, language) {
-        setUpLanguage(language)    
-        var result = mindToTree(mindJson, name, filename, htmlToString)
-        return result.text
-    },    
+var translate
 
-    toTree: function (drakonJson, name, filename, language) {
-        setUpLanguage(language)
-        var result = drakonToStruct(drakonJson, name, filename, translate)
-        return JSON.stringify(result, null, 4)
+function compareVertically(box1, box2) {
+  if (box1.top + box1.height <= box2.top) return -1;
+  if (box2.top + box2.height <= box1.top) return 1;
+  return 0;
+}
+
+function compareHorizontally(box1, box2) {
+  if (box1.left + box1.width <= box2.left) return -1;
+  if (box2.left + box2.width <= box1.left) return 1;
+  return 0;
+}
+
+function byTopLeft(box1, box2) {
+    var vertical = compareVertically(box1, box2)
+    if (vertical == 0) {
+        return compareHorizontally(box1, box2)
+    }
+    return vertical
+}
+
+function parseDiagram(freeJson, filename) {
+    let diagram;
+    try {
+        freeJson = freeJson || ""
+        freeJson = freeJson.trim()
+        freeJson = freeJson || "{}"
+        diagram = JSON.parse(freeJson);
+    } catch (error) {
+        var message = translate("Error parsing JSON") + ": " + error.message
+        throw createError(message, filename)
+    }    
+    return diagram
+}
+
+function sortedItems(diagram) {    
+    var items = diagram.items || {};
+    var result = [];
+    for (var id in items) {
+        var item = items[id];
+        if (item.content && item.top && item.left && item.width && item.height) {
+            result.push(item);
+        }
     }
+    result.sort(byTopLeft);
+    return result;
 }
-},{"./browserTools":1,"./drakonToPromptStruct":2,"./drakonToStruct":3,"./translate":9}],5:[function(require,module,exports){
+
+function freeDiagramToText(freeJson, name, filename, translateFunction, htmlToString) {
+    translate = translateFunction
+    var diagram = parseDiagram(freeJson, filename)
+    var sorted = sortedItems(diagram)
+    var lines = []
+    lines.push("## " + name)
+    lines.push("")
+    for (var item of sorted) {
+        var content = htmlToString(item.content)
+        addRange(lines, content)
+        lines.push("")
+    }
+    var text = lines.join("\n")
+    return {text:text}
+}
+
+module.exports = {freeDiagramToText}
+},{"./tools":10}],6:[function(require,module,exports){
+"use strict";
+
+function decrement_if_count(context, node) {
+    var i;
+    var if_id;
+    var if_node;
+
+    for (i = 0; i < node.stack.length; i++) {
+        if_id = node.stack[i];
+        if_node = context.nodes[if_id];
+        if_node.branching--;
+    }
+}
+
+function flow_no_loop(nodes, start_node_id) {
+    var context;
+
+    context = {
+        nodes: nodes
+    };
+
+    traverse_node(
+        context,
+        start_node_id,
+        []
+    );
+}
+
+function group_stack_by_id(stack) {
+    var counts_by_id;
+    var i;
+    var element;
+    var existing;
+
+    counts_by_id = {};
+
+    for (i = 0; i < stack.length; i++) {
+        element = stack[i];
+
+        if (element in counts_by_id) {
+            existing = counts_by_id[element];
+        } else {
+            existing = 0;
+        }
+
+        counts_by_id[element] = existing + 1;
+    }
+
+    return counts_by_id;
+}
+
+function increment_if_count(context, node) {
+    var i;
+    var if_id;
+    var if_node;
+
+    for (i = 0; i < node.stack.length; i++) {
+        if_id = node.stack[i];
+        if_node = context.nodes[if_id];
+        if_node.branching++;
+    }
+}
+
+function merge_incoming_branches(context, node_id, node, stack) {
+    var common;
+    var counts_by_id;
+    var processed_stack;
+    var ids;
+    var i;
+    var id;
+    var count;
+    var if_node;
+
+    common = node.stack.concat(stack);
+    counts_by_id = group_stack_by_id(common);
+    processed_stack = [];
+
+    ids = Object.keys(counts_by_id);
+
+    for (i = 0; i < ids.length; i++) {
+        id = ids[i];
+        count = counts_by_id[id];
+
+        if_node = context.nodes[id];
+
+        if (!if_node.next) {
+            if (if_node.branching === 1) {
+                if_node.next = node_id;
+            } else {
+                if_node.branching -= count - 1;
+
+                if (if_node.branching === 1) {
+                    if_node.next = node_id;
+                } else {
+                    processed_stack.push(id);
+                }
+            }
+        }
+    }
+
+    node.stack = processed_stack;
+}
+
+function recurse_traversal(context, node_id, node) {
+    var stack1;
+    var stack2;
+
+    if (node.type === "question") {
+        increment_if_count(
+            context,
+            node
+        );
+
+        stack1 = node.stack.slice();
+        stack1.push(node_id);
+
+        stack2 = node.stack.slice();
+        stack2.push(node_id);
+
+        traverse_node(
+            context,
+            node.one,
+            stack1
+        );
+
+        traverse_node(
+            context,
+            node.two,
+            stack2
+        );
+    } else {
+        if (node.final) {
+            decrement_if_count(
+                context,
+                node
+            );
+        } else {
+            stack1 = node.stack.slice();
+
+            traverse_node(
+                context,
+                node.one,
+                stack1
+            );
+        }
+    }
+}
+
+function traverse_node(context, node_id, stack) {
+    var node;
+
+    if (node_id) {
+        node = context.nodes[node_id];
+
+        if (!node.stack) {
+            node.stack = [];
+            node.refs = node.prev.length;
+        }
+
+        node.refs--;
+
+        merge_incoming_branches(
+            context,
+            node_id,
+            node,
+            stack
+        );
+
+        if (!(node.refs > 0)) {
+            recurse_traversal(
+                context,
+                node_id,
+                node
+            );
+        }
+    }
+}
+
+module.exports = {
+    flow_no_loop: flow_no_loop
+};
+},{}],7:[function(require,module,exports){
 var {addRange} = require("./tools")
 
 function makeIndent(depth) {
@@ -679,8 +1113,11 @@ function printWithIndent(lines, indent, output) {
 }
 
 function printPseudo(algorithm, translate, output, htmlToString) {
-    function printStructuredContent(content, indent, output) {
+    function printStructuredContent(content, indent, output, side) {
         var lines = printStructuredContentNoIdent(content)
+        if (side) {
+            lines[0] = side + ": " + lines[0]
+        }
         printWithIndent(lines, indent, output)
     }
 
@@ -744,19 +1181,39 @@ function printPseudo(algorithm, translate, output, htmlToString) {
                 printError(step, indent, output)
             } else if (step.type === "break") {
                 output.push(indent + translate("break"))
+            } else if (step.type === "parbegin") {
+                printParbegin(step, depth, output)
             } else {
                 printOther(step, indent, output)
             }
         }
     }
+
+    function printParbegin(step, depth, output) {
+        const indent2 = makeIndent(depth + 1)
+        const indent = makeIndent(depth)
+        printWithIndent([translate("Group of parallel processes")], indent, output)
+        for (var proc of step.procs) {
+            printWithIndent([translate("Parallel process") + " " + (proc.ordinal + 1)], indent2, output)
+            printSteps(proc.body, depth + 2, output)
+        }
+    }
     
     function printOther(step, indent, output) {
+        var side = step.side
         if (!step.content && !step.secondary) {return}
         if (step.secondary) {            
-            printStructuredContent(step.secondary, indent, output)
+            printStructuredContent(step.secondary, indent, output, side)
+            side = undefined
         }
         if (step.content) {
-            printStructuredContent(step.content, indent, output)
+            var content = step.content
+            if (step.type === "pause") {
+                content = translate("Pause") + " " + htmlToString(content).join(" ")
+            } else if (step.type === "timer") {
+                content = translate("Start timer") + " " + htmlToString(content).join(" ")
+            }
+            printStructuredContent(content, indent, output, side)
         }
     }
 
@@ -797,6 +1254,9 @@ function printPseudo(algorithm, translate, output, htmlToString) {
         var content = step.content
         var lines = printStructuredContentNoIdent(content)
         lines[0] = translate("if") + " " + lines[0]
+        if (step.side) {
+            lines[0] = step.side + ": " + lines[0]
+        }
         printWithIndent(lines, indent, output)
         addRange(output, yesBody)            
         if (!empty(noBody)) {
@@ -825,392 +1285,440 @@ function printPseudo(algorithm, translate, output, htmlToString) {
 }
 
 module.exports = {printPseudo, printWithIndent, makeIndent}
-},{"./tools":8}],6:[function(require,module,exports){
-var {buildTree} = require("./technicalTree")
+},{"./tools":10}],8:[function(require,module,exports){
+var { buildTree } = require("./technicalTree");
 const { createError, sortByProperty } = require("./tools");
-const { optimizeTree } = require("./treeTools")
+const { optimizeTree } = require("./treeTools");
+const { flow_no_loop } = require("./noloop")
 
 function redirectNode(nodes, node, from, to) {
-    if (node.one === from) {
-        node.one = to;
-    }
-    if (node.two === from) {
-        node.two = to;
-    }
-    if (node.next === from) {
-        node.next = to
-    }
-    if (node.start && node.type === "loopend") {
-        start = nodes[node.start]
-        if (start.next === from) {
-            start.next = to
-        }
+  if (node.one === from) {
+    node.one = to;
+  }
+  if (node.two === from) {
+    node.two = to;
+  }
+  if (node.next === from) {
+    node.next = to;
+  }
+  if (node.start && node.type === "loopend") {
+    start = nodes[node.start];
+    if (start.next === from) {
+      start.next = to;
     }
+  }
 }
 
-function structFlow(nodes, branches, filename, translate) {
-
-
-
-    function flowGraph(nodes, nodeId, branchingStack) {
-        if (!nodeId) {return;}
-
-        const node = nodes[nodeId];
+function structFlow(nodes, branches, filename, translate, options) {
+  function flowGraph(nodes, nodeId, branchingStack) {
+    if (!nodeId) {
+      return;
+    }
 
-        if (!node.stack) {
-            node.stack = [];
-            node.remaining = node.prev.length;
-        }
-        node.remaining--;
+    const node = nodes[nodeId];
 
-        mergeBranchingStack(nodes, node, branchingStack);
-        if (node.remaining > 0) {return;}       
+    if (!node.stack) {
+      node.stack = [];
+      node.remaining = node.prev.length;
+    }
+    node.remaining--;
 
-        if (node.type === "question") {
-            for (let i = 0; i < node.stack.length; i++) {
-                const questionId = node.stack[i];
-                const question = nodes[questionId];
-                question.branching++;
-            }
+    mergeBranchingStack(nodes, node, branchingStack);
+    if (node.remaining > 0) {
+      return;
+    }
 
-            const stackOne = node.stack.slice();
-            const stackTwo = node.stack.slice();
-            stackOne.push(nodeId);
-            stackTwo.push(nodeId);
+    if (node.type === "question") {
+      for (let i = 0; i < node.stack.length; i++) {
+        const questionId = node.stack[i];
+        const question = nodes[questionId];
+        question.branching++;
+      }
 
-            flowGraph(nodes, node.two, stackTwo);
-            flowGraph(nodes, node.one, stackOne);
-        } else if (node.type === "arrow-loop") {
-            const stackOne = node.stack.slice();
-            stackOne.push(nodeId);
-            flowGraph(nodes, node.one, stackOne);
-        } else if (node.type === "arrow-stub") {
-            decrementBranchingForArrow(nodes, node)
-        } else {
-            flowGraph(nodes, node.one, node.stack);
-        }
+      const stackOne = node.stack.slice();
+      const stackTwo = node.stack.slice();
+      stackOne.push(nodeId);
+      stackTwo.push(nodeId);
+
+      flowGraph(nodes, node.two, stackTwo);
+      flowGraph(nodes, node.one, stackOne);
+    } else if (node.type === "arrow-loop") {
+      const stackOne = node.stack.slice();
+      stackOne.push(nodeId);
+      flowGraph(nodes, node.one, stackOne);
+    } else if (node.type === "arrow-stub") {
+      decrementBranchingForArrow(nodes, node);
+    } else if (node.type === "parbegin") {
+      for (var proc of node.procs) {
+        flowGraph(nodes, proc.start, []);
+      }
+      flowGraph(nodes, node.one, node.stack);
+    } else {
+      flowGraph(nodes, node.one, node.stack);
     }
+  }
 
-    function decrementBranchingForArrow(nodes, node) {        
-        var algonode = nodes[node.arrow]
-        algonode.branching--        
-    }
+  function decrementBranchingForArrow(nodes, node) {
+    var algonode = nodes[node.arrow];
+    algonode.branching--;
+  }
 
-    function decrementQuestions(nodes, algonode, dictionary) {
-        var stub = nodes[algonode.stub]
-        for (var id of stub.stack) {
-            var snode = nodes[id]
-            if (id != algonode) {
-                if (id in dictionary) {
-                    snode.branching--
-                }
-            }
+  function decrementQuestions(nodes, algonode, dictionary) {
+    var stub = nodes[algonode.stub];
+    for (var id of stub.stack) {
+      var snode = nodes[id];
+      if (id !== algonode.id) {
+        if (id in dictionary) {
+          snode.branching--;
         }
-        return stub
+      }
     }
+    return stub;
+  }
 
+  function mergeBranchingStack(nodes, node, branchingStack) {
+    // Append all elements of the branching stack to node.stack
+    addRange(node.stack, branchingStack);
 
+    // Build a dictionary of occurrences
+    const dictionary = buildDictionaryOfOccurences(node);
 
-    function mergeBranchingStack(nodes, node, branchingStack) {
-        // Append all elements of the branching stack to node.stack
-        addRange(node.stack, branchingStack)
+    // Merge all nodes
+    mergeAll(nodes, node, dictionary);
 
-        // Build a dictionary of occurrences
-        const dictionary = buildDictionaryOfOccurences(node);
+    // Rebuild the stack
+    node.stack = buildStackFromDictionary(dictionary);
+  }
 
-        // Merge all nodes
-        mergeAll(nodes, node, dictionary);
+  function addRange(dst, src) {
+    for (let i = 0; i < src.length; i++) {
+      dst.push(src[i]);
+    }
+  }
 
-        // Rebuild the stack
-        node.stack = buildStackFromDictionary(dictionary);
+  function buildStackFromDictionary(dictionary) {
+    const rebuiltStack = [];
+    for (const id in dictionary) {
+      if (dictionary[id] > 0) {
+        rebuiltStack.push(id);
+      }
     }
+    return rebuiltStack;
+  }
 
-    function addRange(dst, src) {
-        for (let i = 0; i < src.length; i++) {
-            dst.push(src[i]);
-        }
+  function buildDictionaryOfOccurences(node) {
+    const dictionary = {};
+    for (let i = 0; i < node.stack.length; i++) {
+      const id = node.stack[i];
+      dictionary[id] = (dictionary[id] || 0) + 1;
     }
+    return dictionary;
+  }
 
-    function buildStackFromDictionary(dictionary) {
-        const rebuiltStack = [];
-        for (const id in dictionary) {
-            if (dictionary[id] > 0) {
-                rebuiltStack.push(id);
-            }
+  function mergeAll(nodes, node, dictionary) {
+    for (const id in dictionary) {
+      const occurrences = dictionary[id];
+      const algonode = nodes[id];
+      if (occurrences > 1) {
+        algonode.branching--;
+        dictionary[id] = occurrences - 1;
+      }
+      if (algonode.branching === 1) {
+        if (algonode.type === "arrow-loop" && !algonode.next) {
+          if (!isInMap(node.astack, id)) {
+            algonode.next = node.id;
+            dictionary[algonode.id] = 0;
+            var stub = decrementQuestions(nodes, algonode, dictionary);
+            stub.one = node.id;
+          }
         }
-        return rebuiltStack;
+      }
     }
 
-    function buildDictionaryOfOccurences(node) {
-        const dictionary = {};
-        for (let i = 0; i < node.stack.length; i++) {
-            const id = node.stack[i];
-            dictionary[id] = (dictionary[id] || 0) + 1;
+    for (const id in dictionary) {
+      const algonode = nodes[id];
+      if (algonode.branching === 1) {
+        if (algonode.type === "question") {
+          algonode.next = node.id;
+          dictionary[algonode.id] = 0;
         }
-        return dictionary;
+      }
+    }
+  }
+  function isInMap(map, key) {
+    if (!map) {
+      return false;
     }
+    return key in map;
+  }
 
-    function mergeAll(nodes, node, dictionary) {
-        for (const id in dictionary) {
-            const occurrences = dictionary[id];
-            const algonode = nodes[id];
-            if (occurrences > 1) {
-                algonode.branching--;
-                dictionary[id] = occurrences - 1;
-            }
-            if (algonode.branching === 1) {
-                if (algonode.type === "arrow-loop" && !algonode.next) {
-                    if (!isInMap(node.astack, id)) {
-                        algonode.next = node.id
-                        dictionary[algonode.id] = 0;
-                        var stub = decrementQuestions(nodes, algonode, dictionary)
-                        stub.one = node.id
-                    }
-                }                
-            }            
-        }
-      
-        for (const id in dictionary) {
-            const algonode = nodes[id];
-            if (algonode.branching === 1) {
-                if (algonode.type === "question") {
-                    algonode.next = node.id;
-                    dictionary[algonode.id] = 0;
-                }                
-            }
-        }
+  function prepareQuestions(nodes) {
+    for (const nodeId in nodes) {
+      const node = nodes[nodeId];
+      if (node.type === "question") {
+        node.branching = 2;
+      } else if (node.type === "arrow-loop") {
+        node.branching = 1;
+      }
     }
-    function isInMap(map, key) {
-        if (!map) { return false }
-        return key in map
+  }
+
+  function rewireArrows(nodes, branches) {
+    branches.forEach((branch) =>
+      rewireArrowsInBranch(nodes, branch.id, branch.next, []),
+    );
+    for (var id in nodes) {
+      var node = nodes[id];
+      if (node.type === "arrow-loop") {
+        var stub = insertArrowStub(nodes, node);
+        var visited = {};
+        fillAStack(nodes, stub, stub.arrow, visited);
+      }
     }
+  }
 
-    function prepareQuestions(nodes) {
-        for (const nodeId in nodes) {
-            const node = nodes[nodeId];
-            if (node.type === "question") {
-                node.branching = 2;
-            } else if (node.type === "arrow-loop") {
-                node.branching = 1;
-            }
-        }
+  function fillAStack(nodes, node, arrowId, visited) {
+    if (node.id in visited) {
+      return;
     }
+    visited[node.id] = true;
+    if (!node.astack) {
+      node.astack = {};
+    }
+    node.astack[arrowId] = true;
+    if (node.id === arrowId) {
+      return;
+    }
+    for (var prevId of node.prev) {
+      var prev = nodes[prevId];
+      fillAStack(nodes, prev, arrowId, visited);
+    }
+  }
 
-    function rewireArrows(nodes, branches) {
-        branches.forEach(branch => rewireArrowsInBranch(nodes, branch.id, branch.next, []))
-        for (var id in nodes) {
-            var node = nodes[id]
-            if (node.type === "arrow-loop") {
-                var stub = insertArrowStub(nodes, node)
-                fillAStack(nodes, stub, stub.arrow)
-            }
-        }    
+  function rewireArrowsInBranch(nodes, prevNodeId, nodeId, arrowStack) {
+    if (!nodeId) {
+      return;
     }
-    
-    function fillAStack(nodes, node, arrowId) {
-        if (!node.astack) {
-            node.astack = {}
-        }
-        node.astack[arrowId] = true
-        if (node.id === arrowId) {
-            return
-        }    
-        for (var prevId of node.prev) {
-            var prev = nodes[prevId]
-            fillAStack(nodes, prev, arrowId)
-        }
+    var node = nodes[nodeId];
+    if (node.type === "branch") {
+      return;
     }
-    
-    function rewireArrowsInBranch(nodes, prevNodeId, nodeId, arrowStack) {
-        if (!nodeId) {return}
-        var node = nodes[nodeId]
-        if (node.type === "branch") {
-            return
-        }
-        if (node.type === "arrow-loop") {
-            if (!node.noloop) {
-                node.noloop = {}
-            }
-            if (arrowStack.includes(nodeId)) {
-                return            
-            }
-            node.noloop[prevNodeId] = true
-            arrowStack = arrowStack.slice()
-            arrowStack.push(nodeId)
-            rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack)
-        } else if (node.type === "question") {
-            var left = arrowStack.slice()
-            var right = arrowStack.slice()
-            rewireArrowsInBranch(nodes, nodeId, node.one, left)
-            rewireArrowsInBranch(nodes, nodeId, node.two, right)
-        } else {
-            rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack)
-        }
+    if (node.type === "arrow-loop") {
+      if (!node.noloop) {
+        node.noloop = {};
+      }
+      if (arrowStack.includes(nodeId)) {
+        return;
+      }
+      node.noloop[prevNodeId] = true;
+      arrowStack = arrowStack.slice();
+      arrowStack.push(nodeId);
+      rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack);
+    } else if (node.type === "question") {
+      var left = arrowStack.slice();
+      var right = arrowStack.slice();
+      rewireArrowsInBranch(nodes, nodeId, node.one, left);
+      rewireArrowsInBranch(nodes, nodeId, node.two, right);
+    } else if (node.type === "parbegin") {
+      for (var proc of node.procs) {
+        rewireArrowsInBranch(nodes, undefined, proc.start, []);
+      }
+      rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack);
+    } else {
+      rewireArrowsInBranch(nodes, nodeId, node.one, arrowStack);
     }
-    
-    function insertArrowStub(nodes, node) {
-        var stub = {
-            type: "arrow-stub",
-            id: "arrow-stub-" + node.id,
-            arrow: node.id,
-            prev: []
-        }
-        nodes[stub.id] = stub
-        node.stub = stub.id
-        var prev2 = []
-        for (var prevId of node.prev) {
-            if (prevId in node.noloop) {
-                prev2.push(prevId)
-            } else {
-                stub.prev.push(prevId)
-                var prev = nodes[prevId]
-                redirectNode(nodes, prev, node.id, stub.id)
-            }
-        }
-        node.prev = prev2
-        return stub
+  }
+
+  function insertArrowStub(nodes, node) {
+    var stub = {
+      type: "arrow-stub",
+      id: "arrow-stub-" + node.id,
+      arrow: node.id,
+      prev: [],
+    };
+    nodes[stub.id] = stub;
+    node.stub = stub.id;
+    var prev2 = [];
+    for (var prevId of node.prev) {
+      if (prevId in node.noloop) {
+        prev2.push(prevId);
+      } else {
+        stub.prev.push(prevId);
+        var prev = nodes[prevId];
+        redirectNode(nodes, prev, node.id, stub.id);
+      }
     }
+    node.prev = prev2;
+    return stub;
+  }
 
-    function rewriteTree(body, index, endId, output) {
-        while (index < body.length) {
-            var node = body[index]
-            index++
-            if (endId && node.id === endId) {
-                return index
-            }
-            if (node.type === "question") {
-                var transformed = rewriteQuestionTree(node, output)
-                if (endId) {                    
-                    var breakYes = findLoopEnd(transformed.yes, endId)
-                    var breakNo = findLoopEnd(transformed.no, endId) 
-                    if (breakYes || breakNo) {
-                        var toBreak = []
-                        findPlacesToBreak(transformed.yes, endId, toBreak)
-                        findPlacesToBreak(transformed.no, endId, toBreak)                        
-                        addBreaks(toBreak)
-                        return index    
-                    }
-                }
-            } else if (node.type === "loopbegin") {
-                var body2 = []
-                index = rewriteTree(body, index, node.end, body2)
-                output.push({
-                    id: node.id,
-                    type: "loop",
-                    content: node.content,
-                    body: body2
-                })
-            } else {
-                output.push(node)
-            }
-        }
+  function copySide(dst, src) {
+    if (src.side) {
+      dst.side = src.side;
     }
+  }
 
-    function findPlacesToBreak(body, endId, output) {
-        if (body.length === 0) {
-            output.push(body)
-            return
+  function rewriteTree(body, index, endId, output) {
+    while (index < body.length) {
+      var node = body[index];
+      index++;
+      if (endId && node.id === endId) {
+        return index;
+      }
+      if (node.type === "question") {
+        var transformed = rewriteQuestionTree(node, output);
+        copySide(transformed, node);
+        if (endId) {
+          var breakYes = findLoopEnd(transformed.yes, endId);
+          var breakNo = findLoopEnd(transformed.no, endId);
+          if (breakYes || breakNo) {
+            var toBreak = [];
+            findPlacesToBreak(transformed.yes, endId, toBreak);
+            findPlacesToBreak(transformed.no, endId, toBreak);
+            addBreaks(toBreak);
+            return index;
+          }
         }
-        var last = body[body.length - 1]
-        if (last.id === endId) {
-            return
-        }
-        if (last.type === "question") {
-            var qends = []
-            findPlacesToBreak(last.yes, endId, qends)
-            findPlacesToBreak(last.no, endId, qends)
-            if (qends.length === 2
-                && qends[0] === last.yes
-                && qends[1] === last.no) {
-                output.push(body)                
-            } else {
-                addRange(output, qends)
-            }
-        } else {
-            output.push(body)
+      } else if (node.type === "loopbegin") {
+        var body2 = [];
+        index = rewriteTree(body, index, node.end, body2);
+        output.push({
+          id: node.id,
+          type: "loop",
+          content: node.content,
+          body: body2,
+        });
+      } else if (node.type === "parbegin") {
+        var copy = {
+          id: node.id,
+          type: node.type,
+          procs: [],
+        };
+        for (var proc of node.procs) {
+          var procCopy = {
+            ordinal: proc.ordinal,
+            body: [],
+          };
+          copy.procs.push(procCopy);
+          rewriteTree(proc.body, 0, undefined, procCopy.body);
         }
+        output.push(copy);
+      } else {
+        output.push(node);
+      }
     }
+  }
 
-    function findLoopEnd(body, endId) {
-        for (var i = 0; i < body.length; i++) {
-            var node = body[i]
-            if (node.id === endId) {
-                if (i === body.length - 1) {
-                    return true
-                } else {
-                    throw createError(
-                        translate("An exit from the loop must lead to the point right after the loop end"),
-                        filename,
-                        node.id
-                    );
-                }
-            }
-            if (node.type === "question") {
-                if (findLoopEnd(node.yes, endId)) {
-                    return true
-                }
-                if (findLoopEnd(node.no, endId)) {
-                    return true
-                }                
-            }            
-        }
-        return false
+  function findPlacesToBreak(body, endId, output) {
+    if (body.length === 0) {
+      output.push(body);
+      return;
     }
+    var last = body[body.length - 1];
+    if (last.id === endId) {
+      return;
+    }
+    if (last.type === "question") {
+      var qends = [];
+      findPlacesToBreak(last.yes, endId, qends);
+      findPlacesToBreak(last.no, endId, qends);
+      if (qends.length === 2 && qends[0] === last.yes && qends[1] === last.no) {
+        output.push(body);
+      } else {
+        addRange(output, qends);
+      }
+    } else {
+      output.push(body);
+    }
+  }
 
-    function addBreaks(toBreak) {
-        for (var body of toBreak) {
-            body.push({
-                type: "break"
-            })
+  function findLoopEnd(body, endId) {
+    for (var i = 0; i < body.length; i++) {
+      var node = body[i];
+      if (node.id === endId) {
+        if (i === body.length - 1) {
+          return true;
+        } else {
+          throw createError(
+            translate(
+              "An exit from the loop must lead to the point right after the loop end",
+            ),
+            filename,
+            node.id,
+          );
+        }
+      }
+      if (node.type === "question") {
+        if (findLoopEnd(node.yes, endId)) {
+          return true;
         }
+        if (findLoopEnd(node.no, endId)) {
+          return true;
+        }
+      }
     }
+    return false;
+  }
 
-    function rewriteQuestionTree(question, output) {
-        var yes = []
-        var no = []
-        rewriteTree(question.yes, 0, undefined, yes)
-        rewriteTree(question.no, 0, undefined, no)
-        var transformed = {
-            type: "question",
-            id: question.id,
-            content: question.content,
-            yes: yes,
-            no: no
-        }
-        output.push(transformed)
-        return transformed
+  function addBreaks(toBreak) {
+    for (var body of toBreak) {
+      body.push({
+        type: "break",
+      });
     }
-    
+  }
 
-    function structMain() {
-        rewireArrows(nodes, branches)
-        prepareQuestions(nodes)    
-        var result = []
-        for (var branch of branches) {
-            flowGraph(nodes, branch.next, [])
-        }
-        
-        for (var branch of branches) {
-            var body = []
-            buildTree(nodes, branch.next, body, "<dummy id>")
-            var body2 = []
-            rewriteTree(body, 0, undefined, body2)
-            result.push({
-                name: branch.content,
-                branchId: branch.branchId,
-                start: branch.next,
-                refs: branch.prev.length,
-                body: optimizeTree(body2)
-            })
-        }
+  function rewriteQuestionTree(question, output) {
+    var yes = [];
+    var no = [];
+    rewriteTree(question.yes, 0, undefined, yes);
+    rewriteTree(question.no, 0, undefined, no);
+    var transformed = {
+      type: "question",
+      id: question.id,
+      content: question.content,
+      yes: yes,
+      no: no,
+    };
+    output.push(transformed);
+    return transformed;
+  }
+
+  function structMain() {
+    rewireArrows(nodes, branches);
+    prepareQuestions(nodes);
+    var result = [];
+
+    for (var branch of branches) {
+      if (options.noLoop) {
+        flow_no_loop(nodes, branch.next, []);
+      } else {
+        flowGraph(nodes, branch.next, []);
+      }
+    }
 
-        return sortByProperty(result, "branchId")
+    for (var branch of branches) {
+      var body = [];
+      buildTree(nodes, branch.next, body, "<dummy id>");
+      var body2 = [];
+      rewriteTree(body, 0, undefined, body2);
+      result.push({
+        name: branch.content,
+        branchId: branch.branchId,
+        start: branch.next,
+        refs: branch.prev.length,
+        body: optimizeTree(body2),
+      });
     }
 
-    return structMain()
+    return sortByProperty(result, "branchId");
+  }
+
+  return structMain();
 }
 module.exports = { structFlow, redirectNode };
-},{"./technicalTree":7,"./tools":8,"./treeTools":10}],7:[function(require,module,exports){
+
+},{"./noloop":6,"./technicalTree":9,"./tools":10,"./treeTools":12}],9:[function(require,module,exports){
 function buildTree(nodes, nodeId, body, stopId) {
     while (nodeId) {
         if (nodeId === stopId) {return;}
@@ -1250,6 +1758,21 @@ function buildTree(nodes, nodeId, body, stopId) {
                 start: node.arrow
             };
 
+            next = node.one;
+        } else if (node.type === "parbegin") {
+            transformed = {
+                id: node.id,
+                type: node.type,
+                procs: []
+            }            
+            for (var proc of node.procs) {
+                var childProc = {
+                    ordinal: proc.ordinal,
+                    body: []
+                }
+                transformed.procs.push(childProc)
+                buildTree(nodes, proc.start, childProc.body, undefined)
+            }
             next = node.one;
         } else {
             transformed = {
@@ -1268,8 +1791,13 @@ function buildTree(nodes, nodeId, body, stopId) {
                 ]
             )
             next = node.one;
+            if (node.final) {
+                next = undefined
+            }
+        }
+        if (node.side) {
+            transformed.side = node.side
         }
-
         body.push(transformed);
         nodeId = next;
     }
@@ -1285,6 +1813,9 @@ function copyFields(dst, src, fields) {
 }
 
 function reserveNext(nodes, node) {
+    if (!node.next) {
+        return undefined
+    }
     const target = nodes[node.next];
     if (target.targetTaken) {
         return undefined;
@@ -1296,7 +1827,7 @@ function reserveNext(nodes, node) {
 
 module.exports = {buildTree}
 
-},{}],8:[function(require,module,exports){
+},{}],10:[function(require,module,exports){
 
 function createError(message, filename, nodeId) {
     var error = new Error(message)
@@ -1337,7 +1868,7 @@ function addRange(to, from) {
     }
 }
 module.exports = { createError, sortByProperty, addRange, remove }
-},{}],9:[function(require,module,exports){
+},{}],11:[function(require,module,exports){
 var translationsRu = {
     "error": "ОШИБКА",
     "not": "не",
@@ -1366,7 +1897,13 @@ var translationsRu = {
     "Description": "Описание",
     "Algorithm": "Алгоритм",
     Remarks: "Замечания",
-    Parameters: "Параметры"
+    Parameters: "Параметры",
+    "Group of parallel processes": "Группа параллельных процессов",
+    "Parallel process": "Параллельный процесс",
+    "Start at": "Начать в",
+    "Do for": "Делать в течение",
+    "Pause": "Пауза",
+    "Start timer": "Запустить таймер"    
 }
 
 var translationsEn = {
@@ -1397,7 +1934,13 @@ var translationsEn = {
     Description: 'Description',
     Algorithm: 'Algorithm',
     Remarks: "Remarks",
-    Parameters: "Parameters"
+    Parameters: "Parameters",
+    "Group of parallel processes": "Group of parallel processes",
+    "Parallel process": "Parallel process",
+    "Start at": "Start at",
+    "Do for": "Do for",
+    "Pause": "Pause",
+    "Start timer": "Start timer",
 }
 
 var translationsNo = {
@@ -1428,7 +1971,13 @@ var translationsNo = {
     Description: 'Beskrivelse',
     Algorithm: 'Algoritme',
     Remarks: "Bemerkninger",
-    Parameters: "Parametere"
+    Parameters: "Parametere",
+    "Group of parallel processes": "Gruppe av parallelle prosesser",
+    "Parallel process": "Parallell prosess",
+    "Start at": "Start ved",
+    "Do for": "Gjør i",
+    "Pause": "Pause",
+    "Start timer": "Start tidtaker"
 };
 
 
@@ -1452,7 +2001,7 @@ function setUpLanguage(language) {
 
 
 module.exports = { setUpLanguage, translate };
-},{}],10:[function(require,module,exports){
+},{}],12:[function(require,module,exports){
 
 function optimizeTree(steps) {
     var result = []
@@ -1463,6 +2012,8 @@ function optimizeTree(steps) {
         var copy
         if (step.type === "question") {
             copy = optimizeQuestion(step)
+        } else if (step.type === "parbegin") {
+            copy = optimizeParbegin(step)
         } else if (step.type === "loop") {
             copy = optimizeLoop(step)
         } else {
@@ -1474,6 +2025,22 @@ function optimizeTree(steps) {
     return result
 }
 
+function optimizeParbegin(step) {
+    var procs = []
+    for (var proc of step.procs) {
+        var procCopy = {
+            ordinal: proc.ordinal,
+            body: optimizeTree(proc.body)
+        }
+        procs.push(procCopy)
+    }
+    return {
+        id: step.id,
+        type: step.type,
+        procs: procs
+    }
+}
+
 function optimizeLoop(step) {
     return {
         id: step.id,
@@ -1488,6 +2055,7 @@ function optimizeQuestion(step) {
     var no = optimizeTree(step.no)
     if (yes.length === 0 && no.length === 0) {
         return {
+            side: step.side,
             type: step.type,
             content: step.content,
             yes: [],
@@ -1496,6 +2064,7 @@ function optimizeQuestion(step) {
     }
     if (yes.length === 0) {
         return {
+            side: step.side,
             type: step.type,
             content: {operator:"not",operand:step.content},
             yes: no,
@@ -1503,6 +2072,7 @@ function optimizeQuestion(step) {
         }
     }
     return {
+        side: step.side,
         type: step.type,
         content: step.content,
         yes: yes,