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

package/README.md

@@ -108,19 +108,28 @@ widget do not port and need a redesign (`mf.getElementInfo()` exposes per-elemen
   corrupt these fonts (it emits a JS module under a `.woff2` name). Exclude
   mathlive from such rules - see `packages/demo/next.config.js`.
 
+  **Fonts are required, not cosmetic.** Some symbols are composed from Private
+  Use Area glyphs that exist only in the KaTeX fonts: `\neq` is U+E020 (a
+  negation slash) overlapped on `=`, and `\nsim` / `\ncong` are the same. With
+  no fonts the browser substitutes an arbitrary glyph for U+E020, so those keys
+  render as garbage rather than in a plainer face.
+
   **Alternative** - serve the fonts yourself (a static path, or a CDN):
 
   ```js
   import { configureFonts } from '@pie-lib/math-input-mathlive';
 
   configureFonts('/mathlive-fonts'); // before loadMathLive()
-  configureFonts('https://unpkg.com/mathlive@0.110.0/dist/fonts');
-  configureFonts(null); // system fonts
+  configureFonts('https://unpkg.com/mathlive@0.110.0/fonts'); // note: /fonts, /dist/fonts 404s
+  configureFonts(null); // opt out; \neq and friends will render incorrectly
   ```
 
-  Paths are resolved to absolute URLs against `document.baseURI`. If you neither
-  import the stylesheet nor call `configureFonts`, the package disables font
-  loading rather than leaving MathLive's crashing default in place.
+  Paths are resolved to absolute URLs against `document.baseURI`.
+
+  If you neither import the stylesheet nor call `configureFonts`, the package
+  falls back to a **version-pinned CDN** - `https://unpkg.com/mathlive@<engine
+version>/fonts` - so those glyph-dependent symbols still render. Serve the
+  fonts yourself to avoid the third-party request.
 
 - **Custom macros.** `PIE_MACROS` covers the pie-specific commands the MathQuill
   fork understood (`\parallelogram`, `\longdiv`, `\napprox`, …) and is kept in

package/lib/__tests__/composites.test.js

@@ -0,0 +1,255 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _mathInput = _interopRequireDefault(require("../math-input"));
+var _horizontalKeypad = _interopRequireDefault(require("../horizontal-keypad"));
+var _input = _interopRequireDefault(require("../mf/input"));
+/**
+ * The pieces that sit between the keypad and the field: how a pressed key is
+ * routed into the field, and the legacy `{value,type}` shape math-toolbar
+ * consumes.
+ */
+describe('MathInput.keypadPress routing', function () {
+  var withInput = function withInput() {
+    var mi = new _mathInput["default"]({});
+    var calls = {
+      write: [],
+      keystroke: []
+    };
+    mi.input = {
+      write: function write(v) {
+        return calls.write.push(v);
+      },
+      keystroke: function keystroke(v) {
+        return calls.keystroke.push(v);
+      }
+    };
+    return {
+      mi: mi,
+      calls: calls
+    };
+  };
+  it('routes an insert action to write()', function () {
+    var _withInput = withInput(),
+      mi = _withInput.mi,
+      calls = _withInput.calls;
+    mi.keypadPress({
+      latex: '\\pi'
+    });
+    expect(calls.write).toEqual(['\\pi']);
+    expect(calls.keystroke).toEqual([]);
+  });
+  it('expands an argument-taking command before writing', function () {
+    var _withInput2 = withInput(),
+      mi = _withInput2.mi,
+      calls = _withInput2.calls;
+    mi.keypadPress({
+      command: '\\frac'
+    });
+    expect(calls.write).toEqual(['\\frac{#?}{#?}']);
+  });
+  it('routes a cursor keystroke to keystroke()', function () {
+    var _withInput3 = withInput(),
+      mi = _withInput3.mi,
+      calls = _withInput3.calls;
+    mi.keypadPress({
+      keystroke: 'Left'
+    });
+    expect(calls.keystroke).toEqual(['moveToPreviousChar']);
+    expect(calls.write).toEqual([]);
+  });
+  it('ignores keys with no action', function () {
+    var _withInput4 = withInput(),
+      mi = _withInput4.mi,
+      calls = _withInput4.calls;
+    mi.keypadPress({});
+    mi.keypadPress({
+      keystroke: 'Nonsense'
+    });
+    expect(calls.write).toEqual([]);
+    expect(calls.keystroke).toEqual([]);
+  });
+  it('is a no-op before the field ref exists', function () {
+    var mi = new _mathInput["default"]({});
+    expect(function () {
+      return mi.keypadPress({
+        latex: '\\pi'
+      });
+    }).not.toThrow();
+  });
+  it('changeLatex only fires onChange when the value differs', function () {
+    var onChange = jest.fn();
+    var mi = new _mathInput["default"]({
+      latex: 'x',
+      onChange: onChange
+    });
+    mi.changeLatex('x');
+    expect(onChange).not.toHaveBeenCalled();
+    mi.changeLatex('y');
+    expect(onChange).toHaveBeenCalledWith('y');
+  });
+  it('tracks focus state', function () {
+    var mi = new _mathInput["default"]({});
+    mi.setState = function (s) {
+      return Object.assign(mi.state, s);
+    };
+    mi.inputFocus();
+    expect(mi.state.focused).toBe(true);
+    mi.inputBlur();
+    expect(mi.state.focused).toBe(false);
+  });
+});
+describe('HorizontalKeypad legacy {value,type} model', function () {
+  var pressed = function pressed(key) {
+    var onClick = jest.fn();
+    var hk = new _horizontalKeypad["default"]({
+      onClick: onClick
+    });
+    hk.keypadPress(key);
+    return onClick.mock.calls[0][0];
+  };
+  it('maps a command to {value, type: command}', function () {
+    expect(pressed({
+      command: '\\frac'
+    })).toEqual({
+      value: '\\frac',
+      type: 'command'
+    });
+  });
+  it('maps a write to {value}', function () {
+    expect(pressed({
+      write: 'x'
+    })).toEqual({
+      value: 'x'
+    });
+  });
+  it('maps a keystroke to {type: cursor}', function () {
+    expect(pressed({
+      keystroke: 'Left'
+    })).toEqual({
+      type: 'cursor',
+      value: 'Left'
+    });
+  });
+  it('renders without throwing', function () {
+    expect(function () {
+      return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_horizontalKeypad["default"], {
+        onClick: function onClick() {}
+      }));
+    }).not.toThrow();
+  });
+});
+describe('Input: controlled-value sync and events', function () {
+  var withField = function withField() {
+    var input = new _input["default"]({});
+    input.mathField = {
+      value: '',
+      getValue: function getValue() {
+        return input.mathField.value;
+      },
+      insert: function insert(v) {
+        input.mathField.value += v;
+      },
+      executeCommand: function executeCommand() {},
+      focus: function focus() {},
+      blur: function blur() {},
+      addEventListener: function addEventListener() {},
+      removeEventListener: function removeEventListener() {},
+      remove: function remove() {}
+    };
+    return input;
+  };
+  it('emits stored-form latex on edit', function () {
+    var onChange = jest.fn();
+    var input = withField();
+    input.props = {
+      onChange: onChange
+    };
+    input.mathField.value = '\\longdiv{\\placeholder{}}';
+    input.onInputEdit();
+
+    // \placeholder is MathLive-internal and must not reach the model
+    expect(onChange).toHaveBeenCalledWith('\\longdiv{}');
+    expect(input.lastEmitted).toEqual('\\longdiv{}');
+  });
+  it('does not push a prop echo back into the field', function () {
+    var input = withField();
+    input.mathField.value = 'x';
+    input.lastEmitted = 'x';
+    input.props = {
+      latex: 'x'
+    };
+    input.componentDidUpdate({
+      latex: ''
+    });
+    expect(input.mathField.value).toEqual('x');
+  });
+  it('pushes a genuinely new latex prop into the field', function () {
+    var input = withField();
+    input.mathField.value = 'x';
+    input.lastEmitted = 'x';
+    input.props = {
+      latex: 'y'
+    };
+    input.componentDidUpdate({
+      latex: 'x'
+    });
+    expect(input.mathField.value).toEqual('y');
+  });
+  it('bridges stored latex on the way in', function () {
+    var input = withField();
+    input.props = {
+      latex: '\\longdiv{5}'
+    };
+    input.componentDidUpdate({
+      latex: ''
+    });
+
+    // must become native \enclose so the content stays editable
+    expect(input.mathField.value).toEqual('\\enclose{longdiv}{5}');
+  });
+  it('toggles readOnly', function () {
+    var input = withField();
+    input.props = {
+      readOnly: true
+    };
+    input.componentDidUpdate({
+      readOnly: false
+    });
+    expect(input.mathField.readOnly).toBe(true);
+  });
+  it('clear() empties the field', function () {
+    var input = withField();
+    input.mathField.value = 'abc';
+    expect(input.clear()).toEqual('');
+    expect(input.mathField.value).toEqual('');
+  });
+  it('suppresses Enter so it cannot insert a line break', function () {
+    var input = withField();
+    var preventDefault = jest.fn();
+    input.onKeyDown({
+      key: 'Enter',
+      preventDefault: preventDefault
+    });
+    expect(preventDefault).toHaveBeenCalled();
+    preventDefault.mockClear();
+    input.onKeyDown({
+      key: 'a',
+      preventDefault: preventDefault
+    });
+    expect(preventDefault).not.toHaveBeenCalled();
+  });
+  it('componentDidUpdate is safe before the field exists', function () {
+    var input = new _input["default"]({
+      latex: 'x'
+    });
+    expect(function () {
+      return input.componentDidUpdate({
+        latex: ''
+      });
+    }).not.toThrow();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_mathInput","_horizontalKeypad","_input","describe","withInput","mi","MathInput","calls","write","keystroke","input","v","push","it","_withInput","keypadPress","latex","expect","toEqual","_withInput2","command","_withInput3","_withInput4","not","toThrow","onChange","jest","fn","changeLatex","toHaveBeenCalled","toHaveBeenCalledWith","setState","s","Object","assign","state","inputFocus","focused","toBe","inputBlur","pressed","key","onClick","hk","HorizontalKeypad","mock","value","type","render","createElement","withField","Input","mathField","getValue","insert","executeCommand","focus","blur","addEventListener","removeEventListener","remove","props","onInputEdit","lastEmitted","componentDidUpdate","readOnly","clear","preventDefault","onKeyDown","mockClear"],"sources":["../../src/__tests__/composites.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render } from '@testing-library/react';\n\nimport MathInput from '../math-input';\nimport HorizontalKeypad from '../horizontal-keypad';\nimport Input from '../mf/input';\n\n/**\n * The pieces that sit between the keypad and the field: how a pressed key is\n * routed into the field, and the legacy `{value,type}` shape math-toolbar\n * consumes.\n */\ndescribe('MathInput.keypadPress routing', () => {\n  const withInput = () => {\n    const mi = new MathInput({});\n    const calls = { write: [], keystroke: [] };\n\n    mi.input = {\n      write: (v) => calls.write.push(v),\n      keystroke: (v) => calls.keystroke.push(v),\n    };\n\n    return { mi, calls };\n  };\n\n  it('routes an insert action to write()', () => {\n    const { mi, calls } = withInput();\n\n    mi.keypadPress({ latex: '\\\\pi' });\n\n    expect(calls.write).toEqual(['\\\\pi']);\n    expect(calls.keystroke).toEqual([]);\n  });\n\n  it('expands an argument-taking command before writing', () => {\n    const { mi, calls } = withInput();\n\n    mi.keypadPress({ command: '\\\\frac' });\n\n    expect(calls.write).toEqual(['\\\\frac{#?}{#?}']);\n  });\n\n  it('routes a cursor keystroke to keystroke()', () => {\n    const { mi, calls } = withInput();\n\n    mi.keypadPress({ keystroke: 'Left' });\n\n    expect(calls.keystroke).toEqual(['moveToPreviousChar']);\n    expect(calls.write).toEqual([]);\n  });\n\n  it('ignores keys with no action', () => {\n    const { mi, calls } = withInput();\n\n    mi.keypadPress({});\n    mi.keypadPress({ keystroke: 'Nonsense' });\n\n    expect(calls.write).toEqual([]);\n    expect(calls.keystroke).toEqual([]);\n  });\n\n  it('is a no-op before the field ref exists', () => {\n    const mi = new MathInput({});\n\n    expect(() => mi.keypadPress({ latex: '\\\\pi' })).not.toThrow();\n  });\n\n  it('changeLatex only fires onChange when the value differs', () => {\n    const onChange = jest.fn();\n    const mi = new MathInput({ latex: 'x', onChange });\n\n    mi.changeLatex('x');\n    expect(onChange).not.toHaveBeenCalled();\n\n    mi.changeLatex('y');\n    expect(onChange).toHaveBeenCalledWith('y');\n  });\n\n  it('tracks focus state', () => {\n    const mi = new MathInput({});\n\n    mi.setState = (s) => Object.assign(mi.state, s);\n    mi.inputFocus();\n    expect(mi.state.focused).toBe(true);\n\n    mi.inputBlur();\n    expect(mi.state.focused).toBe(false);\n  });\n});\n\ndescribe('HorizontalKeypad legacy {value,type} model', () => {\n  const pressed = (key) => {\n    const onClick = jest.fn();\n    const hk = new HorizontalKeypad({ onClick });\n\n    hk.keypadPress(key);\n\n    return onClick.mock.calls[0][0];\n  };\n\n  it('maps a command to {value, type: command}', () => {\n    expect(pressed({ command: '\\\\frac' })).toEqual({ value: '\\\\frac', type: 'command' });\n  });\n\n  it('maps a write to {value}', () => {\n    expect(pressed({ write: 'x' })).toEqual({ value: 'x' });\n  });\n\n  it('maps a keystroke to {type: cursor}', () => {\n    expect(pressed({ keystroke: 'Left' })).toEqual({ type: 'cursor', value: 'Left' });\n  });\n\n  it('renders without throwing', () => {\n    expect(() => render(<HorizontalKeypad onClick={() => {}} />)).not.toThrow();\n  });\n});\n\ndescribe('Input: controlled-value sync and events', () => {\n  const withField = () => {\n    const input = new Input({});\n\n    input.mathField = {\n      value: '',\n      getValue: () => input.mathField.value,\n      insert(v) {\n        input.mathField.value += v;\n      },\n      executeCommand() {},\n      focus() {},\n      blur() {},\n      addEventListener() {},\n      removeEventListener() {},\n      remove() {},\n    };\n\n    return input;\n  };\n\n  it('emits stored-form latex on edit', () => {\n    const onChange = jest.fn();\n    const input = withField();\n\n    input.props = { onChange };\n    input.mathField.value = '\\\\longdiv{\\\\placeholder{}}';\n    input.onInputEdit();\n\n    // \\placeholder is MathLive-internal and must not reach the model\n    expect(onChange).toHaveBeenCalledWith('\\\\longdiv{}');\n    expect(input.lastEmitted).toEqual('\\\\longdiv{}');\n  });\n\n  it('does not push a prop echo back into the field', () => {\n    const input = withField();\n\n    input.mathField.value = 'x';\n    input.lastEmitted = 'x';\n    input.props = { latex: 'x' };\n\n    input.componentDidUpdate({ latex: '' });\n\n    expect(input.mathField.value).toEqual('x');\n  });\n\n  it('pushes a genuinely new latex prop into the field', () => {\n    const input = withField();\n\n    input.mathField.value = 'x';\n    input.lastEmitted = 'x';\n    input.props = { latex: 'y' };\n\n    input.componentDidUpdate({ latex: 'x' });\n\n    expect(input.mathField.value).toEqual('y');\n  });\n\n  it('bridges stored latex on the way in', () => {\n    const input = withField();\n\n    input.props = { latex: '\\\\longdiv{5}' };\n    input.componentDidUpdate({ latex: '' });\n\n    // must become native \\enclose so the content stays editable\n    expect(input.mathField.value).toEqual('\\\\enclose{longdiv}{5}');\n  });\n\n  it('toggles readOnly', () => {\n    const input = withField();\n\n    input.props = { readOnly: true };\n    input.componentDidUpdate({ readOnly: false });\n\n    expect(input.mathField.readOnly).toBe(true);\n  });\n\n  it('clear() empties the field', () => {\n    const input = withField();\n\n    input.mathField.value = 'abc';\n    expect(input.clear()).toEqual('');\n    expect(input.mathField.value).toEqual('');\n  });\n\n  it('suppresses Enter so it cannot insert a line break', () => {\n    const input = withField();\n    const preventDefault = jest.fn();\n\n    input.onKeyDown({ key: 'Enter', preventDefault });\n    expect(preventDefault).toHaveBeenCalled();\n\n    preventDefault.mockClear();\n    input.onKeyDown({ key: 'a', preventDefault });\n    expect(preventDefault).not.toHaveBeenCalled();\n  });\n\n  it('componentDidUpdate is safe before the field exists', () => {\n    const input = new Input({ latex: 'x' });\n\n    expect(() => input.componentDidUpdate({ latex: '' })).not.toThrow();\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/drop-in-compat.test.js

@@ -0,0 +1,133 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _styles = require("@mui/material/styles");
+var _index = require("../index");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Exercises the exact call patterns real consumers use against
+ * @pie-lib/math-input, to catch drop-in incompatibilities.
+ *
+ * Sources:
+ *  - packages/math-toolbar/src/editor-and-pad.jsx:16,185
+ *  - packages/math-toolbar/src/math-preview.jsx:8,156
+ *  - packages/editable-html/src/plugins/respArea/math-templated/index.jsx:92
+ *  - packages/editable-html-tip-tap/src/components/respArea/MathTemplated.jsx:111
+ */
+describe('drop-in compatibility with @pie-lib/math-input consumers', function () {
+  describe('mq.CommonMqStyles destructuring', function () {
+    it('math-preview.jsx: { commonMqFontStyles, longdivStyles, supsubStyles }', function () {
+      var _mq$CommonMqStyles = _index.mq.CommonMqStyles,
+        commonMqFontStyles = _mq$CommonMqStyles.commonMqFontStyles,
+        longdivStyles = _mq$CommonMqStyles.longdivStyles,
+        supsubStyles = _mq$CommonMqStyles.supsubStyles;
+      expect(commonMqFontStyles).toBeDefined();
+      expect(longdivStyles).toBeDefined();
+      expect(supsubStyles).toBeDefined();
+    });
+    it('editor-and-pad.jsx: also { commonMqKeyboardStyles }', function () {
+      var _mq$CommonMqStyles2 = _index.mq.CommonMqStyles,
+        commonMqFontStyles = _mq$CommonMqStyles2.commonMqFontStyles,
+        commonMqKeyboardStyles = _mq$CommonMqStyles2.commonMqKeyboardStyles,
+        longdivStyles = _mq$CommonMqStyles2.longdivStyles,
+        supsubStyles = _mq$CommonMqStyles2.supsubStyles;
+      expect(commonMqKeyboardStyles).toBeDefined();
+      // All four must be spreadable into an emotion style object.
+      expect(function () {
+        return _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, commonMqFontStyles), commonMqKeyboardStyles), longdivStyles), supsubStyles);
+      }).not.toThrow();
+    });
+    it('the destructured groups survive being spread into a styled component', function () {
+      var _mq$CommonMqStyles3 = _index.mq.CommonMqStyles,
+        commonMqFontStyles = _mq$CommonMqStyles3.commonMqFontStyles,
+        longdivStyles = _mq$CommonMqStyles3.longdivStyles,
+        supsubStyles = _mq$CommonMqStyles3.supsubStyles;
+      var Styled = (0, _styles.styled)('div')(_objectSpread(_objectSpread(_objectSpread({}, commonMqFontStyles), longdivStyles), supsubStyles));
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(Styled, null));
+      }).not.toThrow();
+    });
+  });
+  describe('mq.Input', function () {
+    it('editor-and-pad.jsx: styled(mq.Input) renders', function () {
+      var MathEditor = (0, _styles.styled)(_index.mq.Input)(function () {
+        return {
+          width: '100%'
+        };
+      });
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(MathEditor, {
+          latex: "\\\\frac{1}{2}",
+          onChange: function onChange() {}
+        }));
+      }).not.toThrow();
+    });
+    it('accepts the className that styled() injects', function () {
+      var Styled = (0, _styles.styled)(_index.mq.Input)({
+        padding: 4
+      });
+      var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(Styled, {
+          latex: "x",
+          onChange: function onChange() {}
+        })),
+        container = _render.container;
+      expect(container.firstChild).toBeTruthy();
+      expect(container.firstChild.className).toBeTruthy();
+    });
+  });
+  describe('mq.Static', function () {
+    it('math-preview.jsx: <mq.Static latex onFocus onBlur />', function () {
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.mq.Static, {
+          latex: '\\frac{1}{2}',
+          onFocus: function onFocus() {},
+          onBlur: function onBlur() {}
+        }));
+      }).not.toThrow();
+    });
+    it('math-templated respArea: <mq.Static latex={value} />', function () {
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.mq.Static, {
+          latex: 'x=1'
+        }));
+      }).not.toThrow();
+    });
+    it('renders answer-block latex (the templated-math case) without throwing', function () {
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.mq.Static, {
+          latex: 'x=\\MathQuillMathField[r1]{}',
+          onSubFieldChange: function onSubFieldChange() {}
+        }));
+      }).not.toThrow();
+    });
+    it('is styleable, as keypad labels were in math-input', function () {
+      var Styled = (0, _styles.styled)(_index.mq.Static)({
+        pointerEvents: 'none'
+      });
+      expect(function () {
+        return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(Styled, {
+          latex: '\\pi'
+        }));
+      }).not.toThrow();
+    });
+  });
+  describe('surface parity', function () {
+    it('exposes exactly the names math-input exported', function () {
+      // eslint-disable-next-line global-require
+      var pkg = require('../index');
+      ['keysForGrade', 'addBrackets', 'removeBrackets', 'keys', 'HorizontalKeypad', 'mq', 'updateSpans', 'registerEmbed', 'applyStaticMath'].forEach(function (name) {
+        expect(pkg[name]).toBeDefined();
+      });
+    });
+    it('mq exposes Input, Static and CommonMqStyles', function () {
+      ['Input', 'Static', 'CommonMqStyles'].forEach(function (name) {
+        expect(_index.mq[name]).toBeDefined();
+      });
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_styles","_index","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","defineProperty","describe","it","_mq$CommonMqStyles","mq","CommonMqStyles","commonMqFontStyles","longdivStyles","supsubStyles","expect","toBeDefined","_mq$CommonMqStyles2","commonMqKeyboardStyles","not","toThrow","_mq$CommonMqStyles3","Styled","styled","render","createElement","MathEditor","Input","width","latex","onChange","padding","_render","container","firstChild","toBeTruthy","className","Static","onFocus","onBlur","onSubFieldChange","pointerEvents","pkg","name"],"sources":["../../src/__tests__/drop-in-compat.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render } from '@testing-library/react';\nimport { styled } from '@mui/material/styles';\n\nimport { mq } from '../index';\n\n/**\n * Exercises the exact call patterns real consumers use against\n * @pie-lib/math-input, to catch drop-in incompatibilities.\n *\n * Sources:\n *  - packages/math-toolbar/src/editor-and-pad.jsx:16,185\n *  - packages/math-toolbar/src/math-preview.jsx:8,156\n *  - packages/editable-html/src/plugins/respArea/math-templated/index.jsx:92\n *  - packages/editable-html-tip-tap/src/components/respArea/MathTemplated.jsx:111\n */\ndescribe('drop-in compatibility with @pie-lib/math-input consumers', () => {\n  describe('mq.CommonMqStyles destructuring', () => {\n    it('math-preview.jsx: { commonMqFontStyles, longdivStyles, supsubStyles }', () => {\n      const { commonMqFontStyles, longdivStyles, supsubStyles } = mq.CommonMqStyles;\n\n      expect(commonMqFontStyles).toBeDefined();\n      expect(longdivStyles).toBeDefined();\n      expect(supsubStyles).toBeDefined();\n    });\n\n    it('editor-and-pad.jsx: also { commonMqKeyboardStyles }', () => {\n      const { commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles } = mq.CommonMqStyles;\n\n      expect(commonMqKeyboardStyles).toBeDefined();\n      // All four must be spreadable into an emotion style object.\n      expect(() => ({\n        ...commonMqFontStyles,\n        ...commonMqKeyboardStyles,\n        ...longdivStyles,\n        ...supsubStyles,\n      })).not.toThrow();\n    });\n\n    it('the destructured groups survive being spread into a styled component', () => {\n      const { commonMqFontStyles, longdivStyles, supsubStyles } = mq.CommonMqStyles;\n      const Styled = styled('div')({ ...commonMqFontStyles, ...longdivStyles, ...supsubStyles });\n\n      expect(() => render(<Styled />)).not.toThrow();\n    });\n  });\n\n  describe('mq.Input', () => {\n    it('editor-and-pad.jsx: styled(mq.Input) renders', () => {\n      const MathEditor = styled(mq.Input)(() => ({ width: '100%' }));\n\n      expect(() => render(<MathEditor latex=\"\\\\frac{1}{2}\" onChange={() => {}} />)).not.toThrow();\n    });\n\n    it('accepts the className that styled() injects', () => {\n      const Styled = styled(mq.Input)({ padding: 4 });\n      const { container } = render(<Styled latex=\"x\" onChange={() => {}} />);\n\n      expect(container.firstChild).toBeTruthy();\n      expect(container.firstChild.className).toBeTruthy();\n    });\n  });\n\n  describe('mq.Static', () => {\n    it('math-preview.jsx: <mq.Static latex onFocus onBlur />', () => {\n      expect(() => render(<mq.Static latex={'\\\\frac{1}{2}'} onFocus={() => {}} onBlur={() => {}} />)).not.toThrow();\n    });\n\n    it('math-templated respArea: <mq.Static latex={value} />', () => {\n      expect(() => render(<mq.Static latex={'x=1'} />)).not.toThrow();\n    });\n\n    it('renders answer-block latex (the templated-math case) without throwing', () => {\n      expect(() =>\n        render(<mq.Static latex={'x=\\\\MathQuillMathField[r1]{}'} onSubFieldChange={() => {}} />),\n      ).not.toThrow();\n    });\n\n    it('is styleable, as keypad labels were in math-input', () => {\n      const Styled = styled(mq.Static)({ pointerEvents: 'none' });\n\n      expect(() => render(<Styled latex={'\\\\pi'} />)).not.toThrow();\n    });\n  });\n\n  describe('surface parity', () => {\n    it('exposes exactly the names math-input exported', () => {\n      // eslint-disable-next-line global-require\n      const pkg = require('../index');\n\n      [\n        'keysForGrade',\n        'addBrackets',\n        'removeBrackets',\n        'keys',\n        'HorizontalKeypad',\n        'mq',\n        'updateSpans',\n        'registerEmbed',\n        'applyStaticMath',\n      ].forEach((name) => {\n        expect(pkg[name]).toBeDefined();\n      });\n    });\n\n    it('mq exposes Input, Static and CommonMqStyles', () => {\n      ['Input', 'Static', 'CommonMqStyles'].forEach((name) => {\n        expect(mq[name]).toBeDefined();\n      });\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/embedded-fonts.test.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _embedded = require("../fonts/embedded");
+var _fonts = require("../fonts");
+/**
+ * MathLive composes some glyphs from Private Use Area codepoints that only the
+ * KaTeX fonts carry (`\ne` is U+E020 overlapped on `=`), so a missing font file
+ * renders tofu rather than a plainer glyph. The faces therefore ship in the
+ * bundle - pie-elements has no stylesheet to carry `@font-face` and no asset
+ * path to serve woff2 files from.
+ */
+describe('embedded fonts', function () {
+  var originalFonts = document.fonts;
+  var fakeFontSet = function fakeFontSet() {
+    var existing = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var added = [];
+    var set = (0, _defineProperty2["default"])({
+      add: function add(f) {
+        return added.push(f);
+      }
+    }, Symbol.iterator, function () {
+      return existing[Symbol.iterator]();
+    });
+    Object.defineProperty(document, 'fonts', {
+      value: set,
+      configurable: true
+    });
+    return added;
+  };
+  beforeEach(function () {
+    (0, _fonts.resetEmbeddedFontsForTests)();
+    global.FontFace = jest.fn(function FontFace(family, src, descriptors) {
+      Object.assign(this, {
+        family: family,
+        src: src,
+        descriptors: descriptors
+      });
+    });
+  });
+  afterEach(function () {
+    Object.defineProperty(document, 'fonts', {
+      value: originalFonts,
+      configurable: true
+    });
+    delete global.FontFace;
+  });
+
+  // The 12 families MathLive's own loadFonts() looks for; if every one is in
+  // document.fonts it short-circuits to "ready" and issues no network request.
+  it('covers every family MathLive requires', function () {
+    expect(_fonts.EMBEDDED_FONT_FAMILIES.sort()).toEqual(['KaTeX_AMS', 'KaTeX_Caligraphic', 'KaTeX_Fraktur', 'KaTeX_Main', 'KaTeX_Math', 'KaTeX_SansSerif', 'KaTeX_Script', 'KaTeX_Size1', 'KaTeX_Size2', 'KaTeX_Size3', 'KaTeX_Size4', 'KaTeX_Typewriter'].sort());
+  });
+  it('carries all 20 faces as self-contained data URIs', function () {
+    expect(_embedded.EMBEDDED_FONTS).toHaveLength(20);
+    _embedded.EMBEDDED_FONTS.forEach(function (_ref) {
+      var family = _ref.family,
+        src = _ref.src;
+      expect(family).toMatch(/^KaTeX_/);
+      // No network: a data URI, not a path or a CDN URL.
+      expect(src).toMatch(/^url\(data:font\/woff2;base64,[A-Za-z0-9+/=]+\) format\('woff2'\)$/);
+    });
+  });
+  it('is generated from the installed mathlive, so glyph metrics match the engine', function () {
+    /* eslint-disable global-require */
+    var fs = require('fs');
+    var path = require('path');
+    /* eslint-enable global-require */
+
+    // Read the file rather than require('mathlive/package.json'): MathLive's
+    // exports map does not expose that subpath.
+    var manifest = [path.resolve(__dirname, '../../../../node_modules/mathlive/package.json'), path.resolve(__dirname, '../../node_modules/mathlive/package.json')].find(function (p) {
+      return fs.existsSync(p);
+    });
+    expect(manifest).toBeDefined();
+    expect(_embedded.MATHLIVE_VERSION).toEqual(JSON.parse(fs.readFileSync(manifest, 'utf8')).version);
+  });
+  it('registers every face with the document', function () {
+    var added = fakeFontSet();
+    expect((0, _fonts.registerEmbeddedFonts)()).toBe(true);
+    expect(added).toHaveLength(20);
+    expect(added.map(function (f) {
+      return f.family;
+    })).toContain('KaTeX_Main');
+    // Descriptors ride along, or bold/italic math would synthesise from regular.
+    expect(added.find(function (f) {
+      return f.src.startsWith('url(data:') && f.descriptors.weight === 'bold';
+    })).toBeDefined();
+  });
+  it('does not register twice', function () {
+    var added = fakeFontSet();
+    (0, _fonts.registerEmbeddedFonts)();
+    (0, _fonts.registerEmbeddedFonts)();
+    expect(added).toHaveLength(20);
+  });
+  it('leaves the document alone when it already provides every family', function () {
+    // A host that serves the fonts itself - configureFonts, or importing
+    // mathlive/fonts.css - wins.
+    var added = fakeFontSet(_fonts.EMBEDDED_FONT_FAMILIES.map(function (family) {
+      return {
+        family: family
+      };
+    }));
+    expect((0, _fonts.registerEmbeddedFonts)()).toBe(true);
+    expect(added).toHaveLength(0);
+  });
+  it('reports failure instead of throwing when the FontFace API is missing', function () {
+    fakeFontSet();
+    delete global.FontFace;
+    expect((0, _fonts.registerEmbeddedFonts)()).toBe(false);
+  });
+  it('reports failure instead of throwing when a face cannot be constructed', function () {
+    fakeFontSet();
+    global.FontFace = jest.fn(function () {
+      throw new Error('bad font');
+    });
+    expect((0, _fonts.registerEmbeddedFonts)()).toBe(false);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_embedded","require","_fonts","describe","originalFonts","document","fonts","fakeFontSet","existing","arguments","length","undefined","added","set","_defineProperty2","add","f","push","Symbol","iterator","Object","defineProperty","value","configurable","beforeEach","resetEmbeddedFontsForTests","global","FontFace","jest","fn","family","src","descriptors","assign","afterEach","it","expect","EMBEDDED_FONT_FAMILIES","sort","toEqual","EMBEDDED_FONTS","toHaveLength","forEach","_ref","toMatch","fs","path","manifest","resolve","__dirname","find","p","existsSync","toBeDefined","MATHLIVE_VERSION","JSON","parse","readFileSync","version","registerEmbeddedFonts","toBe","map","toContain","startsWith","weight","Error"],"sources":["../../src/__tests__/embedded-fonts.test.js"],"sourcesContent":["import { EMBEDDED_FONTS, MATHLIVE_VERSION } from '../fonts/embedded';\nimport { EMBEDDED_FONT_FAMILIES, registerEmbeddedFonts, resetEmbeddedFontsForTests } from '../fonts';\n\n/**\n * MathLive composes some glyphs from Private Use Area codepoints that only the\n * KaTeX fonts carry (`\\ne` is U+E020 overlapped on `=`), so a missing font file\n * renders tofu rather than a plainer glyph. The faces therefore ship in the\n * bundle - pie-elements has no stylesheet to carry `@font-face` and no asset\n * path to serve woff2 files from.\n */\ndescribe('embedded fonts', () => {\n  const originalFonts = document.fonts;\n\n  const fakeFontSet = (existing = []) => {\n    const added = [];\n    const set = {\n      add: (f) => added.push(f),\n      [Symbol.iterator]: () => existing[Symbol.iterator](),\n    };\n\n    Object.defineProperty(document, 'fonts', { value: set, configurable: true });\n\n    return added;\n  };\n\n  beforeEach(() => {\n    resetEmbeddedFontsForTests();\n    global.FontFace = jest.fn(function FontFace(family, src, descriptors) {\n      Object.assign(this, { family, src, descriptors });\n    });\n  });\n\n  afterEach(() => {\n    Object.defineProperty(document, 'fonts', { value: originalFonts, configurable: true });\n    delete global.FontFace;\n  });\n\n  // The 12 families MathLive's own loadFonts() looks for; if every one is in\n  // document.fonts it short-circuits to \"ready\" and issues no network request.\n  it('covers every family MathLive requires', () => {\n    expect(EMBEDDED_FONT_FAMILIES.sort()).toEqual(\n      [\n        'KaTeX_AMS',\n        'KaTeX_Caligraphic',\n        'KaTeX_Fraktur',\n        'KaTeX_Main',\n        'KaTeX_Math',\n        'KaTeX_SansSerif',\n        'KaTeX_Script',\n        'KaTeX_Size1',\n        'KaTeX_Size2',\n        'KaTeX_Size3',\n        'KaTeX_Size4',\n        'KaTeX_Typewriter',\n      ].sort(),\n    );\n  });\n\n  it('carries all 20 faces as self-contained data URIs', () => {\n    expect(EMBEDDED_FONTS).toHaveLength(20);\n\n    EMBEDDED_FONTS.forEach(({ family, src }) => {\n      expect(family).toMatch(/^KaTeX_/);\n      // No network: a data URI, not a path or a CDN URL.\n      expect(src).toMatch(/^url\\(data:font\\/woff2;base64,[A-Za-z0-9+/=]+\\) format\\('woff2'\\)$/);\n    });\n  });\n\n  it('is generated from the installed mathlive, so glyph metrics match the engine', () => {\n    /* eslint-disable global-require */\n    const fs = require('fs');\n    const path = require('path');\n    /* eslint-enable global-require */\n\n    // Read the file rather than require('mathlive/package.json'): MathLive's\n    // exports map does not expose that subpath.\n    const manifest = [\n      path.resolve(__dirname, '../../../../node_modules/mathlive/package.json'),\n      path.resolve(__dirname, '../../node_modules/mathlive/package.json'),\n    ].find((p) => fs.existsSync(p));\n\n    expect(manifest).toBeDefined();\n    expect(MATHLIVE_VERSION).toEqual(JSON.parse(fs.readFileSync(manifest, 'utf8')).version);\n  });\n\n  it('registers every face with the document', () => {\n    const added = fakeFontSet();\n\n    expect(registerEmbeddedFonts()).toBe(true);\n    expect(added).toHaveLength(20);\n    expect(added.map((f) => f.family)).toContain('KaTeX_Main');\n    // Descriptors ride along, or bold/italic math would synthesise from regular.\n    expect(added.find((f) => f.src.startsWith('url(data:') && f.descriptors.weight === 'bold')).toBeDefined();\n  });\n\n  it('does not register twice', () => {\n    const added = fakeFontSet();\n\n    registerEmbeddedFonts();\n    registerEmbeddedFonts();\n\n    expect(added).toHaveLength(20);\n  });\n\n  it('leaves the document alone when it already provides every family', () => {\n    // A host that serves the fonts itself - configureFonts, or importing\n    // mathlive/fonts.css - wins.\n    const added = fakeFontSet(EMBEDDED_FONT_FAMILIES.map((family) => ({ family })));\n\n    expect(registerEmbeddedFonts()).toBe(true);\n    expect(added).toHaveLength(0);\n  });\n\n  it('reports failure instead of throwing when the FontFace API is missing', () => {\n    fakeFontSet();\n    delete global.FontFace;\n\n    expect(registerEmbeddedFonts()).toBe(false);\n  });\n\n  it('reports failure instead of throwing when a face cannot be constructed', () => {\n    fakeFontSet();\n    global.FontFace = jest.fn(() => {\n      throw new Error('bad font');\n    });\n\n    expect(registerEmbeddedFonts()).toBe(false);\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,SAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACAE,QAAQ,CAAC,gBAAgB,EAAE,YAAM;EAC/B,IAAMC,aAAa,GAAGC,QAAQ,CAACC,KAAK;EAEpC,IAAMC,WAAW,GAAG,SAAdA,WAAWA,CAAA,EAAsB;IAAA,IAAlBC,QAAQ,GAAAC,SAAA,CAAAC,MAAA,QAAAD,SAAA,QAAAE,SAAA,GAAAF,SAAA,MAAG,EAAE;IAChC,IAAMG,KAAK,GAAG,EAAE;IAChB,IAAMC,GAAG,OAAAC,gBAAA;MACPC,GAAG,EAAE,SAALA,GAAGA,CAAGC,CAAC;QAAA,OAAKJ,KAAK,CAACK,IAAI,CAACD,CAAC,CAAC;MAAA;IAAA,GACxBE,MAAM,CAACC,QAAQ,EAAG;MAAA,OAAMX,QAAQ,CAACU,MAAM,CAACC,QAAQ,CAAC,CAAC,CAAC;IAAA,EACrD;IAEDC,MAAM,CAACC,cAAc,CAAChB,QAAQ,EAAE,OAAO,EAAE;MAAEiB,KAAK,EAAET,GAAG;MAAEU,YAAY,EAAE;IAAK,CAAC,CAAC;IAE5E,OAAOX,KAAK;EACd,CAAC;EAEDY,UAAU,CAAC,YAAM;IACf,IAAAC,iCAA0B,EAAC,CAAC;IAC5BC,MAAM,CAACC,QAAQ,GAAGC,IAAI,CAACC,EAAE,CAAC,SAASF,QAAQA,CAACG,MAAM,EAAEC,GAAG,EAAEC,WAAW,EAAE;MACpEZ,MAAM,CAACa,MAAM,CAAC,IAAI,EAAE;QAAEH,MAAM,EAANA,MAAM;QAAEC,GAAG,EAAHA,GAAG;QAAEC,WAAW,EAAXA;MAAY,CAAC,CAAC;IACnD,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFE,SAAS,CAAC,YAAM;IACdd,MAAM,CAACC,cAAc,CAAChB,QAAQ,EAAE,OAAO,EAAE;MAAEiB,KAAK,EAAElB,aAAa;MAAEmB,YAAY,EAAE;IAAK,CAAC,CAAC;IACtF,OAAOG,MAAM,CAACC,QAAQ;EACxB,CAAC,CAAC;;EAEF;EACA;EACAQ,EAAE,CAAC,uCAAuC,EAAE,YAAM;IAChDC,MAAM,CAACC,6BAAsB,CAACC,IAAI,CAAC,CAAC,CAAC,CAACC,OAAO,CAC3C,CACE,WAAW,EACX,mBAAmB,EACnB,eAAe,EACf,YAAY,EACZ,YAAY,EACZ,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,CACnB,CAACD,IAAI,CAAC,CACT,CAAC;EACH,CAAC,CAAC;EAEFH,EAAE,CAAC,kDAAkD,EAAE,YAAM;IAC3DC,MAAM,CAACI,wBAAc,CAAC,CAACC,YAAY,CAAC,EAAE,CAAC;IAEvCD,wBAAc,CAACE,OAAO,CAAC,UAAAC,IAAA,EAAqB;MAAA,IAAlBb,MAAM,GAAAa,IAAA,CAANb,MAAM;QAAEC,GAAG,GAAAY,IAAA,CAAHZ,GAAG;MACnCK,MAAM,CAACN,MAAM,CAAC,CAACc,OAAO,CAAC,SAAS,CAAC;MACjC;MACAR,MAAM,CAACL,GAAG,CAAC,CAACa,OAAO,CAAC,oEAAoE,CAAC;IAC3F,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFT,EAAE,CAAC,6EAA6E,EAAE,YAAM;IACtF;IACA,IAAMU,EAAE,GAAG5C,OAAO,CAAC,IAAI,CAAC;IACxB,IAAM6C,IAAI,GAAG7C,OAAO,CAAC,MAAM,CAAC;IAC5B;;IAEA;IACA;IACA,IAAM8C,QAAQ,GAAG,CACfD,IAAI,CAACE,OAAO,CAACC,SAAS,EAAE,gDAAgD,CAAC,EACzEH,IAAI,CAACE,OAAO,CAACC,SAAS,EAAE,0CAA0C,CAAC,CACpE,CAACC,IAAI,CAAC,UAACC,CAAC;MAAA,OAAKN,EAAE,CAACO,UAAU,CAACD,CAAC,CAAC;IAAA,EAAC;IAE/Bf,MAAM,CAACW,QAAQ,CAAC,CAACM,WAAW,CAAC,CAAC;IAC9BjB,MAAM,CAACkB,0BAAgB,CAAC,CAACf,OAAO,CAACgB,IAAI,CAACC,KAAK,CAACX,EAAE,CAACY,YAAY,CAACV,QAAQ,EAAE,MAAM,CAAC,CAAC,CAACW,OAAO,CAAC;EACzF,CAAC,CAAC;EAEFvB,EAAE,CAAC,wCAAwC,EAAE,YAAM;IACjD,IAAMvB,KAAK,GAAGL,WAAW,CAAC,CAAC;IAE3B6B,MAAM,CAAC,IAAAuB,4BAAqB,EAAC,CAAC,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;IAC1CxB,MAAM,CAACxB,KAAK,CAAC,CAAC6B,YAAY,CAAC,EAAE,CAAC;IAC9BL,MAAM,CAACxB,KAAK,CAACiD,GAAG,CAAC,UAAC7C,CAAC;MAAA,OAAKA,CAAC,CAACc,MAAM;IAAA,EAAC,CAAC,CAACgC,SAAS,CAAC,YAAY,CAAC;IAC1D;IACA1B,MAAM,CAACxB,KAAK,CAACsC,IAAI,CAAC,UAAClC,CAAC;MAAA,OAAKA,CAAC,CAACe,GAAG,CAACgC,UAAU,CAAC,WAAW,CAAC,IAAI/C,CAAC,CAACgB,WAAW,CAACgC,MAAM,KAAK,MAAM;IAAA,EAAC,CAAC,CAACX,WAAW,CAAC,CAAC;EAC3G,CAAC,CAAC;EAEFlB,EAAE,CAAC,yBAAyB,EAAE,YAAM;IAClC,IAAMvB,KAAK,GAAGL,WAAW,CAAC,CAAC;IAE3B,IAAAoD,4BAAqB,EAAC,CAAC;IACvB,IAAAA,4BAAqB,EAAC,CAAC;IAEvBvB,MAAM,CAACxB,KAAK,CAAC,CAAC6B,YAAY,CAAC,EAAE,CAAC;EAChC,CAAC,CAAC;EAEFN,EAAE,CAAC,iEAAiE,EAAE,YAAM;IAC1E;IACA;IACA,IAAMvB,KAAK,GAAGL,WAAW,CAAC8B,6BAAsB,CAACwB,GAAG,CAAC,UAAC/B,MAAM;MAAA,OAAM;QAAEA,MAAM,EAANA;MAAO,CAAC;IAAA,CAAC,CAAC,CAAC;IAE/EM,MAAM,CAAC,IAAAuB,4BAAqB,EAAC,CAAC,CAAC,CAACC,IAAI,CAAC,IAAI,CAAC;IAC1CxB,MAAM,CAACxB,KAAK,CAAC,CAAC6B,YAAY,CAAC,CAAC,CAAC;EAC/B,CAAC,CAAC;EAEFN,EAAE,CAAC,sEAAsE,EAAE,YAAM;IAC/E5B,WAAW,CAAC,CAAC;IACb,OAAOmB,MAAM,CAACC,QAAQ;IAEtBS,MAAM,CAAC,IAAAuB,4BAAqB,EAAC,CAAC,CAAC,CAACC,IAAI,CAAC,KAAK,CAAC;EAC7C,CAAC,CAAC;EAEFzB,EAAE,CAAC,uEAAuE,EAAE,YAAM;IAChF5B,WAAW,CAAC,CAAC;IACbmB,MAAM,CAACC,QAAQ,GAAGC,IAAI,CAACC,EAAE,CAAC,YAAM;MAC9B,MAAM,IAAIoC,KAAK,CAAC,UAAU,CAAC;IAC7B,CAAC,CAAC;IAEF7B,MAAM,CAAC,IAAAuB,4BAAqB,EAAC,CAAC,CAAC,CAACC,IAAI,CAAC,KAAK,CAAC;EAC7C,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}