drakongen 1.4.7 → 1.9.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) {
@@ -80,7 +81,7 @@ function drakonToPseudocode(drakonJson, name, filename, htmlToString, translate)
 }
 
 
-function mindToTree(drakonJson, name, filename, htmlToString) {
+function mindToTree(drakonJson, name, filename, htmlToString, outputToJson) {
     let drakonGraph;
     try {
         drakonJson = drakonJson || ""
@@ -93,14 +94,40 @@ function mindToTree(drakonJson, name, filename, htmlToString) {
     }
 
     const nodes = drakonGraph.items || {};
-    var root = createMindNode("## " + name)
-    nodes["root"] = root
-    connectMindNodesToParent(nodes)
-    sortMindChildren(nodes)
-    var lines = []
-    printMindNode(root, 0, lines, htmlToString, true)
-    lines.push("")
-    var text = lines.join("\n")
+    for (var id in nodes) {
+        var node = nodes[id]
+        node.id = id
+        delete node.type
+        delete node.treeType
+        if (node.content) {
+            node.content = htmlToString(node.content).join("\n")
+        }
+    }
+
+    var text;
+    if (outputToJson) {
+        var root = createMindNode(name)
+        root.name = root.content
+        delete root.content
+        nodes["root"] = root
+        connectMindNodesToParent(nodes)
+        sortMindChildren(nodes)
+        for (var id in nodes) {
+            var node = nodes[id]
+            delete node.parent
+            delete node.ordinal
+        }
+        text = JSON.stringify(root, null, 4)
+    } else {
+        var root = createMindNode("## " + name)
+        nodes["root"] = root
+        connectMindNodesToParent(nodes)
+        sortMindChildren(nodes)
+        var lines = []
+        printMindNode(root, 0, lines, htmlToString, true)
+        lines.push("")
+        text = lines.join("\n")
+    }
     return {text:text}
 }
 
@@ -144,22 +171,29 @@ function printMindNode(node, depth, lines, htmlToString, first) {
 
 function createMindNode(name) {
     return {
-        "type": "idea",
-        "content": "<p>" + name + "</p>",
+        "type": "graf",
+        "content": name,
         "parent": undefined,
-        "treeType": "treeview",
         "ordinal": 0
     }
 }
 
 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 {
@@ -175,32 +209,122 @@ function drakonToStruct(drakonJson, name, filename, translateFunction) {
   const nodes = drakonGraph.items || {};
 
   var branches = [];
-  var firstNodeId = findStartNode(nodes, filename, branches);
+  var firstNodeId = findStartNode(nodes, filename, branches, htmlToString);
+  var params = decodeContent(drakonGraph.params, htmlToString);
+  var description = decodeContent(drakonGraph.description, htmlToString);
+
+  var result = {
+    name: name,
+    type: "drakon",
+    params:  params,
+    description: description,
+    branches: []
+  };
 
   if (!firstNodeId) {
-    return {
-      name: name,
-      params: drakonGraph.params || "",
-      description: drakonGraph.description || "",
-      branches: [],
-    };
+    return result
   }
 
+  handleParallel(nodes, undefined, firstNodeId, {}, undefined);
   buildTwoWayConnections(nodes, firstNodeId);
 
   rewireSelectsMarkLoops(nodes, filename);
   branches.forEach((branch) =>
-    checkBranchIsReferenced(branch, firstNodeId, filename),
+    checkBranchIsReferenced(
+      branch,
+      firstNodeId,
+      filename,
+      options
+    ),
   );
   rewireShortcircuit(nodes, filename);
   branches.forEach((branch) => cutOffBranch(nodes, branch));
-  var branchTrees = structFlow(nodes, branches, filename, translate);
-  return {
-    name: name,
-    params: drakonGraph.params || "",
-    description: drakonGraph.description || "",
-    branches: branchTrees,
-  };
+  var branchTrees = structFlow(nodes, branches, filename, translate, options);
+
+  result.branches = branchTrees
+  result.secondary = findSecondary(branchTrees, options)
+  return result
+}
+
+function findSecondary(branchTrees, options) {
+  if (!options || !options.secondary) {
+    return undefined;
+  }
+  var ordinal = 0;
+  for (var branch of branchTrees) {
+    var name = branch.name;
+    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) {
@@ -227,7 +351,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 +371,34 @@ function drakonToGraph(drakonJson, name, filename, translateFunction) {
   };
 }
 
-function checkBranchIsReferenced(branch, firstNodeId, filename) {
+function checkBranchIsReferenced(
+  branch,
+  firstNodeId,
+  filename,
+  options  
+) {
   if (branch.id === firstNodeId) {
     return;
   }
-  if (branch.prev.length === 0) {
-    throw createError(
-      translate("A silhouette branch is not referenced"),
-      filename,
-      branch.id,
-    );
+  if (options) {
+    var branchName = branch.content;
+    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,
+        );
+      }
+    }
   }
 }
 
@@ -334,14 +482,19 @@ function buildTwoWayConnections(nodes, firstNodeId) {
     node.prev = [];
   }
 
-  traverse(nodes, firstNodeId, {}, connectBack);
+  var visitor = function (nodes, node) {
+    return connectBack(nodes, node);
+  };
+
+  traverse(nodes, firstNodeId, {}, visitor);
 }
 
-function findStartNode(nodes, filename, branches) {
+function findStartNode(nodes, filename, branches, htmlToString) {
   var firstNodeId = undefined;
   var minBranchId = 10000;
   for (var id in nodes) {
     var node = nodes[id];
+    decodeNodeContent(node, htmlToString);
     if (node.type === "branch") {
       if (node.branchId < minBranchId) {
         firstNodeId = id;
@@ -373,12 +526,33 @@ function findStartNode(nodes, filename, branches) {
           id,
         );
       }
+    } else if (node.final) {
+      delete node.one
+      delete node.two
     }
   }
 
   return firstNodeId;
 }
 
+function decodeNodeContent(node, htmlToString) {
+  if (node.content && typeof node.content === "string") {
+    node.content = decodeContent(node.content, htmlToString);
+  }
+
+  if (node.secondary && typeof node.secondary === "string") {
+    node.secondary = decodeContent(node.secondary, htmlToString);
+  }
+}
+
+function decodeContent(content, htmlToString) {
+  if (!content) {
+    return ""
+  }
+  var lines = htmlToString(content);
+  return lines.join("\n");
+}
+
 function rewireSelectsMarkLoops(nodes, filename) {
   for (var id of Object.keys(nodes)) {
     var node = nodes[id];
@@ -395,6 +569,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 +609,7 @@ function rewireSelect(nodes, selectNode, filename) {
       removeNodeOne(nodes, caseNode.id);
     }
   }
+  caseNode0.side = selectNode.side;
   removeNodeOne(nodes, selectNode.id);
 }
 
@@ -608,6 +784,11 @@ 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) {
@@ -619,6 +800,23 @@ 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);
+    } else {
+      delete node.side;
+    }
+  }
+}
+
+function decodeSide(content) {
+  if (content.indexOf("=") === -1) {
+    return translate("Do for") + " " + content;
+  } else {
+    return translate("Start at") + " " + content;
+  }
 }
 
 function markLoopBody(nodes, start, filename) {
@@ -641,32 +839,270 @@ 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, false);
+    return result.text;
+  },
+
+  toMindTreeJson: function (mindJson, name, filename, language) {
+    setUpLanguage(language);
+    var result = mindToTree(mindJson, name, filename, htmlToString, true);
+    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");
+
+var translate
+
+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
+}
 
-    toMindTree: function (mindJson, name, filename, language) {
-        setUpLanguage(language)    
-        var result = mindToTree(mindJson, name, filename, htmlToString)
-        return result.text
-    },    
+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
+}
 
-    toTree: function (drakonJson, name, filename, language) {
-        setUpLanguage(language)
-        var result = drakonToStruct(drakonJson, name, filename, translate)
-        return JSON.stringify(result, null, 4)
+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){
+function decrement_arrow_count(context, node) {
+    var algonode;
+    algonode = context.nodes[node.arrow];
+    algonode.branching--;
+}
+function decrement_if_count(context, node) {
+    var _collection_12, if_id, if_node;
+    _collection_12 = node.stack;
+    for (if_id of _collection_12) {
+        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, element, existing;
+    counts_by_id = {};
+    for (element of stack) {
+        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 _collection_14, if_id, if_node;
+    _collection_14 = node.stack;
+    for (if_id of _collection_14) {
+        if_node = context.nodes[if_id];
+        if_node.branching++;
+    }
+}
+function is_in_map(map, key) {
+    if (map) {
+        return key in map;
+    } else {
+        return false;
+    }
+}
+function merge_converging_branches(context, node_id, node, stack) {
+    var algonode, algonode_id, common, count, counts_by_id, processed_stack, stub;
+    common = node.stack.concat(stack);
+    counts_by_id = group_stack_by_id(common);
+    for (algonode_id in counts_by_id) {
+        count = counts_by_id[algonode_id];
+        algonode = context.nodes[algonode_id];
+        if (!algonode.next && algonode.type == 'arrow-loop') {
+            algonode.branching -= count - 1;
+            if (!(algonode.branching > 1 || is_in_map(node.astack, algonode_id))) {
+                stub = context.nodes[algonode.stub];
+                decrement_if_count(context, stub);
+                stub.one = node_id;
+                algonode.next = node_id;
+            }
+        }
+    }
+    processed_stack = [];
+    for (algonode_id in counts_by_id) {
+        count = counts_by_id[algonode_id];
+        algonode = context.nodes[algonode_id];
+        if (!algonode.next) {
+            if (algonode.type == 'question') {
+                algonode.branching -= count - 1;
+                if (algonode.branching > 1) {
+                    processed_stack.push(algonode_id);
+                } else {
+                    algonode.next = node_id;
+                }
+            } else {
+                processed_stack.push(algonode_id);
+            }
+        }
+    }
+    node.stack = processed_stack;
+}
+function recurse_traversal(context, node_id, node) {
+    var _collection_20, _selectValue_18, proc, stack1, stack2;
+    _selectValue_18 = node.type;
+    if (_selectValue_18 === '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.two, stack2);
+        traverse_node(context, node.one, stack1);
+    } else {
+        if (_selectValue_18 === 'arrow-loop') {
+            stack1 = node.stack.slice();
+            stack1.push(node_id);
+            traverse_node(context, node.one, stack1);
+        } else {
+            if (_selectValue_18 === 'arrow-stub') {
+                decrement_arrow_count(context, node);
+            } else {
+                if (_selectValue_18 === 'parbegin') {
+                    _collection_20 = node.procs;
+                    for (proc of _collection_20) {
+                        flow_no_loop(context.nodes, proc.start);
+                    }
+                } 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_converging_branches(context, node_id, node, stack);
+        if (!(node.refs > 0)) {
+            recurse_traversal(context, node_id, node);
+        }
+    }
+}
+module.exports = { flow_no_loop };
+},{}],7:[function(require,module,exports){
 var {addRange} = require("./tools")
 
 function makeIndent(depth) {
@@ -679,8 +1115,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 +1183,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 +1256,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,402 +1287,186 @@ 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];
-
-        if (!node.stack) {
-            node.stack = [];
-            node.remaining = node.prev.length;
-        }
-        node.remaining--;
-
-        mergeBranchingStack(nodes, node, branchingStack);
-        if (node.remaining > 0) {return;}       
-
-        if (node.type === "question") {
-            for (let i = 0; i < node.stack.length; i++) {
-                const questionId = node.stack[i];
-                const question = nodes[questionId];
-                question.branching++;
-            }
-
-            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 {
-            flowGraph(nodes, node.one, node.stack);
-        }
-    }
-
-    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--
-                }
-            }
-        }
-        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 structFlow(nodes, branches, filename, translate, options) {
 
-        // Merge all nodes
-        mergeAll(nodes, node, dictionary);
-
-        // Rebuild the stack
-        node.stack = buildStackFromDictionary(dictionary);
-    }
-
-    function addRange(dst, src) {
-        for (let i = 0; i < src.length; i++) {
-            dst.push(src[i]);
-        }
+  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 buildStackFromDictionary(dictionary) {
-        const rebuiltStack = [];
-        for (const id in dictionary) {
-            if (dictionary[id] > 0) {
-                rebuiltStack.push(id);
-            }
-        }
-        return rebuiltStack;
+  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 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 fillAStack(nodes, node, arrowId, visited) {
+    if (node.id in visited) {
+      return;
     }
-
-    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;
-                }                
-            }
-        }
+    visited[node.id] = true;
+    if (!node.astack) {
+      node.astack = {};
     }
-    function isInMap(map, key) {
-        if (!map) { return false }
-        return key in map
+    node.astack[arrowId] = true;
+    if (node.id === arrowId) {
+      return;
     }
-
-    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;
-            }
-        }
+    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)
-        }
-    }
-    
-    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)
-        }
+    var node = nodes[nodeId];
+    if (node.type === "branch") {
+      return;
     }
-    
-    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
+    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 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 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 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 onError(message, nodeId) {
+    throw createError(
+      translate(message),
+      filename,
+      nodeId
+    );
+  }
 
-    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 structMain() {
+    rewireArrows(nodes, branches);
+    prepareQuestions(nodes);
+    var result = [];
 
-    function addBreaks(toBreak) {
-        for (var body of toBreak) {
-            body.push({
-                type: "break"
-            })
-        }
+    for (var branch of branches) {
+      flow_no_loop(nodes, branch.next, []);
     }
 
-    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
+    for (var branch of branches) {
+      var body = [];
+      buildTree(nodes, branch.next, body, "<dummy id>", undefined, onError);
+
+      result.push({
+        name: branch.content,
+        branchId: branch.branchId,
+        id: branch.id,        
+        refs: branch.prev.length,
+        body: optimizeTree(body),
+      });
     }
-    
 
-    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)
-            })
-        }
-
-        return sortByProperty(result, "branchId")
-    }
+    return sortByProperty(result, "branchId");
+  }
 
-    return structMain()
+  return structMain();
 }
 module.exports = { structFlow, redirectNode };
-},{"./technicalTree":7,"./tools":8,"./treeTools":10}],7:[function(require,module,exports){
-function buildTree(nodes, nodeId, body, stopId) {
+
+},{"./noloop":6,"./technicalTree":9,"./tools":10,"./treeTools":12}],9:[function(require,module,exports){
+function buildTree(nodes, nodeId, body, stopId, afterLoop, onError) {
     while (nodeId) {
-        if (nodeId === stopId) {return;}
+        if (nodeId === afterLoop) {
+            body.push({type: "break"}) 
+            return
+        }
+        if (nodeId === stopId) {
+            return;
+        }
         const node = nodes[nodeId];
         let transformed;
         let next;
 
         if (node.type === "question") {
             next = reserveNext(nodes, node)
-
+            
             transformed = {
                 id: node.id,
                 type: "question",
@@ -1232,24 +1478,57 @@ function buildTree(nodes, nodeId, body, stopId) {
             const yesNodeId = node.flag1 === 1 ? node.one : node.two;
             const noNodeId = node.flag1 === 1 ? node.two : node.one;
 
-            buildTree(nodes, yesNodeId, transformed.yes, node.next);
-            buildTree(nodes, noNodeId, transformed.no, node.next);
+            buildTree(nodes, yesNodeId, transformed.yes, node.next, afterLoop, onError);
+            buildTree(nodes, noNodeId, transformed.no, node.next, afterLoop, onError);
+            if (next === afterLoop) {
+                next = undefined
+            }
+        } else if (node.type == "loopbegin") {
+            transformed = {
+                id: node.id,
+                type: "loopbegin",
+                content: node.content,
+                end: node.end,
+                body: []
+            };
+            var end = nodes[node.end]
+            buildTree(nodes, node.one, transformed.body, node.end, end.one, onError)
+            next = node.next;   
+        } else if (node.type == "loopend") {
+            if (stopId !== afterLoop) {
+                onError(
+                    "An exit from the loop must lead to the point right after the loop end",
+                    node.id
+                )
+            }
+            return            
         } else if (node.type === "arrow-loop") {
             transformed = {
                 id: node.id,
                 type: "loopbegin",
                 content: "",
-                end: node.stub
+                end: node.stub,
+                body: []
             };
-
-            next = node.one;
+            var end = nodes[node.stub]
+            buildTree(nodes, node.one, transformed.body, node.stub, end.one, onError)
+            next = node.next;  
         } else if (node.type === "arrow-stub") {
+            return
+        } else if (node.type === "parbegin") {
             transformed = {
                 id: node.id,
-                type: "loopend",
-                start: node.arrow
-            };
-
+                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, undefined, buildTree)
+            }
             next = node.one;
         } else {
             transformed = {
@@ -1268,8 +1547,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 +1569,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 +1583,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 +1624,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 +1653,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 +1690,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,9 +1727,162 @@ 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"
+};
+
+var translationsFr = {
+    error: 'Erreur',
+    not: 'non',
+    break: 'quitter la boucle',
+    and: 'et',
+    or: 'ou',
+    if: 'Si',
+    else: 'Sinon',
+    empty: 'Vide',
+    'loop forever': 'Boucler indéfiniment',
+    pass: 'Ignorer',
+    'Only the rightmost Case icon can be empty': "Seule l'icône Case la plus à droite peut être vide",
+    'Error parsing JSON': "Erreur lors de l'analyse du JSON",
+    'A Loop begin icon must have content': "Une icône de début de boucle doit avoir un contenu",
+    'A Question icon must have content': "Une icône Question doit avoir un contenu",
+    'A Select icon must have content': "Une icône Select doit avoir un contenu",
+    'Unexpected case value': 'Valeur de cas inattendue',
+    'Loop end expected here': 'Fin de boucle attendue ici',
+    'An exit from the loop must lead to the point right after the loop end': 'Une sortie de boucle doit mener au point situé juste après la fin de la boucle',
+    'A silhouette branch is not referenced': "Une branche de silhouette n'est pas référencée",
+    'Call subroutine': 'Appeler la sous-routine',
+    Procedure: 'Procédure',
+    'End of procedure': 'Fin de la procédure',
+    Subroutine: 'Sous-routine',
+    'End of subroutine': 'Fin de la sous-routine',
+    Description: 'Description',
+    Algorithm: 'Algorithme',
+    Remarks: 'Remarques',
+    Parameters: 'Paramètres',
+    'Group of parallel processes': 'Groupe de processus parallèles',
+    'Parallel process': 'Processus parallèle',
+    'Start at': 'Commencer à',
+    'Do for': 'Exécuter pendant',
+    'Pause': 'Pause',
+    'Start timer': 'Démarrer le minuteur'
 };
 
+var translationsDe = {
+    error: 'Fehler',
+    not: 'nicht',
+    break: 'Schleife beenden',
+    and: 'und',
+    or: 'oder',
+    if: 'Wenn',
+    else: 'Sonst',
+    empty: 'Leer',
+    'loop forever': 'Endlos wiederholen',
+    pass: 'Überspringen',
+    'Only the rightmost Case icon can be empty': 'Nur das äußerste rechte Case-Symbol darf leer sein',
+    'Error parsing JSON': 'Fehler beim Parsen von JSON',
+    'A Loop begin icon must have content': 'Ein Schleifenstart-Symbol muss Inhalt haben',
+    'A Question icon must have content': 'Ein Frage-Symbol muss Inhalt haben',
+    'A Select icon must have content': 'Ein Auswahl-Symbol muss Inhalt haben',
+    'Unexpected case value': 'Unerwarteter Fallwert',
+    'Loop end expected here': 'Schleifenende wird hier erwartet',
+    'An exit from the loop must lead to the point right after the loop end': 'Ein Ausgang aus der Schleife muss direkt hinter das Schleifenende führen',
+    'A silhouette branch is not referenced': 'Ein Silhouettenzweig wird nicht referenziert',
+    'Call subroutine': 'Unterprogramm aufrufen',
+    Procedure: 'Prozedur',
+    'End of procedure': 'Ende der Prozedur',
+    Subroutine: 'Unterprogramm',
+    'End of subroutine': 'Ende des Unterprogramms',
+    Description: 'Beschreibung',
+    Algorithm: 'Algorithmus',
+    Remarks: 'Bemerkungen',
+    Parameters: 'Parameter',
+    'Group of parallel processes': 'Gruppe paralleler Prozesse',
+    'Parallel process': 'Paralleler Prozess',
+    'Start at': 'Starten bei',
+    'Do for': 'Ausführen für',
+    'Pause': 'Pause',
+    'Start timer': 'Timer starten'
+};
+
+var translationsEs = {
+    error: 'Error',
+    not: 'no',
+    break: 'salir del bucle',
+    and: 'y',
+    or: 'o',
+    if: 'Si',
+    else: 'De lo contrario',
+    empty: 'Vacío',
+    'loop forever': 'Repetir para siempre',
+    pass: 'Omitir',
+    'Only the rightmost Case icon can be empty': 'Solo el icono Case más a la derecha puede estar vacío',
+    'Error parsing JSON': 'Error al analizar JSON',
+    'A Loop begin icon must have content': 'Un icono de inicio de bucle debe tener contenido',
+    'A Question icon must have content': 'Un icono de Pregunta debe tener contenido',
+    'A Select icon must have content': 'Un icono de Selección debe tener contenido',
+    'Unexpected case value': 'Valor de caso inesperado',
+    'Loop end expected here': 'Se esperaba el final del bucle aquí',
+    'An exit from the loop must lead to the point right after the loop end': 'Una salida del bucle debe conducir al punto inmediatamente después del final del bucle',
+    'A silhouette branch is not referenced': 'Una rama de silueta no está referenciada',
+    'Call subroutine': 'Llamar subrutina',
+    Procedure: 'Procedimiento',
+    'End of procedure': 'Fin del procedimiento',
+    Subroutine: 'Subrutina',
+    'End of subroutine': 'Fin de la subrutina',
+    Description: 'Descripción',
+    Algorithm: 'Algoritmo',
+    Remarks: 'Observaciones',
+    Parameters: 'Parámetros',
+    'Group of parallel processes': 'Grupo de procesos paralelos',
+    'Parallel process': 'Proceso paralelo',
+    'Start at': 'Comenzar en',
+    'Do for': 'Ejecutar durante',
+    'Pause': 'Pausa',
+    'Start timer': 'Iniciar temporizador'
+};
+
+var translationsLt = {
+    error: 'Klaida',
+    not: 'ne',
+    break: 'nutraukti ciklą',
+    and: 'ir',
+    or: 'arba',
+    if: 'Jei',
+    else: 'Kitaip',
+    empty: 'Tuščias',
+    'loop forever': 'Kartoti amžinai',
+    pass: 'Praleisti',
+    'Only the rightmost Case icon can be empty': 'Tik dešiniausia Case piktograma gali būti tuščia',
+    'Error parsing JSON': 'Klaida analizuojant JSON',
+    'A Loop begin icon must have content': 'Ciklo pradžios piktograma turi turėti turinį',
+    'A Question icon must have content': 'Klausimo piktograma turi turėti turinį',
+    'A Select icon must have content': 'Pasirinkimo piktograma turi turėti turinį',
+    'Unexpected case value': 'Netikėta atvejo reikšmė',
+    'Loop end expected here': 'Čia tikimasi ciklo pabaigos',
+    'An exit from the loop must lead to the point right after the loop end': 'Išėjimas iš ciklo turi vesti į tašką iškart po ciklo pabaigos',
+    'A silhouette branch is not referenced': 'Silueto šaka nėra susieta',
+    'Call subroutine': 'Kviesti paprogramę',
+    Procedure: 'Procedūra',
+    'End of procedure': 'Procedūros pabaiga',
+    Subroutine: 'Paprogramė',
+    'End of subroutine': 'Paprogramės pabaiga',
+    Description: 'Aprašymas',
+    Algorithm: 'Algoritmas',
+    Remarks: 'Pastabos',
+    Parameters: 'Parametrai',
+    'Group of parallel processes': 'Lygiagrečių procesų grupė',
+    'Parallel process': 'Lygiagretus procesas',
+    'Start at': 'Pradėti nuo',
+    'Do for': 'Vykdyti',
+    'Pause': 'Pauzė',
+    'Start timer': 'Paleisti laikmatį'
+};
 
 var translations = translationsEn
 
@@ -1445,14 +1897,21 @@ function setUpLanguage(language) {
         translations = translationsNo
     } else if (language === "en") {
         translations = translationsEn
+    } else if (language === "fr") {
+        translations = translationsFr
+    } else if (language === "de") {
+        translations = translationsDe
+    } else if (language === "es") {
+        translations = translationsEs
+    } else if (language === "lt") {
+        translations = translationsLt
     } else {
         translations = {}
     }
 }
 
-
 module.exports = { setUpLanguage, translate };
-},{}],10:[function(require,module,exports){
+},{}],12:[function(require,module,exports){
 
 function optimizeTree(steps) {
     var result = []
@@ -1460,54 +1919,85 @@ function optimizeTree(steps) {
     for (var step of steps) {
         if (step.type === "end" || step.type === "branch" || step.type === "loopend") { continue }
         if ((step.type === "action" || step.type === "comment") && !step.content) { continue }
-        var copy
         if (step.type === "question") {
-            copy = optimizeQuestion(step)
-        } else if (step.type === "loop") {
-            copy = optimizeLoop(step)
+            optimizeQuestion(step, result)
+        } else if (step.type === "parbegin") {
+            optimizeParbegin(step, result)
+        } else if (step.type === "loop" || step.type === "loopbegin") {
+            optimizeLoop(step, result)
         } else {
-            copy = step
+            result.push(step)
         }
-        result.push(copy)
     }
 
     return result
 }
 
-function optimizeLoop(step) {
-    return {
+function optimizeParbegin(step, output) {
+    var procs = []
+    for (var proc of step.procs) {
+        var procCopy = {
+            ordinal: proc.ordinal,
+            body: optimizeTree(proc.body)
+        }
+        procs.push(procCopy)
+    }
+    output.push({
         id: step.id,
         type: step.type,
+        procs: procs
+    })
+}
+
+function optimizeLoop(step, output) {
+    output.push({
+        id: step.id,
+        type: "loop",
         content: step.content,
         body: optimizeTree(step.body)
+    })
+}
+
+function endsWithBreak(body) {
+    if (body.length === 0) {
+        return false
     }
+    var lastId = body.length - 1
+    return body[lastId].type === "break"
 }
 
-function optimizeQuestion(step) {
+function optimizeQuestion(step, output) {
     var yes = optimizeTree(step.yes)
     var no = optimizeTree(step.no)
-    if (yes.length === 0 && no.length === 0) {
-        return {
-            type: step.type,
-            content: step.content,
-            yes: [],
-            no: []
-        }    
-    }
-    if (yes.length === 0) {
-        return {
-            type: step.type,
-            content: {operator:"not",operand:step.content},
-            yes: no,
-            no: []
-        }
+    var breakYes = endsWithBreak(yes)
+    var breakNo = endsWithBreak(no)
+
+    var result = {
+        id: step.id,
+        side: step.side,
+        type: step.type
     }
-    return {
-        type: step.type,
-        content: step.content,
-        yes: yes,
-        no: no
+    if (breakYes && breakNo) {
+        yes.pop()
+        no.pop()
     }    
+    if (yes.length === 0 && no.length === 0) {
+        result.content = step.content
+        result.yes = []
+        result.no = []
+    } else if (yes.length === 0) {
+        result.content = {operator:"not",operand:step.content}
+        result.yes = no
+        result.no = []
+    } else {
+        result.content = step.content,
+        result.yes = yes,
+        result.no = no
+    }
+    output.push(result)
+    if (breakYes && breakNo) {
+        output.push({type: "break"})
+    }
 }