occam-furtle 2.0.63 → 2.0.65

package/lib/nullNode.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+var NullNode = /*#__PURE__*/ function() {
+    function NullNode() {
+        _class_call_check(this, NullNode);
+    }
+    _create_class(NullNode, null, [
+        {
+            key: "fromNothing",
+            value: function fromNothing() {
+                var nullNode = new NullNode();
+                return nullNode;
+            }
+        }
+    ]);
+    return NullNode;
+}();
+var nullNode = NullNode.fromNothing();
+var _default = nullNode;
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9udWxsTm9kZS5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuY2xhc3MgTnVsbE5vZGUge1xuICBzdGF0aWMgZnJvbU5vdGhpbmcoKSB7XG4gICAgY29uc3QgbnVsbE5vZGUgPSBuZXcgTnVsbE5vZGUoKTtcblxuICAgIHJldHVybiBudWxsTm9kZTtcbiAgfVxufVxuXG5jb25zdCBudWxsTm9kZSA9IE51bGxOb2RlLmZyb21Ob3RoaW5nKCk7XG5cbmV4cG9ydCBkZWZhdWx0IG51bGxOb2RlO1xuXG4iXSwibmFtZXMiOlsiTnVsbE5vZGUiLCJmcm9tTm90aGluZyIsIm51bGxOb2RlIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFZQTs7O2VBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFWQSxJQUFBLEFBQU1BLHlCQUFOO2FBQU1BO2dDQUFBQTs7a0JBQUFBOztZQUNHQyxLQUFBQTttQkFBUCxTQUFPQTtnQkFDTCxJQUFNQyxXQUFXLElBRmZGO2dCQUlGLE9BQU9FO1lBQ1Q7OztXQUxJRjs7QUFRTixJQUFNRSxXQUFXRixTQUFTQyxXQUFXO0lBRXJDLFdBQWVDIn0=

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-furtle",
   "author": "James Smith",
-  "version": "2.0.63",
+  "version": "2.0.65",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-furtle",
   "description": "Occam's Furtle language.",
@@ -11,12 +11,12 @@
   },
   "dependencies": {
     "necessary": "^14.3.2",
-    "occam-grammars": "^1.3.149"
+    "occam-grammars": "^1.3.153"
   },
   "devDependencies": {
     "@swc/core": "^1.5.6",
-    "occam-custom-grammars": "^5.0.1079",
-    "occam-entities": "^1.0.289",
+    "occam-custom-grammars": "^5.0.1081",
+    "occam-entities": "^1.0.291",
     "occam-grammar-utilities": "^8.0.258",
     "occam-lexers": "^23.0.45",
     "occam-parsers": "^23.0.50",

package/src/_occam-grammars/furtle/bnf.js

@@ -22,11 +22,9 @@ objectAssignment       ::=  "{" parameters "}" "=" variable ";" ;
 
 arrayAssignment        ::=  "[" parameters "]" "=" variable ";" ;
                                                       
-forEachLoop            ::=  "ForEach"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ";" ;
 
 
-
-anonymousProcedure     ::=  "(" parameters? ")" block ;
+anonymousProcedure     ::=  "(" parameters? ")" returnBlock ;
 
 
 
@@ -71,8 +69,6 @@ step                   ::=  variablesDeclaration
                           
                          |  arrayAssignment
                           
-                         |  forEachLoop
-                          
                          ;  
   
   
@@ -83,6 +79,8 @@ assignment             ::=  "=" value ;
 
 value                  ::=  procedureCall
  
+                         |  comparison
+
                          |  nodesQuery
                           
                          |  nodeQuery
@@ -91,6 +89,10 @@ value                  ::=  procedureCall
                           
                          |  ternary
                           
+                         |  some
+
+                         |  [null]
+
                          |  [number]
                           
                          |  [primitive]
@@ -111,6 +113,8 @@ variable               ::=  [name] ;
 
 ternary                ::=  "If" "(" condition ")" value "Else" value ;
 
+some                   ::=  "Some"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ";" ;
+
 
 
 parameters             ::=  parameter ( "," parameter )* ;

package/src/_occam-grammars/furtle/entries.js

@@ -11,7 +11,7 @@ const entries = [
     "return": "^Return"
   },
   {
-    "keyword": "^(?:If|Else|ForEach)"
+    "keyword": "^(?:If|Else|Some)"
   },
   {
     "primitive": "^(?:null|true|false)"

package/src/dom/block.js

@@ -6,8 +6,7 @@ import BlockContext from "../context/block";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const stepNodesQuery = nodesQuery("/block/step"),
-      forEachLoopBlockNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/block");
+const stepNodesQuery = nodesQuery("/block/step");
 
 export default domAssigned(class Block {
   constructor(string, steps) {
@@ -55,18 +54,6 @@ export default domAssigned(class Block {
 
     return block;
   }
-
-  static fromForEachLoopNode(forEachLoopNode, context) {
-    const forEachLoopBockNode = forEachLoopBlockNodeQuery(forEachLoopNode),
-          blockNode = forEachLoopBockNode,  ///
-          stepNodes = stepNodesQuery(blockNode),
-          node = blockNode, ///
-          string = context.nodeAsString(node),
-          steps = stepsFromStepNodes(stepNodes, context),
-          block = new Block(string, steps);
-
-    return block;
-  }
 });
 
 function stepsFromStepNodes(stepNodes, context) {

package/src/dom/comparison.js

@@ -10,7 +10,8 @@ import { domAssigned } from "../dom";
 const terminalNodeQuery = nodeQuery("/comparison/@*"),
       leftValueNodeQuery = nodeQuery("/comparison/value[0]"),
       rightValueNodeQuery = nodeQuery("/comparison/value[1]"),
-      comparisonNodeQuery = nodeQuery("/condition/comparison");
+      valueComparisonNodeQuery = nodeQuery("/value/comparison"),
+      conditionComparisonNodeQuery = nodeQuery("/condition/comparison");
 
 export default domAssigned(class Comparison {
   constructor(string, negated, leftValue, rightValue) {
@@ -76,22 +77,29 @@ export default domAssigned(class Comparison {
 
   static name = "Comparison";
 
+  static fromValueNode(valudNode, context) {
+    let comparison = null;
+
+    const valueComparisonNode = valueComparisonNodeQuery(valudNode);
+
+    if (valueComparisonNode !== null) {
+      const comparisonNode = valueComparisonNode; ///
+
+      comparison = comparisonFromComparisonNode(comparisonNode, context);
+    }
+
+    return comparison;
+  }
+
   static fromConditionNode(conditionNode, context) {
     let comparison = null;
 
-    const comparisonNode = comparisonNodeQuery(conditionNode);
+    const conditionComparisonNode = conditionComparisonNodeQuery(conditionNode);
 
-    if (comparisonNode !== null) {
-      const { Value } = dom,
-            node = comparisonNode,  ///
-            string = context.nodeAsString(node),
-            leftValueNode = leftValueNodeQuery(comparisonNode),
-            rightValueNode = rightValueNodeQuery(comparisonNode),
-            negated = negatedFromComparisonNode(comparisonNode, context),
-            leftValue = Value.fromValueNode(leftValueNode, context),
-            rightValue = Value.fromValueNode(rightValueNode, context);
+    if (conditionComparisonNode !== null) {
+      const comparisonNode = conditionComparisonNode; ///
 
-      comparison = new Comparison(string, negated, leftValue, rightValue);
+      comparison = comparisonFromComparisonNode(comparisonNode, context);
     }
 
     return comparison;
@@ -104,4 +112,18 @@ function negatedFromComparisonNode(comparisonNode) {
         negated = (terminalNodeContent !== EQUAL_TO);
 
   return negated;
-}
+}
+
+function comparisonFromComparisonNode(comparisonNode, context) {
+  const { Value, Comparison } = dom,
+        node = comparisonNode,  ///
+        string = context.nodeAsString(node),
+        leftValueNode = leftValueNodeQuery(comparisonNode),
+        rightValueNode = rightValueNodeQuery(comparisonNode),
+        negated = negatedFromComparisonNode(comparisonNode, context),
+        leftValue = Value.fromValueNode(leftValueNode, context),
+        rightValue = Value.fromValueNode(rightValueNode, context),
+        comparison = new Comparison(string, negated, leftValue, rightValue);
+
+  return comparison;
+}

package/src/dom/condition.js

@@ -7,7 +7,8 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
-const conditionNodeQuery = nodeQuery("/conditionalBlocks/condition");
+const ternaryConditionNodeQuery = nodeQuery("/ternary/condition"),
+      conditionalBlocksConditionNodeQuery = nodeQuery("/conditionalBlocks/condition");
 
 export default domAssigned(class Condition {
   constructor(string, value, comparison, bitwiseCondition, negatedCondition, bracketedCondition) {
@@ -62,21 +63,13 @@ export default domAssigned(class Condition {
 
         throw exception;
       }
-    }
-
-    if (this.comparison !== null) {
+    } else if (this.comparison !== null) {
       value = this.comparison.evaluate(context);
-    }
-
-    if (this.bitwiseCondition !== null) {
+    } else if (this.bitwiseCondition !== null) {
       value = this.bitwiseCondition.evaluate(context);
-    }
-
-    if (this.negatedCondition !== null) {
+    } else if (this.negatedCondition !== null) {
       value = this.negatedCondition.evaluate(context);
-    }
-
-    if (this.bracketedCondition !== null) {
+    } else if (this.bracketedCondition !== null) {
       value = this.bracketedCondition.evaluate(context);
     }
 
@@ -87,32 +80,39 @@ export default domAssigned(class Condition {
 
   static name = "Condition";
 
+  static fromTernaryNode(ternaryNode, context) {
+    const ternaryConditionNode = ternaryConditionNodeQuery(ternaryNode),
+          conditionNode = ternaryConditionNode, ///
+          condition = conditionFromConditionNode(conditionNode, context);
+
+    return condition;
+  }
+
   static fromConditionNode(conditionNode, context) {
-    const { Value, Comparison, BitwiseCondition, NegatedCondition, BracketedCondition } = dom,
-          node = conditionNode, ///
-          string = context.nodeAsString(node),
-          value = Value.fromConditionNode(conditionNode, context),
-          comparison = Comparison.fromConditionNode(conditionNode, context),
-          bitwiseCondition = BitwiseCondition.fromConditionNode(conditionNode, context),
-          negatedCondition = NegatedCondition.fromConditionNode(conditionNode, context),
-          bracketedCondition = BracketedCondition.fromConditionNode(conditionNode, context),
-          condition = new Condition(string, value, comparison, bitwiseCondition, negatedCondition, bracketedCondition);
+    const condition = conditionFromConditionNode(conditionNode, context);
 
     return condition;
   }
 
   static fromConditionalBlocksNode(conditionalBlocksNode, context) {
-    const { Value, Comparison, BitwiseCondition, NegatedCondition, BracketedCondition } = dom,
-          conditionNode = conditionNodeQuery(conditionalBlocksNode),
-          node = conditionNode, ///
-          string = context.nodeAsString(node),
-          value = Value.fromConditionNode(conditionNode, context),
-          comparison = Comparison.fromConditionNode(conditionNode, context),
-          bitwiseCondition = BitwiseCondition.fromConditionNode(conditionNode, context),
-          negatedCondition = NegatedCondition.fromConditionNode(conditionNode, context),
-          bracketedCondition = BracketedCondition.fromConditionNode(conditionNode, context),
-          condition = new Condition(string, value, comparison, bitwiseCondition, negatedCondition, bracketedCondition);
+    const conditionalBlocksConditionNode = conditionalBlocksConditionNodeQuery(conditionalBlocksNode),
+          conditionNode = conditionalBlocksConditionNode,  ///
+          condition = conditionFromConditionNode(conditionNode, context);
 
     return condition;
   }
 });
+
+function conditionFromConditionNode(conditionNode, context) {
+  const { Condition, Value, Comparison, BitwiseCondition, NegatedCondition, BracketedCondition } = dom,
+        node = conditionNode, ///
+        string = context.nodeAsString(node),
+        value = Value.fromConditionNode(conditionNode, context),
+        comparison = Comparison.fromConditionNode(conditionNode, context),
+        bitwiseCondition = BitwiseCondition.fromConditionNode(conditionNode, context),
+        negatedCondition = NegatedCondition.fromConditionNode(conditionNode, context),
+        bracketedCondition = BracketedCondition.fromConditionNode(conditionNode, context),
+        condition = new Condition(string, value, comparison, bitwiseCondition, negatedCondition, bracketedCondition);
+
+  return condition;
+}

package/src/dom/parameters.js

@@ -6,8 +6,8 @@ import Exception from "../exception";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters"),
-      parameterNodesQuery = nodesQuery("/parameters/parameter"),
+const parameterNodesQuery = nodesQuery("/parameters/parameter"),
+      someParametersNodeQuery = nodeQuery("/some/parameters"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
       objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
@@ -107,16 +107,11 @@ export default domAssigned(class Parameters {
 
   static name = "Parameters";
 
-  static fromStringAndArray(string, array) {
-    const parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
-  static fromForEachLoopNode(forEachLoopNode, context) {
+  static fromSomeNode(someNode, context) {
     const { Parameter } = dom,
-          parametersNode = parametersNodeQuery(forEachLoopNode),
-          parameterNodes = parameterNodesQuery(parametersNode),
+          someParametersNode = someParametersNodeQuery(someNode),
+          parameterNode = someParametersNode, ///
+          parameterNodes = parameterNodesQuery(parameterNode),
           array = parameterNodes.map((parameterNode) => {
             const parameter = Parameter.fromParameterNode(parameterNode, context);
 
@@ -128,6 +123,12 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
+  static fromStringAndArray(string, array) {
+    const parameters = new Parameters(string, array);
+
+    return parameters;
+  }
+
   static fromArrayAssignmentNode(arrayAssignmentNode, context) {
     const arrayAssignmentParametersNode = arrayAssignmentParametersNodeQuery(arrayAssignmentNode),
           parametersNode = arrayAssignmentParametersNode,  ///

package/src/dom/procedure/anonymous.js

@@ -7,15 +7,15 @@ import { domAssigned } from "../../dom";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 import { variablesFromValuesAndParameters } from "../procedure";
 
-const nonsenseNodesQuery = nodesQuery("/forEachLoop/anonymousProcedure/block/nonsense"),
-      parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters");
+const nonsenseNodesQuery = nodesQuery("/some/anonymousProcedure/returnBlock/nonsense"),
+      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
 
 export default domAssigned(class AnonymousProcedure {
-  constructor(string, parameters, nonsensical, block) {
+  constructor(string, parameters, nonsensical, returnBlock) {
     this.string = string;
     this.parameters = parameters;
     this.nonsensical = nonsensical;
-    this.block = block;
+    this.returnBlock = returnBlock;
   }
 
   getString() {
@@ -30,11 +30,13 @@ export default domAssigned(class AnonymousProcedure {
     return this.nonsensical;
   }
 
-  getBlock() {
-    return this.block;
+  getReturnBlock() {
+    return this.returnBlock;
   }
 
   call(values, context) {
+    debugger
+
     const anonymousProcedureString = this.string; ///
 
     context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);
@@ -50,35 +52,35 @@ export default domAssigned(class AnonymousProcedure {
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context);
 
-    this.block.evaluate(variables, context);
+    this.returnBlock.evaluate(variables, context);
 
     context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);
   }
 
   static name = "AnonymousProcedure";
 
-  static fromForEachLoopNode(forEachLoopNode, context) {
-    const { Block, Parameters } = dom,
-          string = stringFromForEachLoopNode(forEachLoopNode, context),
-          parameters = Parameters.fromForEachLoopNode(forEachLoopNode, context),
-          nonsensical = nonsensicalFromForEachLoopNode(forEachLoopNode, context),
-          block = Block.fromForEachLoopNode(forEachLoopNode, context),
-          anonymousProcedureDeclaration = new AnonymousProcedure(string, parameters, nonsensical, block);
+  static fromSomeNode(someNode, context) {
+    const { ReturnBlock, Parameters } = dom,
+          string = stringFromSomeNode(someNode, context),
+          parameters = Parameters.fromSomeNode(someNode, context),
+          nonsensical = nonsensicalFromSomeNode(someNode, context),
+          returnBlock = ReturnBlock.fromSomeNode(someNode, context),
+          anonymousProcedureDeclaration = new AnonymousProcedure(string, parameters, nonsensical, returnBlock);
 
     return anonymousProcedureDeclaration;
   }
 });
 
-function stringFromForEachLoopNode(forEachLoopNode, context) {
-  const parametersNode = parametersNodeQuery(forEachLoopNode),
+function stringFromSomeNode(someNode, context) {
+  const parametersNode = parametersNodeQuery(someNode),
         parametersString = context.nodeAsString(parametersNode),
         string = `(${parametersString}) { ... }`;
 
   return string;
 }
 
-function nonsensicalFromForEachLoopNode(forEachLoopNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(forEachLoopNode),
+function nonsensicalFromSomeNode(someNode, context) {
+  const nonsenseNodes = nonsenseNodesQuery(someNode),
         nonsenseNodesLength = nonsenseNodes.length,
         nonsensical = (nonsenseNodesLength > 0);
 

package/src/dom/{forEachLoop.js → some.js}

@@ -7,11 +7,11 @@ import { nodeQuery } from "../utilities/query";
 import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
 
-const variableNodeQuery = nodeQuery("/forEachLoop/variable"),
-      parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters"),
-      forEachLoopNodeQuery = nodeQuery("/step/forEachLoop");
+const variableNodeQuery = nodeQuery("/some/variable"),
+      valueSomeNodeQuery = nodeQuery("/value/some"),
+      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
 
-export default domAssigned(class ForEachLoop {
+export default domAssigned(class Some {
   constructor(string, variable, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
@@ -31,9 +31,11 @@ export default domAssigned(class ForEachLoop {
   }
 
   evaluate(context) {
-    const forEachLoopString = this.getString();
+    debugger
 
-    context.trace(`Evaluating the '${forEachLoopString}' for-each loop...`);
+    const someString = this.getString();
+
+    context.trace(`Evaluating the '${someString}' some loop...`);
 
     const value = this.variable.evaluate(context),
           valueType = value.getType();
@@ -48,7 +50,7 @@ export default domAssigned(class ForEachLoop {
 
     const nodes = value.getNodes();
 
-    nodes.forEach((node) => {
+    nodes.some((node) => {
       const { Value, Values } = dom,
             value = Value.fromNode(node, context),
             values = Values.fromValue(value, context);
@@ -56,35 +58,36 @@ export default domAssigned(class ForEachLoop {
       this.anonymousProcedure.call(values, context);
     });
 
-    context.trace(`...evaluated the '${forEachLoopString}' for-each loop.`);
+    context.trace(`...evaluated the '${someString}' some loop.`);
   }
 
-  static name = "ForEachLoop";
+  static name = "Some";
 
-  static fromStepNode(stepNode, context) {
-    let forEachLoop = null;
+  static fromValueNode(valueNode, context) {
+    let some = null;
 
-    const forEachLoopNode = forEachLoopNodeQuery(stepNode);
+    const valueSomeNode = valueSomeNodeQuery(valueNode);
 
-    if (forEachLoopNode !== null) {
+    if (valueSomeNode !== null) {
       const { Variable, AnonymousProcedure } = dom,
-            string = stringFromForEachLoopNode(forEachLoopNode, context),
-            variable = Variable.fromForEachLoopNode(forEachLoopNode, context),
-            anonymousProcedure = AnonymousProcedure.fromForEachLoopNode(forEachLoopNode, context);
+            someNode = valueSomeNode, ///
+            string = stringFromSomeNode(someNode, context),
+            variable = Variable.fromSomeNode(someNode, context),
+            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context);
 
-      forEachLoop = new ForEachLoop(string, variable, anonymousProcedure);
+      some = new Some(string, variable, anonymousProcedure);
     }
 
-    return forEachLoop;
+    return some;
   }
 });
 
-function stringFromForEachLoopNode(forEachLoopNode, context) {
-  const variableNode = variableNodeQuery(forEachLoopNode),
-        parametersNode = parametersNodeQuery(forEachLoopNode),
+function stringFromSomeNode(someNode, context) {
+  const variableNode = variableNodeQuery(someNode),
+        parametersNode = parametersNodeQuery(someNode),
         variableString = context.nodeAsString(variableNode),
         parametersString = context.nodeAsString(parametersNode),
-        string = `ForEach(${variableString}, (${parametersString}) { ... })`;
+        string = `Some(${variableString}, (${parametersString}) { ... })`;
 
   return string;
 }

package/src/dom/step.js

@@ -5,9 +5,8 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Step {
-  constructor(string, forEachLoop, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
+  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
     this.string = string;
-    this.forEachLoop = forEachLoop;
     this.arrayAssignment = arrayAssignment;
     this.objectAssigment = objectAssigment;
     this.conditionalBlocks = conditionalBlocks;
@@ -19,10 +18,6 @@ export default domAssigned(class Step {
     return this.string;
   }
 
-  getForEachLoop() {
-    return this.forEachLoop;
-  }
-
   getArrayAssignment() {
     return this.arrayAssignment;
   }
@@ -44,27 +39,18 @@ export default domAssigned(class Step {
   }
 
   evaluate(context) {
-    if (this.forEachLoop !== null) {
-      this.forEachLoop.evaluate(context);
-    }
 
-    if (this.arrayAssignment !== null) {
+    if (false) {
+      ///
+    } else if (this.arrayAssignment !== null) {
       this.arrayAssignment.evaluate(context);
-    }
-
-    if (this.objectAssigment !== null) {
+    } else if (this.objectAssigment !== null) {
       this.objectAssigment.evaluate(context);
-    }
-
-    if (this.conditionalBlocks !== null) {
+    } else if (this.conditionalBlocks !== null) {
       this.conditionalBlocks.evaluate(context);
-    }
-
-    if (this.variableAssignment !== null) {
+    } else if (this.variableAssignment !== null) {
       this.variableAssignment.evaluate(context);
-    }
-
-    if (this.variablesDeclaration !== null) {
+    } else if (this.variablesDeclaration !== null) {
       this.variablesDeclaration.evaluate(context);
     }
   }
@@ -72,16 +58,15 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ForEachLoop, ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
+    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
           node = stepNode,  ///
           string = context.nodeAsString(node),
-          forEachLoop = ForEachLoop.fromStepNode(stepNode, context),
           arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
           objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
           conditionalBlocks = ConditionalBlocks.fromStepNode(stepNode, context),
           variableAssignment = VariableAssignment.fromStepNode(stepNode, context),
           variablesDeclaration = VariablesDeclaration.fromStepNode(stepNode, context),
-          step = new Step(string, forEachLoop, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
+          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
 
     return step;
   }