occam-furtle 2.0.86 → 2.0.89

package/src/dom/parameters.js

@@ -3,6 +3,7 @@
 import dom from "../dom";
 import Exception from "../exception";
 
+import { UNDERSCORE } from "../constants";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
@@ -68,62 +69,57 @@ export default domAssigned(class Parameters {
 
   static name = "Parameters";
 
-  static fromStringAndArray(string, array) {
-    const parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
   static fromArrayAssignmentNode(arrayAssignmentNode, context) {
     const arrayAssignmentParametersNode = arrayAssignmentParametersNodeQuery(arrayAssignmentNode),
           parametersNode = arrayAssignmentParametersNode,  ///
-          node = parametersNode,  ///
-          string = context.nodeAsString(node),
-          parameterNodes = parameterNodesQuery(parametersNode),
-          array = arrayFromParameterNodes(parameterNodes, context),
-          parameters = new Parameters(string, array);
+          parameters = parametersFromParametersNode(parametersNode, context);
 
     return parameters;
   }
 
   static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
-    const { Parameter } = dom,
-          anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),
-          parameterNode = anonymousProcedureParametersNode, ///
-          parameterNodes = parameterNodesQuery(parameterNode),
-          array = parameterNodes.map((parameterNode) => {
-            const parameter = Parameter.fromParameterNode(parameterNode, context);
-
-            return parameter;
-          }),
-          string = stringFromArray(array, context),
-          parameters = new Parameters(string, array);
+    const anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),
+          parametersNode = anonymousProcedureParametersNode,  ///
+          parameters = parametersFromParametersNode(parametersNode, context);
 
     return parameters;
   }
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    let parameters = null;
-
-    const procedureDeclarationParametersNode = procedureDeclarationParametersNodeQuery(procedureDeclarationNode);
-
-    if (procedureDeclarationParametersNode !== null) {
-      const parametersNode = procedureDeclarationParametersNode,  ///
-            node = parametersNode,  ///
-            string = context.nodeAsString(node),
-            parameterNodes = parameterNodesQuery(parametersNode),
-            array = arrayFromParameterNodes(parameterNodes, context);
-
-      parameters = new Parameters(string, array);
-    }
+    const procedureDeclarationParametersNode = procedureDeclarationParametersNodeQuery(procedureDeclarationNode),
+          parametersNode = procedureDeclarationParametersNode,  ///
+          parameters = parametersFromParametersNode(parametersNode, context);
 
     return parameters;
   }
 });
 
+function parametersFromParametersNode(parametersNode, context) {
+  const { Parameters } = dom,
+        array = arrayFromParametersNode(parametersNode, context),
+        string = stringFromArray(array, context),
+        parameters = new Parameters(string, array);
+
+  return parameters;
+}
+
+function arrayFromParametersNode(parametersNode, context) {
+  const parameterNodes = parameterNodesQuery(parametersNode),
+        array = parameterNodes.map((parameterNode) => { ///
+          const { Parameter } = dom,
+                parameter = Parameter.fromParameterNode(parameterNode, context);
+
+          return parameter;
+        });
+
+  return array;
+}
+
 function stringFromArray(array, context) {
   const parametersString = array.reduce((parametersString, parameter) => {
-          const parameterString = parameter.getString();
+          const parameterString = (parameter !== null)?
+                                    parameter.getString() :
+                                      UNDERSCORE;
 
           parametersString = (parametersString === null) ?
                                parameterString :
@@ -135,14 +131,3 @@ function stringFromArray(array, context) {
 
   return string;
 }
-
-function arrayFromParameterNodes(parameterNodes, context) {
-  const { Parameter } = dom,
-        array = parameterNodes.map((parameterNode) => { ///
-          const parameter = Parameter.fromParameterNode(parameterNode, context);
-
-          return parameter;
-        });
-
-  return array;
-}

package/src/dom/procedure.js

@@ -7,9 +7,7 @@ import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
-const labelNodeQuery = nodeQuery("/procedureDeclaration/label"),
-      parametersNodeQuery = nodeQuery("/procedureDeclaration/parameters"),
-      typeTerminalNodeQuery = nodeQuery("/procedureDeclaration/@type");
+const typeTerminalNodeQuery = nodeQuery("/procedureDeclaration/@type");
 
 export default domAssigned(class Procedure {
   constructor(string, type, label, parameters, returnBlock) {
@@ -82,13 +80,7 @@ export default domAssigned(class Procedure {
   static name = "Procedure";
 
   static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    const { Label, ReturnBlock, Parameters } = dom,
-          type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
-          label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          string = stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
-          procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
+    const procedureDeclaration = procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context);
 
     return procedureDeclaration;
   }
@@ -111,12 +103,16 @@ export function variablesFromValuesAndParameters(values, parameters, context) {
   return variables;
 }
 
-function typeFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const typeTerminalNode = typeTerminalNodeQuery(procedureDeclarationNode),
-        typeTerminalNodeContent = typeTerminalNode.getContent(),
-        type = typeTerminalNodeContent; ///
+function procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const { Label, ReturnBlock, Parameters, Procedure } = dom,
+        returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),
+        type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
+        string = stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock),
+        procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
 
-  return type;
+  return procedureDeclaration;
 }
 
 function stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, returnBlock) {
@@ -128,3 +124,11 @@ function stringFromTypeLabelParametersAndReturnBlock(type, label, parameters, re
 
   return string;
 }
+
+function typeFromProcedureDeclarationNode(procedureDeclarationNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(procedureDeclarationNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
+}

package/src/dom/procedureCall.js

@@ -6,7 +6,7 @@ import Exception from "../exception";
 import { domAssigned } from "../dom";
 import { nodeQuery } from "../utilities/query";
 
-const procedureCallNodeQuery = nodeQuery("/value/procedureCall");
+const valueProcedureCallNodeQuery = nodeQuery("/value/procedureCall");
 
 export default domAssigned(class ProcedureCall {
   constructor(string, reference, values) {
@@ -56,22 +56,28 @@ export default domAssigned(class ProcedureCall {
   static fromValueNode(valueNode, context) {
     let procedureCall = null;
 
-    const procedureCallNode = procedureCallNodeQuery(valueNode);
+    const valueProcedureCallNode = valueProcedureCallNodeQuery(valueNode);
 
-    if (procedureCallNode !== null) {
-      const { Values, Reference } = dom,
-            node = procedureCallNode, ///
-            reference = Reference.fromValueNode(valueNode, context),
-            values = Values.fromValueNode(valueNode, context),
-            string = stringFromValuesAndReference(values, reference, context);
+    if (valueProcedureCallNode !== null) {
+      const procedureCallNode = valueProcedureCallNode; ///
 
-      procedureCall = new ProcedureCall(string, reference, values);
+      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
 
     return procedureCall;
   }
 });
 
+function procedureCallFromProcedureCallNode(procedureCallNode, context) {
+  const { Values, Reference, ProcedureCall } = dom,
+        reference = Reference.fromProcedureCallNode(procedureCallNode, context),
+        values = Values.fromProcedureCallNode(procedureCallNode, context),
+        string = stringFromValuesAndReference(values, reference, context),
+        procedureCall = new ProcedureCall(string, reference, values);
+
+  return procedureCall;
+}
+
 function stringFromValuesAndReference(values, reference, context) {
   const valuesString = values.getString(),
         referenceString = reference.getString(),

package/src/dom/query/node.js

@@ -12,8 +12,8 @@ import { domAssigned } from "../../dom";
 
 const { first } = arrayUtilities;
 
-const nodeQueryNodeQuery = nodeQuery("/value/nodeQuery"),
-      expressionNodeQuery = nodeQuery("/nodeQuery/expression");
+const expressionNodeQuery = nodeQuery("/nodeQuery/expression"),
+      valueNodeQueryNodeQuery = nodeQuery("/value/nodeQuery");
 
 export default domAssigned(class NodeQuery {
   constructor(string, variable, query) {
@@ -95,20 +95,27 @@ export default domAssigned(class NodeQuery {
   static fromValueNode(valueNode, context) {
     let nodeQuery = null;
 
-    const nodeQueryNode = nodeQueryNodeQuery(valueNode);
+    const valueNodeQueryNode = valueNodeQueryNodeQuery(valueNode);
 
-    if (nodeQueryNode !== null) {
-      const { Variable } = dom,
-            node = nodeQueryNode, ///
-            string = context.nodeAsString(node),
-            expressionNode = expressionNodeQuery(nodeQueryNode),
-            expression = Expression.fromExpressionNode(expressionNode),
-            variable = Variable.fromNodeQueryNode(nodeQueryNode, context),
-            query = Query.fromExpression(expression);
+    if (valueNodeQueryNode !== null) {
+      const nodeQueryNode = valueNodeQueryNode; ///
 
-      nodeQuery = new NodeQuery(string, variable, query);
+      nodeQuery = nodeQueryFromNodeQueryNode(nodeQueryNode, context);
     }
 
     return nodeQuery;
   }
 });
+
+function nodeQueryFromNodeQueryNode(nodeQueryNode, context) {
+  const { Variable, NodeQuery } = dom,
+        node = nodeQueryNode, ///
+        string = context.nodeAsString(node),
+        expressionNode = expressionNodeQuery(nodeQueryNode),
+        expression = Expression.fromExpressionNode(expressionNode),
+        variable = Variable.fromNodeQueryNode(nodeQueryNode, context),
+        query = Query.fromExpression(expression),
+        nodeQuery = new NodeQuery(string, variable, query);
+
+  return nodeQuery;
+}

package/src/dom/query/nodes.js

@@ -9,8 +9,8 @@ import { nodeQuery } from "../../utilities/query";
 import { NODE_TYPE } from "../../types";
 import { domAssigned } from "../../dom";
 
-const nodesQueryNodeQuery = nodeQuery("/value/nodesQuery"),
-      expressionNodeQuery = nodeQuery("/nodesQuery/expression");
+const expressionNodeQuery = nodeQuery("/nodesQuery/expression"),
+      valueNodesQueryNodeQuery = nodeQuery("/value/nodesQuery");
 
 export default domAssigned(class NodesQuery {
   constructor(string, variable, query) {
@@ -80,20 +80,27 @@ export default domAssigned(class NodesQuery {
   static fromValueNode(valueNode, context) {
     let nodesQuery = null;
 
-    const nodesQueryNode = nodesQueryNodeQuery(valueNode);
+    const valueNodesQueryNode = valueNodesQueryNodeQuery(valueNode);
 
-    if (nodesQueryNode !== null) {
-      const { Variable } = dom,
-            node = nodesQueryNode,  ///
-            string = context.nodeAsString(node),
-            expressionNode = expressionNodeQuery(nodesQueryNode),
-            expression = Expression.fromExpressionNode(expressionNode),
-            variable = Variable.fromNodesQueryNode(nodesQueryNode, context),
-            query = Query.fromExpression(expression);
+    if (valueNodesQueryNode !== null) {
+      const nodesQueryNode = valueNodesQueryNode; ///
 
-      nodesQuery = new NodesQuery(string, variable, query);
+      nodesQuery = nodesQueryFromNodesQueryNode(nodesQueryNode, context);
     }
 
     return nodesQuery;
   }
 });
+
+function nodesQueryFromNodesQueryNode(nodesQueryNode, context) {
+  const { Variable, NodesQuery } = dom,
+        node = nodesQueryNode,  ///
+        string = context.nodeAsString(node),
+        expressionNode = expressionNodeQuery(nodesQueryNode),
+        expression = Expression.fromExpressionNode(expressionNode),
+        variable = Variable.fromNodesQueryNode(nodesQueryNode, context),
+        query = Query.fromExpression(expression),
+        nodesQuery = new NodesQuery(string, variable, query);
+
+  return nodesQuery;
+}

package/src/dom/reduce.js

@@ -4,13 +4,10 @@ import dom from "../dom";
 import Exception from "../exception";
 
 import { nodeQuery } from "../utilities/query";
+import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
-import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
-const variableNodeQuery = nodeQuery("/reduce/variable"),
-      parametersNodeQuery = nodeQuery("/reduce/anonymousProcedure/parameters"),
-      valueReduceNodeQuery = nodeQuery("/value/reduce"),
-      initialValueNodeQuery = nodeQuery("/reduce/value"); ///
+const valueReduceNodeQuery = nodeQuery("/value/reduce"); ///
 
 export default domAssigned(class Reduce {
   constructor(string, variable, initialValue, anonymousProcedure) {
@@ -89,21 +86,27 @@ export default domAssigned(class Reduce {
     const valueReduceNode = valueReduceNodeQuery(valueNode);
 
     if (valueReduceNode !== null) {
-      const { Value, Variable, AnonymousProcedure } = dom,
-            reduceNode = valueReduceNode, ///
-            value = Value.fromReduceNode(reduceNode, context),
-            variable = Variable.fromReduceNode(reduceNode, context),
-            initialValue = value, ///
-            anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context),
-            string = stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure);
-
-      reduce = new Reduce(string, variable, initialValue, anonymousProcedure);
+      const reduceNode = valueReduceNode; ///
+
+      reduce = reduceFromReduceNode(reduceNode, context);
     }
 
     return reduce;
   }
 });
 
+function reduceFromReduceNode(reduceNode, context) {
+  const { Value, Reduce, Variable, AnonymousProcedure } = dom,
+        value = Value.fromReduceNode(reduceNode, context),
+        variable = Variable.fromReduceNode(reduceNode, context),
+        initialValue = value, ///
+        anonymousProcedure = AnonymousProcedure.fromReduceNode(reduceNode, context),
+        string = stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure),
+        reduce = new Reduce(string, variable, initialValue, anonymousProcedure);
+
+  return reduce;
+}
+
 function stringFromVariableInitialValueAndAnonymousProcedure(variable, initialValue, anonymousProcedure) {
   const variableString = variable.getString(),
         initialValueString = initialValue.getString(),

package/src/dom/reference.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import dom from "../dom";
+
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
 const referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
-      valueProcedureCallReferenceNodeQuery = nodeQuery("/value/procedureCall/reference");
+      procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference");
 
 export default domAssigned(class Reference {
   constructor(string, name) {
@@ -23,30 +25,27 @@ export default domAssigned(class Reference {
   static name = "Reference";
 
   static fromReferenceNode(referenceNode, context) {
-    const node = referenceNode, ///
-          string = context.nodeAsString(node),
-          name = nameFromReferenceNode(referenceNode, context),
-          reference = new Reference(string, name);
+    const reference = referenceFromReferenceNode(referenceNode, context);
 
     return reference;
   }
 
-  static fromValueNode(valueNode, context) {
-    const valueProcedureCallReferenceNod = valueProcedureCallReferenceNodeQuery(valueNode),
-          referenceNode = valueProcedureCallReferenceNod,
-          name = nameFromReferenceNode(referenceNode, context),
-          string = stringFromName(name, context),
-          reference = new Reference(string, name);
+  static fromProcedureCallNode(procedureCallNode, context) {
+    const procedureCallReferenceNod = procedureCallReferenceNodeQuery(procedureCallNode),
+          referenceNode = procedureCallReferenceNod,  ///
+          reference = referenceFromReferenceNode(referenceNode, context);
 
     return reference;
   }
 });
 
-function stringFromName(name, context) {
-  const nameString = name,  ///
-        string = nameString;  ///
+function referenceFromReferenceNode(referenceNode, context) {
+  const { Reference } = dom,
+        name = nameFromReferenceNode(referenceNode, context),
+        string = stringFromName(name, context),
+        reference = new Reference(string, name);
 
-  return string;
+  return reference;
 }
 
 function nameFromReferenceNode(referenceNode, context) {
@@ -56,3 +55,10 @@ function nameFromReferenceNode(referenceNode, context) {
 
   return name;
 }
+
+function stringFromName(name, context) {
+  const nameString = name,  ///
+        string = nameString;  ///
+
+  return string;
+}

package/src/dom/some.js

@@ -93,19 +93,25 @@ export default domAssigned(class Some {
     const valueSomeNode = valueSomeNodeQuery(valueNode);
 
     if (valueSomeNode !== null) {
-      const { Variable, AnonymousProcedure } = dom,
-            someNode = valueSomeNode, ///
-            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context),
-            variable = Variable.fromSomeNode(someNode, context),
-            string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context);
+      const someNode = valueSomeNode; ///
 
-      some = new Some(string, variable, anonymousProcedure);
+      some = someFromSomeNode(someNode, context);
     }
 
     return some;
   }
 });
 
+function someFromSomeNode(someNode, context) {
+  const { Some, Variable, AnonymousProcedure } = dom,
+        anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context),
+        variable = Variable.fromSomeNode(someNode, context),
+        string = stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context),
+        some = new Some(string, variable, anonymousProcedure);
+
+  return some;
+}
+
 function stringFromVariableAndAnonymousProcedure(variable, anonymousProcedure, context) {
   const variableString = variable.getString(),
         anonymousProcedureString = anonymousProcedure.getString(),

package/src/dom/statement/return.js

@@ -5,7 +5,7 @@ import dom from "../../dom";
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const returnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
+const returnBlockReturnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 
 export default domAssigned(class ReturnStatement {
   constructor(string, value) {
@@ -38,16 +38,23 @@ export default domAssigned(class ReturnStatement {
   static name = "ReturnStatement";
 
   static fromReturnBlockNode(returnBlockNode, context) {
-    const { Value } = dom,
-          returnStatementNode = returnStatementNodeQuery(returnBlockNode),
-          value = Value.fromReturnStatementNode(returnStatementNode, context),
-          string = stringFromValue(value, context),
-          returnStatement = new ReturnStatement(string, value);
+    const returnBlockReturnStatementNode = returnBlockReturnStatementNodeQuery(returnBlockNode),
+          returnStatementNode = returnBlockReturnStatementNode, ///
+          returnStatement = returnStatementFromReturnStatementNode(returnStatementNode, context);
 
     return returnStatement;
   }
 });
 
+function returnStatementFromReturnStatementNode(returnStatementNode, context) {
+  const { Value, ReturnStatement } = dom,
+        value = Value.fromReturnStatementNode(returnStatementNode, context),
+        string = stringFromValue(value, context),
+        returnStatement = new ReturnStatement(string, value);
+
+  return returnStatement;
+}
+
 function stringFromValue(value, context) {
   const valueString = value.asString(context),
         string = `Return ${valueString};`;

package/src/dom/step.js

@@ -44,17 +44,23 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ArrayAssignment, ObjectAssigment, VariableAssignments } = dom,
-          string = stringFromNothing(context),
-          arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
-          objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
-          variablesDeclaration = VariableAssignments.fromStepNode(stepNode, context),
-          step = new Step(string, arrayAssignment, objectAssigment, variablesDeclaration);
+    const step = stepFromStepNode(stepNode, context);
 
     return step;
   }
 });
 
+function stepFromStepNode(stepNode, context) {
+  const { Step, ArrayAssignment, ObjectAssigment, VariableAssignments } = dom,
+        string = stringFromNothing(context),
+        arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
+        objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
+        variablesDeclaration = VariableAssignments.fromStepNode(stepNode, context),
+        step = new Step(string, arrayAssignment, objectAssigment, variablesDeclaration);
+
+  return step;
+}
+
 function stringFromNothing(context) {
   const string = EMPTY_STRING;
 

package/src/dom/ternary.js

@@ -8,8 +8,8 @@ import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
 
 const ifValueNodeQuery = nodeQuery("/ternary/value[1]"),
-      ternaryNodeQuery = nodeQuery("/value/ternary"),
-      elseValueNodeQuery = nodeQuery("/ternary/value[2]");
+      elseValueNodeQuery = nodeQuery("/ternary/value[2]"),
+      valueTernaryNodeQuery = nodeQuery("/value/ternary");
 
 export default domAssigned(class Ternary {
   constructor(string, value, ifValue, elseValue) {
@@ -57,8 +57,8 @@ export default domAssigned(class Ternary {
     const boolean = value.getBoolean();
 
     value = boolean ?
-      this.ifValue.evaluate(context) :
-        this.elseValue.evaluate(context);
+              this.ifValue.evaluate(context) :
+                this.elseValue.evaluate(context);
 
     context.debug(`...evaluated the '${ternaryString}' ternary.`);
 
@@ -70,24 +70,31 @@ export default domAssigned(class Ternary {
   static fromValueNode(valueNode, context) {
     let ternary = null;
 
-    const ternaryNode = ternaryNodeQuery(valueNode);
+    const valueTernaryNode = valueTernaryNodeQuery(valueNode);
 
-    if (ternaryNode !== null) {
-      const { Value } = dom,
-            ifValueNode = ifValueNodeQuery(ternaryNode),
-            elseValueNode = elseValueNodeQuery(ternaryNode),
-            value = Value.fromTernaryNode(ternaryNode, context),
-            ifValue = Value.fromValueNode(ifValueNode, context),
-            elseValue = Value.fromValueNode(elseValueNode, context),
-            string = stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context);
+    if (valueTernaryNode !== null) {
+      const ternaryNode = valueTernaryNode; ///
 
-      ternary = new Ternary(string, value, ifValue, elseValue);
+      ternary = ternaryFromTernaryNode(ternaryNode, context);
     }
 
     return ternary;
   }
 });
 
+function ternaryFromTernaryNode(ternaryNode, context) {
+  const { Value, Ternary } = dom,
+        ifValueNode = ifValueNodeQuery(ternaryNode),
+        elseValueNode = elseValueNodeQuery(ternaryNode),
+        value = Value.fromTernaryNode(ternaryNode, context),
+        ifValue = Value.fromValueNode(ifValueNode, context),
+        elseValue = Value.fromValueNode(elseValueNode, context),
+        string = stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context),
+        ternary = new Ternary(string, value, ifValue, elseValue);
+
+  return ternary;
+}
+
 function stringFromValueIfValueAndElseValue(value, ifValue, elseValue, context) {
   const valueString = value.asString(context),
         ifValueString = ifValue.asString(context),

package/src/dom/value/bitwise.js

@@ -11,7 +11,7 @@ import { CONJUNCTION, DISJUNCTION } from "../../constants";
 const terminalNodeQuery = nodeQuery("/bitwiseValue/@*"),
       leftValueNodeQuery = nodeQuery("/bitwiseValue/value[0]"),
       rightValueNodeQuery = nodeQuery("/bitwiseValue/value[1]"),
-      bitwiseValueNodeQuery = nodeQuery("/value/bitwiseValue");
+      valueBitwiseValueNodeQuery = nodeQuery("/value/bitwiseValue");
 
 export default domAssigned(class BitwiseValue {
   constructor(string, type, disjoint, leftValue, rightValue) {
@@ -89,25 +89,32 @@ export default domAssigned(class BitwiseValue {
   static fromValueNode(valueNode, context) {
     let bitwiseValue = null;
 
-    const bitwiseValueNode = bitwiseValueNodeQuery(valueNode);
+    const valueBitwiseValueNode = valueBitwiseValueNodeQuery(valueNode);
 
-    if (bitwiseValueNode !== null) {
-      const { Value } = dom,
-            type = BOOLEAN_TYPE,
-            leftValueNode = leftValueNodeQuery(bitwiseValueNode),
-            rightValueNode = rightValueNodeQuery(bitwiseValueNode),
-            disjoint = disjointFromBitwiseValueNode(bitwiseValueNode, context),
-            leftValue = Value.fromValueNode(leftValueNode, context),
-            rightValue = Value.fromValueNode(rightValueNode, context),
-            string = stringFromTypeDisjointLeftValueAndRightValue(disjoint, leftValue, rightValue, context);
+    if (valueBitwiseValueNode !== null) {
+      const bitwiseValueNode = valueBitwiseValueNode; ///
 
-      bitwiseValue = new BitwiseValue(string, type, disjoint, leftValue, rightValue);
+      bitwiseValue = bitwiseValueFromBitwiseValueNode(bitwiseValueNode, context);
     }
 
     return bitwiseValue;
   }
 });
 
+function bitwiseValueFromBitwiseValueNode(bitwiseValueNode, context) {
+  const { Value, BitwiseValue } = dom,
+        leftValueNode = leftValueNodeQuery(bitwiseValueNode),
+        rightValueNode = rightValueNodeQuery(bitwiseValueNode),
+        type = BOOLEAN_TYPE,
+        disjoint = disjointFromBitwiseValueNode(bitwiseValueNode, context),
+        leftValue = Value.fromValueNode(leftValueNode, context),
+        rightValue = Value.fromValueNode(rightValueNode, context),
+        string = stringFromTypeDisjointLeftValueAndRightValue(disjoint, leftValue, rightValue, context),
+        bitwiseValue = new BitwiseValue(string, type, disjoint, leftValue, rightValue);
+
+  return bitwiseValue;
+}
+
 function disjointFromBitwiseValueNode(bitwiseValueNode, context) {
   const terminalNode = terminalNodeQuery(bitwiseValueNode),
         terminalNodeContent = terminalNode.getContent(),