@pie-lib/math-input-mathlive 1.1.5-beta.6 → 1.1.5-beta.8

package/lib/__tests__/mathlive-instance.test.js

@@ -0,0 +1,419 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+describe('mathlive-instance', function () {
+  var instance;
+  beforeEach(function () {
+    jest.resetModules();
+    // eslint-disable-next-line global-require
+    instance = require('../mathlive-instance');
+    instance.__resetEmbeds();
+  });
+  describe('registerEmbed', function () {
+    it('registers a known embed and exposes it as a macro', function () {
+      instance.registerEmbed('answerBlock', function () {
+        return {
+          htmlString: '<div class="answerBlock"></div>',
+          latex: function latex() {
+            return '\\embed{answerBlock}[]';
+          }
+        };
+      });
+      expect(instance.registeredEmbeds()).toEqual(['answerBlock']);
+      // The macro tags output with data-embed so CSS can target it, replacing
+      // MathQuill's htmlString hook.
+      expect(instance.getMacros().answerBlock).toEqual('\\htmlData{embed=answerBlock}{\\placeholder{}}');
+    });
+    it('registers newLine as a harmless macro (it is handled by latex-bridge)', function () {
+      instance.registerEmbed('newLine', function () {
+        return {
+          latex: function latex() {
+            return '\\embed{newLine}[]';
+          }
+        };
+      });
+      expect(instance.getMacros().newLine).toEqual('\\htmlData{embed=newLine}{}');
+    });
+    it('falls back to a placeholder for an unknown embed', function () {
+      instance.registerEmbed('somethingCustom', function () {
+        return {
+          htmlString: '<b>x</b>'
+        };
+      });
+      expect(instance.getMacros().somethingCustom).toEqual('\\htmlData{embed=somethingCustom}{\\placeholder{}}');
+    });
+    it('honours an explicit mathliveLatex from the factory', function () {
+      instance.registerEmbed('custom', function () {
+        return {
+          mathliveLatex: '\\alpha'
+        };
+      });
+      expect(instance.getMacros().custom).toEqual('\\htmlData{embed=custom}{\\alpha}');
+    });
+    it('does not throw when the factory throws', function () {
+      expect(function () {
+        return instance.registerEmbed('bad', function () {
+          throw new Error('boom');
+        });
+      }).not.toThrow();
+      expect(instance.registeredEmbeds()).toEqual(['bad']);
+    });
+    it('ignores bad arguments', function () {
+      instance.registerEmbed(undefined, function () {
+        return {};
+      });
+      instance.registerEmbed('noFactory', undefined);
+      expect(instance.registeredEmbeds()).toEqual([]);
+    });
+    it('always includes the pie macro set', function () {
+      var macros = instance.getMacros();
+      expect(macros.parallelogram).toBeDefined();
+      expect(macros.longdiv).toBeDefined();
+      expect(macros.napprox).toEqual('\\not\\approx');
+    });
+
+    // Argument-taking macros exist only so previously authored latex parses.
+    // Editing never goes through them: MathLive serialises a macro from its
+    // original arguments, so typed content never comes back out.
+    it('argument-taking macros are plain parse-only definitions', function () {
+      ['longdiv', 'overarc', 'abs'].forEach(function (name) {
+        expect((0, _typeof2["default"])(instance.PIE_MACROS[name])).toBe('string');
+        expect(instance.PIE_MACROS[name]).toContain('#1');
+      });
+    });
+    it('argument-less symbols stay atomic', function () {
+      ['perpendicular', 'square', 'degree', 'napprox', 'parallelogram'].forEach(function (name) {
+        expect((0, _typeof2["default"])(instance.PIE_MACROS[name])).toBe('string');
+      });
+    });
+    it('longdiv matches the MathJax macro used by math-rendering', function () {
+      expect(instance.PIE_MACROS.longdiv).toEqual('\\enclose{longdiv}{#1}');
+    });
+  });
+  describe('applyStaticMath', function () {
+    it('returns undefined without an element', function () {
+      expect(instance.applyStaticMath(null, 'x')).toBeUndefined();
+    });
+    it('defers (returns undefined) when MathLive has not loaded', function () {
+      var el = document.createElement('div');
+      expect(instance.applyStaticMath(el, 'x')).toBeUndefined();
+    });
+    it('renders synchronously once MathLive is available', function () {
+      var el = document.createElement('div');
+      instance.__setMathLiveForTest({
+        convertLatexToMarkup: function convertLatexToMarkup(l) {
+          return "<span>".concat(l, "</span>");
+        }
+      });
+      expect(instance.applyStaticMath(el, '\\pi')).toBe(el);
+      expect(el.innerHTML).toEqual('<span>\\pi</span>');
+    });
+    it('falls back to the element textContent when no latex is passed', function () {
+      var el = document.createElement('div');
+      el.textContent = '\\theta';
+      instance.__setMathLiveForTest({
+        convertLatexToMarkup: function convertLatexToMarkup(l) {
+          return "<i>".concat(l, "</i>");
+        }
+      });
+      instance.applyStaticMath(el);
+      expect(el.innerHTML).toEqual('<i>\\theta</i>');
+    });
+    it('bridges stored latex (newLine embed) before rendering', function () {
+      var el = document.createElement('div');
+      instance.__setMathLiveForTest({
+        convertLatexToMarkup: function convertLatexToMarkup(l) {
+          return l;
+        }
+      });
+      instance.applyStaticMath(el, 'a\\embed{newLine}[]b');
+
+      // \embed{newLine}[] must become a multiline environment
+      expect(el.innerHTML).toContain('displaylines');
+    });
+  });
+  describe('configureFonts', function () {
+    // MathLive's default fontsDirectory is the relative './fonts/', which it
+    // resolves against its own (empty, when bundled) script url and throws
+    // "Invalid base URL" from loadFonts. Paths must become absolute.
+    it('is exported and callable before MathLive loads', function () {
+      expect((0, _typeof2["default"])(instance.configureFonts)).toBe('function');
+      expect(function () {
+        return instance.configureFonts('/mathlive-fonts');
+      }).not.toThrow();
+    });
+    it('accepts null to disable font loading', function () {
+      expect(function () {
+        return instance.configureFonts(null);
+      }).not.toThrow();
+    });
+    it('applies an absolute url to an already-loaded MathfieldElement', function () {
+      var MathfieldElement = {};
+
+      // simulate a loaded instance
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement
+      });
+      instance.configureFonts('/mathlive-fonts');
+      expect(MathfieldElement.fontsDirectory).toEqual("".concat(document.baseURI.replace(/\/$/, ''), "/mathlive-fonts"));
+      expect(MathfieldElement.fontsDirectory.startsWith('http')).toBe(true);
+    });
+
+    // \neq, \nsim and \ncong are built from Private Use Area glyphs that only
+    // the KaTeX fonts contain, so "no fonts" renders garbage rather than
+    // degrading gracefully - hence a CDN fallback by default.
+    it('falls back to a version-pinned CDN when nothing is configured', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement,
+        version: {
+          mathlive: '9.9.9'
+        }
+      });
+      instance.configureFonts(undefined);
+      expect(MathfieldElement.fontsDirectory).toEqual('https://unpkg.com/mathlive@9.9.9/fonts');
+    });
+    it('uses /fonts, not /dist/fonts (the latter 404s on unpkg)', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement,
+        version: {
+          mathlive: '0.110.0'
+        }
+      });
+      instance.configureFonts(undefined);
+      expect(MathfieldElement.fontsDirectory).toEqual('https://unpkg.com/mathlive@0.110.0/fonts');
+      expect(MathfieldElement.fontsDirectory).not.toContain('/dist/');
+    });
+    it('a configured path wins over the CDN', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement,
+        version: {
+          mathlive: '0.110.0'
+        }
+      });
+      instance.configureFonts('/mathlive-fonts');
+      expect(MathfieldElement.fontsDirectory).not.toContain('unpkg.com');
+    });
+    it('null still opts out entirely', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement,
+        version: {
+          mathlive: '0.110.0'
+        }
+      });
+      instance.configureFonts(null);
+      expect(MathfieldElement.fontsDirectory).toBeNull();
+    });
+    it('leaves a fully-qualified url untouched', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement
+      });
+      instance.configureFonts('https://cdn.example.com/fonts');
+      expect(MathfieldElement.fontsDirectory).toEqual('https://cdn.example.com/fonts');
+    });
+    it('passes null through rather than resolving it', function () {
+      var MathfieldElement = {};
+      instance.__setMathLiveForTest({
+        MathfieldElement: MathfieldElement
+      });
+      instance.configureFonts(null);
+      expect(MathfieldElement.fontsDirectory).toBeNull();
+    });
+  });
+
+  // A live <math-field> renders in shadow DOM, so nothing in the page's
+  // stylesheets reaches it - the stretchy-accent fix has to be injected there.
+  /**
+   * A keypad key like \frac inserts `\frac{#?}{#?}`; MathLive turns each `#?`
+   * into a `\placeholder{}` atom and *selects* the first one. Measured in
+   * Chromium: that atom is a leaf (its offsets are before/after, there is no
+   * position inside), so MathLive renders NO caret element and shows only the
+   * selection highlight - the box read as focused-but-dead. The caret is drawn
+   * by our own shadow CSS, gated on a class so it is placeholder-specific.
+   */
+  describe('trackPlaceholderCaret', function () {
+    var fakeField = function fakeField(selection, latex) {
+      var classes = new Set();
+      return {
+        listeners: {},
+        selection: selection,
+        selectionIsCollapsed: !selection,
+        getValue: function getValue() {
+          return latex;
+        },
+        classList: {
+          toggle: function toggle(name, on) {
+            return on ? classes.add(name) : classes["delete"](name);
+          },
+          contains: function contains(name) {
+            return classes.has(name);
+          }
+        },
+        addEventListener: function addEventListener(name, fn) {
+          this.listeners[name] = fn;
+        },
+        removeEventListener: function removeEventListener(name) {
+          delete this.listeners[name];
+        }
+      };
+    };
+    it('marks the host when a placeholder is selected', function () {
+      var mf = fakeField({
+        ranges: [[1, 2]]
+      }, '\\placeholder{}');
+      instance.trackPlaceholderCaret(mf);
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(true);
+    });
+    it('does not mark an ordinary selection', function () {
+      var mf = fakeField({
+        ranges: [[0, 3]]
+      }, 'x+1');
+      instance.trackPlaceholderCaret(mf);
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+    });
+    it('does not mark a collapsed selection, which has a real caret already', function () {
+      var mf = fakeField(null, '\\placeholder{}');
+      instance.trackPlaceholderCaret(mf);
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+    });
+    it('leaves a named prompt alone - it takes a real caret inside', function () {
+      var mf = fakeField({
+        ranges: [[1, 2]]
+      }, '\\placeholder[r1]{}');
+      instance.trackPlaceholderCaret(mf);
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+    });
+    it('re-evaluates whenever the selection moves', function () {
+      var mf = fakeField(null, '');
+      instance.trackPlaceholderCaret(mf);
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+
+      // the caret lands on a placeholder
+      mf.selection = {
+        ranges: [[1, 2]]
+      };
+      mf.selectionIsCollapsed = false;
+      mf.getValue = function () {
+        return '\\placeholder{}';
+      };
+      mf.listeners['selection-change']();
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(true);
+
+      // ...and moves off it again
+      mf.selectionIsCollapsed = true;
+      mf.listeners['selection-change']();
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+    });
+    it('returns a teardown that detaches the listener', function () {
+      var mf = fakeField(null, '');
+      var off = instance.trackPlaceholderCaret(mf);
+      expect((0, _typeof2["default"])(mf.listeners['selection-change'])).toEqual('function');
+      off();
+      expect(mf.listeners['selection-change']).toBeUndefined();
+    });
+    it('survives a field that throws while reading the selection', function () {
+      var mf = fakeField({
+        ranges: [[1, 2]]
+      }, '');
+      mf.getValue = function () {
+        throw new Error('detached');
+      };
+      expect(function () {
+        return instance.trackPlaceholderCaret(mf);
+      }).not.toThrow();
+      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);
+    });
+    it('is a no-op without a field', function () {
+      expect(instance.trackPlaceholderCaret(undefined)).toBeUndefined();
+      expect(instance.trackPlaceholderCaret({})).toBeUndefined();
+    });
+  });
+  describe('applyShadowStyles', function () {
+    var host = function host() {
+      var el = document.createElement('div');
+      el.attachShadow({
+        mode: 'open'
+      });
+      return el;
+    };
+    it('is a no-op without a shadow root', function () {
+      expect(function () {
+        return instance.applyShadowStyles(undefined);
+      }).not.toThrow();
+      expect(function () {
+        return instance.applyShadowStyles(document.createElement('div'));
+      }).not.toThrow();
+    });
+    it('injects the accent fix into the shadow root', function () {
+      var el = host();
+      instance.applyShadowStyles(el);
+      var viaSheet = el.shadowRoot.__pieAccentSheet;
+      var viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');
+      var css = viaSheet ? 'adopted' : viaStyle && viaStyle.textContent || '';
+      expect(viaSheet || viaStyle).toBeTruthy();
+      if (viaStyle) {
+        expect(css).toContain('margin-left:0 !important');
+        // scoped so single-glyph accents keep their centring offset
+        expect(css).toContain(':has(.ML__stretchy)');
+      }
+    });
+    it('injects the placeholder caret rules', function () {
+      var el = host();
+      instance.applyShadowStyles(el);
+      var viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');
+      if (viaStyle) {
+        var css = viaStyle.textContent;
+
+        // gated on the host class, so an ordinary selection gets no caret
+        expect(css).toContain(":host(.".concat(instance.PLACEHOLDER_CARET_CLASS, ")"));
+        // MathLive's own blink keyframes and caret colour, already in this root
+        expect(css).toContain('ML__caret-blink');
+        expect(css).toContain('--_caret-color');
+        // the innermost selected element only: MathLive marks a wrapper AND the
+        // glyph span, which would otherwise render two carets
+        expect(css).toContain('.ML__selected:not(:has(.ML__selected))');
+      }
+    });
+    it('injects the radical index size fix', function () {
+      var el = host();
+      instance.applyShadowStyles(el);
+      var viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');
+      if (viaStyle) {
+        var css = viaStyle.textContent;
+
+        // MathLive's scriptscriptstyle index (an inline 50%) reads too small in
+        // the authoring UI; a mathfield's shadow root needs its own copy of the
+        // rule, since host styles do not cross the boundary. Compared against
+        // the exported rule, so the size stays defined in one place.
+        // eslint-disable-next-line global-require
+        var _require = require('../mf/common-styles'),
+          ROOT_INDEX_CSS = _require.ROOT_INDEX_CSS;
+        expect(ROOT_INDEX_CSS).toContain('.ML__sqrt-index >');
+        expect(css).toContain(ROOT_INDEX_CSS);
+      }
+    });
+    it('does not inject twice', function () {
+      var el = host();
+      instance.applyShadowStyles(el);
+      instance.applyShadowStyles(el);
+      var styles = el.shadowRoot.querySelectorAll('style[data-pie-accent]');
+
+      // either one adopted sheet, or exactly one style node
+      expect(el.shadowRoot.__pieAccentSheet ? 1 : styles.length).toBe(1);
+    });
+  });
+  describe('latexToMarkup', function () {
+    it('returns empty string when MathLive is not loaded', function () {
+      expect(instance.latexToMarkup('\\pi')).toEqual('');
+    });
+    it('returns empty string for empty latex', function () {
+      expect(instance.latexToMarkup('')).toEqual('');
+    });
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["describe","instance","beforeEach","jest","resetModules","require","__resetEmbeds","it","registerEmbed","htmlString","latex","expect","registeredEmbeds","toEqual","getMacros","answerBlock","newLine","somethingCustom","mathliveLatex","custom","Error","not","toThrow","undefined","macros","parallelogram","toBeDefined","longdiv","napprox","forEach","name","_typeof2","PIE_MACROS","toBe","toContain","applyStaticMath","toBeUndefined","el","document","createElement","__setMathLiveForTest","convertLatexToMarkup","l","concat","innerHTML","textContent","configureFonts","MathfieldElement","fontsDirectory","baseURI","replace","startsWith","version","mathlive","toBeNull","fakeField","selection","classes","Set","listeners","selectionIsCollapsed","getValue","classList","toggle","on","add","contains","has","addEventListener","fn","removeEventListener","mf","ranges","trackPlaceholderCaret","PLACEHOLDER_CARET_CLASS","off","host","attachShadow","mode","applyShadowStyles","viaSheet","shadowRoot","__pieAccentSheet","viaStyle","querySelector","css","toBeTruthy","_require","ROOT_INDEX_CSS","styles","querySelectorAll","length","latexToMarkup"],"sources":["../../src/__tests__/mathlive-instance.test.js"],"sourcesContent":["describe('mathlive-instance', () => {\n  let instance;\n\n  beforeEach(() => {\n    jest.resetModules();\n    // eslint-disable-next-line global-require\n    instance = require('../mathlive-instance');\n    instance.__resetEmbeds();\n  });\n\n  describe('registerEmbed', () => {\n    it('registers a known embed and exposes it as a macro', () => {\n      instance.registerEmbed('answerBlock', () => ({\n        htmlString: '<div class=\"answerBlock\"></div>',\n        latex: () => '\\\\embed{answerBlock}[]',\n      }));\n\n      expect(instance.registeredEmbeds()).toEqual(['answerBlock']);\n      // The macro tags output with data-embed so CSS can target it, replacing\n      // MathQuill's htmlString hook.\n      expect(instance.getMacros().answerBlock).toEqual('\\\\htmlData{embed=answerBlock}{\\\\placeholder{}}');\n    });\n\n    it('registers newLine as a harmless macro (it is handled by latex-bridge)', () => {\n      instance.registerEmbed('newLine', () => ({ latex: () => '\\\\embed{newLine}[]' }));\n\n      expect(instance.getMacros().newLine).toEqual('\\\\htmlData{embed=newLine}{}');\n    });\n\n    it('falls back to a placeholder for an unknown embed', () => {\n      instance.registerEmbed('somethingCustom', () => ({ htmlString: '<b>x</b>' }));\n\n      expect(instance.getMacros().somethingCustom).toEqual('\\\\htmlData{embed=somethingCustom}{\\\\placeholder{}}');\n    });\n\n    it('honours an explicit mathliveLatex from the factory', () => {\n      instance.registerEmbed('custom', () => ({ mathliveLatex: '\\\\alpha' }));\n\n      expect(instance.getMacros().custom).toEqual('\\\\htmlData{embed=custom}{\\\\alpha}');\n    });\n\n    it('does not throw when the factory throws', () => {\n      expect(() =>\n        instance.registerEmbed('bad', () => {\n          throw new Error('boom');\n        }),\n      ).not.toThrow();\n\n      expect(instance.registeredEmbeds()).toEqual(['bad']);\n    });\n\n    it('ignores bad arguments', () => {\n      instance.registerEmbed(undefined, () => ({}));\n      instance.registerEmbed('noFactory', undefined);\n\n      expect(instance.registeredEmbeds()).toEqual([]);\n    });\n\n    it('always includes the pie macro set', () => {\n      const macros = instance.getMacros();\n\n      expect(macros.parallelogram).toBeDefined();\n      expect(macros.longdiv).toBeDefined();\n      expect(macros.napprox).toEqual('\\\\not\\\\approx');\n    });\n\n    // Argument-taking macros exist only so previously authored latex parses.\n    // Editing never goes through them: MathLive serialises a macro from its\n    // original arguments, so typed content never comes back out.\n    it('argument-taking macros are plain parse-only definitions', () => {\n      ['longdiv', 'overarc', 'abs'].forEach((name) => {\n        expect(typeof instance.PIE_MACROS[name]).toBe('string');\n        expect(instance.PIE_MACROS[name]).toContain('#1');\n      });\n    });\n\n    it('argument-less symbols stay atomic', () => {\n      ['perpendicular', 'square', 'degree', 'napprox', 'parallelogram'].forEach((name) => {\n        expect(typeof instance.PIE_MACROS[name]).toBe('string');\n      });\n    });\n\n    it('longdiv matches the MathJax macro used by math-rendering', () => {\n      expect(instance.PIE_MACROS.longdiv).toEqual('\\\\enclose{longdiv}{#1}');\n    });\n  });\n\n  describe('applyStaticMath', () => {\n    it('returns undefined without an element', () => {\n      expect(instance.applyStaticMath(null, 'x')).toBeUndefined();\n    });\n\n    it('defers (returns undefined) when MathLive has not loaded', () => {\n      const el = document.createElement('div');\n\n      expect(instance.applyStaticMath(el, 'x')).toBeUndefined();\n    });\n\n    it('renders synchronously once MathLive is available', () => {\n      const el = document.createElement('div');\n\n      instance.__setMathLiveForTest({ convertLatexToMarkup: (l) => `<span>${l}</span>` });\n\n      expect(instance.applyStaticMath(el, '\\\\pi')).toBe(el);\n      expect(el.innerHTML).toEqual('<span>\\\\pi</span>');\n    });\n\n    it('falls back to the element textContent when no latex is passed', () => {\n      const el = document.createElement('div');\n\n      el.textContent = '\\\\theta';\n      instance.__setMathLiveForTest({ convertLatexToMarkup: (l) => `<i>${l}</i>` });\n      instance.applyStaticMath(el);\n\n      expect(el.innerHTML).toEqual('<i>\\\\theta</i>');\n    });\n\n    it('bridges stored latex (newLine embed) before rendering', () => {\n      const el = document.createElement('div');\n\n      instance.__setMathLiveForTest({ convertLatexToMarkup: (l) => l });\n      instance.applyStaticMath(el, 'a\\\\embed{newLine}[]b');\n\n      // \\embed{newLine}[] must become a multiline environment\n      expect(el.innerHTML).toContain('displaylines');\n    });\n  });\n\n  describe('configureFonts', () => {\n    // MathLive's default fontsDirectory is the relative './fonts/', which it\n    // resolves against its own (empty, when bundled) script url and throws\n    // \"Invalid base URL\" from loadFonts. Paths must become absolute.\n    it('is exported and callable before MathLive loads', () => {\n      expect(typeof instance.configureFonts).toBe('function');\n      expect(() => instance.configureFonts('/mathlive-fonts')).not.toThrow();\n    });\n\n    it('accepts null to disable font loading', () => {\n      expect(() => instance.configureFonts(null)).not.toThrow();\n    });\n\n    it('applies an absolute url to an already-loaded MathfieldElement', () => {\n      const MathfieldElement = {};\n\n      // simulate a loaded instance\n      instance.__setMathLiveForTest({ MathfieldElement });\n      instance.configureFonts('/mathlive-fonts');\n\n      expect(MathfieldElement.fontsDirectory).toEqual(`${document.baseURI.replace(/\\/$/, '')}/mathlive-fonts`);\n      expect(MathfieldElement.fontsDirectory.startsWith('http')).toBe(true);\n    });\n\n    // \\neq, \\nsim and \\ncong are built from Private Use Area glyphs that only\n    // the KaTeX fonts contain, so \"no fonts\" renders garbage rather than\n    // degrading gracefully - hence a CDN fallback by default.\n    it('falls back to a version-pinned CDN when nothing is configured', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement, version: { mathlive: '9.9.9' } });\n      instance.configureFonts(undefined);\n\n      expect(MathfieldElement.fontsDirectory).toEqual('https://unpkg.com/mathlive@9.9.9/fonts');\n    });\n\n    it('uses /fonts, not /dist/fonts (the latter 404s on unpkg)', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement, version: { mathlive: '0.110.0' } });\n      instance.configureFonts(undefined);\n\n      expect(MathfieldElement.fontsDirectory).toEqual('https://unpkg.com/mathlive@0.110.0/fonts');\n      expect(MathfieldElement.fontsDirectory).not.toContain('/dist/');\n    });\n\n    it('a configured path wins over the CDN', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement, version: { mathlive: '0.110.0' } });\n      instance.configureFonts('/mathlive-fonts');\n\n      expect(MathfieldElement.fontsDirectory).not.toContain('unpkg.com');\n    });\n\n    it('null still opts out entirely', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement, version: { mathlive: '0.110.0' } });\n      instance.configureFonts(null);\n\n      expect(MathfieldElement.fontsDirectory).toBeNull();\n    });\n\n    it('leaves a fully-qualified url untouched', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement });\n      instance.configureFonts('https://cdn.example.com/fonts');\n\n      expect(MathfieldElement.fontsDirectory).toEqual('https://cdn.example.com/fonts');\n    });\n\n    it('passes null through rather than resolving it', () => {\n      const MathfieldElement = {};\n\n      instance.__setMathLiveForTest({ MathfieldElement });\n      instance.configureFonts(null);\n\n      expect(MathfieldElement.fontsDirectory).toBeNull();\n    });\n  });\n\n  // A live <math-field> renders in shadow DOM, so nothing in the page's\n  // stylesheets reaches it - the stretchy-accent fix has to be injected there.\n  /**\n   * A keypad key like \\frac inserts `\\frac{#?}{#?}`; MathLive turns each `#?`\n   * into a `\\placeholder{}` atom and *selects* the first one. Measured in\n   * Chromium: that atom is a leaf (its offsets are before/after, there is no\n   * position inside), so MathLive renders NO caret element and shows only the\n   * selection highlight - the box read as focused-but-dead. The caret is drawn\n   * by our own shadow CSS, gated on a class so it is placeholder-specific.\n   */\n  describe('trackPlaceholderCaret', () => {\n    const fakeField = (selection, latex) => {\n      const classes = new Set();\n\n      return {\n        listeners: {},\n        selection,\n        selectionIsCollapsed: !selection,\n        getValue: () => latex,\n        classList: {\n          toggle: (name, on) => (on ? classes.add(name) : classes.delete(name)),\n          contains: (name) => classes.has(name),\n        },\n        addEventListener(name, fn) {\n          this.listeners[name] = fn;\n        },\n        removeEventListener(name) {\n          delete this.listeners[name];\n        },\n      };\n    };\n\n    it('marks the host when a placeholder is selected', () => {\n      const mf = fakeField({ ranges: [[1, 2]] }, '\\\\placeholder{}');\n\n      instance.trackPlaceholderCaret(mf);\n\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(true);\n    });\n\n    it('does not mark an ordinary selection', () => {\n      const mf = fakeField({ ranges: [[0, 3]] }, 'x+1');\n\n      instance.trackPlaceholderCaret(mf);\n\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n    });\n\n    it('does not mark a collapsed selection, which has a real caret already', () => {\n      const mf = fakeField(null, '\\\\placeholder{}');\n\n      instance.trackPlaceholderCaret(mf);\n\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n    });\n\n    it('leaves a named prompt alone - it takes a real caret inside', () => {\n      const mf = fakeField({ ranges: [[1, 2]] }, '\\\\placeholder[r1]{}');\n\n      instance.trackPlaceholderCaret(mf);\n\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n    });\n\n    it('re-evaluates whenever the selection moves', () => {\n      const mf = fakeField(null, '');\n\n      instance.trackPlaceholderCaret(mf);\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n\n      // the caret lands on a placeholder\n      mf.selection = { ranges: [[1, 2]] };\n      mf.selectionIsCollapsed = false;\n      mf.getValue = () => '\\\\placeholder{}';\n      mf.listeners['selection-change']();\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(true);\n\n      // ...and moves off it again\n      mf.selectionIsCollapsed = true;\n      mf.listeners['selection-change']();\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n    });\n\n    it('returns a teardown that detaches the listener', () => {\n      const mf = fakeField(null, '');\n      const off = instance.trackPlaceholderCaret(mf);\n\n      expect(typeof mf.listeners['selection-change']).toEqual('function');\n      off();\n      expect(mf.listeners['selection-change']).toBeUndefined();\n    });\n\n    it('survives a field that throws while reading the selection', () => {\n      const mf = fakeField({ ranges: [[1, 2]] }, '');\n\n      mf.getValue = () => {\n        throw new Error('detached');\n      };\n\n      expect(() => instance.trackPlaceholderCaret(mf)).not.toThrow();\n      expect(mf.classList.contains(instance.PLACEHOLDER_CARET_CLASS)).toBe(false);\n    });\n\n    it('is a no-op without a field', () => {\n      expect(instance.trackPlaceholderCaret(undefined)).toBeUndefined();\n      expect(instance.trackPlaceholderCaret({})).toBeUndefined();\n    });\n  });\n\n  describe('applyShadowStyles', () => {\n    const host = () => {\n      const el = document.createElement('div');\n\n      el.attachShadow({ mode: 'open' });\n\n      return el;\n    };\n\n    it('is a no-op without a shadow root', () => {\n      expect(() => instance.applyShadowStyles(undefined)).not.toThrow();\n      expect(() => instance.applyShadowStyles(document.createElement('div'))).not.toThrow();\n    });\n\n    it('injects the accent fix into the shadow root', () => {\n      const el = host();\n\n      instance.applyShadowStyles(el);\n\n      const viaSheet = el.shadowRoot.__pieAccentSheet;\n      const viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');\n      const css = viaSheet ? 'adopted' : (viaStyle && viaStyle.textContent) || '';\n\n      expect(viaSheet || viaStyle).toBeTruthy();\n\n      if (viaStyle) {\n        expect(css).toContain('margin-left:0 !important');\n        // scoped so single-glyph accents keep their centring offset\n        expect(css).toContain(':has(.ML__stretchy)');\n      }\n    });\n\n    it('injects the placeholder caret rules', () => {\n      const el = host();\n\n      instance.applyShadowStyles(el);\n\n      const viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');\n\n      if (viaStyle) {\n        const css = viaStyle.textContent;\n\n        // gated on the host class, so an ordinary selection gets no caret\n        expect(css).toContain(`:host(.${instance.PLACEHOLDER_CARET_CLASS})`);\n        // MathLive's own blink keyframes and caret colour, already in this root\n        expect(css).toContain('ML__caret-blink');\n        expect(css).toContain('--_caret-color');\n        // the innermost selected element only: MathLive marks a wrapper AND the\n        // glyph span, which would otherwise render two carets\n        expect(css).toContain('.ML__selected:not(:has(.ML__selected))');\n      }\n    });\n\n    it('injects the radical index size fix', () => {\n      const el = host();\n\n      instance.applyShadowStyles(el);\n\n      const viaStyle = el.shadowRoot.querySelector('style[data-pie-accent]');\n\n      if (viaStyle) {\n        const css = viaStyle.textContent;\n\n        // MathLive's scriptscriptstyle index (an inline 50%) reads too small in\n        // the authoring UI; a mathfield's shadow root needs its own copy of the\n        // rule, since host styles do not cross the boundary. Compared against\n        // the exported rule, so the size stays defined in one place.\n        // eslint-disable-next-line global-require\n        const { ROOT_INDEX_CSS } = require('../mf/common-styles');\n\n        expect(ROOT_INDEX_CSS).toContain('.ML__sqrt-index >');\n        expect(css).toContain(ROOT_INDEX_CSS);\n      }\n    });\n\n    it('does not inject twice', () => {\n      const el = host();\n\n      instance.applyShadowStyles(el);\n      instance.applyShadowStyles(el);\n\n      const styles = el.shadowRoot.querySelectorAll('style[data-pie-accent]');\n\n      // either one adopted sheet, or exactly one style node\n      expect(el.shadowRoot.__pieAccentSheet ? 1 : styles.length).toBe(1);\n    });\n  });\n\n  describe('latexToMarkup', () => {\n    it('returns empty string when MathLive is not loaded', () => {\n      expect(instance.latexToMarkup('\\\\pi')).toEqual('');\n    });\n\n    it('returns empty string for empty latex', () => {\n      expect(instance.latexToMarkup('')).toEqual('');\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}