@pie-lib/math-input-mathlive 1.1.5-beta.1 → 1.1.5-beta.10

package/lib/__tests__/mount-race.test.js

@@ -0,0 +1,218 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _input = _interopRequireDefault(require("../mf/input"));
+/**
+ * MathLive loads asynchronously, so `componentDidMount` resumes after an await
+ * before appending a <math-field>. Two orderings must both hold:
+ *
+ *  - StrictMode dev double-mount (mount -> unmount -> mount on the SAME
+ *    instance) must end up with exactly ONE field. A boolean "unmounted" flag
+ *    latches here and blocks the remount entirely - which is why this uses a
+ *    generation counter.
+ *  - A genuine unmount while the load is in flight must append nothing.
+ *
+ * MathLive cannot load under jsdom, so it is mocked with a minimal stub in
+ * order to actually count appended fields.
+ */
+jest.mock('../mathlive-instance', function () {
+  // Must be a real DOM node: the component uses replaceChildren(), which
+  // rejects anything that is not a Node. Returning an element from the
+  // constructor replaces `this`, so callers get a genuine <math-field>.
+  var FakeMathfieldElement = /*#__PURE__*/(0, _createClass2["default"])(function FakeMathfieldElement() {
+    (0, _classCallCheck2["default"])(this, FakeMathfieldElement);
+    // `global` rather than `document`: jest forbids out-of-scope variables in
+    // a mock factory, and `global` is on its allow-list.
+    var el = global.document.createElement('math-field');
+    el.value = '';
+    el.getValue = function () {
+      return el.value;
+    };
+    return el;
+  });
+  return {
+    loadMathLive: function loadMathLive() {
+      return Promise.resolve({
+        MathfieldElement: FakeMathfieldElement
+      });
+    },
+    getMacros: function getMacros() {
+      return {};
+    },
+    // must mirror the real export, otherwise the component sets `undefined`
+    MATH_MODE_SPACE: '\\ ',
+    applyShadowStyles: function applyShadowStyles() {},
+    trackPlaceholderCaret: function trackPlaceholderCaret() {
+      return function () {};
+    },
+    latexToMarkup: function latexToMarkup(l) {
+      return "<span>".concat(l, "</span>");
+    }
+  };
+});
+
+// eslint-disable-next-line import/first
+
+var holderFor = function holderFor(cmp) {
+  var el = document.createElement('span');
+  cmp.holderRef = {
+    current: el
+  };
+  return el;
+};
+var fieldCount = function fieldCount(el) {
+  return Array.from(el.childNodes).filter(function (n) {
+    return n.tagName === 'MATH-FIELD';
+  }).length;
+};
+describe('async mount race', function () {
+  it('StrictMode mount -> unmount -> mount yields exactly one field', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var input, el, first, second;
+    return _regenerator["default"].wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          input = new _input["default"]({});
+          el = holderFor(input);
+          first = input.componentDidMount();
+          input.componentWillUnmount();
+          second = input.componentDidMount();
+          _context.next = 1;
+          return Promise.all([first, second]);
+        case 1:
+          expect(fieldCount(el)).toBe(1);
+          expect(input.mathField).toBeDefined();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('appends nothing when unmounted while the load is in flight', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2() {
+    var input, el, pending;
+    return _regenerator["default"].wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          input = new _input["default"]({});
+          el = holderFor(input);
+          pending = input.componentDidMount();
+          input.componentWillUnmount();
+          _context2.next = 1;
+          return pending;
+        case 1:
+          expect(fieldCount(el)).toBe(0);
+          expect(input.mathField).toBeUndefined();
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('a normal single mount creates the field', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+    var input, el;
+    return _regenerator["default"].wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          input = new _input["default"]({});
+          el = holderFor(input);
+          _context3.next = 1;
+          return input.componentDidMount();
+        case 1:
+          expect(fieldCount(el)).toBe(1);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('repeated mounts never accumulate fields', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+    var input, el;
+    return _regenerator["default"].wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          input = new _input["default"]({});
+          el = holderFor(input);
+          _context4.next = 1;
+          return input.componentDidMount();
+        case 1:
+          _context4.next = 2;
+          return input.componentDidMount();
+        case 2:
+          _context4.next = 3;
+          return input.componentDidMount();
+        case 3:
+          expect(fieldCount(el)).toBe(1);
+        case 4:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+
+  // MathLive's mathModeSpace defaults to '', which makes the spacebar a no-op.
+  it('configures the spacebar so a space can be typed', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
+    var input;
+    return _regenerator["default"].wrap(function (_context5) {
+      while (1) switch (_context5.prev = _context5.next) {
+        case 0:
+          input = new _input["default"]({});
+          holderFor(input);
+          _context5.next = 1;
+          return input.componentDidMount();
+        case 1:
+          // a LaTeX control space - what MathQuill produced, and MathJax understands
+          expect(input.mathField.mathModeSpace).toEqual('\\ ');
+          expect(input.mathField.mathModeSpace).not.toEqual('');
+        case 2:
+        case "end":
+          return _context5.stop();
+      }
+    }, _callee5);
+  })));
+
+  // MathLive leaves a superscript after one digit by default (`smartSuperscript`),
+  // so x^23 / 10^6 cannot be typed.
+  it('stays in the exponent after a digit instead of jumping out', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6() {
+    var input;
+    return _regenerator["default"].wrap(function (_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          input = new _input["default"]({});
+          holderFor(input);
+          _context6.next = 1;
+          return input.componentDidMount();
+        case 1:
+          expect(input.mathField.smartSuperscript).toBe(false);
+        case 2:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee6);
+  })));
+  it('reports itself through innerRef on mount and clears it on unmount', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+    var innerRef, input;
+    return _regenerator["default"].wrap(function (_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          innerRef = jest.fn();
+          input = new _input["default"]({
+            innerRef: innerRef
+          });
+          holderFor(input);
+          _context7.next = 1;
+          return input.componentDidMount();
+        case 1:
+          expect(innerRef).toHaveBeenCalledWith(input);
+          input.componentWillUnmount();
+          expect(innerRef).toHaveBeenLastCalledWith(null);
+        case 2:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee7);
+  })));
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_input","_interopRequireDefault","require","jest","mock","FakeMathfieldElement","_createClass2","_classCallCheck2","el","global","document","createElement","value","getValue","loadMathLive","Promise","resolve","MathfieldElement","getMacros","MATH_MODE_SPACE","applyShadowStyles","trackPlaceholderCaret","latexToMarkup","l","concat","holderFor","cmp","holderRef","current","fieldCount","Array","from","childNodes","filter","n","tagName","length","describe","it","_asyncToGenerator2","_regenerator","mark","_callee","input","first","second","wrap","_context","prev","next","Input","componentDidMount","componentWillUnmount","all","expect","toBe","mathField","toBeDefined","stop","_callee2","pending","_context2","toBeUndefined","_callee3","_context3","_callee4","_context4","_callee5","_context5","mathModeSpace","toEqual","not","_callee6","_context6","smartSuperscript","_callee7","innerRef","_context7","fn","toHaveBeenCalledWith","toHaveBeenLastCalledWith"],"sources":["../../src/__tests__/mount-race.test.jsx"],"sourcesContent":["/**\n * MathLive loads asynchronously, so `componentDidMount` resumes after an await\n * before appending a <math-field>. Two orderings must both hold:\n *\n *  - StrictMode dev double-mount (mount -> unmount -> mount on the SAME\n *    instance) must end up with exactly ONE field. A boolean \"unmounted\" flag\n *    latches here and blocks the remount entirely - which is why this uses a\n *    generation counter.\n *  - A genuine unmount while the load is in flight must append nothing.\n *\n * MathLive cannot load under jsdom, so it is mocked with a minimal stub in\n * order to actually count appended fields.\n */\njest.mock('../mathlive-instance', () => {\n  // Must be a real DOM node: the component uses replaceChildren(), which\n  // rejects anything that is not a Node. Returning an element from the\n  // constructor replaces `this`, so callers get a genuine <math-field>.\n  class FakeMathfieldElement {\n    constructor() {\n      // `global` rather than `document`: jest forbids out-of-scope variables in\n      // a mock factory, and `global` is on its allow-list.\n      const el = global.document.createElement('math-field');\n\n      el.value = '';\n      el.getValue = () => el.value;\n\n      return el;\n    }\n  }\n\n  return {\n    loadMathLive: () => Promise.resolve({ MathfieldElement: FakeMathfieldElement }),\n    getMacros: () => ({}),\n    // must mirror the real export, otherwise the component sets `undefined`\n    MATH_MODE_SPACE: '\\\\ ',\n    applyShadowStyles: () => {},\n    trackPlaceholderCaret: () => () => {},\n    latexToMarkup: (l) => `<span>${l}</span>`,\n  };\n});\n\n// eslint-disable-next-line import/first\nimport Input from '../mf/input';\n\nconst holderFor = (cmp) => {\n  const el = document.createElement('span');\n\n  cmp.holderRef = { current: el };\n\n  return el;\n};\n\nconst fieldCount = (el) => Array.from(el.childNodes).filter((n) => n.tagName === 'MATH-FIELD').length;\n\ndescribe('async mount race', () => {\n  it('StrictMode mount -> unmount -> mount yields exactly one field', async () => {\n    const input = new Input({});\n    const el = holderFor(input);\n\n    const first = input.componentDidMount();\n\n    input.componentWillUnmount();\n\n    const second = input.componentDidMount();\n\n    await Promise.all([first, second]);\n\n    expect(fieldCount(el)).toBe(1);\n    expect(input.mathField).toBeDefined();\n  });\n\n  it('appends nothing when unmounted while the load is in flight', async () => {\n    const input = new Input({});\n    const el = holderFor(input);\n\n    const pending = input.componentDidMount();\n\n    input.componentWillUnmount();\n\n    await pending;\n\n    expect(fieldCount(el)).toBe(0);\n    expect(input.mathField).toBeUndefined();\n  });\n\n  it('a normal single mount creates the field', async () => {\n    const input = new Input({});\n    const el = holderFor(input);\n\n    await input.componentDidMount();\n\n    expect(fieldCount(el)).toBe(1);\n  });\n\n  it('repeated mounts never accumulate fields', async () => {\n    const input = new Input({});\n    const el = holderFor(input);\n\n    await input.componentDidMount();\n    await input.componentDidMount();\n    await input.componentDidMount();\n\n    expect(fieldCount(el)).toBe(1);\n  });\n\n  // MathLive's mathModeSpace defaults to '', which makes the spacebar a no-op.\n  it('configures the spacebar so a space can be typed', async () => {\n    const input = new Input({});\n\n    holderFor(input);\n    await input.componentDidMount();\n\n    // a LaTeX control space - what MathQuill produced, and MathJax understands\n    expect(input.mathField.mathModeSpace).toEqual('\\\\ ');\n    expect(input.mathField.mathModeSpace).not.toEqual('');\n  });\n\n  // MathLive leaves a superscript after one digit by default (`smartSuperscript`),\n  // so x^23 / 10^6 cannot be typed.\n  it('stays in the exponent after a digit instead of jumping out', async () => {\n    const input = new Input({});\n\n    holderFor(input);\n    await input.componentDidMount();\n\n    expect(input.mathField.smartSuperscript).toBe(false);\n  });\n\n  it('reports itself through innerRef on mount and clears it on unmount', async () => {\n    const innerRef = jest.fn();\n    const input = new Input({ innerRef });\n\n    holderFor(input);\n    await input.componentDidMount();\n\n    expect(innerRef).toHaveBeenCalledWith(input);\n\n    input.componentWillUnmount();\n\n    expect(innerRef).toHaveBeenLastCalledWith(null);\n  });\n});\n"],"mappings":";;;;;;;AA0CA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AA1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAC,IAAI,CAACC,IAAI,CAAC,sBAAsB,EAAE,YAAM;EACtC;EACA;EACA;EAAA,IACMC,oBAAoB,oBAAAC,aAAA,aACxB,SAAAD,qBAAA,EAAc;IAAA,IAAAE,gBAAA,mBAAAF,oBAAA;IACZ;IACA;IACA,IAAMG,EAAE,GAAGC,MAAM,CAACC,QAAQ,CAACC,aAAa,CAAC,YAAY,CAAC;IAEtDH,EAAE,CAACI,KAAK,GAAG,EAAE;IACbJ,EAAE,CAACK,QAAQ,GAAG;MAAA,OAAML,EAAE,CAACI,KAAK;IAAA;IAE5B,OAAOJ,EAAE;EACX,CAAC;EAGH,OAAO;IACLM,YAAY,EAAE,SAAdA,YAAYA,CAAA;MAAA,OAAQC,OAAO,CAACC,OAAO,CAAC;QAAEC,gBAAgB,EAAEZ;MAAqB,CAAC,CAAC;IAAA;IAC/Ea,SAAS,EAAE,SAAXA,SAASA,CAAA;MAAA,OAAS,CAAC,CAAC;IAAA,CAAC;IACrB;IACAC,eAAe,EAAE,KAAK;IACtBC,iBAAiB,EAAE,SAAnBA,iBAAiBA,CAAA,EAAQ,CAAC,CAAC;IAC3BC,qBAAqB,EAAE,SAAvBA,qBAAqBA,CAAA;MAAA,OAAQ,YAAM,CAAC,CAAC;IAAA;IACrCC,aAAa,EAAE,SAAfA,aAAaA,CAAGC,CAAC;MAAA,gBAAAC,MAAA,CAAcD,CAAC;IAAA;EAClC,CAAC;AACH,CAAC,CAAC;;AAEF;;AAGA,IAAME,SAAS,GAAG,SAAZA,SAASA,CAAIC,GAAG,EAAK;EACzB,IAAMlB,EAAE,GAAGE,QAAQ,CAACC,aAAa,CAAC,MAAM,CAAC;EAEzCe,GAAG,CAACC,SAAS,GAAG;IAAEC,OAAO,EAAEpB;EAAG,CAAC;EAE/B,OAAOA,EAAE;AACX,CAAC;AAED,IAAMqB,UAAU,GAAG,SAAbA,UAAUA,CAAIrB,EAAE;EAAA,OAAKsB,KAAK,CAACC,IAAI,CAACvB,EAAE,CAACwB,UAAU,CAAC,CAACC,MAAM,CAAC,UAACC,CAAC;IAAA,OAAKA,CAAC,CAACC,OAAO,KAAK,YAAY;EAAA,EAAC,CAACC,MAAM;AAAA;AAErGC,QAAQ,CAAC,kBAAkB,EAAE,YAAM;EACjCC,EAAE,CAAC,+DAA+D,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAC,QAAA;IAAA,IAAAC,KAAA,EAAAnC,EAAA,EAAAoC,KAAA,EAAAC,MAAA;IAAA,OAAAL,YAAA,YAAAM,IAAA,WAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAC5DN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UACrB1C,EAAE,GAAGiB,SAAS,CAACkB,KAAK,CAAC;UAErBC,KAAK,GAAGD,KAAK,CAACQ,iBAAiB,CAAC,CAAC;UAEvCR,KAAK,CAACS,oBAAoB,CAAC,CAAC;UAEtBP,MAAM,GAAGF,KAAK,CAACQ,iBAAiB,CAAC,CAAC;UAAAJ,QAAA,CAAAE,IAAA;UAAA,OAElClC,OAAO,CAACsC,GAAG,CAAC,CAACT,KAAK,EAAEC,MAAM,CAAC,CAAC;QAAA;UAElCS,MAAM,CAACzB,UAAU,CAACrB,EAAE,CAAC,CAAC,CAAC+C,IAAI,CAAC,CAAC,CAAC;UAC9BD,MAAM,CAACX,KAAK,CAACa,SAAS,CAAC,CAACC,WAAW,CAAC,CAAC;QAAC;QAAA;UAAA,OAAAV,QAAA,CAAAW,IAAA;MAAA;IAAA,GAAAhB,OAAA;EAAA,CACvC,GAAC;EAEFJ,EAAE,CAAC,4DAA4D,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAkB,SAAA;IAAA,IAAAhB,KAAA,EAAAnC,EAAA,EAAAoD,OAAA;IAAA,OAAApB,YAAA,YAAAM,IAAA,WAAAe,SAAA;MAAA,kBAAAA,SAAA,CAAAb,IAAA,GAAAa,SAAA,CAAAZ,IAAA;QAAA;UACzDN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UACrB1C,EAAE,GAAGiB,SAAS,CAACkB,KAAK,CAAC;UAErBiB,OAAO,GAAGjB,KAAK,CAACQ,iBAAiB,CAAC,CAAC;UAEzCR,KAAK,CAACS,oBAAoB,CAAC,CAAC;UAACS,SAAA,CAAAZ,IAAA;UAAA,OAEvBW,OAAO;QAAA;UAEbN,MAAM,CAACzB,UAAU,CAACrB,EAAE,CAAC,CAAC,CAAC+C,IAAI,CAAC,CAAC,CAAC;UAC9BD,MAAM,CAACX,KAAK,CAACa,SAAS,CAAC,CAACM,aAAa,CAAC,CAAC;QAAC;QAAA;UAAA,OAAAD,SAAA,CAAAH,IAAA;MAAA;IAAA,GAAAC,QAAA;EAAA,CACzC,GAAC;EAEFrB,EAAE,CAAC,yCAAyC,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAsB,SAAA;IAAA,IAAApB,KAAA,EAAAnC,EAAA;IAAA,OAAAgC,YAAA,YAAAM,IAAA,WAAAkB,SAAA;MAAA,kBAAAA,SAAA,CAAAhB,IAAA,GAAAgB,SAAA,CAAAf,IAAA;QAAA;UACtCN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UACrB1C,EAAE,GAAGiB,SAAS,CAACkB,KAAK,CAAC;UAAAqB,SAAA,CAAAf,IAAA;UAAA,OAErBN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAE/BG,MAAM,CAACzB,UAAU,CAACrB,EAAE,CAAC,CAAC,CAAC+C,IAAI,CAAC,CAAC,CAAC;QAAC;QAAA;UAAA,OAAAS,SAAA,CAAAN,IAAA;MAAA;IAAA,GAAAK,QAAA;EAAA,CAChC,GAAC;EAEFzB,EAAE,CAAC,yCAAyC,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAwB,SAAA;IAAA,IAAAtB,KAAA,EAAAnC,EAAA;IAAA,OAAAgC,YAAA,YAAAM,IAAA,WAAAoB,SAAA;MAAA,kBAAAA,SAAA,CAAAlB,IAAA,GAAAkB,SAAA,CAAAjB,IAAA;QAAA;UACtCN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UACrB1C,EAAE,GAAGiB,SAAS,CAACkB,KAAK,CAAC;UAAAuB,SAAA,CAAAjB,IAAA;UAAA,OAErBN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAAAe,SAAA,CAAAjB,IAAA;UAAA,OACzBN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAAAe,SAAA,CAAAjB,IAAA;UAAA,OACzBN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAE/BG,MAAM,CAACzB,UAAU,CAACrB,EAAE,CAAC,CAAC,CAAC+C,IAAI,CAAC,CAAC,CAAC;QAAC;QAAA;UAAA,OAAAW,SAAA,CAAAR,IAAA;MAAA;IAAA,GAAAO,QAAA;EAAA,CAChC,GAAC;;EAEF;EACA3B,EAAE,CAAC,iDAAiD,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAA0B,SAAA;IAAA,IAAAxB,KAAA;IAAA,OAAAH,YAAA,YAAAM,IAAA,WAAAsB,SAAA;MAAA,kBAAAA,SAAA,CAAApB,IAAA,GAAAoB,SAAA,CAAAnB,IAAA;QAAA;UAC9CN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UAE3BzB,SAAS,CAACkB,KAAK,CAAC;UAACyB,SAAA,CAAAnB,IAAA;UAAA,OACXN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAE/B;UACAG,MAAM,CAACX,KAAK,CAACa,SAAS,CAACa,aAAa,CAAC,CAACC,OAAO,CAAC,KAAK,CAAC;UACpDhB,MAAM,CAACX,KAAK,CAACa,SAAS,CAACa,aAAa,CAAC,CAACE,GAAG,CAACD,OAAO,CAAC,EAAE,CAAC;QAAC;QAAA;UAAA,OAAAF,SAAA,CAAAV,IAAA;MAAA;IAAA,GAAAS,QAAA;EAAA,CACvD,GAAC;;EAEF;EACA;EACA7B,EAAE,CAAC,4DAA4D,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAA+B,SAAA;IAAA,IAAA7B,KAAA;IAAA,OAAAH,YAAA,YAAAM,IAAA,WAAA2B,SAAA;MAAA,kBAAAA,SAAA,CAAAzB,IAAA,GAAAyB,SAAA,CAAAxB,IAAA;QAAA;UACzDN,KAAK,GAAG,IAAIO,iBAAK,CAAC,CAAC,CAAC,CAAC;UAE3BzB,SAAS,CAACkB,KAAK,CAAC;UAAC8B,SAAA,CAAAxB,IAAA;UAAA,OACXN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAE/BG,MAAM,CAACX,KAAK,CAACa,SAAS,CAACkB,gBAAgB,CAAC,CAACnB,IAAI,CAAC,KAAK,CAAC;QAAC;QAAA;UAAA,OAAAkB,SAAA,CAAAf,IAAA;MAAA;IAAA,GAAAc,QAAA;EAAA,CACtD,GAAC;EAEFlC,EAAE,CAAC,mEAAmE,mBAAAC,kBAAA,0BAAAC,YAAA,YAAAC,IAAA,CAAE,SAAAkC,SAAA;IAAA,IAAAC,QAAA,EAAAjC,KAAA;IAAA,OAAAH,YAAA,YAAAM,IAAA,WAAA+B,SAAA;MAAA,kBAAAA,SAAA,CAAA7B,IAAA,GAAA6B,SAAA,CAAA5B,IAAA;QAAA;UAChE2B,QAAQ,GAAGzE,IAAI,CAAC2E,EAAE,CAAC,CAAC;UACpBnC,KAAK,GAAG,IAAIO,iBAAK,CAAC;YAAE0B,QAAQ,EAARA;UAAS,CAAC,CAAC;UAErCnD,SAAS,CAACkB,KAAK,CAAC;UAACkC,SAAA,CAAA5B,IAAA;UAAA,OACXN,KAAK,CAACQ,iBAAiB,CAAC,CAAC;QAAA;UAE/BG,MAAM,CAACsB,QAAQ,CAAC,CAACG,oBAAoB,CAACpC,KAAK,CAAC;UAE5CA,KAAK,CAACS,oBAAoB,CAAC,CAAC;UAE5BE,MAAM,CAACsB,QAAQ,CAAC,CAACI,wBAAwB,CAAC,IAAI,CAAC;QAAC;QAAA;UAAA,OAAAH,SAAA,CAAAnB,IAAA;MAAA;IAAA,GAAAiB,QAAA;EAAA,CACjD,GAAC;AACJ,CAAC,CAAC","ignoreList":[]}