occam-furtle 2.0.71 → 2.0.74

package/src/dom/parameter.js

@@ -10,24 +10,24 @@ const terminalNodesQuery = nodesQuery("/parameter/@*"),
       typeTerminalNodeQuery = nodeQuery("/parameter/@type");
 
 export default domAssigned(class Parameter {
-  constructor(string, name, type) {
+  constructor(string, type, name) {
     this.string = string;
-    this.name = name;
     this.type = type;
+    this.name = name;
   }
 
   getString() {
     return this.string;
   }
 
-  getName() {
-    return this.name;
-  }
-
   getType() {
     return this.type;
   }
 
+  getName() {
+    return this.name;
+  }
+
   matchValue(value, context) {
     const valueString = value.asString(context),
           parameterString = this.string;  ///
@@ -46,38 +46,8 @@ export default domAssigned(class Parameter {
     context.debug(`...matched the ${valueString} value against the '${parameterString}' parameter.`);
   }
 
-  matchParameter(parameter, context) {
-    let parameterMatches;
-
-    const parameterA = this,  ///
-          parameterB = parameter; ///
-
-    const parameterAString = parameterA.getString(),
-          parameterBString = parameterB.getString();
-
-    context.trace(`Matching the '${parameterAString}' parameter against the '${parameterBString}' parameter...`);
-
-    const name = parameter.getName(),
-          type = parameter.getType();
-
-    parameterMatches = ((this.name === name) && (this.type === type));
-
-    if (parameterMatches) {
-      context.debug(`...matched the '${parameterAString}' parameter against the '${parameterBString}' parameter.`);
-    }
-
-    return parameterMatches;
-  }
-
   static name = "Parameter";
 
-  static fromNameAndType(name, type, context) {
-    const string = stringFromNameAndType(name, type, context),
-          parameter = new Parameter(string, name, type);
-
-    return parameter;
-  }
-
   static fromParameterNode(parameterNode, context) {
     let parameter = null;
 
@@ -90,19 +60,13 @@ export default domAssigned(class Parameter {
             node = parameterNode, //
             string = context.nodeAsString(node);
 
-      parameter = new Parameter(string, name, type);
+      parameter = new Parameter(string, type, name);
     }
 
     return parameter;
   }
 });
 
-function stringFromNameAndType(name, type) {
-  const string = `${type} ${name}`;
-
-  return string;
-}
-
 function nameFromParameterNode(parameterNode, context) {
   const nameTerminalNode = nameTerminalNodeQuery(parameterNode),
         nameTerminalNodeContent = nameTerminalNode.getContent(),

package/src/dom/parameters/named.js

@@ -0,0 +1,129 @@
+"use strict";
+
+import dom from "../../dom";
+import Exception from "../../exception";
+
+import { domAssigned } from "../../dom";
+import { nodeQuery, nodesQuery } from "../../utilities/query";
+
+const namedParameterNodesQuery = nodesQuery("/namedParameters/namedParameter"),
+      objectAssignmentNamedParametersNodeQuery = nodeQuery("/objectAssignment/namedParameters");
+
+export default domAssigned(class NamedParameters {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getLength() {
+    const length = this.array.length;
+
+    return length;
+  }
+
+  getNamedParameter(index) {
+    const namedParameter = this.array[index] || null;
+
+    return namedParameter;
+  }
+
+  someNamedParameter(callback) { return this.array.some(callback); }
+
+  forEachNamedParameter(callback) { this.array.forEach(callback); }
+
+  matchValues(values, context) {
+    const valuesString = values.getString(),
+          namedParametersString = this.string; ///
+
+    context.trace(`Matching the ${valuesString} values against the '${namedParametersString}' named parameters...`);
+
+    const valuesLength = values.getLength(),
+          namedParametersLength = this.getLength();
+
+    if (valuesLength !== namedParametersLength) {
+      const message = `The ${valuesString} values and '${namedParametersString}' named parameters are not of the same length.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    this.forEachNamedParameter((namedParameter, index) => {
+      if (namedParameter !== null) {
+        const value = values.getValue(index);
+
+        namedParameter.matchValue(value, context);
+      }
+    });
+
+    context.debug(`...matched the ${valuesString} values against the '${namedParametersString}' named parameters.`);
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    const namedParameterString = namedParameter.getString(),
+          namedParametersString = this.string; ///
+
+    context.trace(`Matching the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters...`);
+
+    const namedParameterA = namedParameter, ///
+          namedParameterMatches = this.someNamedParameter((namedParameter) => {
+            if (namedParameter !== null) {
+              const namedParameterB = namedParameter, ///
+                    namedParameterBMatchesNamedParameterA = namedParameterA.matchNamedParameter(namedParameterB, context);
+
+              if (namedParameterBMatchesNamedParameterA) {
+                return true;
+              }
+            }
+          });
+
+    if (!namedParameterMatches) {
+      const message = `The '${namedParameterString}' namedParameter does not match any of the '${namedParametersString}' named parameters.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the '${namedParameterString}' namedParameter against the '${namedParametersString}' named parameters.`);
+  }
+
+  matchNamedParameters(namedParameters, context) {
+    namedParameters.forEachNamedParameter((namedParameter) => {
+      if (namedParameter !== null) {
+        this.matchNamedParameter(namedParameter, context);
+      }
+    });
+  }
+
+  static name = "NamedParameters";
+
+  static fromObjectAssignmentNode(objectAssignmentNode, context) {
+    const objectAssignmentNamedParametersNode = objectAssignmentNamedParametersNodeQuery(objectAssignmentNode),
+          parametersNode = objectAssignmentNamedParametersNode,  ///
+          node = parametersNode,  ///
+          string = context.nodeAsString(node),
+          namedParameterNodes = namedParameterNodesQuery(parametersNode),
+          array = arrayFromNamedParameterNodes(namedParameterNodes, context),
+          namedParameters = new NamedParameters(string, array);
+
+    return namedParameters;
+  }
+});
+
+function arrayFromNamedParameterNodes(namedParameterNodes, context) {
+  const { NamedParameter } = dom,
+        array = namedParameterNodes.map((namedParameterNode) => { ///
+          const namedParameter = NamedParameter.fromNamedParameterNode(namedParameterNode, context);
+
+          return namedParameter;
+        });
+
+  return array;
+}

package/src/dom/parameters.js

@@ -8,7 +8,6 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/parameters/parameter"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
-      objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
       anonymousProcedureParametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
 
@@ -38,8 +37,6 @@ export default domAssigned(class Parameters {
     return parameter;
   }
 
-  someParameter(callback) { return this.array.some(callback); }
-
   forEachParameter(callback) { this.array.forEach(callback); }
 
   matchValues(values, context) {
@@ -69,42 +66,6 @@ export default domAssigned(class Parameters {
     context.debug(`...matched the ${valuesString} values against the '${parametersString}' parameters.`);
   }
 
-  matchParameter(parameter, context) {
-    const parameterString = parameter.getString(),
-          parametersString = this.string; ///
-
-    context.trace(`Matching the '${parameterString}' parameter against the '${parametersString}' parameters...`);
-
-    const parameterA = parameter, ///
-          parameterMatches = this.someParameter((parameter) => {
-            if (parameter !== null) {
-              const parameterB = parameter, ///
-                    parameterBMatchesParameterA = parameterA.matchParameter(parameterB, context);
-
-              if (parameterBMatchesParameterA) {
-                return true;
-              }
-            }
-          });
-
-    if (!parameterMatches) {
-      const message = `The '${parameterString}' parameter does not match any of the '${parametersString}' parameters.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
-    context.debug(`...matched the '${parameterString}' parameter against the '${parametersString}' parameters.`);
-  }
-
-  matchParameters(parameters, context) {
-    parameters.forEachParameter((parameter) => {
-      if (parameter !== null) {
-        this.matchParameter(parameter, context);
-      }
-    });
-  }
-
   static name = "Parameters";
 
   static fromStringAndArray(string, array) {
@@ -125,18 +86,6 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
-  static fromObjectAssignmentNode(objectAssignmentNode, context) {
-    const objectAssignmentParametersNode = objectAssignmentParametersNodeQuery(objectAssignmentNode),
-          parametersNode = objectAssignmentParametersNode,  ///
-          node = parametersNode,  ///
-          string = context.nodeAsString(node),
-          parameterNodes = parameterNodesQuery(parametersNode),
-          array = arrayFromParameterNodes(parameterNodes, context),
-          parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
   static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
     const { Parameter } = dom,
           anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),

package/src/dom/procedure/anonymous.js

@@ -9,7 +9,8 @@ import { variablesFromValuesAndParameters } from "../procedure";
 
 const parametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
       typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
-      somAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure");
+      someAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure"),
+      anonymousProcedureCallAnonymousProcedureNodeQuery = nodeQuery("/anonymousProcedureCall/anonymousProcedure");
 
 export default domAssigned(class AnonymousProcedure {
   constructor(string, type, parameters, returnBlock) {
@@ -63,12 +64,20 @@ export default domAssigned(class AnonymousProcedure {
   static name = "AnonymousProcedure";
 
   static fromSomeNode(someNode, context) {
-    const someAnonymousProcedureNode = somAnonymousProcedureNodeQuery(someNode),
+    const someAnonymousProcedureNode = someAnonymousProcedureNodeQuery(someNode),
           anonymousProcedureNode = someAnonymousProcedureNode,  ///
           anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
 
     return anonymousProcedure;
   }
+
+  static fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context) {
+    const anonymousProcedureCallAnonymousProcedureNode = anonymousProcedureCallAnonymousProcedureNodeQuery(anonymousProcedureCallNode),
+          anonymousProcedureNode = anonymousProcedureCallAnonymousProcedureNode,  ///
+          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+
+    return anonymousProcedure;
+  }
 });
 
 function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {

package/src/dom/procedureCall/anonymous.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+
+const anonymousProcedureCallNodeQuery = nodeQuery("/value/anonymousProcedureCall");
+
+export default domAssigned(class AnonymousProcedureCall {
+  constructor(string, anonymousProcedure, values) {
+    this.string = string;
+    this.anonymousProcedure = anonymousProcedure;
+    this.values = values;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getAnonymousProcedure() {
+    return this.anonymousProcedure;
+  }
+
+  getValues() {
+    return this.values;
+  }
+
+  evaluate(context) {
+    const anonymousProcedureCallString = this.string;  ///
+
+    context.trace(`Evaluating the '${anonymousProcedureCallString}' anonymous procedure call...`);
+
+    const values = this.values.evaluate(context),
+          value = this.anonymousProcedure.call(values, context);
+
+    context.debug(`...evaluated the '${anonymousProcedureCallString}' anonymous procedure call.`);
+
+    return value;
+  }
+
+  static name = "AnonymousProcedureCall";
+
+  static fromValueNode(valueNode, context) {
+    let anonymousProcedureCall = null;
+
+    const anonymousProcedureCallNode = anonymousProcedureCallNodeQuery(valueNode);
+
+    if (anonymousProcedureCallNode !== null) {
+      const { Values, AnonymousProcedure } = dom,
+            node = anonymousProcedureCallNode, ///
+            string = context.nodeAsString(node),
+            anonymousProcedure = AnonymousProcedure.fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context),
+            values = Values.fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context);
+
+      anonymousProcedureCall = new AnonymousProcedureCall(string, anonymousProcedure, values);
+    }
+
+    return anonymousProcedureCall;
+  }
+});

package/src/dom/some.js

@@ -4,8 +4,8 @@ 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("/some/variable"),
       valueSomeNodeQuery = nodeQuery("/value/some"),
@@ -49,11 +49,29 @@ export default domAssigned(class Some {
     const nodes = value.getNodes();
 
     nodes.some((node) => {
-      const { Value, Values } = dom,
-            value = Value.fromNode(node, context),
-            values = Values.fromValue(value, context);
+      let value;
 
-      this.anonymousProcedure.call(values, context);
+      const { Value, Values } = dom;
+
+      value = Value.fromNode(node, context);
+
+      const values = Values.fromValue(value, context);
+
+      value = this.anonymousProcedure.call(values, context);
+
+      const valueType = value.getType();
+
+      if (valueType !== BOOLEAN_TYPE) {
+        const valueString = value.asString(context),
+              message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+              exception = Exception.fromMessage(message);
+
+        throw exception;
+      }
+
+      const boolean = value.getBoolean();
+
+      return boolean;
     });
 
     context.trace(`...evaluated the '${someString}' some.`);

package/src/dom/step.js

@@ -34,7 +34,6 @@ export default domAssigned(class Step {
   }
 
   evaluate(context) {
-
     if (false) {
       ///
     } else if (this.arrayAssignment !== null) {

package/src/dom/value.js

@@ -22,7 +22,7 @@ const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value");
 
 export default domAssigned(class Value {
-  constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall) {
+  constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall) {
     this.node = node;
     this.nodes = nodes;
     this.number = number;
@@ -38,6 +38,7 @@ export default domAssigned(class Value {
     this.bitwiseValue = bitwiseValue;
     this.bracketedValue = bracketedValue;
     this.procedureCall = procedureCall;
+    this.anonymousProcedureCall = anonymousProcedureCall;
   }
 
   getNode() {
@@ -100,6 +101,10 @@ export default domAssigned(class Value {
     return this.procedureCall;
   }
 
+  getAnonymousProcedureCall() {
+    return this.anonymousProcedureCall;
+  }
+
   getType() {
     let type;
 
@@ -127,8 +132,16 @@ export default domAssigned(class Value {
       type = this.nodesQuery.getType();
     } else if (this.comparison !== null) {
       type = this.comparison.getType();
+    } else if (this.negatedValue !== null) {
+      type = this.negatedValue.getType();
+    } else if (this.bitwiseValue !== null) {
+      type = this.bitwiseValue.getType();
+    } else if (this.bracketedValue !== null) {
+      type = this.bracketedValue.getType();
     } else if (this.procedureCall !== null) {
       type = this.procedureCall.getType();
+    } else if (this.anonymousProcedureCall !== null) {
+      type = this.anonymousProcedureCall.getType();
     }
 
     return type;
@@ -161,8 +174,16 @@ export default domAssigned(class Value {
       string = this.nodesQuery.asString(context);
     } else if (this.comparison !== null) {
       string = this.comparison.asString(context);
+    } else if (this.negatedValue !== null) {
+      string = this.negatedValue.asString(context);
+    } else if (this.bitwiseValue !== null) {
+      string = this.bitwiseValue.asString(context);
+    } else if (this.bracketedValue !== null) {
+      string = this.bracketedValue.asString(context);
     } else if (this.procedureCall !== null) {
       string = this.procedureCall.asString(context);
+    } else if (this.anonymousProcedureCall !== null) {
+      string = this.anonymousProcedureCall.asString(context);
     }
 
     return string;
@@ -191,8 +212,16 @@ export default domAssigned(class Value {
       value = this.nodesQuery.evaluate(context);
     } else if (this.comparison !== null) {
       value = this.comparison.evaluate(context);
+    } else if (this.negatedValue !== null) {
+      value = this.negatedValue.evaluate(context);
+    } else if (this.bitwiseValue !== null) {
+      value = this.bitwiseValue.evaluate(context);
+    } else if (this.bracketedValue !== null) {
+      value = this.bracketedValue.evaluate(context);
     } else if (this.procedureCall !== null) {
       value = this.procedureCall.evaluate(context);
+    } else if (this.anonymousProcedureCall !== null) {
+      value = this.anonymousProcedureCall.evaluate(context);
     }
 
     return value;
@@ -267,7 +296,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -287,7 +317,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -307,7 +338,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -327,7 +359,8 @@ export default domAssigned(class Value {
           bitwiseValue = null,
           bracketedValue = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+          anonymousProcedureCall = null,
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
     return value;
   }
@@ -470,7 +503,7 @@ function booleanAsString(boolean, context) {
 }
 
 function valueFromValueNode(valueNode, context) {
-  const { Some, Value, Ternary, Variable, NodeQuery, NodesQuery, Comparison, NegatedValue, BitwiseValue, BracketedValue, ProcedureCall } = dom,
+  const { Some, Value, Ternary, Variable, NodeQuery, NodesQuery, Comparison, NegatedValue, BitwiseValue, BracketedValue, ProcedureCall, AnonymousProcedureCall } = dom,
         node = nodeFromValueNode(valueNode, context),
         nodes = nodesFromValueNode(valueNode, context),
         number = numberFromValueNode(valueNode, context),
@@ -486,7 +519,8 @@ function valueFromValueNode(valueNode, context) {
         bitwiseValue = BitwiseValue.fromValueNode(valueNode, context),
         bracketedValue = BracketedValue.fromValueNode(valueNode, context),
         procedureCall = ProcedureCall.fromValueNode(valueNode, context),
-        value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall);
+        anonymousProcedureCall = AnonymousProcedureCall.fromValueNode(valueNode, context),
+        value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall, anonymousProcedureCall);
 
   return value;
 }

package/src/dom/values.js

@@ -6,7 +6,8 @@ import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const valuesNodeQuery = nodeQuery("/value/procedureCall/values"),
-      valueNodesQuery = nodesQuery("/values/value");
+      valueNodesQuery = nodesQuery("/values/value"),
+      anonymousProcedureCallValuesNodeQuery = nodeQuery("/anonymousProcedureCall/values");
 
 export default domAssigned(class Values {
   constructor(string, array) {
@@ -97,6 +98,14 @@ export default domAssigned(class Values {
 
     return values;
   }
+
+  static fromAnonymousProcedureCallNode(anonymousProcedureCallNode, context) {
+    const anonymousProcedureCallValuesNode = anonymousProcedureCallValuesNodeQuery(anonymousProcedureCallNode),
+          valuesNode = anonymousProcedureCallValuesNode,  ///
+          values = valuesFromValuesNode(valuesNode, context);
+
+    return values;
+  }
 });
 
 function arrayFromNodes(nodes, context) {

package/src/dom/variable.js

@@ -217,6 +217,19 @@ export default domAssigned(class Variable {
     return variable;
   }
 
+  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+    const asName = namedParameter.getAsName(),
+          name = (asName !== null) ?
+                   asName : ///
+                    namedParameter.getName(),
+          type = namedParameter.getType(),
+          value = null,
+          string = name,  ///
+          variable = new Variable(string, type, name, value, assignment);
+
+    return variable;
+  }
+
   static fromTypeVariableNodeAndAssignmentNode(type, variableNode, assignmentNode, context) {
     const { Assignment } = dom,
           node = variableNode,  ///

package/src/index.js

@@ -21,16 +21,18 @@ import ReturnBlock from "./dom/block/return";
 import NegatedValue from "./dom/value/negated";
 import BitwiseValue from "./dom/value/bitwise";
 import ProcedureCall from "./dom/procedureCall";
+import NamedParameter from "./dom/parameter/named";
 import BracketedValue from "./dom/value/bracketed";
 import ArrayAssigment from "./dom/assignment/array";
 import ReturnStatement from "./dom/returnStatement";
+import NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";
 import ProcedureDeclaration from "./dom/declaration/procedure";
 import VariablesDeclaration from "./dom/declaration/variables";
+import AnonymousProcedureCall from "./dom/procedureCall/anonymous";
 
 export { default as Values } from "./dom/values";
 export { default as FileContext } from "./context/file";
 export { default as stringUtilities } from "./utilities/string";
-