occam-verify-cli 1.0.448 → 1.0.472

package/lib/element/proof.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 var _element = /*#__PURE__*/ _interop_require_default(require("../element"));
-var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+var _context = require("../utilities/context");
 var _elements = require("../elements");
 function _assert_this_initialized(self) {
     if (self === void 0) {
@@ -184,20 +184,21 @@ var _default = (0, _elements.define)((_Proof = /*#__PURE__*/ function(Element) {
         },
         {
             key: "verify",
-            value: function verify(substitutions, conclusion, context) {
+            value: function verify(conclusion, context) {
+                var _this = this;
                 var verifies = false;
-                var localContext = _local.default.fromNothing(context); ///
-                context = localContext; ///
-                var derivationVerifies = this.derivation.verify(substitutions, context);
-                if (derivationVerifies) {
-                    var lastProofAssertion = context.getLastProofAssertion();
-                    if (lastProofAssertion !== null) {
-                        var statement = this.getStatement(), conclusionStatement = conclusion.getStatement(), conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
-                        if (conclusionStatementEqualToStatement) {
-                            verifies = true;
+                (0, _context.scope)(function(context) {
+                    var derivationVerifies = _this.derivation.verify(context);
+                    if (derivationVerifies) {
+                        var lastProofAssertion = context.getLastProofAssertion();
+                        if (lastProofAssertion !== null) {
+                            var statement = _this.getStatement(), conclusionStatement = conclusion.getStatement(), conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);
+                            if (conclusionStatementEqualToStatement) {
+                                verifies = true;
+                            }
                         }
                     }
-                }
+                }, context);
                 return verifies;
             }
         }
@@ -205,4 +206,4 @@ var _default = (0, _elements.define)((_Proof = /*#__PURE__*/ function(Element) {
     return Proof;
 }(_wrap_native_super(_element.default)), _define_property(_Proof, "name", "Proof"), _Proof));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/element/proofAssertion/premise.js

@@ -0,0 +1,319 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _proofAssertion = /*#__PURE__*/ _interop_require_default(require("../proofAssertion"));
+var _assign = /*#__PURE__*/ _interop_require_default(require("../../process/assign"));
+var _elements = require("../../elements");
+var _context = require("../../utilities/context");
+var _json = require("../../utilities/json");
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+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 _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+var _Premise;
+var _default = (0, _elements.define)((_Premise = /*#__PURE__*/ function(ProofAssertion) {
+    _inherits(Premise, ProofAssertion);
+    function Premise(context, string, node, statement, procedureCall) {
+        _class_call_check(this, Premise);
+        var _this;
+        _this = _call_super(this, Premise, [
+            context,
+            string,
+            node,
+            statement
+        ]);
+        _this.procedureCall = procedureCall;
+        return _this;
+    }
+    _create_class(Premise, [
+        {
+            key: "getProcedureCall",
+            value: function getProcedureCall() {
+                return this.procedureCall;
+            }
+        },
+        {
+            key: "isStated",
+            value: function isStated() {
+                var stated = true; ///
+                return stated;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var _this = this;
+                var verifies = false;
+                var node = this.getNode(), premiseString = this.getString(); ///
+                context.trace("Verifying the '".concat(premiseString, "' premise..."), node);
+                var statement = this.getStatement(), procedureCall = this.getProcedureCall();
+                if (statement !== null || procedureCall !== null) {
+                    (0, _context.attempt)(function(context) {
+                        if (statement !== null) {
+                            var assignments = [], statementValidates = _this.validateStatement(assignments, context);
+                            if (statementValidates) {
+                                var assignmentsAssigned = (0, _assign.default)(assignments, context);
+                                if (assignmentsAssigned) {
+                                    var subproofOrProofAssertion = _this; ///
+                                    context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+                                    _this.setContext(context);
+                                    verifies = true;
+                                }
+                            }
+                        }
+                        if (procedureCall !== null) {
+                            var procedureCallValidates = procedureCall.validate(context);
+                            if (procedureCallValidates) {
+                                _this.setContext(context);
+                                verifies = true;
+                            }
+                        }
+                    }, context);
+                } else {
+                    context.debug("Unable to verify the '".concat(premiseString, "' premise because it is nonsense."), node);
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(premiseString, "' premise."), node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently = false;
+                var premiseString = this.getString(); ///
+                context.trace("Unifying the '".concat(premiseString, "' premise independently..."));
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var statement = this.getStatement();
+                if (statement !== null) {
+                    var statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
+                    if (statementUnifiesIndependently) {
+                        unifiesIndependently = true;
+                    }
+                }
+                if (this.procedureCall !== null) {
+                    var procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+                    if (procedureCallResolvedIndependently) {
+                        unifiesIndependently = true;
+                    }
+                }
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(premiseString, "' premise independenly."));
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "unifySubproofOrProofAssertion",
+            value: function unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {
+                var subproofOrProofAssertionUnifies = false;
+                var subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(), proofAssertion = subproofOrProofAssertionProofAssertion ? subproofOrProofAssertion : null, subproof = subproofOrProofAssertionProofAssertion ? null : subproofOrProofAssertion;
+                substitutions.snapshot(context);
+                if (subproof !== null) {
+                    var subproofUnifies = this.unifySubproof(subproof, substitutions, context);
+                    if (subproofUnifies) {
+                        subproofOrProofAssertionUnifies = true;
+                    }
+                }
+                if (proofAssertion !== null) {
+                    var proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
+                    if (proofAssertionUnifies) {
+                        subproofOrProofAssertionUnifies = true;
+                    }
+                }
+                if (subproofOrProofAssertionUnifies) {
+                    substitutions.resolve(context);
+                }
+                subproofOrProofAssertionUnifies ? substitutions.continue(context) : substitutions.rollback(context);
+                return subproofOrProofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifyProofAssertion",
+            value: function unifyProofAssertion(proofAssertion, substitutions, context) {
+                var _this = this;
+                var proofAssertionUnifies = false;
+                var premiseString = this.getString(), proofAssertionString = proofAssertion.getString();
+                context.trace("Unifying the '".concat(proofAssertionString, "' proof assertion with the '").concat(premiseString, "' premise..."));
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var proofAssertionContext = proofAssertion.getContext(), statementUnifies = (0, _context.synthetically)(function(specificContext) {
+                    var statement = proofAssertion.getStatement(), statementUnifies = _this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                    return statementUnifies;
+                }, specificContext, proofAssertionContext);
+                if (statementUnifies) {
+                    proofAssertionUnifies = true;
+                }
+                if (proofAssertionUnifies) {
+                    context.debug("...unified the '".concat(proofAssertionString, "' proof assertion with the '").concat(premiseString, "' premise."));
+                }
+                return proofAssertionUnifies;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, context) {
+                var subproofUnifies = false;
+                var node = this.getNode(), premiseString = this.getString(), subproofString = subproof.getString();
+                context.trace("Unifying the '".concat(subproofString, "' subproof with the '").concat(premiseString, "' premise..."), node);
+                var specificContext = context; ///
+                context = this.getContext();
+                var generalContext = context; ///
+                context = specificContext; ///
+                var statement = this.getStatement();
+                if (statement !== null) {
+                    var statementNode = statement.getNode(), subproofAssertionNode = statementNode.getSubproofAssertionNode();
+                    if (subproofAssertionNode !== null) {
+                        var _$context = generalContext, assertionNode = subproofAssertionNode, assertion = _$context.findAssertionByAssertionNode(assertionNode);
+                        if (assertion !== null) {
+                            var subproofAssertion = assertion; ///
+                            subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                        }
+                    }
+                }
+                if (subproofUnifies) {
+                    context.debug("...unified the '".concat(subproofString, "' subproof with the '").concat(premiseString, "' premise."), node);
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var frames, terms;
+                frames = this.context.getFrames();
+                terms = this.context.getTerms();
+                var procedureCallJSON = (0, _json.procedureCallToProcedureCallJSON)(this.procedureCall), statementJSON = (0, _json.statementToStatementJSON)(this.statement), framesJSON = (0, _json.framesToFramesJSON)(frames), termsJSON = (0, _json.termsToTermsJSON)(terms);
+                frames = framesJSON; ///
+                terms = termsJSON; ///
+                var procedureCall = procedureCallJSON, statement = statementJSON, json = {
+                    procedureCall: procedureCall,
+                    statement: statement,
+                    frames: frames,
+                    terms: terms
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var terms = (0, _json.termsFromJSON)(json, context), frames = (0, _json.framesFromJSON)(json, context), statement = (0, _json.statementFromJSON)(json, context), procedureCall = (0, _json.procedureCallFromJSON)(json, context);
+                var string;
+                if (statement !== null) {
+                    string = statement.getString();
+                }
+                if (procedureCall !== null) {
+                    string = procedureCall.getString();
+                }
+                var node = null;
+                var premise = new Premise(context, string, node, statement, procedureCall);
+                return premise;
+            }
+        }
+    ]);
+    return Premise;
+}(_proofAssertion.default), _define_property(_Premise, "name", "Premise"), _Premise));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/proofAssertion/premise.js"],"sourcesContent":["\"use strict\";\n\nimport ProofAssertion from \"../proofAssertion\";\nimport assignAssignments from \"../../process/assign\";\n\nimport { define } from \"../../elements\";\nimport { attempt, synthetically } from \"../../utilities/context\";\nimport { termsFromJSON,\n         framesFromJSON,\n         termsToTermsJSON,\n         statementFromJSON,\n         framesToFramesJSON,\n         procedureCallFromJSON,\n         statementToStatementJSON,\n         procedureCallToProcedureCallJSON } from \"../../utilities/json\";\n\nexport default define(class Premise extends ProofAssertion {\n  constructor(context, string, node, statement, procedureCall) {\n    super(context, string, node, statement);\n\n    this.procedureCall = procedureCall;\n  }\n\n  getProcedureCall() {\n    return this.procedureCall;\n  }\n\n  isStated() {\n    const stated = true; ///\n\n    return stated;\n  }\n\n  verify(context) {\n    let verifies = false;\n\n    const node = this.getNode(),\n          premiseString = this.getString(); ///\n\n    context.trace(`Verifying the '${premiseString}' premise...`, node);\n\n    const statement = this.getStatement(),\n          procedureCall = this.getProcedureCall();\n\n    if ((statement !== null) || (procedureCall !== null)) {\n      attempt((context) => {\n        if (statement !== null) {\n          const assignments = [],\n                statementValidates = this.validateStatement(assignments, context);\n\n          if (statementValidates) {\n            const assignmentsAssigned = assignAssignments(assignments, context);\n\n            if (assignmentsAssigned) {\n              const subproofOrProofAssertion = this;  ///\n\n              context.addSubproofOrProofAssertion(subproofOrProofAssertion);\n\n              this.setContext(context);\n\n              verifies = true;\n            }\n          }\n        }\n\n        if (procedureCall !== null) {\n          const procedureCallValidates = procedureCall.validate(context);\n\n          if (procedureCallValidates) {\n            this.setContext(context);\n\n            verifies = true;\n          }\n        }\n      }, context);\n    } else {\n      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${premiseString}' premise.`, node);\n    }\n\n    return verifies;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently = false;\n\n    const premiseString = this.getString(); ///\n\n    context.trace(`Unifying the '${premiseString}' premise independently...`);\n\n    const specificContext = context; ///\n\n    context = this.getContext();\n\n    const generalContext = context;  ///\n\n    context = specificContext;  ///\n\n    const statement = this.getStatement();\n\n    if (statement !== null) {\n      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);\n\n      if (statementUnifiesIndependently) {\n        unifiesIndependently = true;\n      }\n    }\n\n    if (this.procedureCall !== null) {\n      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);\n\n      if (procedureCallResolvedIndependently) {\n        unifiesIndependently = true;\n      }\n    }\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${premiseString}' premise independenly.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {\n    let subproofOrProofAssertionUnifies = false;\n\n    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),\n          proofAssertion = subproofOrProofAssertionProofAssertion ?\n                             subproofOrProofAssertion :\n                               null,\n          subproof = subproofOrProofAssertionProofAssertion ?\n                        null :\n                          subproofOrProofAssertion;\n\n    substitutions.snapshot(context);\n\n    if (subproof !== null) {\n      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);\n\n      if (subproofUnifies) {\n        subproofOrProofAssertionUnifies = true;\n      }\n    }\n\n    if (proofAssertion !== null) {\n      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);\n\n      if (proofAssertionUnifies) {\n        subproofOrProofAssertionUnifies = true;\n      }\n    }\n\n    if (subproofOrProofAssertionUnifies) {\n      substitutions.resolve(context);\n    }\n\n    subproofOrProofAssertionUnifies ?\n      substitutions.continue(context) :\n        substitutions.rollback(context);\n\n    return subproofOrProofAssertionUnifies;\n  }\n\n  unifyProofAssertion(proofAssertion, substitutions, context) {\n    let proofAssertionUnifies = false;\n\n    const premiseString = this.getString(), ///\n          proofAssertionString = proofAssertion.getString();\n\n    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);\n\n    const specificContext = context;  ///\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = specificContext;  ///\n\n    const proofAssertionContext = proofAssertion.getContext(),\n          statementUnifies = synthetically((specificContext) => {\n            const statement = proofAssertion.getStatement(),\n                  statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n            return statementUnifies;\n          }, specificContext, proofAssertionContext);\n\n    if (statementUnifies) {\n      proofAssertionUnifies = true;\n    }\n\n    if (proofAssertionUnifies) {\n      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);\n    }\n\n    return proofAssertionUnifies;\n  }\n\n  unifySubproof(subproof, substitutions, context) {\n    let subproofUnifies = false;\n\n    const node = this.getNode(),\n          premiseString = this.getString(),\n          subproofString = subproof.getString();\n\n    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, node);\n\n    const specificContext = context;  ///\n\n    context = this.getContext();\n\n    const generalContext = context; ///\n\n    context = specificContext;  ///\n\n    const statement = this.getStatement();\n\n    if (statement !== null) {\n      const statementNode = statement.getNode(),\n            subproofAssertionNode = statementNode.getSubproofAssertionNode();\n\n      if (subproofAssertionNode !== null) {\n        const context = generalContext, ///\n              assertionNode = subproofAssertionNode,  ///\n              assertion = context.findAssertionByAssertionNode(assertionNode)\n\n        if (assertion !== null) {\n          const subproofAssertion = assertion;  ///\n\n          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);\n        }\n      }\n    }\n\n    if (subproofUnifies) {\n      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`, node);\n    }\n\n    return subproofUnifies;\n  }\n\n  toJSON() {\n    let frames,\n        terms;\n\n    frames = this.context.getFrames();\n\n    terms = this.context.getTerms();\n\n    const procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),\n          statementJSON = statementToStatementJSON(this.statement),\n          framesJSON = framesToFramesJSON(frames),\n          termsJSON = termsToTermsJSON(terms);\n\n    frames = framesJSON;  ///\n\n    terms = termsJSON;  ///\n\n    const procedureCall = procedureCallJSON,  ///\n          statement = statementJSON,  ///\n          json = {\n            procedureCall,\n            statement,\n            frames,\n            terms\n          };\n\n    return json;\n  }\n\n  static name = \"Premise\";\n\n  static fromJSON(json, context) {\n    const terms = termsFromJSON(json, context),\n          frames = framesFromJSON(json, context),\n          statement = statementFromJSON(json, context),\n          procedureCall = procedureCallFromJSON(json, context);\n\n    let string;\n\n    if (statement !== null) {\n      string = statement.getString();\n    }\n\n    if (procedureCall !== null) {\n      string = procedureCall.getString();\n    }\n\n    const node = null;\n\n    const premise = new Premise(context, string, node, statement, procedureCall);\n\n    return premise;\n  }\n});\n"],"names":["define","Premise","context","string","node","statement","procedureCall","getProcedureCall","isStated","stated","verify","verifies","getNode","premiseString","getString","trace","getStatement","attempt","assignments","statementValidates","validateStatement","assignmentsAssigned","assignAssignments","subproofOrProofAssertion","addSubproofOrProofAssertion","setContext","procedureCallValidates","validate","debug","unifyIndependently","substitutions","unifiesIndependently","specificContext","getContext","generalContext","statementUnifiesIndependently","procedureCallResolvedIndependently","unifySubproofOrProofAssertion","subproofOrProofAssertionUnifies","subproofOrProofAssertionProofAssertion","isProofAssertion","proofAssertion","subproof","snapshot","subproofUnifies","unifySubproof","proofAssertionUnifies","unifyProofAssertion","resolve","continue","rollback","proofAssertionString","proofAssertionContext","statementUnifies","synthetically","unifyStatement","subproofString","statementNode","subproofAssertionNode","getSubproofAssertionNode","assertionNode","assertion","findAssertionByAssertionNode","subproofAssertion","toJSON","frames","terms","getFrames","getTerms","procedureCallJSON","procedureCallToProcedureCallJSON","statementJSON","statementToStatementJSON","framesJSON","framesToFramesJSON","termsJSON","termsToTermsJSON","json","fromJSON","termsFromJSON","framesFromJSON","statementFromJSON","procedureCallFromJSON","premise","ProofAssertion","name"],"mappings":"AAAA;;;;+BAgBA;;;eAAA;;;qEAd2B;6DACG;wBAEP;uBACgB;oBAQU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEjD,WAAeA,IAAAA,gBAAM,4BAAC;;aAAMC,QACdC,OAAO,EAAEC,MAAM,EAAEC,IAAI,EAAEC,SAAS,EAAEC,aAAa;gCADjCL;;gBAExB,kBAFwBA;YAElBC;YAASC;YAAQC;YAAMC;;QAE7B,MAAKC,aAAa,GAAGA;;;;;YAGvBC,KAAAA;mBAAAA,SAAAA;gBACE,OAAO,IAAI,CAACD,aAAa;YAC3B;;;YAEAE,KAAAA;mBAAAA,SAAAA;gBACE,IAAMC,SAAS,MAAM,GAAG;gBAExB,OAAOA;YACT;;;YAEAC,KAAAA;mBAAAA,SAAAA,OAAOR,OAAO;;gBACZ,IAAIS,WAAW;gBAEf,IAAMP,OAAO,IAAI,CAACQ,OAAO,IACnBC,gBAAgB,IAAI,CAACC,SAAS,IAAI,GAAG;gBAE3CZ,QAAQa,KAAK,CAAC,AAAC,kBAA+B,OAAdF,eAAc,iBAAeT;gBAE7D,IAAMC,YAAY,IAAI,CAACW,YAAY,IAC7BV,gBAAgB,IAAI,CAACC,gBAAgB;gBAE3C,IAAI,AAACF,cAAc,QAAUC,kBAAkB,MAAO;oBACpDW,IAAAA,gBAAO,EAAC,SAACf;wBACP,IAAIG,cAAc,MAAM;4BACtB,IAAMa,cAAc,EAAE,EAChBC,qBAAqB,MAAKC,iBAAiB,CAACF,aAAahB;4BAE/D,IAAIiB,oBAAoB;gCACtB,IAAME,sBAAsBC,IAAAA,eAAiB,EAACJ,aAAahB;gCAE3D,IAAImB,qBAAqB;oCACvB,IAAME,kCAAkC,GAAG;oCAE3CrB,QAAQsB,2BAA2B,CAACD;oCAEpC,MAAKE,UAAU,CAACvB;oCAEhBS,WAAW;gCACb;4BACF;wBACF;wBAEA,IAAIL,kBAAkB,MAAM;4BAC1B,IAAMoB,yBAAyBpB,cAAcqB,QAAQ,CAACzB;4BAEtD,IAAIwB,wBAAwB;gCAC1B,MAAKD,UAAU,CAACvB;gCAEhBS,WAAW;4BACb;wBACF;oBACF,GAAGT;gBACL,OAAO;oBACLA,QAAQ0B,KAAK,CAAC,AAAC,yBAAsC,OAAdf,eAAc,sCAAoCT;gBAC3F;gBAEA,IAAIO,UAAU;oBACZT,QAAQ0B,KAAK,CAAC,AAAC,oBAAiC,OAAdf,eAAc,eAAaT;gBAC/D;gBAEA,OAAOO;YACT;;;YAEAkB,KAAAA;mBAAAA,SAAAA,mBAAmBC,aAAa,EAAE5B,OAAO;gBACvC,IAAI6B,uBAAuB;gBAE3B,IAAMlB,gBAAgB,IAAI,CAACC,SAAS,IAAI,GAAG;gBAE3CZ,QAAQa,KAAK,CAAC,AAAC,iBAA8B,OAAdF,eAAc;gBAE7C,IAAMmB,kBAAkB9B,SAAS,GAAG;gBAEpCA,UAAU,IAAI,CAAC+B,UAAU;gBAEzB,IAAMC,iBAAiBhC,SAAU,GAAG;gBAEpCA,UAAU8B,iBAAkB,GAAG;gBAE/B,IAAM3B,YAAY,IAAI,CAACW,YAAY;gBAEnC,IAAIX,cAAc,MAAM;oBACtB,IAAM8B,gCAAgC9B,UAAUwB,kBAAkB,CAACC,eAAeI,gBAAgBF;oBAElG,IAAIG,+BAA+B;wBACjCJ,uBAAuB;oBACzB;gBACF;gBAEA,IAAI,IAAI,CAACzB,aAAa,KAAK,MAAM;oBAC/B,IAAM8B,qCAAqC,IAAI,CAAC9B,aAAa,CAACuB,kBAAkB,CAACC,eAAe5B;oBAEhG,IAAIkC,oCAAoC;wBACtCL,uBAAuB;oBACzB;gBACF;gBAEA,IAAIA,sBAAsB;oBACxB7B,QAAQ0B,KAAK,CAAC,AAAC,mBAAgC,OAAdf,eAAc;gBACjD;gBAEA,OAAOkB;YACT;;;YAEAM,KAAAA;mBAAAA,SAAAA,8BAA8Bd,wBAAwB,EAAEO,aAAa,EAAE5B,OAAO;gBAC5E,IAAIoC,kCAAkC;gBAEtC,IAAMC,yCAAyChB,yBAAyBiB,gBAAgB,IAClFC,iBAAiBF,yCACEhB,2BACE,MACrBmB,WAAWH,yCACG,OACEhB;gBAEtBO,cAAca,QAAQ,CAACzC;gBAEvB,IAAIwC,aAAa,MAAM;oBACrB,IAAME,kBAAkB,IAAI,CAACC,aAAa,CAACH,UAAUZ,eAAe5B;oBAEpE,IAAI0C,iBAAiB;wBACnBN,kCAAkC;oBACpC;gBACF;gBAEA,IAAIG,mBAAmB,MAAM;oBAC3B,IAAMK,wBAAwB,IAAI,CAACC,mBAAmB,CAACN,gBAAgBX,eAAe5B;oBAEtF,IAAI4C,uBAAuB;wBACzBR,kCAAkC;oBACpC;gBACF;gBAEA,IAAIA,iCAAiC;oBACnCR,cAAckB,OAAO,CAAC9C;gBACxB;gBAEAoC,kCACER,cAAcmB,QAAQ,CAAC/C,WACrB4B,cAAcoB,QAAQ,CAAChD;gBAE3B,OAAOoC;YACT;;;YAEAS,KAAAA;mBAAAA,SAAAA,oBAAoBN,cAAc,EAAEX,aAAa,EAAE5B,OAAO;;gBACxD,IAAI4C,wBAAwB;gBAE5B,IAAMjC,gBAAgB,IAAI,CAACC,SAAS,IAC9BqC,uBAAuBV,eAAe3B,SAAS;gBAErDZ,QAAQa,KAAK,CAAC,AAAC,iBAAmEF,OAAnDsC,sBAAqB,gCAA4C,OAAdtC,eAAc;gBAEhG,IAAMmB,kBAAkB9B,SAAU,GAAG;gBAErCA,UAAU,IAAI,CAAC+B,UAAU;gBAEzB,IAAMC,iBAAiBhC,SAAS,GAAG;gBAEnCA,UAAU8B,iBAAkB,GAAG;gBAE/B,IAAMoB,wBAAwBX,eAAeR,UAAU,IACjDoB,mBAAmBC,IAAAA,sBAAa,EAAC,SAACtB;oBAChC,IAAM3B,YAAYoC,eAAezB,YAAY,IACvCqC,mBAAmB,MAAKE,cAAc,CAAClD,WAAWyB,eAAeI,gBAAgBF;oBAEvF,OAAOqB;gBACT,GAAGrB,iBAAiBoB;gBAE1B,IAAIC,kBAAkB;oBACpBP,wBAAwB;gBAC1B;gBAEA,IAAIA,uBAAuB;oBACzB5C,QAAQ0B,KAAK,CAAC,AAAC,mBAAqEf,OAAnDsC,sBAAqB,gCAA4C,OAAdtC,eAAc;gBACpG;gBAEA,OAAOiC;YACT;;;YAEAD,KAAAA;mBAAAA,SAAAA,cAAcH,QAAQ,EAAEZ,aAAa,EAAE5B,OAAO;gBAC5C,IAAI0C,kBAAkB;gBAEtB,IAAMxC,OAAO,IAAI,CAACQ,OAAO,IACnBC,gBAAgB,IAAI,CAACC,SAAS,IAC9B0C,iBAAiBd,SAAS5B,SAAS;gBAEzCZ,QAAQa,KAAK,CAAC,AAAC,iBAAsDF,OAAtC2C,gBAAe,yBAAqC,OAAd3C,eAAc,iBAAeT;gBAElG,IAAM4B,kBAAkB9B,SAAU,GAAG;gBAErCA,UAAU,IAAI,CAAC+B,UAAU;gBAEzB,IAAMC,iBAAiBhC,SAAS,GAAG;gBAEnCA,UAAU8B,iBAAkB,GAAG;gBAE/B,IAAM3B,YAAY,IAAI,CAACW,YAAY;gBAEnC,IAAIX,cAAc,MAAM;oBACtB,IAAMoD,gBAAgBpD,UAAUO,OAAO,IACjC8C,wBAAwBD,cAAcE,wBAAwB;oBAEpE,IAAID,0BAA0B,MAAM;wBAClC,IAAMxD,YAAUgC,gBACV0B,gBAAgBF,uBAChBG,YAAY3D,UAAQ4D,4BAA4B,CAACF;wBAEvD,IAAIC,cAAc,MAAM;4BACtB,IAAME,oBAAoBF,WAAY,GAAG;4BAEzCjB,kBAAkBmB,kBAAkBlB,aAAa,CAACH,UAAUZ,eAAeI,gBAAgBF;wBAC7F;oBACF;gBACF;gBAEA,IAAIY,iBAAiB;oBACnB1C,QAAQ0B,KAAK,CAAC,AAAC,mBAAwDf,OAAtC2C,gBAAe,yBAAqC,OAAd3C,eAAc,eAAaT;gBACpG;gBAEA,OAAOwC;YACT;;;YAEAoB,KAAAA;mBAAAA,SAAAA;gBACE,IAAIC,QACAC;gBAEJD,SAAS,IAAI,CAAC/D,OAAO,CAACiE,SAAS;gBAE/BD,QAAQ,IAAI,CAAChE,OAAO,CAACkE,QAAQ;gBAE7B,IAAMC,oBAAoBC,IAAAA,sCAAgC,EAAC,IAAI,CAAChE,aAAa,GACvEiE,gBAAgBC,IAAAA,8BAAwB,EAAC,IAAI,CAACnE,SAAS,GACvDoE,aAAaC,IAAAA,wBAAkB,EAACT,SAChCU,YAAYC,IAAAA,sBAAgB,EAACV;gBAEnCD,SAASQ,YAAa,GAAG;gBAEzBP,QAAQS,WAAY,GAAG;gBAEvB,IAAMrE,gBAAgB+D,mBAChBhE,YAAYkE,eACZM,OAAO;oBACLvE,eAAAA;oBACAD,WAAAA;oBACA4D,QAAAA;oBACAC,OAAAA;gBACF;gBAEN,OAAOW;YACT;;;;YAIOC,KAAAA;mBAAP,SAAOA,SAASD,IAAI,EAAE3E,OAAO;gBAC3B,IAAMgE,QAAQa,IAAAA,mBAAa,EAACF,MAAM3E,UAC5B+D,SAASe,IAAAA,oBAAc,EAACH,MAAM3E,UAC9BG,YAAY4E,IAAAA,uBAAiB,EAACJ,MAAM3E,UACpCI,gBAAgB4E,IAAAA,2BAAqB,EAACL,MAAM3E;gBAElD,IAAIC;gBAEJ,IAAIE,cAAc,MAAM;oBACtBF,SAASE,UAAUS,SAAS;gBAC9B;gBAEA,IAAIR,kBAAkB,MAAM;oBAC1BH,SAASG,cAAcQ,SAAS;gBAClC;gBAEA,IAAMV,OAAO;gBAEb,IAAM+E,UAAU,IAAIlF,QAAQC,SAASC,QAAQC,MAAMC,WAAWC;gBAE9D,OAAO6E;YACT;;;;EAxR0CC,uBAAc,GAiQxD,2BAAOC,QAAO"}