occam-verify-cli 0.0.1063 → 0.0.1066

package/src/substitution/termForVariable.js

@@ -6,7 +6,8 @@ import Substitution from "../substitution";
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!"),
+const substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
       substitutionTermNodeQuery = nodeQuery("/substitution/term!"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
@@ -83,7 +84,7 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution) {
+  static fromSubstitution(substitution, localContext) {
     let termForVariableSubstitution = null;
 
     const substitutionNode = substitution.getNode();
@@ -91,30 +92,61 @@ export default class TermForVariableSubstitution extends Substitution {
     let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
     if (substitutionTermNode !== null) {
-      let termNode = substitutionTermNode;  ///
-
-      termNode = stripBracketsFromTerm(termNode); ///
+      let termNode;
 
       const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
             variableNode = substitutionVariableNode;  ///
 
-      termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+      termNode = substitutionTermNode;  ///
+
+      termNode = stripBracketsFromTerm(termNode); ///
+
+      const { Term, Variable } = shim,
+            term = Term.fromTermNode(termNode, localContext),
+            variable = Variable.fromVariableNode(variableNode, localContext),
+            string = stringFromTermAndVariable(term, variable);
+
+      termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable, localContext) {
-    let termNode = term.getNode();
+  static fromStatementNode(statementNode, localContext) {
+    let termForVariableSubstitution = null;
 
-    termNode = stripBracketsFromTerm(termNode); ///
+    const substitutionNode = substitutionNodeQuery(statementNode);
+
+    if (substitutionNode !== null) {
+      let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
+
+      if (substitutionTermNode !== null) {
+        let termNode;
 
-    const { Term } = shim;
+        const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
+              variableNode = substitutionVariableNode;  ///
 
-    term = Term.fromTermNode(termNode, localContext); ///
+        termNode = substitutionTermNode;  ///
+
+        const { Term, Variable } = shim,
+              term = Term.fromTermNode(termNode, localContext),
+              variable = Variable.fromVariableNode(variableNode, localContext),
+              string = stringFromTermAndVariable(term, variable);
+
+        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+      }
+    }
+
+    return termForVariableSubstitution;
+  }
+
+  static fromTernAndVariable(term, variable) {
+    let termNode = term.getNode();
+
+    termNode = stripBracketsFromTerm(termNode); ///
 
-    const string = stringFromTermAndVariable(term, variable),
-          variableNode = variable.getNode(),
+    const variableNode = variable.getNode(),
+          string = stringFromTermAndVariable(term, variable),
           termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
 
     return termForVariableSubstitution;

package/src/supposition.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import LocalContext from "./context/local";
-import metaLevelUnifier from "./unifier/metaLevel";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -111,26 +109,15 @@ export default class Supposition {
   unifyStatement(statement, substitutions, localContext) {
     let statementUnified;
 
-    const supposition = this, ///
-          statementString = statement.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement...`);
+    const statementString = statement.getString(),
+          suppositionString = this.getString();
 
-    const statementNode = statement.getNode(),
-          suppositionStatementNode = suppositionStatement.getNode(),
-          nodeA = suppositionStatementNode,  ///
-          nodeB = statementNode,  ///
-          fileContextA = this.fileContext,  ///
-          localContextA = LocalContext.fromFileContext(fileContextA),
-          localContextB = localContext, ///
-          unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    localContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
-    statementUnified = unified; ///
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the supposition's '${suppositionStatementString}' statement.`);
+      localContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);
     }
 
     return statementUnified;

package/src/unifier/intrinsicLevel.js

@@ -11,15 +11,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class IntrinsicLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtIntrinsicLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtIntrinsicLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtIntrinsicLevel;
   }
 
   static maps = [

package/src/unifier/metaLevel.js

@@ -16,15 +16,15 @@ const termNodeQuery = nodeQuery("/term!"),
 
 class MetaLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
-    let unified;
+    let unifiedAtMetaLevel;
 
     const nonTerminalNodeA = nodeA, ///
           nonTerminalNodeB = nodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
 
-    unified = nonTerminalNodeUnified; ///
+    unifiedAtMetaLevel = nonTerminalNodeUnified; ///
 
-    return unified;
+    return unifiedAtMetaLevel;
   }
 
   static maps = [
@@ -39,30 +39,24 @@ class MetaLevelUnifier extends Unifier {
         if (matches) {
           statementUnified = true;
         } else {
-          const { Statement } = shim,
-                statementB = Statement.fromStatementNode(statementNodeB, localContextB),
-                statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
+          const statementNode = statementNodeA, ///
+                statementSubstitution = null, ///
+                statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
-          if (statementMetavariableNodeA !== null) {
-            let statement;
-
-            const statementA = Statement.fromStatementNode(statementNodeA, localContextA);
-
-            statement = statementA; ///
-
-            const substitution = statement.getSubstitution();
-
-            statement = statementB; ///
-
-            const localContext = localContextB, ///
-                  metavariableNode = statementMetavariableNodeA,  ///
+          if (statementMetavariableNode !== null) {
+            const { Statement } = shim,
+                  metavariableNode = statementMetavariableNode, ///
                   metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName),
+                  substitution = statementSubstitution, ///
+                  localContext = localContextB, ///
+                  statementNode = statementNodeB, ///
+                  statement = Statement.fromStatementNode(statementNode, localContext);
 
             if (substitution === null) {
               statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
             } else {
-              const statementUnifiedGivenSubstitution = metavariableNode.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
+              const statementUnifiedGivenSubstitution = metavariable.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
 
               statementUnified = statementUnifiedGivenSubstitution; ///
             }

package/src/unifier/metavariable.js

@@ -11,15 +11,15 @@ const typeNodeQuery = nodeQuery("/type!"),
 
 class MetavariableUnifier extends Unifier {
   unify(metavariableNodeA, metavariableNodeB, localContext) {
-    let unified;
+    let metavariableUnified;
 
     const nonTerminalNodeA = metavariableNodeA, ///
           nonTerminalNodeB = metavariableNodeB, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    unified = nonTerminalNodeUnified; ///
+    metavariableUnified = nonTerminalNodeUnified; ///
 
-    return unified;
+    return metavariableUnified;
   }
 
   static maps = [

package/src/unify/simpleSubstitutionStatementWithComplexSubstitutionStatement.js

@@ -15,9 +15,9 @@ export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionS
 
   localContextA = localContextB;  ///
 
-  const unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-  simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement = unified;  ///
+  simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement = unifiedAtMetaLevel;  ///
 
   if (simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement) {
     localContextB.trace(`...unified the simple substitution's '${simpleSubstitutionStatementString}' statement with the complex substitution's '${complexSubstitutionStatementString}' statement.`, simpleSubstitutionStatementNode);

package/src/unify/statementWithSttaemetnGivenEquivalences.js

@@ -15,9 +15,9 @@ export default function unifyStatementWithStatementGivenEquivalences(statementNo
     const substitutions = Substitutions.fromNothing(),
           nodeA = statementNodeA,  ///
           nodeB = statementNodeB,  ///
-          unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+          unifiedAtIntrinsicLevel = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-    if (unified) {
+    if (unifiedAtIntrinsicLevel) {
       const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
 
       statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///
@@ -34,9 +34,9 @@ export default function unifyStatementWithStatementGivenEquivalences(statementNo
     const substitutions = Substitutions.fromNothing(),
           nodeA = statementNodeB,  ///
           nodeB = statementNodeA,  ///
-          unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+          unifiedAtIntrinsicLevel = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-    if (unified) {
+    if (unifiedAtIntrinsicLevel) {
       const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
 
       statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///

package/src/utilities/brackets.js

@@ -1,9 +1,8 @@
 "use strict";
 
-import bracketedTermNode from "../node/term/bracketed";
-import bracketedStatementNode from "../node/statement/bracketed";
-
 import { nodeQuery } from "../utilities/query";
+import { bracketedTermNode } from "../constructor/bracketed";
+import { bracketedStatementNode } from "../combinator/bracketed";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
 const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),

package/src/utilities/node.js

@@ -6,12 +6,10 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
-         SUBSTITUTION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
-         substitutionTokensFromSubstitutionString,
          unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
@@ -24,11 +22,10 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationString = `Constructor ${termString}
-`,
+  const constructorDeclarationString = constructorDeclarationStringFromTermString(termString),
         constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer),
         constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
-        termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
+        termNode = termNodeFromConstructorDeclarationNode(constructorDeclarationNode);
 
   return termNode;
 }
@@ -41,15 +38,40 @@ export function variableNodeFromVariableString(variableString, lexer, parser) {
 }
 
 export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementString = `${statementString}
-`,
+  const unqualifiedStatementString =unqualifiedStatementStringFromStatementString(statementString),
         unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
         unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+        statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function termNodeFromConstructorDeclarationNode(constructorDeclarationNode) {
+  const termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
+
+  return termNode;
+}
+
+export function statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode) {
+  const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   return statementNode;
 }
 
+export function constructorDeclarationStringFromTermString(termString) {
+  const constructorDeclarationString = `Constructor ${termString}
+`;
+
+  return constructorDeclarationString;
+}
+
+export function unqualifiedStatementStringFromStatementString(statementString) {
+  const unqualifiedStatementString = `${statementString}
+`;
+
+  return unqualifiedStatementString;
+}
+
 export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
   const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
         metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
@@ -57,13 +79,6 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionString(substitutionString, lexer, parser) {
-  const substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString, lexer),
-        substitutionNode = substitutionNodeFromSubstitutionTokens(substitutionTokens, parser);
-
-  return substitutionNode;
-}
-
 export function variableNodeFromVariableTokens(variableTokens, parser) {
   const ruleName = VARIABLE_RULE_NAME,
         variableNode = nodeFromTokensRuleNameAndParser(variableTokens, ruleName, parser);
@@ -78,13 +93,6 @@ export function metavariableNodeFromMetavariableTokens(metavariableTokens, parse
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionTokens(substitutionTokens, parser) {
-  const ruleName = SUBSTITUTION_RULE_NAME,
-        substitutionNode = nodeFromTokensRuleNameAndParser(substitutionTokens, ruleName, parser);
-
-  return substitutionNode;
-}
-
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const tokens = unqualifiedStatementTokens,  ///
         ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,

package/src/utilities/string.js

@@ -11,17 +11,9 @@ export function trim(string) {
 export function nodeAsString(node, tokens) {
   let string;
 
-  const nodeTerminalNode = node.isTerminalNode();
-
-  if (nodeTerminalNode) {
-    const terminalNode = node;  ///
-
-    string = terminalNodeAsString(terminalNode);
-  } else {
-    const nonTerminalNode = node; ///
+  tokens = nodeAsTokens(node, tokens);  ///
 
-    string = nonTerminalNodeAsString(nonTerminalNode, tokens);
-  }
+  string = tokensAsString(tokens);
 
   return string;
 }
@@ -40,14 +32,46 @@ export function nodesAsString(nodes, tokens) {
   return string;
 }
 
-function terminalNodeAsString(terminalNode) {
-  const content = terminalNode.getContent(),
-        string = content; ///
+export function tokensAsString(tokens) {
+  const string = tokens.reduce((string, token) => {
+    const content = token.getContent();
+
+    string = `${string}${content}`;
+
+    return string;
+  }, EMPTY_STRING);
 
   return string;
 }
 
-function nonTerminalNodeAsString(nonTerminalNode, tokens) {
+export function nodeAsTokens(node, tokens) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {z
+    const terminalNode = node;  ///
+
+    tokens = terminalNodeAsTokens(terminalNode, tokens);
+  } else {
+    const nonTerminalNode = node; ///
+
+    tokens = nonTerminalNodeAsTokens(nonTerminalNode, tokens);
+  }
+
+  return tokens;
+}
+
+function terminalNodeAsTokens(terminalNode, tokens) {
+  const significantToken = terminalNode.getSignificantToken(),
+        token = significantToken; ///
+
+  tokens = [  ///
+    token
+  ];
+
+  return tokens;
+}
+
+function nonTerminalNodeAsTokens(nonTerminalNode, tokens) {
   const lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens),
         firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens),
         start = firstSignificantTokenIndex, ///
@@ -55,13 +79,5 @@ function nonTerminalNodeAsString(nonTerminalNode, tokens) {
 
   tokens = tokens.slice(start, end);  ///
 
-  const string = tokens.reduce((string, token) => {
-    const content = token.getContent();
-
-    string = `${string}${content}`;
-
-    return string;
-  }, EMPTY_STRING);
-
-  return string;
+  return tokens;
 }

package/src/utilities/tokens.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
 import { lexersUtilities } from "occam-custom-grammars";
 
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 
-const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
+const { front } = arrayUtilities,
+      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
@@ -23,13 +25,6 @@ export function metavariableTokensFromMetavariableString(metavariableString, lex
   return metavariableTokens;
 }
 
-export function substitutionTokensFromSubstitutionString(substitutionString, lexer) {
-  const substitutionContent = `${substitutionString}`,
-        substitutionTokens = tokensFromContentAndLexer(substitutionContent, lexer);
-
-  return substitutionTokens;
-}
-
 export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
   const content = unqualifiedStatementString,  ///
         unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);
@@ -44,6 +39,20 @@ export function constructorDeclarationTokensFromConstructorDeclarationString(con
   return constructorDeclarationTokens;
 }
 
+export function termTokensFromConstructorDeclarationTokens(constructorDeclarationTokens) {
+  const frontConstructorDeclarationTokens = front(constructorDeclarationTokens),
+        termTokens = frontConstructorDeclarationTokens;  ///
+
+  return termTokens;
+}
+
+export function statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens) {
+  const frontUnqualifiedStatementTokens = front(unqualifiedStatementTokens),
+        statementTokens = frontUnqualifiedStatementTokens;  ///
+
+  return statementTokens;
+}
+
 function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);
 

package/src/utilities/unify.js

@@ -21,17 +21,3 @@ export function metavariableFromFrameNode(frameNode, localContext) {
   return metavariable;
 }
 
-export function metavariableFromStatementNode(statementNode, localContext) {
-  let metavariable = null;
-
-  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
-
-  if (statementMetavariableNode !== null) {
-    const metavariableNode = statementMetavariableNode, ///
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
-
-    metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-  }
-
-  return metavariable;
-}

package/src/variable.js

@@ -165,7 +165,7 @@ class Variable {
       if (termVariable === variable) {
         termUnified = true;
       } else {
-        const termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable, localContext),
+        const termForVariableSubstitution = TermForVariableSubstitution.fromTernAndVariable(term, variable),
               substitution = termForVariableSubstitution;  ///
 
         substitutions.addSubstitution(substitution, localContext);
@@ -209,6 +209,25 @@ class Variable {
     return variable;
   }
 
+  static fromTermNode(termNode, localContext) {
+    let variable = null;
+
+    const termVariableNode = termVariableNodeQuery(termNode);
+
+    if (termVariableNode !== null) {
+      const variableNode = termVariableNode,  ///
+            variableName = variableNameFromVariableNode(variableNode),
+            node = variableNode,  ///
+            string = localContext.nodeAsString(node),
+            name = variableName,  ///
+            type = null;
+
+      variable = new Variable(localContext, string, node, name, type);
+    }
+
+    return variable;
+  }
+
   static fromVariableNode(variableNode, localContext) {
     let variable = null;
 

package/lib/node/statement/bracketed.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _node = require("../../utilities/node");
-var bracketedStatementString = "(n=m)";
-var bracketedStatementNode = (0, _node.statementNodeFromStatementString)(bracketedStatementString);
-var _default = bracketedStatementNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ub2RlL3N0YXRlbWVudC9icmFja2V0ZWQuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IHN0YXRlbWVudE5vZGVGcm9tU3RhdGVtZW50U3RyaW5nIH0gZnJvbSBcIi4uLy4uL3V0aWxpdGllcy9ub2RlXCI7XG5cbmNvbnN0IGJyYWNrZXRlZFN0YXRlbWVudFN0cmluZyA9IFwiKG49bSlcIjtcblxuY29uc3QgYnJhY2tldGVkU3RhdGVtZW50Tm9kZSA9IHN0YXRlbWVudE5vZGVGcm9tU3RhdGVtZW50U3RyaW5nKGJyYWNrZXRlZFN0YXRlbWVudFN0cmluZyk7XG5cbmV4cG9ydCBkZWZhdWx0IGJyYWNrZXRlZFN0YXRlbWVudE5vZGU7XG4iXSwibmFtZXMiOlsiYnJhY2tldGVkU3RhdGVtZW50U3RyaW5nIiwiYnJhY2tldGVkU3RhdGVtZW50Tm9kZSIsInN0YXRlbWVudE5vZGVGcm9tU3RhdGVtZW50U3RyaW5nIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFRQTs7O2VBQUE7OztvQkFOaUQ7QUFFakQsSUFBTUEsMkJBQTJCO0FBRWpDLElBQU1DLHlCQUF5QkMsSUFBQUEsc0NBQWdDLEVBQUNGO0lBRWhFLFdBQWVDIn0=

package/lib/node/statement/combinator/bracketed.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    bracketedCombinatorStatementString: function() {
-        return bracketedCombinatorStatementString;
-    },
-    default: function() {
-        return _default;
-    }
-});
-var _metaTypeNames = require("../../../metaTypeNames");
-var _node = require("../../../utilities/node");
-var bracketedCombinatorStatementString = "(".concat(_metaTypeNames.STATEMENT_META_TYPE_NAME, ")");
-var bracketedCombinatorStatementNode = (0, _node.statementNodeFromStatementString)(bracketedCombinatorStatementString);
-var _default = bracketedCombinatorStatementNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9ub2RlL3N0YXRlbWVudC9jb21iaW5hdG9yL2JyYWNrZXRlZC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgU1RBVEVNRU5UX01FVEFfVFlQRV9OQU1FIH0gZnJvbSBcIi4uLy4uLy4uL21ldGFUeXBlTmFtZXNcIjtcbmltcG9ydCB7IHN0YXRlbWVudE5vZGVGcm9tU3RhdGVtZW50U3RyaW5nIH0gZnJvbSBcIi4uLy4uLy4uL3V0aWxpdGllcy9ub2RlXCI7XG5cbmV4cG9ydCBjb25zdCBicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50U3RyaW5nID0gYCgke1NUQVRFTUVOVF9NRVRBX1RZUEVfTkFNRX0pYDtcblxuY29uc3QgYnJhY2tldGVkQ29tYmluYXRvclN0YXRlbWVudE5vZGUgPSBzdGF0ZW1lbnROb2RlRnJvbVN0YXRlbWVudFN0cmluZyhicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50U3RyaW5nKVxuXG5leHBvcnQgZGVmYXVsdCBicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50Tm9kZTtcbiJdLCJuYW1lcyI6WyJicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50U3RyaW5nIiwiU1RBVEVNRU5UX01FVEFfVFlQRV9OQU1FIiwiYnJhY2tldGVkQ29tYmluYXRvclN0YXRlbWVudE5vZGUiLCJzdGF0ZW1lbnROb2RlRnJvbVN0YXRlbWVudFN0cmluZyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O0lBS2FBLGtDQUFrQztlQUFsQ0E7O0lBSWIsT0FBZ0Q7ZUFBaEQ7Ozs2QkFQeUM7b0JBQ1E7QUFFMUMsSUFBTUEscUNBQXFDLEFBQUMsSUFBNEIsT0FBekJDLHVDQUF3QixFQUFDO0FBRS9FLElBQU1DLG1DQUFtQ0MsSUFBQUEsc0NBQWdDLEVBQUNIO0lBRTFFLFdBQWVFIn0=

package/lib/node/term/bracketed.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _node = require("../../utilities/node");
-var bracketedTermString = "(n)";
-var bracketedTermNode = (0, _node.termNodeFromTermString)(bracketedTermString);
-var _default = bracketedTermNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9ub2RlL3Rlcm0vYnJhY2tldGVkLmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgeyB0ZXJtTm9kZUZyb21UZXJtU3RyaW5nIH0gZnJvbSBcIi4uLy4uL3V0aWxpdGllcy9ub2RlXCI7XG5cbmNvbnN0IGJyYWNrZXRlZFRlcm1TdHJpbmcgPSBcIihuKVwiO1xuXG5jb25zdCBicmFja2V0ZWRUZXJtTm9kZSA9IHRlcm1Ob2RlRnJvbVRlcm1TdHJpbmcoYnJhY2tldGVkVGVybVN0cmluZyk7XG5cbmV4cG9ydCBkZWZhdWx0IGJyYWNrZXRlZFRlcm1Ob2RlO1xuIl0sIm5hbWVzIjpbImJyYWNrZXRlZFRlcm1TdHJpbmciLCJicmFja2V0ZWRUZXJtTm9kZSIsInRlcm1Ob2RlRnJvbVRlcm1TdHJpbmciXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQVFBOzs7ZUFBQTs7O29CQU51QztBQUV2QyxJQUFNQSxzQkFBc0I7QUFFNUIsSUFBTUMsb0JBQW9CQyxJQUFBQSw0QkFBc0IsRUFBQ0Y7SUFFakQsV0FBZUMifQ==