occam-verify-cli 1.0.438 → 1.0.444

package/src/{mixins/statement/validate.js → utilities/validation.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-import elements from "../../elements";
+import elements from "../elements";
 
 import { equalityFromStatement,
          judgementFromStatement,
@@ -10,10 +10,80 @@ import { equalityFromStatement,
          propertyAssertionFromStatement,
          subproofAssertionFromStatement,
          containedAssertionFromStatement,
-         satisfiesAssertionFromStatement } from "../../utilities/statement";
+         satisfiesAssertionFromStatement } from "../utilities/statement";
 
-function validateAsMetavariableAndSubstitution(statement, assignments, stated, context) {
-  let validatesAsMetavariableAndSubstitution = false;
+function unifyTermWithBracketedConstructor(term, context, validateAhead) {
+  let termUnifiesWithBracketedConstructor;
+
+  const { BracketedConstructor } = elements,
+    bracketedConstructor = BracketedConstructor.fromNothing();
+
+  termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);
+
+  return termUnifiesWithBracketedConstructor;
+}
+
+function unifyTermWithConstructors(term, context, validateAhead) {
+  let termUnifiesWithConstructors;
+
+  const constructors = context.getConstructors();
+
+  termUnifiesWithConstructors = constructors.some((constructor) => {
+    const unifiesWithConstructor = constructor.unifyTerm(term, context, validateAhead);
+
+    if (unifiesWithConstructor) {
+      return true;
+    }
+  });
+
+  return termUnifiesWithConstructors;
+}
+
+function validateTermAsVariable(term, context, validateAhead) {
+  let termValidatesAsVariable = false;
+
+  const { Variable } = elements,
+    termNode = term.getNode(),
+    singularVariableNode = termNode.getSingularVariableNode();
+
+  if (singularVariableNode !== null) {
+    let variable;
+
+    const termString = term.getString(),
+      variableNode = singularVariableNode;  ///
+
+    variable = Variable.fromVariableNode(variableNode, context);
+
+    context.trace(`Verifying the '${termString}' term as a variable...`);
+
+    const variableValidates = variable.validate(context);
+
+    if (variableValidates) {
+      let verifiesAhead;
+
+      const variableIdentifier = variable.getIdentifier();
+
+      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+      const type = variable.getType();
+
+      term.setType(type);
+
+      verifiesAhead = validateAhead();
+
+      termValidatesAsVariable = verifiesAhead; ///
+    }
+
+    if (termValidatesAsVariable) {
+      context.debug(`...verified the '${termString}' term as a variable.`);
+    }
+  }
+
+  return termValidatesAsVariable;
+}
+
+function validateStatementAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+  let statementValidatesAsMetavariableAndSubstitution = false;
 
   const metavariable = metavariableFromStatement(statement, context);
 
@@ -34,40 +104,40 @@ function validateAsMetavariableAndSubstitution(statement, assignments, stated, c
         const substitutionValidates = substitution.validate(context);
 
         if (substitutionValidates) {
-          validatesAsMetavariableAndSubstitution = true;
+          statementValidatesAsMetavariableAndSubstitution = true;
         }
       } else {
-        validatesAsMetavariableAndSubstitution = true;
+        statementValidatesAsMetavariableAndSubstitution = true;
       }
     }
 
-    if (validatesAsMetavariableAndSubstitution) {
+    if (statementValidatesAsMetavariableAndSubstitution) {
       context.debug(`...validated the '${statementString}' statement as a metavariable and substitution.`);
     }
   }
 
-  return validatesAsMetavariableAndSubstitution;
+  return statementValidatesAsMetavariableAndSubstitution;
 }
 
-function unifyWithBracketedCombinatorStatement(statement, assignments, stated, context) {
+function unifyStatementWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///
 
   assignments = null; ///
 
-  const { BracketedCombinatorStatement } = elements,
-        bracketedCombinatorStatement = BracketedCombinatorStatement.fromNothing(),
-        unifiesWithBracketedCombinatorStatement = bracketedCombinatorStatement.unifyStatement(statement, assignments, stated, context);
+  const { BracketedCombinator } = elements,
+        bracketedCombinator = BracketedCombinator.fromNothing(),
+        statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
 
-  return unifiesWithBracketedCombinatorStatement;
+  return statementUnifiesWithBracketedCombinator;
 }
 
-function unifyWithCombinators(statement, assignments, stated, context) {
+function unifyStatementWithCombinators(statement, assignments, stated, context) {
   stated = true;  ///
 
   assignments = null; ///
 
   const combinators = context.getCombinators(),
-        unifiesWithCombinators = combinators.some((combinator) => {
+        statementUnifiesWithCombinators = combinators.some((combinator) => {
           const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
 
           if (unifiesWithCombinator) {
@@ -75,11 +145,11 @@ function unifyWithCombinators(statement, assignments, stated, context) {
           }
         });
 
-  return unifiesWithCombinators;
+  return statementUnifiesWithCombinators;
 }
 
-function validateAsEquality(statement, assignments, stated, context) {
-  let validatesAsEquality = false;
+function validateStatementAsEquality(statement, assignments, stated, context) {
+  let statementValidatesAsEquality = false;
 
   const equality = equalityFromStatement(statement, context);
 
@@ -90,18 +160,18 @@ function validateAsEquality(statement, assignments, stated, context) {
 
     const equalityValidates = equality.validate(assignments, stated, context);
 
-    validatesAsEquality = equalityValidates; ///
+    statementValidatesAsEquality = equalityValidates; ///
 
-    if (validatesAsEquality) {
+    if (statementValidatesAsEquality) {
       context.debug(`...validated the '${statementString}' statement as an equality.`);
     }
   }
 
-  return validatesAsEquality;
+  return statementValidatesAsEquality;
 }
 
-function validateAsJudgement(statement, assignments, stated, context) {
-  let validatesAsJudgement = false;
+function validateStatementAsJudgement(statement, assignments, stated, context) {
+  let validatesStatementAsJudgement = false;
 
   const judgement = judgementFromStatement(statement, context);
 
@@ -112,18 +182,18 @@ function validateAsJudgement(statement, assignments, stated, context) {
 
     const judgementValidates = judgement.validate(assignments, stated, context);
 
-    validatesAsJudgement = judgementValidates;  ///
+    validatesStatementAsJudgement = judgementValidates;  ///
 
-    if (validatesAsJudgement) {
+    if (validatesStatementAsJudgement) {
       context.debug(`...validated the '${statementString}' statement as a judgement.`);
     }
   }
 
-  return validatesAsJudgement;
+  return validatesStatementAsJudgement;
 }
 
-function validateAsTypeAssertion(statement, assignments, stated, context) {
-  let validatesAsTypeAssertion = false;
+function validateStatementAsTypeAssertion(statement, assignments, stated, context) {
+  let validatesStatementAsTypeAssertion = false;
 
   const typeAssertion = typeAssertionFromStatement(statement, context);
 
@@ -134,9 +204,9 @@ function validateAsTypeAssertion(statement, assignments, stated, context) {
 
     const typeAssertionValidates = typeAssertion.validate(assignments, stated, context);
 
-    validatesAsTypeAssertion = typeAssertionValidates; ///
+    validatesStatementAsTypeAssertion = typeAssertionValidates; ///
 
-    if (validatesAsTypeAssertion) {
+    if (validatesStatementAsTypeAssertion) {
       const assertion = typeAssertion;  ///
 
       context.addAssertion(assertion);
@@ -145,11 +215,11 @@ function validateAsTypeAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsTypeAssertion;
+  return validatesStatementAsTypeAssertion;
 }
 
-function validateAsDefinedAssertion(statement, assignments, stated, context) {
-  let validatesAsDefinedAssertion = false;
+function validateStatementAsDefinedAssertion(statement, assignments, stated, context) {
+  let validatesStatementAsDefinedAssertion = false;
 
   const definedAssertion = definedAssertionFromStatement(statement, context);
 
@@ -160,9 +230,9 @@ function validateAsDefinedAssertion(statement, assignments, stated, context) {
 
     const definedAssertionValidates = definedAssertion.validate(assignments, stated, context);
 
-    validatesAsDefinedAssertion = definedAssertionValidates; ///
+    validatesStatementAsDefinedAssertion = definedAssertionValidates; ///
 
-    if (validatesAsDefinedAssertion) {
+    if (validatesStatementAsDefinedAssertion) {
       const assertion = definedAssertion;  ///
 
       context.addAssertion(assertion);
@@ -171,11 +241,11 @@ function validateAsDefinedAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsDefinedAssertion;
+  return validatesStatementAsDefinedAssertion;
 }
 
-function validateAsPropertyAssertion(statement, assignments, stated, context) {
-  let validatesAsPropertyAssertion = false;
+function validateStatementAsPropertyAssertion(statement, assignments, stated, context) {
+  let statementValidatesAsPropertyAssertion = false;
 
   const propertyAssertion = propertyAssertionFromStatement(statement, context);
 
@@ -186,9 +256,9 @@ function validateAsPropertyAssertion(statement, assignments, stated, context) {
 
     const propertyAssertionValidates = propertyAssertion.validate(assignments, stated, context);
 
-    validatesAsPropertyAssertion = propertyAssertionValidates; ///
+    statementValidatesAsPropertyAssertion = propertyAssertionValidates; ///
 
-    if (validatesAsPropertyAssertion) {
+    if (statementValidatesAsPropertyAssertion) {
       const assertion = propertyAssertion; ///
 
       context.addAssertion(assertion);
@@ -197,11 +267,11 @@ function validateAsPropertyAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsPropertyAssertion;
+  return statementValidatesAsPropertyAssertion;
 }
 
-function validateAsSubproofAssertion(statement, assignments, stated, context) {
-  let validatesAsSubproofAssertion = false;
+function validateStatementAsSubproofAssertion(statement, assignments, stated, context) {
+  let statementValidatesAsSubproofAssertion = false;
 
   const subproofAssertion = subproofAssertionFromStatement(statement, context);
 
@@ -212,9 +282,9 @@ function validateAsSubproofAssertion(statement, assignments, stated, context) {
 
     const subproofAssertionValidates = subproofAssertion.validate(assignments, stated, context);
 
-    validatesAsSubproofAssertion = subproofAssertionValidates; ///
+    statementValidatesAsSubproofAssertion = subproofAssertionValidates; ///
 
-    if (validatesAsSubproofAssertion) {
+    if (statementValidatesAsSubproofAssertion) {
       const assertion = subproofAssertion; ///
 
       context.addAssertion(assertion);
@@ -223,11 +293,11 @@ function validateAsSubproofAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsSubproofAssertion;
+  return statementValidatesAsSubproofAssertion;
 }
 
-function validateAsContainedAssertion(statement, assignments, stated, context) {
-  let validatesAsContainedAssertion = false;
+function validateStatementAsContainedAssertion(statement, assignments, stated, context) {
+  let validatesStatementAsContainedAssertion = false;
 
   const containedAssertion = containedAssertionFromStatement(statement, context);
 
@@ -238,9 +308,9 @@ function validateAsContainedAssertion(statement, assignments, stated, context) {
 
     const containedAssertionValidates = containedAssertion.validate(assignments, stated, context);
 
-    validatesAsContainedAssertion = containedAssertionValidates; ///
+    validatesStatementAsContainedAssertion = containedAssertionValidates; ///
 
-    if (validatesAsContainedAssertion) {
+    if (validatesStatementAsContainedAssertion) {
       const assertion = containedAssertion; ///
 
       context.addAssertion(assertion);
@@ -249,11 +319,11 @@ function validateAsContainedAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsContainedAssertion;
+  return validatesStatementAsContainedAssertion;
 }
 
-function validateAsSatisfiesAssertion(statement, assignments, stated, context) {
-  let validatesAsSatisfiesAssertion = false;
+function validateStatementAsSatisfiesAssertion(statement, assignments, stated, context) {
+  let validatesAStatementsSatisfiesAssertion = false;
 
   const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
@@ -264,9 +334,9 @@ function validateAsSatisfiesAssertion(statement, assignments, stated, context) {
 
     const satisfiesAssertionValidates = satisfiesAssertion.validate(assignments, stated, context);
 
-    validatesAsSatisfiesAssertion = satisfiesAssertionValidates; ///
+    validatesAStatementsSatisfiesAssertion = satisfiesAssertionValidates; ///
 
-    if (validatesAsSatisfiesAssertion) {
+    if (validatesAStatementsSatisfiesAssertion) {
       const assertion = satisfiesAssertion; ///
 
       context.addAssertion(assertion);
@@ -275,21 +345,25 @@ function validateAsSatisfiesAssertion(statement, assignments, stated, context) {
     }
   }
 
-  return validatesAsSatisfiesAssertion;
+  return validatesAStatementsSatisfiesAssertion;
 }
 
-const validateMixins = [
-  validateAsMetavariableAndSubstitution,
-  unifyWithBracketedCombinatorStatement,
-  unifyWithCombinators,
-  validateAsEquality,
-  validateAsJudgement,
-  validateAsTypeAssertion,
-  validateAsDefinedAssertion,
-  validateAsPropertyAssertion,
-  validateAsSubproofAssertion,
-  validateAsContainedAssertion,
-  validateAsSatisfiesAssertion
+export const validateTerms = [
+  unifyTermWithBracketedConstructor,
+  unifyTermWithConstructors,
+  validateTermAsVariable
 ];
 
-export default validateMixins;
+export const validateStatements = [
+  validateStatementAsMetavariableAndSubstitution,
+  unifyStatementWithBracketedCombinator,
+  unifyStatementWithCombinators,
+  validateStatementAsEquality,
+  validateStatementAsJudgement,
+  validateStatementAsTypeAssertion,
+  validateStatementAsDefinedAssertion,
+  validateStatementAsPropertyAssertion,
+  validateStatementAsSubproofAssertion,
+  validateStatementAsContainedAssertion,
+  validateStatementAsSatisfiesAssertion
+];

package/lib/element/statement/combinator.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _elements = require("../../elements");
-var _unify = require("../../process/unify");
-var _json = require("../../utilities/json");
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-var _CombinatorStatement;
-var _default = (0, _elements.define)((_CombinatorStatement = /*#__PURE__*/ function() {
-    function CombinatorStatement(statement) {
-        _class_call_check(this, CombinatorStatement);
-        this.statement = statement;
-    }
-    _create_class(CombinatorStatement, [
-        {
-            key: "getStatement",
-            value: function getStatement() {
-                return this.statement;
-            }
-        },
-        {
-            key: "getString",
-            value: function getString() {
-                return this.statement.getString();
-            }
-        },
-        {
-            key: "getStatementNode",
-            value: function getStatementNode() {
-                var statementNode = this.statement.getNode();
-                return statementNode;
-            }
-        },
-        {
-            key: "unifyStatement",
-            value: function unifyStatement(statement, assignments, stated, context) {
-                var statementUnifies;
-                var statementString = statement.getString(), combinatorStatementString = this.getString();
-                context.trace("Unifying the '".concat(statementString, "' statement with the '").concat(combinatorStatementString, "' combinator's statement..."));
-                var combinatorStatement = this, statementUnifiesWithCombinator = (0, _unify.unifyStatementWithCombinatorStatement)(statement, combinatorStatement, assignments, stated, context);
-                statementUnifies = statementUnifiesWithCombinator; ///
-                if (statementUnifies) {
-                    context.debug("...unified the '".concat(statementString, "' statement with the '").concat(combinatorStatementString, "' combinator's statement."));
-                }
-                return statementUnifies;
-            }
-        },
-        {
-            key: "toJSON",
-            value: function toJSON() {
-                var statementJSON = (0, _json.statementToStatementJSON)(this.statement), json = statementJSON;
-                return json;
-            }
-        }
-    ], [
-        {
-            key: "fromJSON",
-            value: function fromJSON(json, context) {
-                var statement = (0, _json.statementFromJSON)(json, context), combinator = new CombinatorStatement(statement);
-                return combinator;
-            }
-        }
-    ]);
-    return CombinatorStatement;
-}(), _define_property(_CombinatorStatement, "name", "CombinatorStatement"), _CombinatorStatement));
-
-//# sourceMappingURL=data:application/json;base64,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

package/lib/element/term/constructor.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../../elements"));
-var _unify = require("../../process/unify");
-var _json = require("../../utilities/json");
-function _class_call_check(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-        throw new TypeError("Cannot call a class as a function");
-    }
-}
-function _defineProperties(target, props) {
-    for(var i = 0; i < props.length; i++){
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-    }
-}
-function _create_class(Constructor, protoProps, staticProps) {
-    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-    if (staticProps) _defineProperties(Constructor, staticProps);
-    return Constructor;
-}
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
-var _ConstructorTerm;
-var _default = (0, _elements.define)((_ConstructorTerm = /*#__PURE__*/ function() {
-    function ConstructorTerm(term) {
-        _class_call_check(this, ConstructorTerm);
-        this.term = term;
-    }
-    _create_class(ConstructorTerm, [
-        {
-            key: "getTerm",
-            value: function getTerm() {
-                return this.term;
-            }
-        },
-        {
-            key: "getType",
-            value: function getType() {
-                return this.term.getType();
-            }
-        },
-        {
-            key: "getString",
-            value: function getString() {
-                return this.term.getString();
-            }
-        },
-        {
-            key: "isProvisional",
-            value: function isProvisional() {
-                return this.term.isProvisional();
-            }
-        },
-        {
-            key: "setType",
-            value: function setType(type) {
-                this.term.setType(type);
-            }
-        },
-        {
-            key: "unifyTerm",
-            value: function unifyTerm(term, context, verifyAhead) {
-                var termUnifies = false;
-                var termString = term.getString(), constructorTermString = this.getString();
-                context.trace("Unifying the '".concat(termString, "' term with the '").concat(constructorTermString, "' constructor's term..."));
-                var constructorTerm = this, termUnifiesWithConstructor = (0, _unify.unifyTermWithConstructorTerm)(term, constructorTerm, context);
-                if (termUnifiesWithConstructor) {
-                    var verifiesAhead;
-                    var type = this.getType();
-                    term.setType(type);
-                    verifiesAhead = verifyAhead();
-                    termUnifies = verifiesAhead; ///
-                }
-                if (termUnifies) {
-                    context.debug("...unified the '".concat(termString, "' term with the '").concat(constructorTermString, "' constructor's term."));
-                }
-                return termUnifies;
-            }
-        },
-        {
-            key: "toJSON",
-            value: function toJSON() {
-                var termJSON = (0, _json.termToTermJSON)(this.term), term = termJSON, json = {
-                    term: term
-                };
-                return json;
-            }
-        }
-    ], [
-        {
-            key: "fromJSON",
-            value: function fromJSON(json, context) {
-                var term = (0, _json.termFromJSON)(json, context), constructor = new ConstructorTerm(term);
-                return constructor;
-            }
-        },
-        {
-            key: "fromConstructorDeclarationNode",
-            value: function fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-                var Term = _elements.default.Term, term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context), constructor = new ConstructorTerm(term);
-                return constructor;
-            }
-        }
-    ]);
-    return ConstructorTerm;
-}(), _define_property(_ConstructorTerm, "name", "ConstructorTerm"), _ConstructorTerm));
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lbGVtZW50L3Rlcm0vY29uc3RydWN0b3IuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBlbGVtZW50cyBmcm9tIFwiLi4vLi4vZWxlbWVudHNcIjtcblxuaW1wb3J0IHsgZGVmaW5lIH0gZnJvbSBcIi4uLy4uL2VsZW1lbnRzXCI7XG5pbXBvcnQgeyB1bmlmeVRlcm1XaXRoQ29uc3RydWN0b3JUZXJtIH0gZnJvbSBcIi4uLy4uL3Byb2Nlc3MvdW5pZnlcIjtcbmltcG9ydCB7IHRlcm1Gcm9tSlNPTiwgdGVybVRvVGVybUpTT04gfSBmcm9tIFwiLi4vLi4vdXRpbGl0aWVzL2pzb25cIjtcblxuZXhwb3J0IGRlZmF1bHQgZGVmaW5lKGNsYXNzIENvbnN0cnVjdG9yVGVybSB7XG4gIGNvbnN0cnVjdG9yKHRlcm0pIHtcbiAgICB0aGlzLnRlcm0gPSB0ZXJtO1xuICB9XG5cbiAgZ2V0VGVybSgpIHtcbiAgICByZXR1cm4gdGhpcy50ZXJtO1xuICB9XG5cbiAgZ2V0VHlwZSgpIHsgcmV0dXJuIHRoaXMudGVybS5nZXRUeXBlKCk7IH1cblxuICBnZXRTdHJpbmcoKSB7IHJldHVybiB0aGlzLnRlcm0uZ2V0U3RyaW5nKCk7IH1cblxuICBpc1Byb3Zpc2lvbmFsKCkgeyByZXR1cm4gdGhpcy50ZXJtLmlzUHJvdmlzaW9uYWwoKTsgfVxuXG4gIHNldFR5cGUodHlwZSkgeyB0aGlzLnRlcm0uc2V0VHlwZSh0eXBlKTsgfVxuXG4gIHVuaWZ5VGVybSh0ZXJtLCBjb250ZXh0LCB2ZXJpZnlBaGVhZCkge1xuICAgIGxldCB0ZXJtVW5pZmllcyA9IGZhbHNlO1xuXG4gICAgY29uc3QgdGVybVN0cmluZyA9IHRlcm0uZ2V0U3RyaW5nKCksXG4gICAgICAgICAgY29uc3RydWN0b3JUZXJtU3RyaW5nID0gdGhpcy5nZXRTdHJpbmcoKTtcblxuICAgIGNvbnRleHQudHJhY2UoYFVuaWZ5aW5nIHRoZSAnJHt0ZXJtU3RyaW5nfScgdGVybSB3aXRoIHRoZSAnJHtjb25zdHJ1Y3RvclRlcm1TdHJpbmd9JyBjb25zdHJ1Y3RvcidzIHRlcm0uLi5gKTtcblxuICAgIGNvbnN0IGNvbnN0cnVjdG9yVGVybSA9IHRoaXMsIC8vL1xuICAgICAgICAgIHRlcm1VbmlmaWVzV2l0aENvbnN0cnVjdG9yID0gdW5pZnlUZXJtV2l0aENvbnN0cnVjdG9yVGVybSh0ZXJtLCBjb25zdHJ1Y3RvclRlcm0sIGNvbnRleHQpO1xuXG4gICAgaWYgKHRlcm1VbmlmaWVzV2l0aENvbnN0cnVjdG9yKSB7XG4gICAgICBsZXQgdmVyaWZpZXNBaGVhZDtcblxuICAgICAgY29uc3QgdHlwZSA9IHRoaXMuZ2V0VHlwZSgpO1xuXG4gICAgICB0ZXJtLnNldFR5cGUodHlwZSk7XG5cbiAgICAgIHZlcmlmaWVzQWhlYWQgPSB2ZXJpZnlBaGVhZCgpO1xuXG4gICAgICB0ZXJtVW5pZmllcyA9IHZlcmlmaWVzQWhlYWQ7ICAvLy9cbiAgICB9XG5cbiAgICBpZiAodGVybVVuaWZpZXMpIHtcbiAgICAgIGNvbnRleHQuZGVidWcoYC4uLnVuaWZpZWQgdGhlICcke3Rlcm1TdHJpbmd9JyB0ZXJtIHdpdGggdGhlICcke2NvbnN0cnVjdG9yVGVybVN0cmluZ30nIGNvbnN0cnVjdG9yJ3MgdGVybS5gKTtcbiAgICB9XG5cbiAgICByZXR1cm4gdGVybVVuaWZpZXM7XG4gIH1cblxuICB0b0pTT04oKSB7XG4gICAgY29uc3QgdGVybUpTT04gPSB0ZXJtVG9UZXJtSlNPTih0aGlzLnRlcm0pLFxuICAgICAgICAgIHRlcm0gPSB0ZXJtSlNPTiwgIC8vL1xuICAgICAgICAgIGpzb24gPSB7XG4gICAgICAgICAgICB0ZXJtXG4gICAgICAgICAgfTtcblxuICAgIHJldHVybiBqc29uO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIkNvbnN0cnVjdG9yVGVybVwiO1xuXG4gIHN0YXRpYyBmcm9tSlNPTihqc29uLCBjb250ZXh0KSB7XG4gICAgY29uc3QgdGVybSA9IHRlcm1Gcm9tSlNPTihqc29uLCBjb250ZXh0KSxcbiAgICAgICAgICBjb25zdHJ1Y3RvciA9IG5ldyBDb25zdHJ1Y3RvclRlcm0odGVybSk7XG5cbiAgICByZXR1cm4gY29uc3RydWN0b3I7XG4gIH1cblxuICBzdGF0aWMgZnJvbUNvbnN0cnVjdG9yRGVjbGFyYXRpb25Ob2RlKGNvbnN0cnVjdG9yRGVjbGFyYXRpb25Ob2RlLCBjb250ZXh0KSB7XG4gICAgY29uc3QgeyBUZXJtIH0gPSBlbGVtZW50cyxcbiAgICAgICAgICB0ZXJtID0gVGVybS5mcm9tQ29uc3RydWN0b3JEZWNsYXJhdGlvbk5vZGUoY29uc3RydWN0b3JEZWNsYXJhdGlvbk5vZGUsIGNvbnRleHQpLFxuICAgICAgICAgIGNvbnN0cnVjdG9yID0gbmV3IENvbnN0cnVjdG9yVGVybSh0ZXJtKTtcblxuICAgIHJldHVybiBjb25zdHJ1Y3RvcjtcbiAgfVxufSk7XG4iXSwibmFtZXMiOlsiZGVmaW5lIiwiQ29uc3RydWN0b3JUZXJtIiwidGVybSIsImdldFRlcm0iLCJnZXRUeXBlIiwiZ2V0U3RyaW5nIiwiaXNQcm92aXNpb25hbCIsInNldFR5cGUiLCJ0eXBlIiwidW5pZnlUZXJtIiwiY29udGV4dCIsInZlcmlmeUFoZWFkIiwidGVybVVuaWZpZXMiLCJ0ZXJtU3RyaW5nIiwiY29uc3RydWN0b3JUZXJtU3RyaW5nIiwidHJhY2UiLCJjb25zdHJ1Y3RvclRlcm0iLCJ0ZXJtVW5pZmllc1dpdGhDb25zdHJ1Y3RvciIsInVuaWZ5VGVybVdpdGhDb25zdHJ1Y3RvclRlcm0iLCJ2ZXJpZmllc0FoZWFkIiwiZGVidWciLCJ0b0pTT04iLCJ0ZXJtSlNPTiIsInRlcm1Ub1Rlcm1KU09OIiwianNvbiIsImZyb21KU09OIiwidGVybUZyb21KU09OIiwiY29uc3RydWN0b3IiLCJmcm9tQ29uc3RydWN0b3JEZWNsYXJhdGlvbk5vZGUiLCJjb25zdHJ1Y3RvckRlY2xhcmF0aW9uTm9kZSIsIlRlcm0iLCJlbGVtZW50cyIsIm5hbWUiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQVFBOzs7ZUFBQTs7O2dFQU5xQjtxQkFHd0I7b0JBQ0E7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztJQUU3QyxXQUFlQSxJQUFBQSxnQkFBTSxvQ0FBQzthQUFNQyxnQkFDZEMsSUFBSTtnQ0FEVUQ7UUFFeEIsSUFBSSxDQUFDQyxJQUFJLEdBQUdBOzs7O1lBR2RDLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFDRSxPQUFPLElBQUksQ0FBQ0QsSUFBSTtZQUNsQjs7O1lBRUFFLEtBQUFBO21CQUFBQSxTQUFBQTtnQkFBWSxPQUFPLElBQUksQ0FBQ0YsSUFBSSxDQUFDRSxPQUFPO1lBQUk7OztZQUV4Q0MsS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUFjLE9BQU8sSUFBSSxDQUFDSCxJQUFJLENBQUNHLFNBQVM7WUFBSTs7O1lBRTVDQyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQWtCLE9BQU8sSUFBSSxDQUFDSixJQUFJLENBQUNJLGFBQWE7WUFBSTs7O1lBRXBEQyxLQUFBQTttQkFBQUEsU0FBQUEsUUFBUUMsSUFBSTtnQkFBSSxJQUFJLENBQUNOLElBQUksQ0FBQ0ssT0FBTyxDQUFDQztZQUFPOzs7WUFFekNDLEtBQUFBO21CQUFBQSxTQUFBQSxVQUFVUCxJQUFJLEVBQUVRLE9BQU8sRUFBRUMsV0FBVztnQkFDbEMsSUFBSUMsY0FBYztnQkFFbEIsSUFBTUMsYUFBYVgsS0FBS0csU0FBUyxJQUMzQlMsd0JBQXdCLElBQUksQ0FBQ1QsU0FBUztnQkFFNUNLLFFBQVFLLEtBQUssQ0FBQyxBQUFDLGlCQUE4Q0QsT0FBOUJELFlBQVcscUJBQXlDLE9BQXRCQyx1QkFBc0I7Z0JBRW5GLElBQU1FLGtCQUFrQixJQUFJLEVBQ3RCQyw2QkFBNkJDLElBQUFBLG1DQUE0QixFQUFDaEIsTUFBTWMsaUJBQWlCTjtnQkFFdkYsSUFBSU8sNEJBQTRCO29CQUM5QixJQUFJRTtvQkFFSixJQUFNWCxPQUFPLElBQUksQ0FBQ0osT0FBTztvQkFFekJGLEtBQUtLLE9BQU8sQ0FBQ0M7b0JBRWJXLGdCQUFnQlI7b0JBRWhCQyxjQUFjTyxlQUFnQixHQUFHO2dCQUNuQztnQkFFQSxJQUFJUCxhQUFhO29CQUNmRixRQUFRVSxLQUFLLENBQUMsQUFBQyxtQkFBZ0ROLE9BQTlCRCxZQUFXLHFCQUF5QyxPQUF0QkMsdUJBQXNCO2dCQUN2RjtnQkFFQSxPQUFPRjtZQUNUOzs7WUFFQVMsS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLElBQU1DLFdBQVdDLElBQUFBLG9CQUFjLEVBQUMsSUFBSSxDQUFDckIsSUFBSSxHQUNuQ0EsT0FBT29CLFVBQ1BFLE9BQU87b0JBQ0x0QixNQUFBQTtnQkFDRjtnQkFFTixPQUFPc0I7WUFDVDs7OztZQUlPQyxLQUFBQTttQkFBUCxTQUFPQSxTQUFTRCxJQUFJLEVBQUVkLE9BQU87Z0JBQzNCLElBQU1SLE9BQU93QixJQUFBQSxrQkFBWSxFQUFDRixNQUFNZCxVQUMxQmlCLGNBQWMsSUFBSTFCLGdCQUFnQkM7Z0JBRXhDLE9BQU95QjtZQUNUOzs7WUFFT0MsS0FBQUE7bUJBQVAsU0FBT0EsK0JBQStCQywwQkFBMEIsRUFBRW5CLE9BQU87Z0JBQ3ZFLElBQU0sQUFBRW9CLE9BQVNDLGlCQUFRLENBQWpCRCxNQUNGNUIsT0FBTzRCLEtBQUtGLDhCQUE4QixDQUFDQyw0QkFBNEJuQixVQUN2RWlCLGNBQWMsSUFBSTFCLGdCQUFnQkM7Z0JBRXhDLE9BQU95QjtZQUNUOzs7O0tBZkEsbUNBQU9LLFFBQU8ifQ==