drakongen 1.4.6 → 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,450 +154,953 @@ 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) {
-    translate = translateFunction
-    let drakonGraph;
-    try {
-        drakonJson = drakonJson || ""
-        drakonJson = drakonJson.trim()
-        drakonJson = drakonJson || "{}"
-        drakonGraph = JSON.parse(drakonJson);
-    } catch (error) {
-        var message = translate("Error parsing JSON") + ": " + error.message
-        throw createError(message, filename)
-    }
-
-    const nodes = drakonGraph.items || {};
-
-    var branches = []
-    var firstNodeId = findStartNode(nodes, filename, branches)
-
-    if (!firstNodeId) {
-        return {
-            name: name,
-            params: drakonGraph.params || "",
-            description: drakonGraph.description || "",
-            branches: []
-        }
-    }
-
-    buildTwoWayConnections(nodes, firstNodeId)
-
-    rewireSelectsMarkLoops(nodes, filename)
-    branches.forEach(branch => checkBranchIsReferenced(branch, firstNodeId, filename))
-    rewireShortcircuit(nodes, filename)
-    branches.forEach(branch => cutOffBranch(nodes, branch))
-    var branchTrees = structFlow(nodes, branches, filename, translate)
+var translate;
+
+function drakonToStruct(
+  drakonJson,
+  name,
+  filename,
+  translateFunction,
+  htmlToString,
+  options,
+) {
+  options = options || {};
+  translate = translateFunction;
+  let drakonGraph;
+  try {
+    drakonJson = drakonJson || "";
+    drakonJson = drakonJson.trim();
+    drakonJson = drakonJson || "{}";
+    drakonGraph = JSON.parse(drakonJson);
+  } catch (error) {
+    var message = translate("Error parsing JSON") + ": " + error.message;
+    throw createError(message, filename);
+  }
+
+  const nodes = drakonGraph.items || {};
+
+  var branches = [];
+  var firstNodeId = findStartNode(nodes, filename, branches);
+
+  if (!firstNodeId) {
     return {
-        name: name,
-        params: drakonGraph.params || "",
-        description: drakonGraph.description || "",
-        branches: branchTrees
-    }
+      name: name,
+      params: drakonGraph.params || "",
+      description: drakonGraph.description || "",
+      branches: [],
+    };
+  }
+
+  handleParallel(nodes, undefined, firstNodeId, {}, undefined);
+  buildTwoWayConnections(nodes, firstNodeId, htmlToString);
+
+  rewireSelectsMarkLoops(nodes, filename);
+  branches.forEach((branch) =>
+    checkBranchIsReferenced(
+      branch,
+      firstNodeId,
+      filename,
+      options,
+      htmlToString,
+    ),
+  );
+  rewireShortcircuit(nodes, filename);
+  branches.forEach((branch) => cutOffBranch(nodes, branch));
+  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 drakonToGraph(drakonJson, name, filename, translateFunction) {
-    translate = translateFunction
-    let drakonGraph;
-    try {
-        drakonGraph = JSON.parse(drakonJson);
-    } catch (error) {
-        var message = translate("Error parsing JSON") + ": " + error.message
-        throw createError(message, filename)
-    }
-
-    const nodes = drakonGraph.items || {};
-
-    var branches = []
-    var firstNodeId = findStartNode(nodes, filename, branches)
-
-    if (!firstNodeId) {
-        return undefined
-    }
-
-    buildTwoWayConnections(nodes, firstNodeId)
-
-    rewireSelectsMarkLoops(nodes, filename)
-    rewireShortcircuit(nodes, filename)
-    branches.forEach(branch => checkBranchIsReferenced(branch, firstNodeId, filename))
-    branches.forEach(branch => cutOffBranch(nodes, branch))
-    
-    var branchTrees = structFlow(nodes, branches, filename, translate)
+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;
+}
 
-    return {
-        name: name,
-        params: drakonGraph.params || "",
-        description: drakonGraph.description || "",
-        branches: branchTrees
-    }
+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;
+  try {
+    drakonGraph = JSON.parse(drakonJson);
+  } catch (error) {
+    var message = translate("Error parsing JSON") + ": " + error.message;
+    throw createError(message, filename);
+  }
+
+  const nodes = drakonGraph.items || {};
+
+  var branches = [];
+  var firstNodeId = findStartNode(nodes, filename, branches);
+
+  if (!firstNodeId) {
+    return undefined;
+  }
+
+  buildTwoWayConnections(nodes, firstNodeId);
+
+  rewireSelectsMarkLoops(nodes, filename);
+  rewireShortcircuit(nodes, filename);
+  branches.forEach((branch) =>
+    checkBranchIsReferenced(
+      branch,
+      firstNodeId,
+      filename,
+      undefined,
+      undefined,
+    ),
+  );
+  branches.forEach((branch) => cutOffBranch(nodes, branch));
+
+  var branchTrees = structFlow(nodes, branches, filename, translate);
+
+  return {
+    name: name,
+    params: drakonGraph.params || "",
+    description: drakonGraph.description || "",
+    branches: branchTrees,
+  };
+}
 
-function checkBranchIsReferenced(branch, firstNodeId, filename) {
-    if (branch.id === firstNodeId) {
-        return
-    }
-    if (branch.prev.length === 0) {
-        throw createError(translate("A silhouette branch is not referenced"), filename, branch.id)
-    }
+function checkBranchIsReferenced(
+  branch,
+  firstNodeId,
+  filename,
+  options,
+  htmlToString,
+) {
+  if (branch.id === firstNodeId) {
+    return;
+  }
+  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,
+        );
+      }
+    }
+  }
 }
 
 function cutOffBranch(nodes, branch) {
-    var end = {
-        type: "end",
-        id: branch.id + "-end",
-        prev: []
-    }
-    nodes[end.id] = end
-    branch.next = branch.one
-    var addresses = []
-    traverseToHitBranch(nodes, branch.id, {}, (prev, node) => addFakeEnd(nodes, prev, node, end, addresses))
+  var end = {
+    type: "end",
+    id: branch.id + "-end",
+    prev: [],
+  };
+  nodes[end.id] = end;
+  branch.next = branch.one;
+  var addresses = [];
+  traverseToHitBranch(nodes, branch.id, {}, (prev, node) =>
+    addFakeEnd(nodes, prev, node, end, addresses),
+  );
 }
 
 function traverseToHitBranch(nodes, nodeId, visited, action) {
-    if (!nodeId) {return}
-    if (nodeId in visited) {return}
-    visited[nodeId] = true
-    var node = nodes[nodeId]
-    if (!node) {return}
-    if (node.one) {
-        var one = nodes[node.one]
-        if (one.type === "branch") {
-            action(node, one)
-        } else {
-            traverseToHitBranch(nodes, node.one, visited, action)
-        }
+  if (!nodeId) {
+    return;
+  }
+  if (nodeId in visited) {
+    return;
+  }
+  visited[nodeId] = true;
+  var node = nodes[nodeId];
+  if (!node) {
+    return;
+  }
+  if (node.one) {
+    var one = nodes[node.one];
+    if (one.type === "branch") {
+      action(node, one);
+    } else {
+      traverseToHitBranch(nodes, node.one, visited, action);
     }
-    if (node.two) {
-        var two = nodes[node.two]
-        if (two.type === "branch") {
-            action(node, two)
-        } else {
-            traverseToHitBranch(nodes, node.two, visited, action)
-        }
-    }    
+  }
+  if (node.two) {
+    var two = nodes[node.two];
+    if (two.type === "branch") {
+      action(node, two);
+    } else {
+      traverseToHitBranch(nodes, node.two, visited, action);
+    }
+  }
 }
 
-var idCounter = 1000
+var idCounter = 1000;
 function addFakeEnd(nodes, prev, node, end, addresses) {
-    var lastAddress = undefined
-    if (addresses.length > 0) {
-        lastAddress = addresses[addresses.length - 1]
-    }        
-    var address
-    if (lastAddress && lastAddress.branch === node.id) {
-        address = lastAddress
-    } else {
-        address = {
-            type: "address",
-            content: node.content,
-            id: "ad-" + idCounter,
-            branch: node.id,
-            one: end.id,
-            prev: []
-        }   
-        idCounter++
-        nodes[address.id] = address
-        end.prev.push(address.id)
-        addresses.push(address)
-        node.prev.push(address.id)
-    }
-    redirectNode(nodes, prev, node.id, address.id)
-    address.prev.push(prev.id)
-    node.prev = remove(node.prev, prev.id)
-}
-
-function buildTwoWayConnections(nodes, firstNodeId) {
-    for (var id in nodes) {
-        var node = nodes[id]
-        node.id = id
-        node.prev = []        
-    }
+  var lastAddress = undefined;
+  if (addresses.length > 0) {
+    lastAddress = addresses[addresses.length - 1];
+  }
+  var address;
+  if (lastAddress && lastAddress.branch === node.id) {
+    address = lastAddress;
+  } else {
+    address = {
+      type: "address",
+      content: node.content,
+      id: "ad-" + idCounter,
+      branch: node.id,
+      one: end.id,
+      prev: [],
+    };
+    idCounter++;
+    nodes[address.id] = address;
+    end.prev.push(address.id);
+    addresses.push(address);
+    node.prev.push(address.id);
+  }
+  redirectNode(nodes, prev, node.id, address.id);
+  address.prev.push(prev.id);
+  node.prev = remove(node.prev, prev.id);
+}
+
+function buildTwoWayConnections(nodes, firstNodeId, htmlToString) {
+  for (var id in nodes) {
+    var node = nodes[id];
+    node.id = id;
+    node.prev = [];
+  }
+
+  var visitor = function (nodes, node) {
+    return connectBack(nodes, node, htmlToString);
+  };
 
-    traverse(nodes, firstNodeId, {}, connectBack)
+  traverse(nodes, firstNodeId, {}, visitor);
 }
 
 function findStartNode(nodes, filename, branches) {
-    var firstNodeId = undefined
-    var minBranchId = 10000    
-    for (var id in nodes) {
-        var node = nodes[id]
-        if (node.type === "branch") {
-            if (node.branchId < minBranchId) {
-                firstNodeId = id
-                minBranchId = node.branchId
-            }
-            branches.push(node)
-        } else if (node.type === "select") {
-            if (!node.content) {
-                throw createError(translate("A Select icon must have content"), filename, id)
-            }            
-            node.cases = [];
-        } else if (node.type === "loopbegin") {
-            if (!node.content) {
-                throw createError(translate("A Loop begin icon must have content"), filename, id)
-            }             
-        } else if (node.type === "question") {
-            if (!node.content) {
-                throw createError(translate("A Question icon must have content"), filename, id)
-            }             
-        }
-    }
-
-    return firstNodeId
+  var firstNodeId = undefined;
+  var minBranchId = 10000;
+  for (var id in nodes) {
+    var node = nodes[id];
+    if (node.type === "branch") {
+      if (node.branchId < minBranchId) {
+        firstNodeId = id;
+        minBranchId = node.branchId;
+      }
+      branches.push(node);
+    } else if (node.type === "select") {
+      if (!node.content) {
+        throw createError(
+          translate("A Select icon must have content"),
+          filename,
+          id,
+        );
+      }
+      node.cases = [];
+    } else if (node.type === "loopbegin") {
+      if (!node.content) {
+        throw createError(
+          translate("A Loop begin icon must have content"),
+          filename,
+          id,
+        );
+      }
+    } else if (node.type === "question") {
+      if (!node.content) {
+        throw createError(
+          translate("A Question icon must have content"),
+          filename,
+          id,
+        );
+      }
+    } else if (node.final) {
+      delete node.one
+      delete node.two
+    }
+  }
+
+  return firstNodeId;
 }
 
 function rewireSelectsMarkLoops(nodes, filename) {
-    for (var id of Object.keys(nodes)) {
-        var node = nodes[id]
-        if (!node) { continue }
-        if (node.type === "select") {
-            rewireSelect(nodes, node, filename)
-        } else if (node.type === "loopbegin") {
-            markLoopBody(nodes, node, filename)
-        }
+  for (var id of Object.keys(nodes)) {
+    var node = nodes[id];
+    if (!node) {
+      continue;
+    }
+    if (node.type === "select") {
+      rewireSelect(nodes, node, filename);
+    } else if (node.type === "loopbegin") {
+      markLoopBody(nodes, node, filename);
     }
+  }
 }
 
 function rewireSelect(nodes, selectNode, filename) {
-    var caseNodeId = selectNode.one
-    while (caseNodeId) {
-        var caseNode = nodes[caseNodeId]
-        caseNodeId = caseNode.two
-        if (caseNode.content) {
-            caseNode.type = "question"
-            caseNode.flag1 = 1
-            caseNode.content = {operator: "equal", left:selectNode.content, right:caseNode.content}
-            if (!caseNode.two) {
-                var errorId = caseNode.id + "-unexpected"
-                var errorAction = insertIcon(nodes, "error", errorId,  selectNode.content)
-                errorAction.message = translate("Unexpected case value")
-
-                caseNode.two = errorId
-                errorAction.prev.push(caseNode.id)
-                errorAction.one = caseNode.one
-
-                var next = nodes[caseNode.one]
-                next.prev.push(errorId)
-            }
-        } else {
-            if (caseNode.two) {
-                throw createError(translate("Only the rightmost Case icon can be empty"), filename, caseNode.id)
-            }
-            removeNodeOne(nodes, caseNode.id)
-        }
-    }
-    removeNodeOne(nodes, selectNode.id)
+  var caseNodeId = selectNode.one;
+  var caseNode0 = nodes[caseNodeId];
+  while (caseNodeId) {
+    var caseNode = nodes[caseNodeId];
+    caseNodeId = caseNode.two;
+    if (caseNode.content) {
+      caseNode.type = "question";
+      caseNode.flag1 = 1;
+      caseNode.content = {
+        operator: "equal",
+        left: selectNode.content,
+        right: caseNode.content,
+      };
+      if (!caseNode.two) {
+        var errorId = caseNode.id + "-unexpected";
+        var errorAction = insertIcon(
+          nodes,
+          "error",
+          errorId,
+          selectNode.content,
+        );
+        errorAction.message = translate("Unexpected case value");
+
+        caseNode.two = errorId;
+        errorAction.prev.push(caseNode.id);
+        errorAction.one = caseNode.one;
+
+        var next = nodes[caseNode.one];
+        next.prev.push(errorId);
+      }
+    } else {
+      if (caseNode.two) {
+        throw createError(
+          translate("Only the rightmost Case icon can be empty"),
+          filename,
+          caseNode.id,
+        );
+      }
+      removeNodeOne(nodes, caseNode.id);
+    }
+  }
+  caseNode0.side = selectNode.side;
+  removeNodeOne(nodes, selectNode.id);
 }
 
 function insertIcon(nodes, type, id, content) {
-    var node = {
-        type: type,
-        id: id,
-        content: content,
-        prev: []
-    }
-    nodes[id] = node
-    return node
+  var node = {
+    type: type,
+    id: id,
+    content: content,
+    prev: [],
+  };
+  nodes[id] = node;
+  return node;
 }
 
 function removeNodeOne(nodes, nodeId) {
-    var node = nodes[nodeId]
-    redirectPrev(nodes, node, node.one)
-    redirectNext(nodes, node, node.one)
-    delete nodes[nodeId]
+  var node = nodes[nodeId];
+  redirectPrev(nodes, node, node.one);
+  redirectNext(nodes, node, node.one);
+  delete nodes[nodeId];
 }
 
 function removeFromNext(node, next) {
-    next.prev = next.prev.filter(prevId => prevId !== node.id)
+  next.prev = next.prev.filter((prevId) => prevId !== node.id);
 }
 
 function redirectPrev(nodes, node, newTarget) {
-    for (var prevId of node.prev) {
-        var prev = nodes[prevId]
-        if (prev.one === node.id) {
-            prev.one = newTarget
-        }
-        if (prev.two === node.id) {
-            prev.two = newTarget
-        }      
+  for (var prevId of node.prev) {
+    var prev = nodes[prevId];
+    if (prev.one === node.id) {
+      prev.one = newTarget;
+    }
+    if (prev.two === node.id) {
+      prev.two = newTarget;
     }
+  }
 }
 
 function redirectNext(nodes, node, newTarget) {
-    var target = nodes[newTarget]
-    removeFromNext(node, target)
-    for (var prevId of node.prev) {
-        target.prev.push(prevId)
-    }
+  var target = nodes[newTarget];
+  removeFromNext(node, target);
+  for (var prevId of node.prev) {
+    target.prev.push(prevId);
+  }
 }
 
 function rewireShortcircuit(nodes) {
-    while (findShortcusts(nodes)) {
-
-    }
+  while (findShortcusts(nodes)) {}
 }
 
 function findShortcusts(nodes) {
-    for (var id in nodes) {
-        var node = nodes[id]
-        if (node.type === "question") {
-            var andOperand = findAndOperand(nodes, node)
-            if (andOperand) {
-                writeAndShortcut(nodes, node, andOperand)
-                return true
-            }
-            var orOperand = findOrOperand(nodes, node)
-            if (orOperand) {
-                writeOrShortcut(nodes, node, orOperand)
-                return true
-            }            
-        }
-    }
-    return false
+  for (var id in nodes) {
+    var node = nodes[id];
+    if (node.type === "question") {
+      var andOperand = findAndOperand(nodes, node);
+      if (andOperand) {
+        writeAndShortcut(nodes, node, andOperand);
+        return true;
+      }
+      var orOperand = findOrOperand(nodes, node);
+      if (orOperand) {
+        writeOrShortcut(nodes, node, orOperand);
+        return true;
+      }
+    }
+  }
+  return false;
 }
 
 function findAndOperand(nodes, node) {
-    var below = nodes[node.one]
-    if (below.type === "question") {
-        if (below.prev.length === 1 && below.two === node.two) {
-            return below
-        }
+  var below = nodes[node.one];
+  if (below.type === "question") {
+    if (below.prev.length === 1 && below.two === node.two) {
+      return below;
     }
-    return undefined
+  }
+  return undefined;
 }
 
 function findOrOperand(nodes, node) {
-    var right = nodes[node.two]
-    if (right.type === "question") {
-        if (right.prev.length === 1 && right.one === node.one) {
-            return right
-        }
+  var right = nodes[node.two];
+  if (right.type === "question") {
+    if (right.prev.length === 1 && right.one === node.one) {
+      return right;
     }
-    return undefined
+  }
+  return undefined;
 }
 
 function writeAndShortcut(nodes, node, andOperand) {
-    var right = nodes[node.two]
-    var down = nodes[andOperand.one]
-    removeFromNext(andOperand, right)
-    removeFromNext(andOperand, down)
-    node.content = {
-        operator: "and",
-        left: normalizeContent(node),
-        right: normalizeContent(andOperand)
-    }
-    node.one = down.id
-    node.flag1 = 1
-    down.prev.push(node.id)
-    delete nodes[andOperand.id]
+  var right = nodes[node.two];
+  var down = nodes[andOperand.one];
+  removeFromNext(andOperand, right);
+  removeFromNext(andOperand, down);
+  node.content = {
+    operator: "and",
+    left: normalizeContent(node),
+    right: normalizeContent(andOperand),
+  };
+  node.one = down.id;
+  node.flag1 = 1;
+  normalizeAnd(node);
+  down.prev.push(node.id);
+  delete nodes[andOperand.id];
 }
 
 function writeOrShortcut(nodes, node, orOperand) {
-    var right = nodes[orOperand.two]
-    var down = nodes[orOperand.one]
-    removeFromNext(orOperand, right)
-    removeFromNext(orOperand, down)
+  var right = nodes[orOperand.two];
+  var down = nodes[orOperand.one];
+  removeFromNext(orOperand, right);
+  removeFromNext(orOperand, down);
+  node.content = {
+    operator: "or",
+    left: normalizeContent(node),
+    right: normalizeContent(orOperand),
+  };
+  node.two = right.id;
+  node.flag1 = 1;
+  normalizeOr(node);
+  right.prev.push(node.id);
+  delete nodes[orOperand.id];
+}
+
+function normalizeAnd(node) {
+  var op = node.content;
+  var left = op.left;
+  var right = op.right;
+  if (left.operator === "not" && right.operator === "not") {
     node.content = {
-        operator: "or",
-        left: normalizeContent(node),
-        right: normalizeContent(orOperand)
-    }
-    node.two = right.id
-    node.flag1 = 1
-    right.prev.push(node.id)
-    delete nodes[orOperand.id]
+      operator: "or",
+      left: left.operand,
+      right: right.operand,
+    };
+    node.flag1 = 0;
+  }
+}
+
+function normalizeOr(node) {
+  var op = node.content;
+  var left = op.left;
+  var right = op.right;
+  if (left.operator === "not" && right.operator === "not") {
+    node.content = {
+      operator: "and",
+      left: left.operand,
+      right: right.operand,
+    };
+    node.flag1 = 0;
+  }
 }
 
 function normalizeContent(question) {
-    if (question.flag1 === 1) {
-        return question.content
+  if (question.flag1 === 1) {
+    return question.content;
+  }
+
+  return {
+    operator: "not",
+    operand: question.content,
+  };
+}
+
+function traverse(nodes, nodeId, visited, action) {
+  if (!nodeId) {
+    return;
+  }
+
+  if (nodeId in visited) {
+    return;
+  }
+  visited[nodeId] = true;
+  var node = nodes[nodeId];
+  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, htmlToString) {
+  if (node.one) {
+    var one = nodes[node.one];
+    one.prev.push(node.id);
+  }
+  if (node.two) {
+    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;
     }
+  }
+}
 
-    return {
-        operator: "not",
-        operand: question.content
+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) {
+  var nextNodeId = start.one;
+  while (nextNodeId) {
+    var current = nodes[nextNodeId];
+    nextNodeId = current.one;
+    current.parentLoopId = start.id;
+    if (current.type === "loopbegin") {
+      nextNodeId = markLoopBody(nodes, current, filename);
+    } else if (current.type === "loopend") {
+      start.end = current.id;
+      start.next = current.one;
+      current.start = start.id;
+      return nextNodeId;
+    }
+  }
+  throw createError(translate("Loop end expected here"), filename, start.one);
+}
+
+module.exports = { drakonToStruct, drakonToGraph };
+
+},{"./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;
+  },
+
+  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");
+
+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
 }
 
+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 traverse(nodes, nodeId, visited, action) {
-    if (!nodeId) {
-        return
+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;
+}
 
-    if (nodeId in visited) {
-        return
+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("")
     }
-    visited[nodeId] = true
-    var node = nodes[nodeId]
-    action(nodes, node)
-    traverse(nodes, node.one, visited, action)
-    traverse(nodes, node.two, visited, action)
+    var text = lines.join("\n")
+    return {text:text}
 }
 
-function connectBack(nodes, node) {
-    if (node.one) {
-        var one = nodes[node.one]
-        one.prev.push(node.id)
+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--;
     }
-    if (node.two) {
-        var two = nodes[node.two]
-        two.prev.push(node.id)
-    }    
 }
 
-function markLoopBody(nodes, start, filename) {
-    var nextNodeId = start.one
-    while (nextNodeId) {
-        var current = nodes[nextNodeId]
-        nextNodeId = current.one
-        current.parentLoopId = start.id
-        if (current.type === "loopbegin") {
-            nextNodeId = markLoopBody(nodes, current, filename)
-        } else if (current.type === "loopend") {
-            start.end = current.id
-            start.next = current.one
-            current.start = start.id
-            return nextNodeId
+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;
     }
-    throw createError(translate("Loop end expected here"), filename, start.one)
+
+    return counts_by_id;
 }
 
-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")
-const { drakonToStruct } = require("./drakonToStruct");
+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;
 
-window.drakongen = {
-    toPseudocode: function (drakonJson, name, filename, language) {
-        setUpLanguage(language)
-        return drakonToPseudocode(drakonJson, name, filename, htmlToString, translate).text
-    },
+    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);
+                }
+            }
+        }
+    }
 
-    toMindTree: function (mindJson, name, filename, language) {
-        setUpLanguage(language)    
-        var result = mindToTree(mindJson, name, filename, htmlToString)
-        return result.text
-    },    
+    node.stack = processed_stack;
+}
 
-    toTree: function (drakonJson, name, filename, language) {
-        setUpLanguage(language)
-        var result = drakonToStruct(drakonJson, name, filename, translate)
-        return JSON.stringify(result, null, 4)
+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
+            );
+        }
     }
 }
-},{"./browserTools":1,"./drakonToPromptStruct":2,"./drakonToStruct":3,"./translate":9}],5:[function(require,module,exports){
+
+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) {
@@ -609,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)
     }
 
@@ -674,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)
         }
     }
 
@@ -727,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)) {
@@ -755,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];
-
-        if (!node.stack) {
-            node.stack = [];
-            node.remaining = node.prev.length;
+function structFlow(nodes, branches, filename, translate, options) {
+  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 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 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--;
         }
-        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);
+      }
+    }
+    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);
+
+    // 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 buildStackFromDictionary(dictionary) {
+    const rebuiltStack = [];
+    for (const id in dictionary) {
+      if (dictionary[id] > 0) {
+        rebuiltStack.push(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;
+    }
+    return dictionary;
+  }
+
+  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;
+          }
         }
+      }
     }
 
-    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--
-                }
-            }
+    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 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);
-
-        // Merge all nodes
-        mergeAll(nodes, node, dictionary);
-
-        // Rebuild the stack
-        node.stack = buildStackFromDictionary(dictionary);
+      }
+    }
+  }
+  function isInMap(map, key) {
+    if (!map) {
+      return false;
+    }
+    return key in map;
+  }
+
+  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 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 addRange(dst, src) {
-        for (let i = 0; i < src.length; i++) {
-            dst.push(src[i]);
-        }
+  function fillAStack(nodes, node, arrowId, visited) {
+    if (node.id in visited) {
+      return;
     }
-
-    function buildStackFromDictionary(dictionary) {
-        const rebuiltStack = [];
-        for (const id in dictionary) {
-            if (dictionary[id] > 0) {
-                rebuiltStack.push(id);
-            }
-        }
-        return rebuiltStack;
+    visited[node.id] = true;
+    if (!node.astack) {
+      node.astack = {};
     }
-
-    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;
+    node.astack[arrowId] = true;
+    if (node.id === arrowId) {
+      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;
-                }                
-            }
-        }
-    }
-    function isInMap(map, key) {
-        if (!map) { return false }
-        return key in map
-    }
-
-    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 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)
+  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 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 copySide(dst, src) {
+    if (src.side) {
+      dst.side = src.side;
+    }
+  }
+
+  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;
+          }
         }
-    }
-    
-    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)
-            }
+      } 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 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 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)
-            }
+  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 {
-            output.push(body)
+          throw createError(
+            translate(
+              "An exit from the loop must lead to the point right after the loop end",
+            ),
+            filename,
+            node.id,
+          );
         }
-    }
-
-    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
-                }                
-            }            
+      }
+      if (node.type === "question") {
+        if (findLoopEnd(node.yes, endId)) {
+          return true;
         }
-        return false
-    }
-
-    function addBreaks(toBreak) {
-        for (var body of toBreak) {
-            body.push({
-                type: "break"
-            })
-        }
-    }
-
-    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
+        if (findLoopEnd(node.no, endId)) {
+          return true;
         }
-        output.push(transformed)
-        return transformed
-    }
-    
-
-    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 structMain()
+      }
+    }
+    return false;
+  }
+
+  function addBreaks(toBreak) {
+    for (var body of toBreak) {
+      body.push({
+        type: "break",
+      });
+    }
+  }
+
+  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, []);
+      }
+    }
+
+    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 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;}
@@ -1180,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 = {
@@ -1198,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;
     }
@@ -1215,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;
@@ -1226,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)
@@ -1267,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": "не",
@@ -1296,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 = {
@@ -1327,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 = {
@@ -1358,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"
 };
 
 
@@ -1382,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 = []
@@ -1393,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 {
@@ -1404,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,
@@ -1418,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: [],
@@ -1426,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,
@@ -1433,6 +2072,7 @@ function optimizeQuestion(step) {
         }
     }
     return {
+        side: step.side,
         type: step.type,
         content: step.content,
         yes: yes,