occam-verify-cli 1.0.421 → 1.0.427

package/lib/utilities/node.js

@@ -9,75 +9,63 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get statementFromStatementNode () {
-        return statementFromStatementNode;
+    get nodeAsString () {
+        return nodeAsString;
     },
-    get stringFromTerms () {
-        return stringFromTerms;
-    },
-    get termFromTermNode () {
-        return termFromTermNode;
-    },
-    get termsFromTermNodes () {
-        return termsFromTermNodes;
-    },
-    get typeFromTypeNode () {
-        return typeFromTypeNode;
-    },
-    get variableFromTerm () {
-        return variableFromTerm;
+    get nodesAsString () {
+        return nodesAsString;
     }
 });
-var _ontology = /*#__PURE__*/ _interop_require_default(require("../ontology"));
-var _type = require("../ontology/type");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function typeFromTypeNode(typeNode, context) {
-    var type;
-    if (typeNode === null) {
-        type = _type.baseType;
-    } else {
-        var Type = _ontology.default.Type, typeName = typeNode.getTypeName(), typePrefixName = typeNode.getTypePrefixName(), nominalTypeName = typeNode.getNominalTypeName(), string = nominalTypeName, name = typeName, prefixName = typePrefixName, superTypes = null, properties = null, provisional = null;
-        type = new Type(string, name, prefixName, superTypes, properties, provisional);
-    }
-    return type;
+var _constants = require("../constants");
+function nodeAsString(node, tokens) {
+    var string;
+    tokens = nodeAsTokens(node, tokens); ///
+    string = tokensAsString(tokens);
+    string = trimString(string); ///
+    return string;
 }
-function termFromTermNode(termNode, context) {
-    var Term = _ontology.default.Term, node = termNode, string = context.nodeAsString(node), type = null, term = new Term(string, node, type);
-    return term;
+function nodesAsString(nodes, tokens) {
+    var string = nodes.reduce(function(string, node) {
+        var nodeString = nodeAsString(node, tokens);
+        string = string === null ? nodeString : "".concat(string, ", ").concat(nodeString);
+        return string;
+    }, null);
+    return string;
 }
-function statementFromStatementNode(statementNode, context) {
-    var Statement = _ontology.default.Statement, node = statementNode, tokens = context.nodeAsTokens(node), string = context.tokensAsString(tokens), statement = new Statement(string, node, tokens);
-    return statement;
+function trimString(string) {
+    string = string.replace(/\s+$/, _constants.EMPTY_STRING); ///
+    return string;
 }
-function termsFromTermNodes(termNodes, context) {
-    var terms = termNodes.map(function(termNode) {
-        var term = termFromTermNode(termNode, context);
-        return term;
-    });
-    return terms;
+function tokensAsString(tokens) {
+    var string = tokens.reduce(function(string, token) {
+        var content = token.getContent();
+        string = "".concat(string).concat(content);
+        return string;
+    }, _constants.EMPTY_STRING);
+    return string;
 }
-function variableFromTerm(term, context) {
-    var variable = null;
-    var termNode = term.getNode(), singularVariableNode = termNode.getSingularVariableNode();
-    if (singularVariableNode !== null) {
-        var Variable = _ontology.default.Variable, variableNode = singularVariableNode; ///
-        variable = Variable.fromVariableNode(variableNode, context);
-        var type = term.getType();
-        variable.setType(type);
+function nodeAsTokens(node, tokens) {
+    var nodeTerminalNode = node.isTerminalNode();
+    if (nodeTerminalNode) {
+        var terminalNode = node; ///
+        tokens = terminalNodeAsTokens(terminalNode, tokens);
+    } else {
+        var nonTerminalNode = node; ///
+        tokens = nonTerminalNodeAsTokens(nonTerminalNode, tokens);
     }
-    return variable;
+    return tokens;
 }
-function stringFromTerms(terms) {
-    var termsString = terms.reduce(function(termsString, term) {
-        var termString = term.getString();
-        termsString = termsString !== null ? "".concat(termsString, ", ").concat(termString) : termString;
-        return termsString;
-    }, null), string = "[".concat(termsString, "]");
-    return string;
+function terminalNodeAsTokens(terminalNode, tokens) {
+    var significantToken = terminalNode.getSignificantToken(), token = significantToken; ///
+    tokens = [
+        token
+    ];
+    return tokens;
+}
+function nonTerminalNodeAsTokens(nonTerminalNode, tokens) {
+    var lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens), firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1;
+    tokens = tokens.slice(start, end); ///
+    return tokens;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/statement.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get containedAssertionFromStatement () {
+        return containedAssertionFromStatement;
+    },
+    get definedAssertionFromStatement () {
+        return definedAssertionFromStatement;
+    },
+    get equalityFromStatement () {
+        return equalityFromStatement;
+    },
+    get judgementFromStatement () {
+        return judgementFromStatement;
+    },
+    get metavariableFromStatement () {
+        return metavariableFromStatement;
+    },
+    get propertyAssertionFromStatement () {
+        return propertyAssertionFromStatement;
+    },
+    get satisfiesAssertionFromStatement () {
+        return satisfiesAssertionFromStatement;
+    },
+    get subproofAssertionFromStatement () {
+        return subproofAssertionFromStatement;
+    },
+    get typeAssertionFromStatement () {
+        return typeAssertionFromStatement;
+    }
+});
+var _elements = /*#__PURE__*/ _interop_require_default(require("../elements"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function equalityFromStatement(statement, context) {
+    var Equality = _elements.default.Equality, statementNode = statement.getNode(), equality = Equality.fromStatementNode(statementNode, context);
+    return equality;
+}
+function judgementFromStatement(statement, context) {
+    var Judgement = _elements.default.Judgement, statementNode = statement.getNode(), judgement = Judgement.fromStatementNode(statementNode, context);
+    return judgement;
+}
+function metavariableFromStatement(statement, context) {
+    var Metavariable = _elements.default.Metavariable, statementNode = statement.getNode(), metavariable = Metavariable.fromStatementNode(statementNode, context);
+    return metavariable;
+}
+function typeAssertionFromStatement(statement, context) {
+    var TypeAssertion = _elements.default.TypeAssertion, statementNode = statement.getNode(), typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);
+    return typeAssertion;
+}
+function definedAssertionFromStatement(statement, context) {
+    var DefinedAssertion = _elements.default.DefinedAssertion, statementNode = statement.getNode(), definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);
+    return definedAssertion;
+}
+function propertyAssertionFromStatement(statement, context) {
+    var PropertyAssertion = _elements.default.PropertyAssertion, statementNode = statement.getNode(), propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);
+    return propertyAssertion;
+}
+function subproofAssertionFromStatement(statement, context) {
+    var SubproofAssertion = _elements.default.SubproofAssertion, statementNode = statement.getNode(), subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
+    return subproofAssertion;
+}
+function containedAssertionFromStatement(statement, context) {
+    var ContainedAssertion = _elements.default.ContainedAssertion, statementNode = statement.getNode(), containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
+    return containedAssertion;
+}
+function satisfiesAssertionFromStatement(statement, context) {
+    var SatisfiesAssertion = _elements.default.SatisfiesAssertion, statementNode = statement.getNode(), satisfiesAssertion = SatisfiesAssertion.fromStatementNode(statementNode, context);
+    return satisfiesAssertion;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utilities/string.js

@@ -9,76 +9,118 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get nodeAsString () {
-        return nodeAsString;
+    get axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction () {
+        return axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction;
     },
-    get nodeAsTokens () {
-        return nodeAsTokens;
+    get labelsStringFromLabels () {
+        return labelsStringFromLabels;
     },
-    get nodesAsString () {
-        return nodesAsString;
+    get signatureStringFromTerms () {
+        return signatureStringFromTerms;
     },
-    get tokensAsString () {
-        return tokensAsString;
+    get subproofStringFromSubproof () {
+        return subproofStringFromSubproof;
     },
-    get trimTrailingSlash () {
-        return trimTrailingSlash;
+    get superTypesStringFromSuperTypes () {
+        return superTypesStringFromSuperTypes;
+    },
+    get suppositionsStringFromSuppositions () {
+        return suppositionsStringFromSuppositions;
+    },
+    get termsStringFromTerms () {
+        return termsStringFromTerms;
+    },
+    get typeStringFromTypeNameTypePrefixNameAndSuperTypes () {
+        return typeStringFromTypeNameTypePrefixNameAndSuperTypes;
     }
 });
-var _constants = require("../constants");
-function nodeAsString(node, tokens) {
-    var string;
-    tokens = nodeAsTokens(node, tokens); ///
-    string = tokensAsString(tokens);
-    string = trimString(string); ///
-    return string;
+var _type = require("../element/type");
+function termsStringFromTerms(terms) {
+    var termsString = terms.reduce(function(termsString, term) {
+        var termString = term.getString();
+        termsString = termsString !== null ? "".concat(termsString, ", ").concat(termString) : termString;
+        return termsString;
+    }, null);
+    return termsString;
 }
-function nodesAsString(nodes, tokens) {
-    var string = nodes.reduce(function(string, node) {
-        var nodeString = nodeAsString(node, tokens);
-        string = string === null ? nodeString : "".concat(string, ", ").concat(nodeString);
-        return string;
+function labelsStringFromLabels(labels) {
+    var labelsString = labels.reduce(function(labelsString, label) {
+        var labelString = label.getString();
+        labelsString = labelsString === null ? labelString : "".concat(labelsString, ", ").concat(labelString);
+        return labelsString;
     }, null);
-    return string;
+    return labelsString;
 }
-function tokensAsString(tokens) {
-    var string = tokens.reduce(function(string, token) {
-        var content = token.getContent();
-        string = "".concat(string).concat(content);
-        return string;
-    }, _constants.EMPTY_STRING);
-    return string;
+function signatureStringFromTerms(terms) {
+    var termsString = termsStringFromTerms(terms), signatureString = "[".concat(termsString, "]");
+    return signatureString;
 }
-function nodeAsTokens(node, tokens) {
-    var nodeTerminalNode = node.isTerminalNode();
-    if (nodeTerminalNode) {
-        var terminalNode = node; ///
-        tokens = terminalNodeAsTokens(terminalNode, tokens);
-    } else {
-        var nonTerminalNode = node; ///
-        tokens = nonTerminalNodeAsTokens(nonTerminalNode, tokens);
+function subproofStringFromSubproof(subproof) {
+    var suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context), lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context), subproofString = "[".concat(suppositionStatementsOrNonsenseString, "] ... ").concat(lastStatementOrNonsenseString);
+    return subproofString;
+}
+function superTypesStringFromSuperTypes(superTypes) {
+    var superTypesString = superTypes.reduce(function(superTypesString, superType) {
+        if (superType !== _type.baseType) {
+            var superTypeString = superType.getString();
+            superTypesString = superTypesString === null ? "'".concat(superTypeString, "'") : "".concat(superTypesString, ", '").concat(superTypeString, "'");
+        }
+        return superTypesString;
+    }, null);
+    return superTypesString;
+}
+function suppositionsStringFromSuppositions(suppositions) {
+    var suppositionsString = suppositions.reduce(function(suppositionsString, supposition) {
+        var suppositionString = supposition.getString();
+        suppositionsString = suppositionsString !== null ? "".concat(suppositionsString, ", ").concat(suppositionString) : suppositionString; ///
+        return suppositionsString;
+    }, null);
+    return suppositionsString;
+}
+function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
+    var typeString;
+    typeString = typePrefixName !== null ? "".concat(typePrefixName).concat(typeName) : typeName;
+    var superTypesString = superTypesStringFromSuperTypes(superTypes);
+    if (superTypesString !== null) {
+        typeString = "".concat(typeString, ":").concat(superTypesString);
     }
-    return tokens;
+    return typeString;
 }
-function trimTrailingSlash(string) {
-    string = string.replace(/\/$/, _constants.EMPTY_STRING); ///
-    return string;
+function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
+    var axiomLemmaTheoremConjectureString;
+    var suppositionsString = suppositionsStringFromSuppositions(suppositions), deductionString = deduction.getString(), labelsString = labelsStringFromLabels(labels);
+    if (labelsString !== null) {
+        axiomLemmaTheoremConjectureString = suppositionsString !== null ? "".concat(labelsString, " :: [").concat(suppositionsString, "] ... ").concat(deductionString) : "".concat(labelsString, " :: ").concat(deductionString);
+    } else {
+        axiomLemmaTheoremConjectureString = suppositionsString !== null ? "[".concat(suppositionsString, "] ... ").concat(deductionString) : deductionString;
+    }
+    return axiomLemmaTheoremConjectureString;
 }
-function trimString(string) {
-    string = string.replace(/\s+$/, _constants.EMPTY_STRING); ///
-    return string;
+function suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode1, context1) {
+    var suppositionNodes = subproofNode1.getSuppositionNodes(), suppositionStatementsOrNonsenseString = suppositionNodes.reduce(function(suppositionStatementsOrNonsenseString, suppositionNode) {
+        var suppositionOrStepNode = suppositionNode, statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context1), suppositionStatementOrNonsenseString = statementOrNonsenseString; ///
+        suppositionStatementsOrNonsenseString = suppositionStatementsOrNonsenseString !== null ? "".concat(suppositionStatementsOrNonsenseString, ", ").concat(suppositionStatementOrNonsenseString) : suppositionStatementOrNonsenseString; ///
+        return suppositionStatementsOrNonsenseString;
+    }, null);
+    return suppositionStatementsOrNonsenseString;
 }
-function terminalNodeAsTokens(terminalNode, tokens) {
-    var significantToken = terminalNode.getSignificantToken(), token = significantToken; ///
-    tokens = [
-        token
-    ];
-    return tokens;
+function statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context1) {
+    var statementOrNonsenseString;
+    var nonsenseNode = suppositionOrStepNode.getNonsenseNode(), statementNode = suppositionOrStepNode.getStatementNode();
+    if (false) {
+    ///
+    } else if (nonsenseNode !== null) {
+        var nonsenseString = context1.nodeAsString(nonsenseNode);
+        statementOrNonsenseString = nonsenseString; ///
+    } else if (statementNode !== null) {
+        var statementString = context1.nodeAsString(statementNode);
+        statementOrNonsenseString = statementString; ///
+    }
+    return statementOrNonsenseString;
 }
-function nonTerminalNodeAsTokens(nonTerminalNode, tokens) {
-    var lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens), firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens), start = firstSignificantTokenIndex, end = lastSignificantTokenIndex + 1;
-    tokens = tokens.slice(start, end); ///
-    return tokens;
+function lastStatementOrNonsenseStringFromSubproofNode(subproofNode1, context1) {
+    var lastStepNode = subproofNode1.getLastStepNode(), suppositionOrStepNode = lastStepNode, statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context1), lastStatementOrNonsenseString = statementOrNonsenseString; ///
+    return lastStatementOrNonsenseString;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/string.js"],"sourcesContent":["\"use strict\";\n\nimport { baseType } from \"../element/type\";\n\nexport function termsStringFromTerms(terms) {\n  const termsString = terms.reduce((termsString, term) => {\n    const termString = term.getString();\n\n    termsString = (termsString !== null) ?\n                   `${termsString}, ${termString}` :\n                      termString;\n\n    return termsString;\n  }, null);\n\n  return termsString;\n}\n\nexport function labelsStringFromLabels(labels) {\n  const labelsString = labels.reduce((labelsString, label) => {\n    const labelString = label.getString();\n\n    labelsString = (labelsString === null) ?\n                     labelString: ///\n                      `${labelsString}, ${labelString}`;\n\n    return labelsString;\n  }, null);\n\n  return labelsString;\n}\n\nexport function signatureStringFromTerms(terms) {\n  const termsString = termsStringFromTerms(terms),\n        signatureString = `[${termsString}]`;\n\n  return signatureString;\n}\n\nexport function subproofStringFromSubproof(subproof) {\n  const suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context),\n        lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context),\n        subproofString = `[${suppositionStatementsOrNonsenseString}] ... ${lastStatementOrNonsenseString}`;\n\n  return subproofString;\n}\n\nexport function superTypesStringFromSuperTypes(superTypes) {\n  const superTypesString = superTypes.reduce((superTypesString, superType) => {\n    if (superType !== baseType) {\n      const superTypeString = superType.getString();\n\n      superTypesString = (superTypesString === null) ?\n                           `'${superTypeString}'` :\n                             `${superTypesString}, '${superTypeString}'`;\n    }\n\n    return superTypesString;\n  }, null);\n\n  return superTypesString;\n}\n\nexport function suppositionsStringFromSuppositions(suppositions) {\n  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {\n    const suppositionString = supposition.getString();\n\n    suppositionsString = (suppositionsString !== null) ?\n                          `${suppositionsString}, ${suppositionString}` :\n                            suppositionString;  ///\n\n    return suppositionsString;\n  }, null);\n\n  return suppositionsString;\n}\n\nexport function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {\n  let typeString;\n\n  typeString = (typePrefixName !== null) ?\n                 `${typePrefixName}${typeName}`:\n                   typeName;\n\n  const superTypesString = superTypesStringFromSuperTypes(superTypes);\n\n  if (superTypesString !== null) {\n    typeString = `${typeString}:${superTypesString}`;\n  }\n\n  return typeString;\n}\n\nexport function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {\n  let axiomLemmaTheoremConjectureString;\n\n  const suppositionsString = suppositionsStringFromSuppositions(suppositions),\n        deductionString = deduction.getString(),\n        labelsString = labelsStringFromLabels(labels);\n\n  if (labelsString !== null) {\n    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?\n                                          `${labelsString} :: [${suppositionsString}] ... ${deductionString}` :\n                                            `${labelsString} :: ${deductionString}`;\n  } else {\n    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?\n                                         `[${suppositionsString}] ... ${deductionString}` :\n                                            deductionString;\n  }\n\n  return axiomLemmaTheoremConjectureString;\n}\n\nfunction suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {\n  const suppositionNodes = subproofNode.getSuppositionNodes(),\n        suppositionStatementsOrNonsenseString = suppositionNodes.reduce((suppositionStatementsOrNonsenseString, suppositionNode) => {\n          const suppositionOrStepNode = suppositionNode,  ///\n                statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),\n                suppositionStatementOrNonsenseString = statementOrNonsenseString; ///\n\n          suppositionStatementsOrNonsenseString = (suppositionStatementsOrNonsenseString !== null) ?\n                                                    `${suppositionStatementsOrNonsenseString}, ${suppositionStatementOrNonsenseString}` :\n                                                      suppositionStatementOrNonsenseString; ///\n\n          return suppositionStatementsOrNonsenseString;\n        }, null);\n\n  return suppositionStatementsOrNonsenseString;\n}\n\nfunction statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context) {\n  let statementOrNonsenseString;\n\n  const nonsenseNode = suppositionOrStepNode.getNonsenseNode(),\n        statementNode = suppositionOrStepNode.getStatementNode();\n\n  if (false) {\n    ///\n  } else if (nonsenseNode !== null) {\n    const nonsenseString = context.nodeAsString(nonsenseNode);\n\n    statementOrNonsenseString = nonsenseString; ///\n  } else if (statementNode !== null) {\n    const statementString = context.nodeAsString(statementNode);\n\n    statementOrNonsenseString = statementString;  ///\n  }\n\n  return statementOrNonsenseString;\n}\n\nfunction lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {\n  const lastStepNode = subproofNode.getLastStepNode(),\n        suppositionOrStepNode = lastStepNode, ///\n        statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),\n        lastStatementOrNonsenseString = statementOrNonsenseString; ///\n\n  return lastStatementOrNonsenseString;\n}\n"],"names":["axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction","labelsStringFromLabels","signatureStringFromTerms","subproofStringFromSubproof","superTypesStringFromSuperTypes","suppositionsStringFromSuppositions","termsStringFromTerms","typeStringFromTypeNameTypePrefixNameAndSuperTypes","terms","termsString","reduce","term","termString","getString","labels","labelsString","label","labelString","signatureString","subproof","suppositionStatementsOrNonsenseString","suppositionStatementOrNonsenseStringFromSubproofNode","subproofNode","context","lastStatementOrNonsenseString","lastStatementOrNonsenseStringFromSubproofNode","subproofString","superTypes","superTypesString","superType","baseType","superTypeString","suppositions","suppositionsString","supposition","suppositionString","typeName","typePrefixName","typeString","deduction","axiomLemmaTheoremConjectureString","deductionString","suppositionNodes","getSuppositionNodes","suppositionNode","suppositionOrStepNode","statementOrNonsenseString","statementOrNonsenseStringFromSuppositionOrStepNode","suppositionStatementOrNonsenseString","nonsenseNode","getNonsenseNode","statementNode","getStatementNode","nonsenseString","nodeAsString","statementString","lastStepNode","getLastStepNode"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.421",
+  "version": "1.0.427",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,11 +12,11 @@
   "dependencies": {
     "argumentative": "^2.0.36",
     "necessary": "^17.0.7",
-    "occam-custom-grammars": "^5.0.1332",
-    "occam-entities": "^1.0.438",
-    "occam-file-system": "^6.0.453",
-    "occam-furtle": "^2.0.272",
-    "occam-grammars": "^1.3.424",
+    "occam-custom-grammars": "^5.0.1334",
+    "occam-entities": "^1.0.439",
+    "occam-file-system": "^6.0.454",
+    "occam-furtle": "^2.0.273",
+    "occam-grammars": "^1.3.427",
     "occam-lexers": "^23.1.32",
     "occam-parsers": "^23.1.35",
     "occam-query": "^4.1.140"

package/src/action/verify.js

@@ -4,8 +4,8 @@ import { Dependency } from "occam-entities";
 
 import "../preamble";
 
+import { EMPTY_STRING } from "../constants";
 import { verifyRelease } from "../utilities/release";
-import { trimTrailingSlash } from "../utilities/string";
 import { releaseContextFromDependency } from "../utilities/fileSystem";
 import { createReleaseContext, initialiseReleaseContext } from "../utilities/releaseContext";
 
@@ -80,3 +80,10 @@ function stopClock(now, log) {
 
   log.info(`Time ${seconds} seconds.`);
 }
+
+function trimTrailingSlash(string) {
+  string = string.replace(/\/$/, EMPTY_STRING); ///
+
+  return string;
+}
+

package/src/context/file.js

@@ -2,11 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
-import { baseType } from "../ontology/type";
+import { baseType } from "../element/type";
 import { verifyFile } from "../process/verify";
-import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
+import { nodeAsString, nodesAsString } from "../utilities/node";
 import { typesFromJSON,
          rulesFromJSON,
          axiomsFromJSON,
@@ -91,7 +91,7 @@ export default class FileContext {
   }
 
   getEquivalences() {
-    const { Equivalences } = ontology,
+    const { Equivalences } = elements,
           equivalences = Equivalences.fromNothing();
 
     return equivalences;
@@ -736,7 +736,7 @@ export default class FileContext {
   isLabelPresentByReference(reference) {
     const labels = this.getLabels(),
           labelPresent = labels.some((label) => {
-            const { Substitutions } = ontology,
+            const { Substitutions } = elements,
                   context = this, ///
                   substitutions = Substitutions.fromNothing(),
                   labelUnifies = reference.unifyLabel(label, substitutions, context);
@@ -777,48 +777,18 @@ export default class FileContext {
     return metaLemmaMetatheoremPresent;
   }
 
-  nodeAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    const string = nodeAsString(node, tokens);
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
 
     return string;
   }
 
-  nodesAsString(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    const string = nodesAsString(node, tokens);
+  nodesAsString(node) {
+    const string = nodesAsString(node, this.tokens);
 
     return string;
   }
 
-  nodeAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    tokens = nodeAsTokens(node, tokens);  ///
-
-    return tokens;
-  }
-
-  nodesAsTokens(node, tokens = null) {
-    if (tokens === null) {
-      tokens = this.tokens;
-    }
-
-    tokens = nodesAsTokens(node, tokens); ///
-
-    return tokens;
-  }
-
-  tokensAsString(tokens) { return tokensAsString(tokens); }
-
   findFile(filePath) { return this.releaseContext.findFile(filePath); }
 
   trace(message, node = null) {

package/src/context/local.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import ontology from "../ontology";
+import elements from "../elements";
 
 const { last } = arrayUtilities;
 
@@ -124,7 +124,7 @@ class LocalContext {
     const equalityReflexive = equality.isReflexive();
 
     if (!equalityReflexive) {
-      const { Equivalence } = ontology,
+      const { Equivalence } = elements,
             equivalence = Equivalence.fromEquality(equality),
             context = this; ///
 
@@ -358,15 +358,9 @@ class LocalContext {
     return termAndPropertyRelationMatches;
   }
 
-  nodeAsString(node, tokens) { return this.context.nodeAsString(node, tokens); }
+  nodeAsString(node) { return this.context.nodeAsString(node); }
 
-  nodesAsString(node, tokens) { return this.context.nodesAsString(node, tokens); }
-
-  nodeAsTokens(node, tokens) { return this.context.nodeAsTokens(node, tokens); }
-
-  nodesAsTokens(node, tokens) { return this.context.nodesAsTokens(node, tokens); }
-
-  tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
+  nodesAsString(node) { return this.context.nodesAsString(node); }
 
   trace(message, node = null) { this.context.trace(message, node); }
 
@@ -379,7 +373,7 @@ class LocalContext {
   error(message, node = null) { this.context.error(message, node); }
 
   static fromNothing(context) {
-    const { Equivalences } = ontology,
+    const { Equivalences } = elements,
           variables = [],
           judgements = [],
           equivalences = Equivalences.fromNothing(),