occam-verify-cli 0.0.983 → 0.0.984

package/src/substitution/statementForMetavariable.js

@@ -7,8 +7,7 @@ import FrameForMetavariableSubstitution from "../substitution/frameForMetavariab
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
-const statementNodeQuery = nodeQuery("/substitution/statement!"),
-      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+const statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(statementNode, metavariableNode, substitution) {
@@ -99,23 +98,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return string;
   }
 
-  // static fromSubstitutionNode(substitutionNode) {
-  //   let statementForMetavariableSubstitution = null;
-  //
-  //   let statementNode = statementNodeQuery(substitutionNode),
-  //       metavariableNode = metavariableNodeQuery(substitutionNode);
-  //
-  //   if (statementNode !== null) {
-  //     statementNode = stripBracketsFromStatement(statementNode); ///
-  //
-  //     const substitution = null;
-  //
-  //     statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
-  //   }
-  //
-  //   return statementForMetavariableSubstitution;
-  // }
-
   static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
@@ -160,9 +142,11 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 function transformStatementNode(statementNode, substitutions) {
   let transformedStatementNode = null;
 
-  const metavariableNode = metavariableNodeQuery(statementNode);
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode; ///
 
-  if (metavariableNode !== null) {
     substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
 

package/src/tokens/combinatorFrame/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { FRAME_META_TYPE_NAME } from "../../metaTypeNames";
+import { fromTokensFromFrameString } from "../../utilities/tokens";
+
+const bracketedCombinatorFrameString = `(${FRAME_META_TYPE_NAME})`;
+
+const bracketedCombinatorFrameTokens = fromTokensFromFrameString(bracketedCombinatorFrameString)
+
+export default bracketedCombinatorFrameTokens;

package/src/tokens/combinatorStatement/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
+import { statementTokensFromStatementString } from "../../utilities/tokens";
+
+const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+const bracketedCombinatorStatementTokens = statementTokensFromStatementString(bracketedCombinatorStatementString)
+
+export default bracketedCombinatorStatementTokens;

package/src/tokens/constructorTerm/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../typeNames";
+import { termTokensFromTermString } from "../../utilities/tokens";
+
+const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME})`;
+
+const bracketedConstructorDeclarationTokens = termTokensFromTermString(bracketedConstructorTermString)
+
+export default bracketedConstructorDeclarationTokens;

package/src/utilities/brackets.js

@@ -1,10 +1,11 @@
 "use strict";
 
 import bracketedTermNode from "../node/term/bracketed";
+import bracketedFrameNode from "../node/frame/bracketed";
 import bracketedStatementNode from "../node/statement/bracketed";
 
 import { nodeQuery } from "../utilities/query";
-import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
+import { BRACKETED_TERM_DEPTH, BRACKETED_FRAME_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
 const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
       bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
@@ -19,6 +20,16 @@ export function stripBracketsFromTerm(statementNode) {
   return statementNode;
 }
 
+export function stripBracketsFromFrame(frameNode) {
+  const bracketedFrameChildNode = bracketedFrameChildNodeFromFrameNode(frameNode);
+
+  if (bracketedFrameChildNode !== null) {
+    frameNode = bracketedFrameChildNode;  ///
+  }
+
+  return frameNode;
+}
+
 export function stripBracketsFromStatement(statementNode) {
   const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
@@ -42,6 +53,19 @@ function bracketedTermChildNodeFromTermNode(termNode) {
   return bracketedTermChildNode;
 }
 
+function bracketedFrameChildNodeFromFrameNode(frameNode) {
+  let bracketedFrameChildNode = null;
+
+  const depth = BRACKETED_FRAME_DEPTH,
+        frameNodeMatchBracketedFrameNode = frameNode.match(bracketedFrameNode, depth);
+
+  if (frameNodeMatchBracketedFrameNode) {
+    bracketedFrameChildNode = bracketedFrameChildNodeQuery(frameNode);
+  }
+
+  return bracketedFrameChildNode;
+}
+
 function bracketedStatementChildNodeFromStatementNode(statementNode) {
   let bracketedStatementChildNode = null;
 

package/src/utilities/node.js

@@ -2,59 +2,58 @@
 
 import { parsersUtilities } from "occam-custom-grammars";
 
-import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { constructorDeclarationTokensFromTermString, unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { TERM_RULE_NAME, FRAME_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import { termTokensFromTermString, frameTokensFromFrameString, statementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
-
 export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, lexer),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
+  const termTokens = termTokensFromTermString(termString, lexer),
+        termNode = termNodeFromTermTokens(termTokens, parser);
 
   return termNode;
 }
 
-export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
-        statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+export function frameNodeFromFrameString(frameString, lexer, parser) {
+  const frameTokens = frameTokensFromFrameString(frameString, lexer),
+        frameNode = frameNodeFromFrameTokens(frameTokens, parser);
 
-  return statementNode;
+  return frameNode;
 }
 
-export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
-        termNode = termNodeQuery(constructorDeclarationNode);
+export function statementNodeFromStatementString(statementString, lexer, parser) {
+  const statementTokens = statementTokensFromStatementString(statementString, lexer),
+        statementNode = statementNodeFromStatementTokens(statementTokens, parser);
 
-  return termNode;
+  return statementNode;
 }
 
-export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+export function termNodeFromTermTokens(termTokens, parser) {
+  const tokens = termTokens,  ///
+        ruleName = TERM_RULE_NAME,
+        termNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return statementNode;
+  return termNode;
 }
 
-function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);
+export function frameNodeFromFrameTokens(frameTokens, parser) {
+  const tokens = frameTokens,  ///
+        ruleName = FRAME_RULE_NAME,
+        frameNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return unqualifiedStatementNode;
+  return frameNode;
 }
 
-function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
-        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
+export function statementNodeFromStatementTokens(statementTokens, parser) {
+  const tokens = statementTokens,  ///
+        ruleName = STATEMENT_RULE_NAME,
+        statementNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return constructorDeclarationNode;
+  return statementNode;
 }
 
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {

package/src/utilities/tokens.js

@@ -9,20 +9,25 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function constructorDeclarationTokensFromTermString(termString, lexer) {
-  const constructorDeclarationContent = `Constructor ${termString}
-`,
-        constructorDeclarationTokens = tokensFromContentAndLexer(constructorDeclarationContent, lexer);
+export function termTokensFromTermString(termString, lexer) {
+  const content = termString, ///
+        termTokens = tokensFromContentAndLexer(content, lexer);
 
-  return constructorDeclarationTokens;
+  return termTokens;
 }
 
-export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
-  const unqualifiedStatementContent = `${statementString}
-`,
-        unqualifiedStatementTokens = tokensFromContentAndLexer(unqualifiedStatementContent, lexer);
+export function frameTokensFromFrameString(frameString, lexer) {
+  const content = frameString,  ///
+        frameTokens = tokensFromContentAndLexer(content, lexer);
 
-  return unqualifiedStatementTokens;
+  return frameTokens;
+}
+
+export function statementTokensFromStatementString(statementString, lexer) {
+  const content = statementString,  ///
+        statementTokens = tokensFromContentAndLexer(content, lexer);
+
+  return statementTokens;
 }
 
 function tokensFromContentAndLexer(content, lexer = florenceLexer) {

package/src/verify/assertion/contained.js

@@ -6,9 +6,9 @@ import { isAssertionNegated } from "../../utilities/assertion";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metavariableNodeQuery = nodeQuery("/containedAssertion/frame[0]/metavariable"),
-      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//variable"),
-      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//metavariable");
+      metavariableNodeQuery = nodeQuery("/containedAssertion/frame/statement!/metavariable!"),
+      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement//metavariable");
 
 const verifyContainedAssertionFunctions = [
   verifyDerivedContainedAssertion,
@@ -56,53 +56,56 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, st
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`, containedAssertionNode);
 
-    const assertionNegated = isAssertionNegated(containedAssertionNode),
-          metavariableNode = metavariableNodeQuery(containedAssertionNode),
-          variableNode = variableNodeQuery(containedAssertionNode),
-          negated = assertionNegated; ///
-
-    if (false) {
-      ///
-    } else if (metavariableNode !== null) {
-      const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
-              const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
-
-              if (variableNodeMatchesStatementMetavariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+    const metavariableNode = metavariableNodeQuery(containedAssertionNode);
+
+    if (metavariableNode !== null) {
+      const assertionNegated = isAssertionNegated(containedAssertionNode),
+            variableNode = variableNodeQuery(containedAssertionNode),
+            negated = assertionNegated; ///
+
+      if (false) {
+        ///
+      } else if (metavariableNode !== null) {
+        const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
+                const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+
+                if (variableNodeMatchesStatementMetavariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
-    } else if (variableNode !== null) {
-      const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
-              const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
-
-              if (variableNodeMatchesStatementVariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+      } else if (variableNode !== null) {
+        const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+                const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+                if (variableNodeMatchesStatementVariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
       }
     }

package/src/verify/assertion/defined.js

@@ -1,15 +1,13 @@
 "use strict";
 
-import verifyTerm from "../../verify/term";
 import metaLevelVerifier from "../../verifier/metaLevel";
 
-import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
 import { isAssertionNegated } from "../../utilities/assertion";
 import { metavariableNameFromMetavariableNode } from "../../utilities/name";
 
 const variableNodeQuery = nodeQuery("/definedAssertion/term/variable!"),
-      metavariableNodeQuery = nodeQuery("/definedAssertion/frame[-1]/metavariable!");
+      metavariableNodeQuery = nodeQuery("/definedAssertion/frame/statement!/metavariable!");
 
 const verifyDefinedAssertionFunctions = [
   verifyDerivedDefinedAssertion,
@@ -57,40 +55,43 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated
 
     localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);
 
-    const assertionNegated = isAssertionNegated(definedAssertionNode),
-          metavariableNode = metavariableNodeQuery(definedAssertionNode),
-          variableNode = variableNodeQuery(definedAssertionNode);
+    const metavariableNode = metavariableNodeQuery(definedAssertionNode);
 
-    if (false) {
-      ///
-    } else if (metavariableNode !== null) {
-      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-            metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
+    if (metavariableNode !== null) {
+      const assertionNegated = isAssertionNegated(definedAssertionNode),
+        variableNode = variableNodeQuery(definedAssertionNode);
 
-      if (!assertionNegated) {
-        if (metavariableDefinedByMetavariableName) {
-          derivedDefinedAssertionVerified = true;
-        }
-      }
+      if (false) {
+        ///
+      } else if (metavariableNode !== null) {
+        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariableDefinedByMetavariableName = localContext.isMetavariableDefinedByMetavariableName(metavariableName);
 
-      if (assertionNegated) {
-        if (!metavariableDefinedByMetavariableName) {
-          derivedDefinedAssertionVerified = true;
+        if (!assertionNegated) {
+          if (metavariableDefinedByMetavariableName) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
-    } else if (variableNode !== null) {
-      const variable = localContext.findVariableByVariableNode(variableNode),
-            variableDefined = localContext.isVariableDefined(variable);
 
-      if (!assertionNegated) {
-        if (variableDefined) {
-          derivedDefinedAssertionVerified = true;
+        if (assertionNegated) {
+          if (!metavariableDefinedByMetavariableName) {
+            derivedDefinedAssertionVerified = true;
+          }
+        }
+      } else if (variableNode !== null) {
+        const variable = localContext.findVariableByVariableNode(variableNode),
+              variableDefined = localContext.isVariableDefined(variable);
+
+        if (!assertionNegated) {
+          if (variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
-      }
 
-      if (assertionNegated) {
-        if (!variableDefined) {
-          derivedDefinedAssertionVerified = true;
+        if (assertionNegated) {
+          if (!variableDefined) {
+            derivedDefinedAssertionVerified = true;
+          }
         }
       }
     }
@@ -120,18 +121,3 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, stated,
 
   return statedDefinedAssertionVerified;
 }
-
-function termFromTermNode(termNode, localContext) {
-  const terms = [];
-
-  verifyTerm(termNode, terms, localContext, () => {
-    const verifiedAhead = true;
-
-    return verifiedAhead;
-  });
-
-  const firstTerm = first(terms),
-        term = firstTerm; ///
-
-  return term;
-}

package/lib/tokens/constructorDeclaration/bracketed.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _typeNames = require("../../typeNames");
-var _tokens = require("../../utilities/tokens");
-var bracketedConstructorTermString = "(".concat(_typeNames.OBJECT_TYPE_NAME, "):").concat(_typeNames.OBJECT_TYPE_NAME);
-var bracketedConstructorDeclarationTokens = (0, _tokens.constructorDeclarationTokensFromTermString)(bracketedConstructorTermString);
-var _default = bracketedConstructorDeclarationTokens;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90b2tlbnMvY29uc3RydWN0b3JEZWNsYXJhdGlvbi9icmFja2V0ZWQuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IE9CSkVDVF9UWVBFX05BTUUgfSBmcm9tIFwiLi4vLi4vdHlwZU5hbWVzXCI7XG5pbXBvcnQgeyBjb25zdHJ1Y3RvckRlY2xhcmF0aW9uVG9rZW5zRnJvbVRlcm1TdHJpbmcgfSBmcm9tIFwiLi4vLi4vdXRpbGl0aWVzL3Rva2Vuc1wiO1xuXG5jb25zdCBicmFja2V0ZWRDb25zdHJ1Y3RvclRlcm1TdHJpbmcgPSBgKCR7T0JKRUNUX1RZUEVfTkFNRX0pOiR7T0JKRUNUX1RZUEVfTkFNRX1gO1xuXG5jb25zdCBicmFja2V0ZWRDb25zdHJ1Y3RvckRlY2xhcmF0aW9uVG9rZW5zID0gY29uc3RydWN0b3JEZWNsYXJhdGlvblRva2Vuc0Zyb21UZXJtU3RyaW5nKGJyYWNrZXRlZENvbnN0cnVjdG9yVGVybVN0cmluZylcblxuZXhwb3J0IGRlZmF1bHQgYnJhY2tldGVkQ29uc3RydWN0b3JEZWNsYXJhdGlvblRva2VucztcbiJdLCJuYW1lcyI6WyJicmFja2V0ZWRDb25zdHJ1Y3RvclRlcm1TdHJpbmciLCJPQkpFQ1RfVFlQRV9OQU1FIiwiYnJhY2tldGVkQ29uc3RydWN0b3JEZWNsYXJhdGlvblRva2VucyIsImNvbnN0cnVjdG9yRGVjbGFyYXRpb25Ub2tlbnNGcm9tVGVybVN0cmluZyJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBU0E7OztlQUFBOzs7eUJBUGlDO3NCQUMwQjtBQUUzRCxJQUFNQSxpQ0FBaUMsQUFBQyxJQUF3QkMsT0FBckJBLDJCQUFnQixFQUFDLE1BQXFCLE9BQWpCQSwyQkFBZ0I7QUFFaEYsSUFBTUMsd0NBQXdDQyxJQUFBQSxrREFBMEMsRUFBQ0g7SUFFekYsV0FBZUUifQ==

package/lib/tokens/unqualifiedStatement/combinator/bracketed.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _metaTypeNames = require("../../../metaTypeNames");
-var _tokens = require("../../../utilities/tokens");
-var bracketedCombinatorStatementString = "(".concat(_metaTypeNames.STATEMENT_META_TYPE_NAME, ")");
-var bracketedCombinatorUnqualifiedStatementTokens = (0, _tokens.unqualifiedStatementTokensFromStatementString)(bracketedCombinatorStatementString);
-var _default = bracketedCombinatorUnqualifiedStatementTokens;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy90b2tlbnMvdW5xdWFsaWZpZWRTdGF0ZW1lbnQvY29tYmluYXRvci9icmFja2V0ZWQuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IFNUQVRFTUVOVF9NRVRBX1RZUEVfTkFNRSB9IGZyb20gXCIuLi8uLi8uLi9tZXRhVHlwZU5hbWVzXCI7XG5pbXBvcnQgeyB1bnF1YWxpZmllZFN0YXRlbWVudFRva2Vuc0Zyb21TdGF0ZW1lbnRTdHJpbmcgfSBmcm9tIFwiLi4vLi4vLi4vdXRpbGl0aWVzL3Rva2Vuc1wiO1xuXG5jb25zdCBicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50U3RyaW5nID0gYCgke1NUQVRFTUVOVF9NRVRBX1RZUEVfTkFNRX0pYDtcblxuY29uc3QgYnJhY2tldGVkQ29tYmluYXRvclVucXVhbGlmaWVkU3RhdGVtZW50VG9rZW5zID0gdW5xdWFsaWZpZWRTdGF0ZW1lbnRUb2tlbnNGcm9tU3RhdGVtZW50U3RyaW5nKGJyYWNrZXRlZENvbWJpbmF0b3JTdGF0ZW1lbnRTdHJpbmcpXG5cbmV4cG9ydCBkZWZhdWx0IGJyYWNrZXRlZENvbWJpbmF0b3JVbnF1YWxpZmllZFN0YXRlbWVudFRva2VucztcbiJdLCJuYW1lcyI6WyJicmFja2V0ZWRDb21iaW5hdG9yU3RhdGVtZW50U3RyaW5nIiwiU1RBVEVNRU5UX01FVEFfVFlQRV9OQU1FIiwiYnJhY2tldGVkQ29tYmluYXRvclVucXVhbGlmaWVkU3RhdGVtZW50VG9rZW5zIiwidW5xdWFsaWZpZWRTdGF0ZW1lbnRUb2tlbnNGcm9tU3RhdGVtZW50U3RyaW5nIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFTQTs7O2VBQUE7Ozs2QkFQeUM7c0JBQ3FCO0FBRTlELElBQU1BLHFDQUFxQyxBQUFDLElBQTRCLE9BQXpCQyx1Q0FBd0IsRUFBQztBQUV4RSxJQUFNQyxnREFBZ0RDLElBQUFBLHFEQUE2QyxFQUFDSDtJQUVwRyxXQUFlRSJ9

package/src/tokens/constructorDeclaration/bracketed.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import { OBJECT_TYPE_NAME } from "../../typeNames";
-import { constructorDeclarationTokensFromTermString } from "../../utilities/tokens";
-
-const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME}):${OBJECT_TYPE_NAME}`;
-
-const bracketedConstructorDeclarationTokens = constructorDeclarationTokensFromTermString(bracketedConstructorTermString)
-
-export default bracketedConstructorDeclarationTokens;

package/src/tokens/unqualifiedStatement/combinator/bracketed.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
-import { unqualifiedStatementTokensFromStatementString } from "../../../utilities/tokens";
-
-const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
-
-const bracketedCombinatorUnqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(bracketedCombinatorStatementString)
-
-export default bracketedCombinatorUnqualifiedStatementTokens;