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

package/lib/__tests__/index.test.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+var _index = require("../index");
+describe('math-input-mathlive public API', function () {
+  it('mirrors the @pie-lib/math-input export surface', function () {
+    expect((0, _typeof2["default"])(_index.keysForGrade)).toBe('function');
+    expect((0, _typeof2["default"])(_index.addBrackets)).toBe('function');
+    expect((0, _typeof2["default"])(_index.removeBrackets)).toBe('function');
+    expect((0, _typeof2["default"])(_index.registerEmbed)).toBe('function');
+    expect((0, _typeof2["default"])(_index.applyStaticMath)).toBe('function');
+    expect((0, _typeof2["default"])(_index.updateSpans)).toBe('function');
+    expect(_index.keys).toBeDefined();
+    expect(_index.keys.baseSet).toBeDefined();
+  });
+  it('exports the field wrappers under both mf and mq', function () {
+    expect(_index.mf.Input).toBeDefined();
+    expect(_index.mf.Static).toBeDefined();
+    // `mq` alias lets a consumer swap packages by changing only the import.
+    expect(_index.mq).toBe(_index.mf);
+  });
+  it('updateSpans is a safe no-op', function () {
+    expect(function () {
+      return (0, _index.updateSpans)();
+    }).not.toThrow();
+  });
+  it('CommonMqStyles keeps the shape consumers destructure', function () {
+    // math-toolbar does:
+    //   const { commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles }
+    //     = mq.CommonMqStyles;
+    var _mf$CommonMqStyles = _index.mf.CommonMqStyles,
+      commonMqFontStyles = _mf$CommonMqStyles.commonMqFontStyles,
+      commonMqKeyboardStyles = _mf$CommonMqStyles.commonMqKeyboardStyles,
+      longdivStyles = _mf$CommonMqStyles.longdivStyles,
+      supsubStyles = _mf$CommonMqStyles.supsubStyles;
+    [commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles].forEach(function (s) {
+      expect(s).toBeDefined();
+      expect((0, _typeof2["default"])(s)).toBe('object');
+    });
+  });
+  it('bracket helpers round-trip', function () {
+    expect((0, _index.addBrackets)('x')).toEqual('\\(x\\)');
+    expect((0, _index.removeBrackets)('\\(x\\)')).toEqual('x');
+    expect((0, _index.removeBrackets)((0, _index.addBrackets)('\\frac{1}{2}'))).toEqual('\\frac{1}{2}');
+  });
+  it('keysForGrade returns a 5-row keyset', function () {
+    var set = (0, _index.keysForGrade)('geometry');
+    expect(Array.isArray(set)).toBe(true);
+    expect(set.length).toBe(5);
+  });
+});
+describe('rendering', function () {
+  // MathLive is a browser-only custom element; loadMathLive() resolves async and
+  // is a no-op-ish under jsdom. These assert the components mount without
+  // throwing, which is what regressed most often in the MathQuill version.
+  it('KeyPad renders without a live MathLive instance', function () {
+    var _render = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.KeyPad, {
+        onPress: function onPress() {}
+      })),
+      container = _render.container;
+    expect(container.querySelectorAll('button').length).toBeGreaterThan(0);
+  });
+  it('KeyPad falls back to raw latex for labels before MathLive loads', function () {
+    var _render2 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.KeyPad, {
+        onPress: function onPress() {},
+        baseSet: [[{
+          name: 'pi',
+          latex: '\\pi',
+          category: 'constants'
+        }]]
+      })),
+      container = _render2.container;
+    expect(container.textContent).toContain('\\pi');
+  });
+  it('KeyPad fires onPress with the key definition', function () {
+    var onPress = jest.fn();
+    var key = {
+      name: 'x',
+      label: 'x',
+      write: 'x',
+      category: 'vars'
+    };
+    var _render3 = (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.KeyPad, {
+        onPress: onPress,
+        baseSet: [[key]]
+      })),
+      container = _render3.container;
+    container.querySelector('button').click();
+    expect(onPress).toHaveBeenCalledWith(key);
+  });
+  it('MathInput mounts', function () {
+    expect(function () {
+      return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.MathInput, {
+        latex: "\\\\frac{1}{2}",
+        onChange: function onChange() {}
+      }));
+    }).not.toThrow();
+  });
+  it('HorizontalKeypad mounts and reports the legacy {value,type} model', function () {
+    var onClick = jest.fn();
+    expect(function () {
+      return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.HorizontalKeypad, {
+        onClick: onClick
+      }));
+    }).not.toThrow();
+  });
+  it('Static renders display-mode latex without a mathfield', function () {
+    expect(function () {
+      return (0, _react2.render)(/*#__PURE__*/_react["default"].createElement(_index.mf.Static, {
+        latex: "\\\\frac{1}{2}"
+      }));
+    }).not.toThrow();
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_react2","_index","describe","it","expect","_typeof2","keysForGrade","toBe","addBrackets","removeBrackets","registerEmbed","applyStaticMath","updateSpans","keys","toBeDefined","baseSet","mf","Input","Static","mq","not","toThrow","_mf$CommonMqStyles","CommonMqStyles","commonMqFontStyles","commonMqKeyboardStyles","longdivStyles","supsubStyles","forEach","s","toEqual","set","Array","isArray","length","_render","render","createElement","KeyPad","onPress","container","querySelectorAll","toBeGreaterThan","_render2","name","latex","category","textContent","toContain","jest","fn","key","label","write","_render3","querySelector","click","toHaveBeenCalledWith","MathInput","onChange","onClick","HorizontalKeypad"],"sources":["../../src/__tests__/index.test.jsx"],"sourcesContent":["import React from 'react';\nimport { render } from '@testing-library/react';\n\nimport {\n  keys,\n  keysForGrade,\n  addBrackets,\n  removeBrackets,\n  registerEmbed,\n  applyStaticMath,\n  updateSpans,\n  mf,\n  mq,\n  MathInput,\n  HorizontalKeypad,\n  KeyPad,\n} from '../index';\n\ndescribe('math-input-mathlive public API', () => {\n  it('mirrors the @pie-lib/math-input export surface', () => {\n    expect(typeof keysForGrade).toBe('function');\n    expect(typeof addBrackets).toBe('function');\n    expect(typeof removeBrackets).toBe('function');\n    expect(typeof registerEmbed).toBe('function');\n    expect(typeof applyStaticMath).toBe('function');\n    expect(typeof updateSpans).toBe('function');\n    expect(keys).toBeDefined();\n    expect(keys.baseSet).toBeDefined();\n  });\n\n  it('exports the field wrappers under both mf and mq', () => {\n    expect(mf.Input).toBeDefined();\n    expect(mf.Static).toBeDefined();\n    // `mq` alias lets a consumer swap packages by changing only the import.\n    expect(mq).toBe(mf);\n  });\n\n  it('updateSpans is a safe no-op', () => {\n    expect(() => updateSpans()).not.toThrow();\n  });\n\n  it('CommonMqStyles keeps the shape consumers destructure', () => {\n    // math-toolbar does:\n    //   const { commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles }\n    //     = mq.CommonMqStyles;\n    const { commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles } = mf.CommonMqStyles;\n\n    [commonMqFontStyles, commonMqKeyboardStyles, longdivStyles, supsubStyles].forEach((s) => {\n      expect(s).toBeDefined();\n      expect(typeof s).toBe('object');\n    });\n  });\n\n  it('bracket helpers round-trip', () => {\n    expect(addBrackets('x')).toEqual('\\\\(x\\\\)');\n    expect(removeBrackets('\\\\(x\\\\)')).toEqual('x');\n    expect(removeBrackets(addBrackets('\\\\frac{1}{2}'))).toEqual('\\\\frac{1}{2}');\n  });\n\n  it('keysForGrade returns a 5-row keyset', () => {\n    const set = keysForGrade('geometry');\n\n    expect(Array.isArray(set)).toBe(true);\n    expect(set.length).toBe(5);\n  });\n});\n\ndescribe('rendering', () => {\n  // MathLive is a browser-only custom element; loadMathLive() resolves async and\n  // is a no-op-ish under jsdom. These assert the components mount without\n  // throwing, which is what regressed most often in the MathQuill version.\n  it('KeyPad renders without a live MathLive instance', () => {\n    const { container } = render(<KeyPad onPress={() => {}} />);\n\n    expect(container.querySelectorAll('button').length).toBeGreaterThan(0);\n  });\n\n  it('KeyPad falls back to raw latex for labels before MathLive loads', () => {\n    const { container } = render(\n      <KeyPad onPress={() => {}} baseSet={[[{ name: 'pi', latex: '\\\\pi', category: 'constants' }]]} />,\n    );\n\n    expect(container.textContent).toContain('\\\\pi');\n  });\n\n  it('KeyPad fires onPress with the key definition', () => {\n    const onPress = jest.fn();\n    const key = { name: 'x', label: 'x', write: 'x', category: 'vars' };\n    const { container } = render(<KeyPad onPress={onPress} baseSet={[[key]]} />);\n\n    container.querySelector('button').click();\n\n    expect(onPress).toHaveBeenCalledWith(key);\n  });\n\n  it('MathInput mounts', () => {\n    expect(() => render(<MathInput latex=\"\\\\frac{1}{2}\" onChange={() => {}} />)).not.toThrow();\n  });\n\n  it('HorizontalKeypad mounts and reports the legacy {value,type} model', () => {\n    const onClick = jest.fn();\n\n    expect(() => render(<HorizontalKeypad onClick={onClick} />)).not.toThrow();\n  });\n\n  it('Static renders display-mode latex without a mathfield', () => {\n    expect(() => render(<mf.Static latex=\"\\\\frac{1}{2}\" />)).not.toThrow();\n  });\n});\n"],"mappings":";;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,MAAA,GAAAF,OAAA;AAeAG,QAAQ,CAAC,gCAAgC,EAAE,YAAM;EAC/CC,EAAE,CAAC,gDAAgD,EAAE,YAAM;IACzDC,MAAM,KAAAC,QAAA,aAAQC,mBAAY,EAAC,CAACC,IAAI,CAAC,UAAU,CAAC;IAC5CH,MAAM,KAAAC,QAAA,aAAQG,kBAAW,EAAC,CAACD,IAAI,CAAC,UAAU,CAAC;IAC3CH,MAAM,KAAAC,QAAA,aAAQI,qBAAc,EAAC,CAACF,IAAI,CAAC,UAAU,CAAC;IAC9CH,MAAM,KAAAC,QAAA,aAAQK,oBAAa,EAAC,CAACH,IAAI,CAAC,UAAU,CAAC;IAC7CH,MAAM,KAAAC,QAAA,aAAQM,sBAAe,EAAC,CAACJ,IAAI,CAAC,UAAU,CAAC;IAC/CH,MAAM,KAAAC,QAAA,aAAQO,kBAAW,EAAC,CAACL,IAAI,CAAC,UAAU,CAAC;IAC3CH,MAAM,CAACS,WAAI,CAAC,CAACC,WAAW,CAAC,CAAC;IAC1BV,MAAM,CAACS,WAAI,CAACE,OAAO,CAAC,CAACD,WAAW,CAAC,CAAC;EACpC,CAAC,CAAC;EAEFX,EAAE,CAAC,iDAAiD,EAAE,YAAM;IAC1DC,MAAM,CAACY,SAAE,CAACC,KAAK,CAAC,CAACH,WAAW,CAAC,CAAC;IAC9BV,MAAM,CAACY,SAAE,CAACE,MAAM,CAAC,CAACJ,WAAW,CAAC,CAAC;IAC/B;IACAV,MAAM,CAACe,SAAE,CAAC,CAACZ,IAAI,CAACS,SAAE,CAAC;EACrB,CAAC,CAAC;EAEFb,EAAE,CAAC,6BAA6B,EAAE,YAAM;IACtCC,MAAM,CAAC;MAAA,OAAM,IAAAQ,kBAAW,EAAC,CAAC;IAAA,EAAC,CAACQ,GAAG,CAACC,OAAO,CAAC,CAAC;EAC3C,CAAC,CAAC;EAEFlB,EAAE,CAAC,sDAAsD,EAAE,YAAM;IAC/D;IACA;IACA;IACA,IAAAmB,kBAAA,GAAoFN,SAAE,CAACO,cAAc;MAA7FC,kBAAkB,GAAAF,kBAAA,CAAlBE,kBAAkB;MAAEC,sBAAsB,GAAAH,kBAAA,CAAtBG,sBAAsB;MAAEC,aAAa,GAAAJ,kBAAA,CAAbI,aAAa;MAAEC,YAAY,GAAAL,kBAAA,CAAZK,YAAY;IAE/E,CAACH,kBAAkB,EAAEC,sBAAsB,EAAEC,aAAa,EAAEC,YAAY,CAAC,CAACC,OAAO,CAAC,UAACC,CAAC,EAAK;MACvFzB,MAAM,CAACyB,CAAC,CAAC,CAACf,WAAW,CAAC,CAAC;MACvBV,MAAM,KAAAC,QAAA,aAAQwB,CAAC,EAAC,CAACtB,IAAI,CAAC,QAAQ,CAAC;IACjC,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFJ,EAAE,CAAC,4BAA4B,EAAE,YAAM;IACrCC,MAAM,CAAC,IAAAI,kBAAW,EAAC,GAAG,CAAC,CAAC,CAACsB,OAAO,CAAC,SAAS,CAAC;IAC3C1B,MAAM,CAAC,IAAAK,qBAAc,EAAC,SAAS,CAAC,CAAC,CAACqB,OAAO,CAAC,GAAG,CAAC;IAC9C1B,MAAM,CAAC,IAAAK,qBAAc,EAAC,IAAAD,kBAAW,EAAC,cAAc,CAAC,CAAC,CAAC,CAACsB,OAAO,CAAC,cAAc,CAAC;EAC7E,CAAC,CAAC;EAEF3B,EAAE,CAAC,qCAAqC,EAAE,YAAM;IAC9C,IAAM4B,GAAG,GAAG,IAAAzB,mBAAY,EAAC,UAAU,CAAC;IAEpCF,MAAM,CAAC4B,KAAK,CAACC,OAAO,CAACF,GAAG,CAAC,CAAC,CAACxB,IAAI,CAAC,IAAI,CAAC;IACrCH,MAAM,CAAC2B,GAAG,CAACG,MAAM,CAAC,CAAC3B,IAAI,CAAC,CAAC,CAAC;EAC5B,CAAC,CAAC;AACJ,CAAC,CAAC;AAEFL,QAAQ,CAAC,WAAW,EAAE,YAAM;EAC1B;EACA;EACA;EACAC,EAAE,CAAC,iDAAiD,EAAE,YAAM;IAC1D,IAAAgC,OAAA,GAAsB,IAAAC,cAAM,eAACvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAAqC,MAAM;QAACC,OAAO,EAAE,SAATA,OAAOA,CAAA,EAAQ,CAAC;MAAE,CAAE,CAAC,CAAC;MAAnDC,SAAS,GAAAL,OAAA,CAATK,SAAS;IAEjBpC,MAAM,CAACoC,SAAS,CAACC,gBAAgB,CAAC,QAAQ,CAAC,CAACP,MAAM,CAAC,CAACQ,eAAe,CAAC,CAAC,CAAC;EACxE,CAAC,CAAC;EAEFvC,EAAE,CAAC,iEAAiE,EAAE,YAAM;IAC1E,IAAAwC,QAAA,GAAsB,IAAAP,cAAM,eAC1BvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAAqC,MAAM;QAACC,OAAO,EAAE,SAATA,OAAOA,CAAA,EAAQ,CAAC,CAAE;QAACxB,OAAO,EAAE,CAAC,CAAC;UAAE6B,IAAI,EAAE,IAAI;UAAEC,KAAK,EAAE,MAAM;UAAEC,QAAQ,EAAE;QAAY,CAAC,CAAC;MAAE,CAAE,CACjG,CAAC;MAFON,SAAS,GAAAG,QAAA,CAATH,SAAS;IAIjBpC,MAAM,CAACoC,SAAS,CAACO,WAAW,CAAC,CAACC,SAAS,CAAC,MAAM,CAAC;EACjD,CAAC,CAAC;EAEF7C,EAAE,CAAC,8CAA8C,EAAE,YAAM;IACvD,IAAMoC,OAAO,GAAGU,IAAI,CAACC,EAAE,CAAC,CAAC;IACzB,IAAMC,GAAG,GAAG;MAAEP,IAAI,EAAE,GAAG;MAAEQ,KAAK,EAAE,GAAG;MAAEC,KAAK,EAAE,GAAG;MAAEP,QAAQ,EAAE;IAAO,CAAC;IACnE,IAAAQ,QAAA,GAAsB,IAAAlB,cAAM,eAACvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAAqC,MAAM;QAACC,OAAO,EAAEA,OAAQ;QAACxB,OAAO,EAAE,CAAC,CAACoC,GAAG,CAAC;MAAE,CAAE,CAAC,CAAC;MAApEX,SAAS,GAAAc,QAAA,CAATd,SAAS;IAEjBA,SAAS,CAACe,aAAa,CAAC,QAAQ,CAAC,CAACC,KAAK,CAAC,CAAC;IAEzCpD,MAAM,CAACmC,OAAO,CAAC,CAACkB,oBAAoB,CAACN,GAAG,CAAC;EAC3C,CAAC,CAAC;EAEFhD,EAAE,CAAC,kBAAkB,EAAE,YAAM;IAC3BC,MAAM,CAAC;MAAA,OAAM,IAAAgC,cAAM,eAACvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAAyD,SAAS;QAACb,KAAK,EAAC,gBAAc;QAACc,QAAQ,EAAE,SAAVA,QAAQA,CAAA,EAAQ,CAAC;MAAE,CAAE,CAAC,CAAC;IAAA,EAAC,CAACvC,GAAG,CAACC,OAAO,CAAC,CAAC;EAC5F,CAAC,CAAC;EAEFlB,EAAE,CAAC,mEAAmE,EAAE,YAAM;IAC5E,IAAMyD,OAAO,GAAGX,IAAI,CAACC,EAAE,CAAC,CAAC;IAEzB9C,MAAM,CAAC;MAAA,OAAM,IAAAgC,cAAM,eAACvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAA4D,gBAAgB;QAACD,OAAO,EAAEA;MAAQ,CAAE,CAAC,CAAC;IAAA,EAAC,CAACxC,GAAG,CAACC,OAAO,CAAC,CAAC;EAC5E,CAAC,CAAC;EAEFlB,EAAE,CAAC,uDAAuD,EAAE,YAAM;IAChEC,MAAM,CAAC;MAAA,OAAM,IAAAgC,cAAM,eAACvC,MAAA,YAAAwC,aAAA,CAACpC,MAAA,CAAAe,EAAE,CAACE,MAAM;QAAC2B,KAAK,EAAC;MAAc,CAAE,CAAC,CAAC;IAAA,EAAC,CAACzB,GAAG,CAACC,OAAO,CAAC,CAAC;EACxE,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}

package/lib/__tests__/input-imperative.test.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _latexBridge = require("../latex-bridge");
+var _input = _interopRequireDefault(require("../mf/input"));
+/**
+ * The imperative surface that @pie-lib/math-toolbar drives
+ * (editor-and-pad.jsx: clear/command/keystroke/write/latex).
+ *
+ * These call the methods against a stub mathfield, because a real
+ * <math-field> needs a browser. What matters here is the *translation*:
+ * MathQuill-era arguments must become valid MathLive operations.
+ */
+var stubField = function stubField() {
+  var calls = {
+    insert: [],
+    executeCommand: [],
+    focus: 0
+  };
+  return {
+    calls: calls,
+    value: '',
+    getValue: function getValue() {
+      return '';
+    },
+    insert: function insert(v) {
+      calls.insert.push(v);
+    },
+    executeCommand: function executeCommand(v) {
+      calls.executeCommand.push(v);
+    },
+    focus: function focus() {
+      calls.focus++;
+    },
+    blur: function blur() {}
+  };
+};
+var withField = function withField() {
+  var input = new _input["default"]({});
+  var f = stubField();
+  input.mathField = f;
+  return {
+    input: input,
+    f: f
+  };
+};
+describe('Input imperative API (drives math-toolbar)', function () {
+  describe('keystroke', function () {
+    it('maps MathQuill keystroke names to MathLive selectors', function () {
+      var _withField = withField(),
+        input = _withField.input,
+        f = _withField.f;
+      input.keystroke('Left');
+      input.keystroke('Right');
+      input.keystroke('Backspace');
+      expect(f.calls.executeCommand).toEqual(['moveToPreviousChar', 'moveToNextChar', 'deleteBackward']);
+    });
+    it('passes an unknown value through as a selector', function () {
+      var _withField2 = withField(),
+        input = _withField2.input,
+        f = _withField2.f;
+      input.keystroke('deleteForward');
+      expect(f.calls.executeCommand).toEqual(['deleteForward']);
+    });
+    it('does not throw when the engine rejects the selector', function () {
+      var _withField3 = withField(),
+        input = _withField3.input;
+      input.mathField.executeCommand = function () {
+        throw new Error('unknown command');
+      };
+      expect(function () {
+        return input.keystroke('Nonsense');
+      }).not.toThrow();
+    });
+    it('covers every keystroke the keypad emits', function () {
+      // navigation.js / edit.js only produce these three
+      ['Left', 'Right', 'Backspace'].forEach(function (k) {
+        return expect(_latexBridge.KEYSTROKES[k]).toBeDefined();
+      });
+    });
+  });
+  describe('command', function () {
+    it('expands argument-taking commands into placeholders', function () {
+      var _withField4 = withField(),
+        input = _withField4.input,
+        f = _withField4.f;
+      input.command('\\frac');
+
+      // a bare \frac would give no editable slots
+      expect(f.calls.insert).toEqual(['\\frac{#?}{#?}']);
+    });
+    it('handles array commands', function () {
+      var _withField5 = withField(),
+        input = _withField5.input,
+        f = _withField5.f;
+      input.command(['\\log', '_']);
+      expect(f.calls.insert).toEqual(['\\log_{#?}']);
+    });
+    it('passes argument-less commands through', function () {
+      var _withField6 = withField(),
+        input = _withField6.input,
+        f = _withField6.f;
+      input.command('\\pi');
+      expect(f.calls.insert).toEqual(['\\pi']);
+    });
+    it('agrees with keyToAction', function () {
+      expect((0, _latexBridge.keyToAction)({
+        command: '\\sqrt'
+      }).value).toEqual('\\sqrt{#?}');
+    });
+  });
+  describe('safety before MathLive loads', function () {
+    it('every method is a no-op rather than a crash', function () {
+      var input = new _input["default"]({});
+
+      // mathField is undefined until loadMathLive() resolves
+      expect(input.latex()).toEqual('');
+      expect(input.clear()).toEqual('');
+      expect(input.command('\\frac')).toEqual('');
+      expect(input.keystroke('Left')).toEqual('');
+      expect(input.write('x')).toEqual('');
+      expect(function () {
+        return input.focus();
+      }).not.toThrow();
+      expect(function () {
+        return input.blur();
+      }).not.toThrow();
+      expect(function () {
+        return input.setLatex('x');
+      }).not.toThrow();
+      expect(input.element).toBeUndefined();
+    });
+  });
+  describe('mqCompat facade', function () {
+    // math-toolbar used to call this.input.mathField.latex(); external
+    // consumers may still do the same.
+    it('exposes latex() as a getter', function () {
+      var _withField7 = withField(),
+        input = _withField7.input;
+      input.mathField.getValue = function () {
+        return '\\frac{1}{2}';
+      };
+      expect(input.mqCompat.latex()).toEqual('\\frac{1}{2}');
+    });
+    it('exposes latex(v) as a setter and el()', function () {
+      var _withField8 = withField(),
+        input = _withField8.input,
+        f = _withField8.f;
+      input.mqCompat.latex('x+1');
+      expect(f.value).toEqual('x+1');
+      expect(input.mqCompat.el()).toBe(f);
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_latexBridge","require","_input","_interopRequireDefault","stubField","calls","insert","executeCommand","focus","value","getValue","v","push","blur","withField","input","Input","f","mathField","describe","it","_withField","keystroke","expect","toEqual","_withField2","_withField3","Error","not","toThrow","forEach","k","KEYSTROKES","toBeDefined","_withField4","command","_withField5","_withField6","keyToAction","latex","clear","write","setLatex","element","toBeUndefined","_withField7","mqCompat","_withField8","el","toBe"],"sources":["../../src/__tests__/input-imperative.test.jsx"],"sourcesContent":["import { KEYSTROKES, keyToAction } from '../latex-bridge';\nimport Input from '../mf/input';\n\n/**\n * The imperative surface that @pie-lib/math-toolbar drives\n * (editor-and-pad.jsx: clear/command/keystroke/write/latex).\n *\n * These call the methods against a stub mathfield, because a real\n * <math-field> needs a browser. What matters here is the *translation*:\n * MathQuill-era arguments must become valid MathLive operations.\n */\nconst stubField = () => {\n  const calls = { insert: [], executeCommand: [], focus: 0 };\n\n  return {\n    calls,\n    value: '',\n    getValue: () => '',\n    insert(v) {\n      calls.insert.push(v);\n    },\n    executeCommand(v) {\n      calls.executeCommand.push(v);\n    },\n    focus() {\n      calls.focus++;\n    },\n    blur() {},\n  };\n};\n\nconst withField = () => {\n  const input = new Input({});\n  const f = stubField();\n\n  input.mathField = f;\n\n  return { input, f };\n};\n\ndescribe('Input imperative API (drives math-toolbar)', () => {\n  describe('keystroke', () => {\n    it('maps MathQuill keystroke names to MathLive selectors', () => {\n      const { input, f } = withField();\n\n      input.keystroke('Left');\n      input.keystroke('Right');\n      input.keystroke('Backspace');\n\n      expect(f.calls.executeCommand).toEqual(['moveToPreviousChar', 'moveToNextChar', 'deleteBackward']);\n    });\n\n    it('passes an unknown value through as a selector', () => {\n      const { input, f } = withField();\n\n      input.keystroke('deleteForward');\n\n      expect(f.calls.executeCommand).toEqual(['deleteForward']);\n    });\n\n    it('does not throw when the engine rejects the selector', () => {\n      const { input } = withField();\n\n      input.mathField.executeCommand = () => {\n        throw new Error('unknown command');\n      };\n\n      expect(() => input.keystroke('Nonsense')).not.toThrow();\n    });\n\n    it('covers every keystroke the keypad emits', () => {\n      // navigation.js / edit.js only produce these three\n      ['Left', 'Right', 'Backspace'].forEach((k) => expect(KEYSTROKES[k]).toBeDefined());\n    });\n  });\n\n  describe('command', () => {\n    it('expands argument-taking commands into placeholders', () => {\n      const { input, f } = withField();\n\n      input.command('\\\\frac');\n\n      // a bare \\frac would give no editable slots\n      expect(f.calls.insert).toEqual(['\\\\frac{#?}{#?}']);\n    });\n\n    it('handles array commands', () => {\n      const { input, f } = withField();\n\n      input.command(['\\\\log', '_']);\n\n      expect(f.calls.insert).toEqual(['\\\\log_{#?}']);\n    });\n\n    it('passes argument-less commands through', () => {\n      const { input, f } = withField();\n\n      input.command('\\\\pi');\n\n      expect(f.calls.insert).toEqual(['\\\\pi']);\n    });\n\n    it('agrees with keyToAction', () => {\n      expect(keyToAction({ command: '\\\\sqrt' }).value).toEqual('\\\\sqrt{#?}');\n    });\n  });\n\n  describe('safety before MathLive loads', () => {\n    it('every method is a no-op rather than a crash', () => {\n      const input = new Input({});\n\n      // mathField is undefined until loadMathLive() resolves\n      expect(input.latex()).toEqual('');\n      expect(input.clear()).toEqual('');\n      expect(input.command('\\\\frac')).toEqual('');\n      expect(input.keystroke('Left')).toEqual('');\n      expect(input.write('x')).toEqual('');\n      expect(() => input.focus()).not.toThrow();\n      expect(() => input.blur()).not.toThrow();\n      expect(() => input.setLatex('x')).not.toThrow();\n      expect(input.element).toBeUndefined();\n    });\n  });\n\n  describe('mqCompat facade', () => {\n    // math-toolbar used to call this.input.mathField.latex(); external\n    // consumers may still do the same.\n    it('exposes latex() as a getter', () => {\n      const { input } = withField();\n\n      input.mathField.getValue = () => '\\\\frac{1}{2}';\n\n      expect(input.mqCompat.latex()).toEqual('\\\\frac{1}{2}');\n    });\n\n    it('exposes latex(v) as a setter and el()', () => {\n      const { input, f } = withField();\n\n      input.mqCompat.latex('x+1');\n      expect(f.value).toEqual('x+1');\n      expect(input.mqCompat.el()).toBe(f);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/__tests__/keypad-label.test.js

@@ -0,0 +1,231 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _latexBridge = require("../latex-bridge");
+/**
+ * Keys use empty groups to show a command's shape (`\frac{}{}`, `x^{}`).
+ * MathLive renders `{}` as nothing, so labels need a visible stand-in - but the
+ * value that gets *inserted* must stay untouched.
+ */
+describe('keypad label display normalisation', function () {
+  it('gives empty groups a visible glyph', function () {
+    var out = (0, _latexBridge.withVisibleEmptySlots)('\\frac{}{}');
+    expect(out).not.toEqual('\\frac{}{}');
+    // a \rule, not a glyph: font metrics for a substituted glyph do not match
+    // MathLive's, which left stretchy accents narrower than the box
+    expect(out).toContain('\\rule');
+    expect(out).toContain('pie-empty');
+  });
+  it.each([['absolute value', '\\abs{}', '|', '|'], ['parenthesis', '\\left(\\right)', '(', ')'], ['brackets', '\\left[\\right]', '[', ']']])('gives an empty %s a tall, filled slot (the same muted tag as other slots)', function (_name, latex, open, close) {
+    var out = (0, _latexBridge.withVisibleEmptySlots)((0, _latexBridge.toMathLive)(latex));
+    expect(out).toContain('pie-empty=1');
+    expect(out).toContain('\\rule[-0.25em]{0.55em}{1em}');
+    expect(out).not.toContain('\\boxed');
+    // the strut that keeps the fences tall while the box is centred on the axis
+    expect(out).toContain('\\rule{0em}{1em}');
+    expect(out.startsWith("\\left".concat(open))).toBe(true);
+    expect(out.endsWith("\\right".concat(close))).toBe(true);
+  });
+  it('leaves a filled pair of fences alone', function () {
+    expect((0, _latexBridge.withVisibleEmptySlots)((0, _latexBridge.toMathLive)('\\abs{x}'))).toEqual('\\left|x\\right|');
+    expect((0, _latexBridge.withVisibleEmptySlots)('\\left(x\\right)')).toEqual('\\left(x\\right)');
+  });
+  it('handles every empty-group key shape', function () {
+    ['\\frac{}{}', '\\overline{}', 'x^{}', 'x_{}', '\\sqrt{}', '\\sqrt[{}]{}', '\\abs{}', '\\log_{}', '\\longdiv{}'].forEach(function (latex) {
+      expect((0, _latexBridge.withVisibleEmptySlots)(latex)).not.toContain('{}');
+    });
+  });
+  it('treats a whitespace-only group as empty', function () {
+    // e.g. \frac{x}{ }
+    expect((0, _latexBridge.withVisibleEmptySlots)('\\frac{x}{ }')).toContain('pie-empty');
+  });
+
+  // MathQuill needed a nested \overline{} to draw the empty box. MathLive
+  // renders that as a real line, so those labels showed a spurious bar (a line
+  // under the arrows, and a straight line instead of the arc).
+  it('accent keys do not carry the nested-overline box hack', function () {
+    // eslint-disable-next-line global-require
+    var geometry = require('../keys/geometry');
+    Object.values(geometry).forEach(function (key) {
+      if (key && typeof key.latex === 'string') {
+        expect(key.latex).not.toContain('\\overline{}}');
+      }
+    });
+  });
+  it('an accent over an empty slot still gets a visible box', function () {
+    ['\\overleftrightarrow{}', '\\overarc{}'].forEach(function (latex) {
+      var out = (0, _latexBridge.withVisibleEmptySlots)(latex);
+      expect(out).toContain('pie-empty');
+      expect(out).not.toContain('\\overline');
+    });
+  });
+
+  // A glyph's width comes from font metrics; U+25AB is not in the KaTeX fonts,
+  // so the browser substituted a wider one and stretchy accents came out
+  // narrower than the box. A rule has an explicit width.
+  it('the empty slot has an explicit width, not font-dependent metrics', function () {
+    var out = (0, _latexBridge.withVisibleEmptySlots)('\\overarc{}');
+    expect(out).toContain('\\rule');
+    expect(out).toMatch(/rule\{[\d.]+em\}\{[\d.]+em\}/);
+    expect(out).not.toContain('unicode');
+  });
+
+  // Measured in the browser: the accent's immediate wrapper computes to 0px
+  // (its .ML__stretchy child is absolutely positioned), so the svg width has to
+  // resolve against .ML__base - whose width equals the content. Without pinning
+  // that, the arc collapsed to a spike and sat right of the box.
+  it('pins the accent containing block and drops the centering shift', function () {
+    // eslint-disable-next-line global-require
+    var _require = require('../mf/common-styles'),
+      placeholderStyles = _require.placeholderStyles;
+    expect(placeholderStyles['& .ML__base'].position).toEqual('relative');
+    expect(placeholderStyles['& .ML__stretchy']).toEqual({
+      position: 'absolute',
+      left: 0,
+      width: '100%'
+    });
+    // must be !important: MathLive writes margin-left as an inline style, and a
+    // class cannot override that. Leaving it un-important also halved the arc's
+    // width, because .ML__center is the stretchy's containing block.
+    expect(placeholderStyles['& .ML__center:has(.ML__stretchy)'].marginLeft).toEqual('0 !important');
+  });
+
+  // MathLive sets the index of \sqrt[n]{x} in scriptscriptstyle - an inline
+  // `font-size: 50%` - which is too small to read on the nth-root key and in
+  // authored radicals. It is scaled up to 80%.
+  describe('radical index size', function () {
+    // Real MathLive 0.110 output for `\sqrt[1]{2}`, trimmed to the index. The
+    // selector walks this exact chain, so this fixture is what pins it down.
+    var INDEX_MARKUP = "\n      <span class=\"ML__base\">\n        <span class=\"ML__sqrt-index\">\n          <span class=\"ML__vlist-t\"><span class=\"ML__vlist-r\"><span class=\"ML__vlist\" style=\"height:0.78em\">\n            <span style=\"top:-3.45em\">\n              <span class=\"ML__pstrut\" style=\"height:3em\"></span>\n              <span id=\"index-size\" style=\"height:0.33em;display:inline-block;font-size: 50%\">\n                <span class=\"ML__cmr\">1</span>\n                <span id=\"nested-size\" style=\"font-size: 50%\">nested</span>\n              </span>\n            </span>\n          </span></span></span>\n        </span>\n        <span class=\"ML__sqrt-sign\"><span class=\"ML__delim-size1\">&#8730;</span></span>\n      </span>";
+    var rule = function rule() {
+      // eslint-disable-next-line global-require
+      var _require2 = require('../mf/common-styles'),
+        rootIndexStyles = _require2.rootIndexStyles;
+      var selectors = Object.keys(rootIndexStyles);
+      expect(selectors).toHaveLength(1);
+      return {
+        selector: selectors[0],
+        value: rootIndexStyles[selectors[0]].fontSize
+      };
+    };
+    it("scales the index glyph to 80%, up from MathLive's 50%", function () {
+      // !important: the 50% is an inline style, which a class cannot override.
+      expect(rule().value).toEqual('80% !important');
+    });
+    it('targets the span MathLive puts the inline font-size on', function () {
+      var holder = document.createElement('div');
+      holder.innerHTML = INDEX_MARKUP;
+      var matched = holder.querySelectorAll(rule().selector.replace(/^&\s*/, ''));
+      expect(Array.from(matched).map(function (el) {
+        return el.id;
+      })).toEqual(['index-size']);
+    });
+    it('leaves the radical index box itself unscaled', function () {
+      // Scaling `.ML__sqrt-index` would scale the em-based top/height offsets
+      // that tuck the index into the radical, lifting it clear of the crook.
+      var _rule = rule(),
+        selector = _rule.selector;
+      expect(selector).not.toMatch(/\.ML__sqrt-index\s*\{?$/);
+      expect(selector.startsWith('& .ML__sqrt-index >')).toBe(true);
+    });
+    it('applies wherever math renders - keypad labels, static math, mathfield', function () {
+      // eslint-disable-next-line global-require
+      var cs = require('../mf/common-styles');
+      var _rule2 = rule(),
+        selector = _rule2.selector;
+      ['commonKeyboardStyles', 'commonMathLiveStyles', 'supsubStyles'].forEach(function (name) {
+        expect(cs[name][selector]).toBeDefined();
+      });
+
+      // The live mathfield renders in a shadow root, which host styles cannot
+      // reach, so the same rule ships as plain CSS for `applyShadowStyles`.
+      expect(cs.ROOT_INDEX_CSS).toContain('.ML__sqrt-index >');
+      // Derived, so the size lives in one place: the two copies cannot drift.
+      expect(cs.ROOT_INDEX_CSS).toContain("font-size:".concat(rule().value));
+    });
+  });
+  it('applies those rules wherever static math renders', function () {
+    // eslint-disable-next-line global-require
+    var cs = require('../mf/common-styles');
+    ['commonKeyboardStyles', 'commonMathLiveStyles'].forEach(function (name) {
+      expect(cs[name]['& .ML__stretchy']).toBeDefined();
+      expect(cs[name]['& .ML__base']).toBeDefined();
+    });
+  });
+
+  // A bare `& svg` rule re-parents every svg in the subtree; MathLive's own rule
+  // is descendant-scoped to .ML__latex .ML__stretchy svg.
+  it('does not use a blanket svg rule', function () {
+    // eslint-disable-next-line global-require
+    var cs = require('../mf/common-styles');
+    Object.values(cs).forEach(function (style) {
+      if (style && (0, _typeof2["default"])(style) === 'object') {
+        expect(Object.keys(style)).not.toContain('& svg');
+      }
+    });
+  });
+
+  // The Percent key showed as a blank button on the Advanced Algebra keypad
+  // (row 1, position 6). MathQuill defined `LatexCmds['%']` as a symbol that
+  // serialised to `\\%`, so its bare `%` label parsed fine; MathLive parses real
+  // LaTeX, where `%` opens a comment - the label rendered nothing, and pressing
+  // the key inserted a comment that swallowed the rest of the expression.
+  it('the percent key is escaped, not a latex comment', function () {
+    // eslint-disable-next-line global-require
+    var _require3 = require('../keys/misc'),
+      percentage = _require3.percentage;
+    expect(percentage.latex).toEqual('\\%');
+    expect((0, _latexBridge.keyToAction)(percentage).value).toEqual('\\%');
+  });
+
+  // Any bare `%` in a key would fail the same way, silently.
+  it('no keypad key carries an unescaped %', function () {
+    // eslint-disable-next-line global-require
+    var _require4 = require('../keys'),
+      baseSet = _require4.baseSet;
+    // eslint-disable-next-line global-require
+    var _require5 = require('../keys/grades'),
+      gradeSets = _require5.gradeSets;
+    var every = [].concat((0, _toConsumableArray2["default"])(baseSet), (0, _toConsumableArray2["default"])(gradeSets.map(function (g) {
+      return g.set;
+    })));
+    var _walk = function walk(node) {
+      if (Array.isArray(node)) {
+        node.forEach(_walk);
+        return;
+      }
+      if (!node) {
+        return;
+      }
+      ['latex', 'write', 'command'].forEach(function (field) {
+        var value = node[field];
+        if (typeof value === 'string') {
+          // a `%` is only safe when preceded by an odd run of backslashes
+          expect(value.replace(/\\./g, '')).not.toContain('%');
+        }
+      });
+    };
+    _walk(every);
+  });
+  it('leaves latex without empty groups alone', function () {
+    ['\\pi', '\\sin', 'x^2', '\\overline{AB}'].forEach(function (latex) {
+      expect((0, _latexBridge.withVisibleEmptySlots)(latex)).toEqual(latex);
+    });
+  });
+  it('handles nullish input', function () {
+    expect((0, _latexBridge.withVisibleEmptySlots)(undefined)).toEqual('');
+    expect((0, _latexBridge.withVisibleEmptySlots)('')).toEqual('');
+  });
+  it('does NOT affect what gets inserted into the field', function () {
+    // the action must use the key's own latex, never the display form
+    var key = {
+      name: 'frac',
+      latex: '\\frac{}{}'
+    };
+    expect((0, _latexBridge.keyToAction)(key).value).toEqual('\\frac{}{}');
+    expect((0, _latexBridge.keyToAction)(key).value).not.toContain('pie-empty');
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_latexBridge","require","describe","it","out","latexForDisplay","expect","not","toEqual","toContain","each","_name","latex","open","close","toMathLive","startsWith","concat","toBe","endsWith","forEach","geometry","Object","values","key","toMatch","_require","placeholderStyles","position","left","width","marginLeft","INDEX_MARKUP","rule","_require2","rootIndexStyles","selectors","keys","toHaveLength","selector","value","fontSize","holder","document","createElement","innerHTML","matched","querySelectorAll","replace","Array","from","map","el","id","_rule","cs","_rule2","name","toBeDefined","ROOT_INDEX_CSS","style","_typeof2","_require3","percentage","keyToAction","_require4","baseSet","_require5","gradeSets","every","_toConsumableArray2","g","set","walk","node","isArray","field","undefined"],"sources":["../../src/__tests__/keypad-label.test.jsx"],"sourcesContent":["import { withVisibleEmptySlots as latexForDisplay } from '../latex-bridge';\nimport { keyToAction, toMathLive } from '../latex-bridge';\n\n/**\n * Keys use empty groups to show a command's shape (`\\frac{}{}`, `x^{}`).\n * MathLive renders `{}` as nothing, so labels need a visible stand-in - but the\n * value that gets *inserted* must stay untouched.\n */\ndescribe('keypad label display normalisation', () => {\n  it('gives empty groups a visible glyph', () => {\n    const out = latexForDisplay('\\\\frac{}{}');\n\n    expect(out).not.toEqual('\\\\frac{}{}');\n    // a \\rule, not a glyph: font metrics for a substituted glyph do not match\n    // MathLive's, which left stretchy accents narrower than the box\n    expect(out).toContain('\\\\rule');\n    expect(out).toContain('pie-empty');\n  });\n\n  it.each([\n    ['absolute value', '\\\\abs{}', '|', '|'],\n    ['parenthesis', '\\\\left(\\\\right)', '(', ')'],\n    ['brackets', '\\\\left[\\\\right]', '[', ']'],\n  ])('gives an empty %s a tall, filled slot (the same muted tag as other slots)', (_name, latex, open, close) => {\n    const out = latexForDisplay(toMathLive(latex));\n\n    expect(out).toContain('pie-empty=1');\n    expect(out).toContain('\\\\rule[-0.25em]{0.55em}{1em}');\n    expect(out).not.toContain('\\\\boxed');\n    // the strut that keeps the fences tall while the box is centred on the axis\n    expect(out).toContain('\\\\rule{0em}{1em}');\n    expect(out.startsWith(`\\\\left${open}`)).toBe(true);\n    expect(out.endsWith(`\\\\right${close}`)).toBe(true);\n  });\n\n  it('leaves a filled pair of fences alone', () => {\n    expect(latexForDisplay(toMathLive('\\\\abs{x}'))).toEqual('\\\\left|x\\\\right|');\n    expect(latexForDisplay('\\\\left(x\\\\right)')).toEqual('\\\\left(x\\\\right)');\n  });\n\n  it('handles every empty-group key shape', () => {\n    [\n      '\\\\frac{}{}',\n      '\\\\overline{}',\n      'x^{}',\n      'x_{}',\n      '\\\\sqrt{}',\n      '\\\\sqrt[{}]{}',\n      '\\\\abs{}',\n      '\\\\log_{}',\n      '\\\\longdiv{}',\n    ].forEach((latex) => {\n      expect(latexForDisplay(latex)).not.toContain('{}');\n    });\n  });\n\n  it('treats a whitespace-only group as empty', () => {\n    // e.g. \\frac{x}{ }\n    expect(latexForDisplay('\\\\frac{x}{ }')).toContain('pie-empty');\n  });\n\n  // MathQuill needed a nested \\overline{} to draw the empty box. MathLive\n  // renders that as a real line, so those labels showed a spurious bar (a line\n  // under the arrows, and a straight line instead of the arc).\n  it('accent keys do not carry the nested-overline box hack', () => {\n    // eslint-disable-next-line global-require\n    const geometry = require('../keys/geometry');\n\n    Object.values(geometry).forEach((key) => {\n      if (key && typeof key.latex === 'string') {\n        expect(key.latex).not.toContain('\\\\overline{}}');\n      }\n    });\n  });\n\n  it('an accent over an empty slot still gets a visible box', () => {\n    ['\\\\overleftrightarrow{}', '\\\\overarc{}'].forEach((latex) => {\n      const out = latexForDisplay(latex);\n\n      expect(out).toContain('pie-empty');\n      expect(out).not.toContain('\\\\overline');\n    });\n  });\n\n  // A glyph's width comes from font metrics; U+25AB is not in the KaTeX fonts,\n  // so the browser substituted a wider one and stretchy accents came out\n  // narrower than the box. A rule has an explicit width.\n  it('the empty slot has an explicit width, not font-dependent metrics', () => {\n    const out = latexForDisplay('\\\\overarc{}');\n\n    expect(out).toContain('\\\\rule');\n    expect(out).toMatch(/rule\\{[\\d.]+em\\}\\{[\\d.]+em\\}/);\n    expect(out).not.toContain('unicode');\n  });\n\n  // Measured in the browser: the accent's immediate wrapper computes to 0px\n  // (its .ML__stretchy child is absolutely positioned), so the svg width has to\n  // resolve against .ML__base - whose width equals the content. Without pinning\n  // that, the arc collapsed to a spike and sat right of the box.\n  it('pins the accent containing block and drops the centering shift', () => {\n    // eslint-disable-next-line global-require\n    const { placeholderStyles } = require('../mf/common-styles');\n\n    expect(placeholderStyles['& .ML__base'].position).toEqual('relative');\n    expect(placeholderStyles['& .ML__stretchy']).toEqual({ position: 'absolute', left: 0, width: '100%' });\n    // must be !important: MathLive writes margin-left as an inline style, and a\n    // class cannot override that. Leaving it un-important also halved the arc's\n    // width, because .ML__center is the stretchy's containing block.\n    expect(placeholderStyles['& .ML__center:has(.ML__stretchy)'].marginLeft).toEqual('0 !important');\n  });\n\n  // MathLive sets the index of \\sqrt[n]{x} in scriptscriptstyle - an inline\n  // `font-size: 50%` - which is too small to read on the nth-root key and in\n  // authored radicals. It is scaled up to 80%.\n  describe('radical index size', () => {\n    // Real MathLive 0.110 output for `\\sqrt[1]{2}`, trimmed to the index. The\n    // selector walks this exact chain, so this fixture is what pins it down.\n    const INDEX_MARKUP = `\n      <span class=\"ML__base\">\n        <span class=\"ML__sqrt-index\">\n          <span class=\"ML__vlist-t\"><span class=\"ML__vlist-r\"><span class=\"ML__vlist\" style=\"height:0.78em\">\n            <span style=\"top:-3.45em\">\n              <span class=\"ML__pstrut\" style=\"height:3em\"></span>\n              <span id=\"index-size\" style=\"height:0.33em;display:inline-block;font-size: 50%\">\n                <span class=\"ML__cmr\">1</span>\n                <span id=\"nested-size\" style=\"font-size: 50%\">nested</span>\n              </span>\n            </span>\n          </span></span></span>\n        </span>\n        <span class=\"ML__sqrt-sign\"><span class=\"ML__delim-size1\">&#8730;</span></span>\n      </span>`;\n\n    const rule = () => {\n      // eslint-disable-next-line global-require\n      const { rootIndexStyles } = require('../mf/common-styles');\n      const selectors = Object.keys(rootIndexStyles);\n\n      expect(selectors).toHaveLength(1);\n\n      return { selector: selectors[0], value: rootIndexStyles[selectors[0]].fontSize };\n    };\n\n    it(\"scales the index glyph to 80%, up from MathLive's 50%\", () => {\n      // !important: the 50% is an inline style, which a class cannot override.\n      expect(rule().value).toEqual('80% !important');\n    });\n\n    it('targets the span MathLive puts the inline font-size on', () => {\n      const holder = document.createElement('div');\n\n      holder.innerHTML = INDEX_MARKUP;\n\n      const matched = holder.querySelectorAll(rule().selector.replace(/^&\\s*/, ''));\n\n      expect(Array.from(matched).map((el) => el.id)).toEqual(['index-size']);\n    });\n\n    it('leaves the radical index box itself unscaled', () => {\n      // Scaling `.ML__sqrt-index` would scale the em-based top/height offsets\n      // that tuck the index into the radical, lifting it clear of the crook.\n      const { selector } = rule();\n\n      expect(selector).not.toMatch(/\\.ML__sqrt-index\\s*\\{?$/);\n      expect(selector.startsWith('& .ML__sqrt-index >')).toBe(true);\n    });\n\n    it('applies wherever math renders - keypad labels, static math, mathfield', () => {\n      // eslint-disable-next-line global-require\n      const cs = require('../mf/common-styles');\n      const { selector } = rule();\n\n      ['commonKeyboardStyles', 'commonMathLiveStyles', 'supsubStyles'].forEach((name) => {\n        expect(cs[name][selector]).toBeDefined();\n      });\n\n      // The live mathfield renders in a shadow root, which host styles cannot\n      // reach, so the same rule ships as plain CSS for `applyShadowStyles`.\n      expect(cs.ROOT_INDEX_CSS).toContain('.ML__sqrt-index >');\n      // Derived, so the size lives in one place: the two copies cannot drift.\n      expect(cs.ROOT_INDEX_CSS).toContain(`font-size:${rule().value}`);\n    });\n  });\n\n  it('applies those rules wherever static math renders', () => {\n    // eslint-disable-next-line global-require\n    const cs = require('../mf/common-styles');\n\n    ['commonKeyboardStyles', 'commonMathLiveStyles'].forEach((name) => {\n      expect(cs[name]['& .ML__stretchy']).toBeDefined();\n      expect(cs[name]['& .ML__base']).toBeDefined();\n    });\n  });\n\n  // A bare `& svg` rule re-parents every svg in the subtree; MathLive's own rule\n  // is descendant-scoped to .ML__latex .ML__stretchy svg.\n  it('does not use a blanket svg rule', () => {\n    // eslint-disable-next-line global-require\n    const cs = require('../mf/common-styles');\n\n    Object.values(cs).forEach((style) => {\n      if (style && typeof style === 'object') {\n        expect(Object.keys(style)).not.toContain('& svg');\n      }\n    });\n  });\n\n  // The Percent key showed as a blank button on the Advanced Algebra keypad\n  // (row 1, position 6). MathQuill defined `LatexCmds['%']` as a symbol that\n  // serialised to `\\\\%`, so its bare `%` label parsed fine; MathLive parses real\n  // LaTeX, where `%` opens a comment - the label rendered nothing, and pressing\n  // the key inserted a comment that swallowed the rest of the expression.\n  it('the percent key is escaped, not a latex comment', () => {\n    // eslint-disable-next-line global-require\n    const { percentage } = require('../keys/misc');\n\n    expect(percentage.latex).toEqual('\\\\%');\n    expect(keyToAction(percentage).value).toEqual('\\\\%');\n  });\n\n  // Any bare `%` in a key would fail the same way, silently.\n  it('no keypad key carries an unescaped %', () => {\n    // eslint-disable-next-line global-require\n    const { baseSet } = require('../keys');\n    // eslint-disable-next-line global-require\n    const { gradeSets } = require('../keys/grades');\n\n    const every = [...baseSet, ...gradeSets.map((g) => g.set)];\n\n    const walk = (node) => {\n      if (Array.isArray(node)) {\n        node.forEach(walk);\n        return;\n      }\n\n      if (!node) {\n        return;\n      }\n\n      ['latex', 'write', 'command'].forEach((field) => {\n        const value = node[field];\n\n        if (typeof value === 'string') {\n          // a `%` is only safe when preceded by an odd run of backslashes\n          expect(value.replace(/\\\\./g, '')).not.toContain('%');\n        }\n      });\n    };\n\n    walk(every);\n  });\n\n  it('leaves latex without empty groups alone', () => {\n    ['\\\\pi', '\\\\sin', 'x^2', '\\\\overline{AB}'].forEach((latex) => {\n      expect(latexForDisplay(latex)).toEqual(latex);\n    });\n  });\n\n  it('handles nullish input', () => {\n    expect(latexForDisplay(undefined)).toEqual('');\n    expect(latexForDisplay('')).toEqual('');\n  });\n\n  it('does NOT affect what gets inserted into the field', () => {\n    // the action must use the key's own latex, never the display form\n    const key = { name: 'frac', latex: '\\\\frac{}{}' };\n\n    expect(keyToAction(key).value).toEqual('\\\\frac{}{}');\n    expect(keyToAction(key).value).not.toContain('pie-empty');\n  });\n});\n"],"mappings":"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","ignoreList":[]}