occam-verify-cli 1.0.421 → 1.0.428

package/lib/element/step.js

@@ -0,0 +1,274 @@
+"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 = /*#__PURE__*/ _interop_require_default(require("../mixins/step/unify"));
+var _temporary = /*#__PURE__*/ _interop_require_default(require("../context/temporary"));
+var _equate = require("../process/equate");
+var _statement = require("../utilities/statement");
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: 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 _Step;
+var _default = (0, _elements.define)((_Step = /*#__PURE__*/ function() {
+    function Step(context, string, node, statement, reference, satisfiesAssertion) {
+        _class_call_check(this, Step);
+        this.context = context;
+        this.string = string;
+        this.node = node;
+        this.statement = statement;
+        this.reference = reference;
+        this.satisfiesAssertion = satisfiesAssertion;
+    }
+    _create_class(Step, [
+        {
+            key: "getContext",
+            value: function getContext() {
+                return this.context;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "getReference",
+            value: function getReference() {
+                return this.reference;
+            }
+        },
+        {
+            key: "getSatisfiesAssertion",
+            value: function getSatisfiesAssertion() {
+                return this.satisfiesAssertion;
+            }
+        },
+        {
+            key: "isSatisfied",
+            value: function isSatisfied() {
+                var satisfied = this.satisfiesAssertion !== null;
+                return satisfied;
+            }
+        },
+        {
+            key: "isQualified",
+            value: function isQualified() {
+                var qualified = this.reference !== null;
+                return qualified;
+            }
+        },
+        {
+            key: "isStated",
+            value: function isStated() {
+                var qualified = this.isQualified(), stated = qualified; ///
+                return stated;
+            }
+        },
+        {
+            key: "isStep",
+            value: function isStep() {
+                var step = true;
+                return step;
+            }
+        },
+        {
+            key: "matchTermAndPropertyRelation",
+            value: function matchTermAndPropertyRelation(term, propertyRelation, context) {
+                var termAndPropertyRelationMatch = false;
+                var propertyAssertion = (0, _statement.propertyAssertionFromStatement)(this.statement, context);
+                if (propertyAssertion !== null) {
+                    termAndPropertyRelationMatch = propertyAssertion.matchTermAndPropertyRelation(term, propertyRelation, context);
+                }
+                return termAndPropertyRelationMatch;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, assignments, context) {
+                var verifies = false;
+                var temporaryContext = _temporary.default.fromNothing(context);
+                context = temporaryContext; ///
+                var stepString = this.string; ///
+                context.trace("Verifying the '".concat(stepString, "' step..."), this.node);
+                if (this.statement !== null) {
+                    var stated = this.isStated(), statementVerifies = this.statement.verify(assignments, stated, context);
+                    if (statementVerifies) {
+                        var qualified = this.isQualified(), satisfied = this.isSatisfied();
+                        if (false) {
+                        ///
+                        } else if (qualified) {
+                            var referenceVerifies = this.reference.verify(context);
+                            if (referenceVerifies) {
+                                verifies = true;
+                            }
+                        } else if (satisfied) {
+                            var stated1 = true, _$assignments = null, satisfiesAssertionVerifies = this.satisfiesAssertion.verify(_$assignments, stated1, context);
+                            if (satisfiesAssertionVerifies) {
+                                verifies = true;
+                            }
+                        } else {
+                            verifies = true;
+                        }
+                    }
+                } else {
+                    context.debug("Cannot verify the '".concat(stepString, "' step because it is nonsense."), this.node);
+                }
+                if (verifies) {
+                    this.context = context;
+                    context.debug("...verified the '".concat(stepString, "' step."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unify",
+            value: function unify(substitutions, context) {
+                var _this = this;
+                var unifies;
+                context = this.context;
+                var stepString = this.string; ///
+                context.trace("Unifying the '".concat(stepString, "' step..."), this.node);
+                unifies = _unify.default.some(function(unifyMixin) {
+                    var unifies = unifyMixin(_this.statement, _this.reference, _this.satisfiesAssertion, substitutions, context);
+                    if (unifies) {
+                        return true;
+                    }
+                });
+                if (unifies) {
+                    context.debug("...unified the '".concat(stepString, "' step."), this.node);
+                }
+                return unifies;
+            }
+        },
+        {
+            key: "equateWithStatement",
+            value: function equateWithStatement(statement, context) {
+                var statementEquates;
+                var leftStatement = statement, rightStatement = this.statement, leftStatementNode = leftStatement.getNode(), rightStatementNode = rightStatement.getNode(), statementsEquate = (0, _equate.equateStatements)(leftStatementNode, rightStatementNode, context);
+                statementEquates = statementsEquate; ///
+                return statementEquates;
+            }
+        },
+        {
+            key: "unifyWithSatisfiesAssertion",
+            value: function unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
+                var unifiesWithSatisfiesAssertion = false;
+                var stepString = this.string, satisfiesAssertionString = satisfiesAssertion.getString();
+                context.trace("Unifying the '".concat(stepString, "' step with the '").concat(satisfiesAssertionString, "' satisfies assertion..."), this.node);
+                var reference = satisfiesAssertion.getReference(), axiom = context.findAxiomByReference(reference);
+                if (axiom !== null) {
+                    var Substitutions = _elements.default.Substitutions, step = this, substitutions = Substitutions.fromNothing(), stepUnifies = axiom.unifyStep(step, substitutions, context);
+                    if (stepUnifies) {
+                        var substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
+                        if (substitutionsCompare) {
+                            unifiesWithSatisfiesAssertion = true;
+                        }
+                    }
+                }
+                if (unifiesWithSatisfiesAssertion) {
+                    context.debug("...unified the '".concat(stepString, "' step with the '").concat(satisfiesAssertionString, "' satisfies assertion."), this.node);
+                }
+                return unifiesWithSatisfiesAssertion;
+            }
+        }
+    ]);
+    return Step;
+}(), _define_property(_Step, "name", "Step"), _Step));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/step.js"],"sourcesContent":["\"use strict\";\n\nimport elements from \"../elements\";\nimport unifyMixins from \"../mixins/step/unify\";\nimport TemporaryContext from \"../context/temporary\";\n\nimport { define } from \"../elements\";\nimport { equateStatements } from \"../process/equate\";\nimport { propertyAssertionFromStatement } from \"../utilities/statement\";\n\nexport default define(class Step {\n  constructor(context, string, node, statement, reference, satisfiesAssertion) {\n    this.context = context;\n    this.string = string;\n    this.node = node;\n    this.statement = statement;\n    this.reference = reference;\n    this.satisfiesAssertion = satisfiesAssertion;\n  }\n\n  getContext() {\n    return this.context;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  getReference() {\n    return this.reference;\n  }\n\n  getSatisfiesAssertion() {\n    return this.satisfiesAssertion;\n  }\n\n  isSatisfied() {\n    const satisfied = (this.satisfiesAssertion !== null);\n\n    return satisfied;\n  }\n\n  isQualified() {\n    const qualified = (this.reference !== null);\n\n    return qualified;\n  }\n\n  isStated() {\n    const qualified = this.isQualified(),\n          stated = qualified; ///\n\n    return stated;\n  }\n\n  isStep() {\n    const step = true;\n\n    return step;\n  }\n\n  matchTermAndPropertyRelation(term, propertyRelation, context) {\n    let termAndPropertyRelationMatch = false;\n\n    const propertyAssertion = propertyAssertionFromStatement(this.statement, context);\n\n    if (propertyAssertion !== null) {\n      termAndPropertyRelationMatch = propertyAssertion.matchTermAndPropertyRelation(term, propertyRelation, context);\n    }\n\n    return termAndPropertyRelationMatch;\n  }\n\n  verify(substitutions, assignments, context) {\n    let verifies = false;\n\n    const temporaryContext = TemporaryContext.fromNothing(context);\n\n    context = temporaryContext; ///\n\n    const stepString = this.string; ///\n\n    context.trace(`Verifying the '${stepString}' step...`, this.node);\n\n    if (this.statement !== null) {\n      const stated = this.isStated(),\n            statementVerifies = this.statement.verify(assignments, stated, context);\n\n      if (statementVerifies) {\n        const qualified = this.isQualified(),\n              satisfied = this.isSatisfied();\n\n        if (false) {\n          ///\n        } else if (qualified) {\n          const referenceVerifies = this.reference.verify(context);\n\n          if (referenceVerifies) {\n            verifies = true;\n          }\n        } else if (satisfied) {\n          const stated = true,\n                assignments = null,\n                satisfiesAssertionVerifies = this.satisfiesAssertion.verify(assignments, stated, context);\n\n          if (satisfiesAssertionVerifies) {\n            verifies = true;\n          }\n        } else {\n          verifies = true;\n        }\n      }\n    } else {\n      context.debug(`Cannot verify the '${stepString}' step because it is nonsense.`, this.node);\n    }\n\n    if (verifies) {\n      this.context = context;\n\n      context.debug(`...verified the '${stepString}' step.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  unify(substitutions, context) {\n    let unifies;\n\n    context = this.context;\n\n    const stepString = this.string;  ///\n\n    context.trace(`Unifying the '${stepString}' step...`, this.node);\n\n    unifies = unifyMixins.some((unifyMixin) => {\n      const unifies = unifyMixin(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);\n\n      if (unifies) {\n        return true;\n      }\n    });\n\n    if (unifies) {\n      context.debug(`...unified the '${stepString}' step.`, this.node);\n    }\n\n    return unifies;\n  }\n\n  equateWithStatement(statement, context) {\n    let statementEquates;\n\n    const leftStatement = statement,  ///\n          rightStatement = this.statement,  ///\n          leftStatementNode = leftStatement.getNode(),\n          rightStatementNode = rightStatement.getNode(),\n          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);\n\n    statementEquates = statementsEquate;  ///\n\n    return statementEquates;\n  }\n\n  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {\n    let unifiesWithSatisfiesAssertion = false;\n\n    const stepString = this.string, ///\n          satisfiesAssertionString = satisfiesAssertion.getString();\n\n    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`, this.node);\n\n    const reference = satisfiesAssertion.getReference(),\n          axiom = context.findAxiomByReference(reference);\n\n    if (axiom !== null) {\n      const { Substitutions } = elements,\n            step = this,  ///\n            substitutions = Substitutions.fromNothing(),\n            stepUnifies = axiom.unifyStep(step, substitutions, context);\n\n      if (stepUnifies) {\n        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);\n\n        if (substitutionsCompare) {\n          unifiesWithSatisfiesAssertion = true;\n        }\n      }\n    }\n\n    if (unifiesWithSatisfiesAssertion) {\n      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`, this.node);\n    }\n\n    return unifiesWithSatisfiesAssertion;\n  }\n\n  static name = \"Step\";\n});\n"],"names":["define","Step","context","string","node","statement","reference","satisfiesAssertion","getContext","getString","getNode","getStatement","getReference","getSatisfiesAssertion","isSatisfied","satisfied","isQualified","qualified","isStated","stated","isStep","step","matchTermAndPropertyRelation","term","propertyRelation","termAndPropertyRelationMatch","propertyAssertion","propertyAssertionFromStatement","verify","substitutions","assignments","verifies","temporaryContext","TemporaryContext","fromNothing","stepString","trace","statementVerifies","referenceVerifies","satisfiesAssertionVerifies","debug","unify","unifies","unifyMixins","some","unifyMixin","equateWithStatement","statementEquates","leftStatement","rightStatement","leftStatementNode","rightStatementNode","statementsEquate","equateStatements","unifyWithSatisfiesAssertion","unifiesWithSatisfiesAssertion","satisfiesAssertionString","axiom","findAxiomByReference","Substitutions","elements","stepUnifies","unifyStep","substitutionsCompare","compareSubstitutions","name"],"mappings":"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"}

package/lib/element/subDerivation.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _necessary = require("necessary");
+var _elements = /*#__PURE__*/ _interop_require_wildcard(require("../elements"));
+var _assign = /*#__PURE__*/ _interop_require_default(require("../process/assign"));
+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 _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: 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 _SubDerivation;
+var last = _necessary.arrayUtilities.last;
+var _default = (0, _elements.define)((_SubDerivation = /*#__PURE__*/ function() {
+    function SubDerivation(stepsOrSubproofs) {
+        _class_call_check(this, SubDerivation);
+        this.stepsOrSubproofs = stepsOrSubproofs;
+    }
+    _create_class(SubDerivation, [
+        {
+            key: "getStepsOrSubproofs",
+            value: function getStepsOrSubproofs() {
+                return this.stepsOrSubproofs;
+            }
+        },
+        {
+            key: "getLastStep",
+            value: function getLastStep() {
+                var lastStepOrSubproof = last(this.stepsOrSubproofs), lastStep = lastStepOrSubproof; ///
+                return lastStep;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(substitutions, context) {
+                var verifies;
+                verifies = this.stepsOrSubproofs.every(function(stepOrSubproof) {
+                    var assignments = [], stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
+                    if (stepOrSubproofVerifies) {
+                        var stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+                        if (stepOrSubproofUnifies) {
+                            var assignmentsAssigned = (0, _assign.default)(assignments, context);
+                            if (assignmentsAssigned) {
+                                context.addStepOrSubproof(stepOrSubproof);
+                                return true;
+                            }
+                        }
+                    }
+                });
+                return verifies;
+            }
+        }
+    ]);
+    return SubDerivation;
+}(), _define_property(_SubDerivation, "name", "SubDerivation"), _SubDerivation));
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbGVtZW50L3N1YkRlcml2YXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IGFycmF5VXRpbGl0aWVzIH0gZnJvbSBcIm5lY2Vzc2FyeVwiO1xuXG5pbXBvcnQgZWxlbWVudHMgZnJvbSBcIi4uL2VsZW1lbnRzXCI7XG5pbXBvcnQgYXNzaWduQXNzaWdubWVudHMgZnJvbSBcIi4uL3Byb2Nlc3MvYXNzaWduXCI7XG5cbmltcG9ydCB7IGRlZmluZSB9IGZyb20gXCIuLi9lbGVtZW50c1wiO1xuXG5jb25zdCB7IGxhc3QgfSA9IGFycmF5VXRpbGl0aWVzO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmUoY2xhc3MgU3ViRGVyaXZhdGlvbiB7XG4gIGNvbnN0cnVjdG9yKHN0ZXBzT3JTdWJwcm9vZnMpIHtcbiAgICB0aGlzLnN0ZXBzT3JTdWJwcm9vZnMgPSBzdGVwc09yU3VicHJvb2ZzO1xuICB9XG5cbiAgZ2V0U3RlcHNPclN1YnByb29mcygpIHtcbiAgICByZXR1cm4gdGhpcy5zdGVwc09yU3VicHJvb2ZzO1xuICB9XG5cbiAgZ2V0TGFzdFN0ZXAoKSB7XG4gICAgY29uc3QgbGFzdFN0ZXBPclN1YnByb29mID0gbGFzdCh0aGlzLnN0ZXBzT3JTdWJwcm9vZnMpLFxuICAgICAgICAgIGxhc3RTdGVwID0gbGFzdFN0ZXBPclN1YnByb29mOyAgLy8vXG5cbiAgICByZXR1cm4gbGFzdFN0ZXA7XG4gIH1cblxuICB2ZXJpZnkoc3Vic3RpdHV0aW9ucywgY29udGV4dCkge1xuICAgIGxldCB2ZXJpZmllcztcblxuICAgIHZlcmlmaWVzID0gdGhpcy5zdGVwc09yU3VicHJvb2ZzLmV2ZXJ5KChzdGVwT3JTdWJwcm9vZikgPT4geyAvLy9cbiAgICAgIGNvbnN0IGFzc2lnbm1lbnRzID0gW10sXG4gICAgICAgICAgICBzdGVwT3JTdWJwcm9vZlZlcmlmaWVzID0gc3RlcE9yU3VicHJvb2YudmVyaWZ5KHN1YnN0aXR1dGlvbnMsIGFzc2lnbm1lbnRzLCBjb250ZXh0KTtcblxuICAgICAgaWYgKHN0ZXBPclN1YnByb29mVmVyaWZpZXMpIHtcbiAgICAgICAgY29uc3Qgc3RlcE9yU3VicHJvb2ZVbmlmaWVzID0gc3RlcE9yU3VicHJvb2YudW5pZnkoc3Vic3RpdHV0aW9ucywgY29udGV4dCk7XG5cbiAgICAgICAgaWYgKHN0ZXBPclN1YnByb29mVW5pZmllcykge1xuICAgICAgICAgIGNvbnN0IGFzc2lnbm1lbnRzQXNzaWduZWQgPSBhc3NpZ25Bc3NpZ25tZW50cyhhc3NpZ25tZW50cywgY29udGV4dCk7XG5cbiAgICAgICAgICBpZiAoYXNzaWdubWVudHNBc3NpZ25lZCkge1xuICAgICAgICAgICAgY29udGV4dC5hZGRTdGVwT3JTdWJwcm9vZihzdGVwT3JTdWJwcm9vZik7XG5cbiAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfVxuICAgIH0pO1xuXG4gICAgcmV0dXJuIHZlcmlmaWVzO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIlN1YkRlcml2YXRpb25cIjtcbn0pO1xuIl0sIm5hbWVzIjpbImxhc3QiLCJhcnJheVV0aWxpdGllcyIsImRlZmluZSIsIlN1YkRlcml2YXRpb24iLCJzdGVwc09yU3VicHJvb2ZzIiwiZ2V0U3RlcHNPclN1YnByb29mcyIsImdldExhc3RTdGVwIiwibGFzdFN0ZXBPclN1YnByb29mIiwibGFzdFN0ZXAiLCJ2ZXJpZnkiLCJzdWJzdGl0dXRpb25zIiwiY29udGV4dCIsInZlcmlmaWVzIiwiZXZlcnkiLCJzdGVwT3JTdWJwcm9vZiIsImFzc2lnbm1lbnRzIiwic3RlcE9yU3VicHJvb2ZWZXJpZmllcyIsInN0ZXBPclN1YnByb29mVW5pZmllcyIsInVuaWZ5IiwiYXNzaWdubWVudHNBc3NpZ25lZCIsImFzc2lnbkFzc2lnbm1lbnRzIiwiYWRkU3RlcE9yU3VicHJvb2YiLCJuYW1lIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFXQTs7O2VBQUE7Ozt5QkFUK0I7Z0VBRVY7NkRBQ1M7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBSTlCLElBQU0sQUFBRUEsT0FBU0MseUJBQWMsQ0FBdkJEO0lBRVIsV0FBZUUsSUFBQUEsZ0JBQU0sa0NBQUM7YUFBTUMsY0FDZEMsZ0JBQWdCO2dDQURGRDtRQUV4QixJQUFJLENBQUNDLGdCQUFnQixHQUFHQTs7OztZQUcxQkMsS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLE9BQU8sSUFBSSxDQUFDRCxnQkFBZ0I7WUFDOUI7OztZQUVBRSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsSUFBTUMscUJBQXFCUCxLQUFLLElBQUksQ0FBQ0ksZ0JBQWdCLEdBQy9DSSxXQUFXRCxvQkFBcUIsR0FBRztnQkFFekMsT0FBT0M7WUFDVDs7O1lBRUFDLEtBQUFBO21CQUFBQSxTQUFBQSxPQUFPQyxhQUFhLEVBQUVDLE9BQU87Z0JBQzNCLElBQUlDO2dCQUVKQSxXQUFXLElBQUksQ0FBQ1IsZ0JBQWdCLENBQUNTLEtBQUssQ0FBQyxTQUFDQztvQkFDdEMsSUFBTUMsY0FBYyxFQUFFLEVBQ2hCQyx5QkFBeUJGLGVBQWVMLE1BQU0sQ0FBQ0MsZUFBZUssYUFBYUo7b0JBRWpGLElBQUlLLHdCQUF3Qjt3QkFDMUIsSUFBTUMsd0JBQXdCSCxlQUFlSSxLQUFLLENBQUNSLGVBQWVDO3dCQUVsRSxJQUFJTSx1QkFBdUI7NEJBQ3pCLElBQU1FLHNCQUFzQkMsSUFBQUEsZUFBaUIsRUFBQ0wsYUFBYUo7NEJBRTNELElBQUlRLHFCQUFxQjtnQ0FDdkJSLFFBQVFVLGlCQUFpQixDQUFDUDtnQ0FFMUIsT0FBTzs0QkFDVDt3QkFDRjtvQkFDRjtnQkFDRjtnQkFFQSxPQUFPRjtZQUNUOzs7O0tBRUEsaUNBQU9VLFFBQU8ifQ==