@pie-lib/editable-html-tip-tap 1.0.12 → 1.0.14

package/lib/extensions/responseArea.js

@@ -11,6 +11,10 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _react = _interopRequireDefault(require("react"));
 
+var _prosemirrorState = require("prosemirror-state");
+
+var _core = require("@tiptap/core");
+
 var _react2 = require("@tiptap/react");
 
 var _ExplicitConstructedResponse = _interopRequireDefault(require("../components/respArea/ExplicitConstructedResponse"));
@@ -19,37 +23,211 @@ var _DragInTheBlank = _interopRequireDefault(require("../components/respArea/Dra
 
 var _InlineDropdown = _interopRequireDefault(require("../components/respArea/InlineDropdown"));
 
-var _core = require("@tiptap/core");
+var _propTypes = _interopRequireDefault(require("prop-types"));
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
+var lastIndexMap = {};
+
+var normalizeType = function normalizeType(type) {
+  return String(type || '').replace(/-/g, '_');
+};
+
+var getAttrIndex = function getAttrIndex(node) {
+  return node && node.attrs && node.attrs.index != null ? String(node.attrs.index) : null;
+};
+
+var collectNodesOfType = function collectNodesOfType(doc, typeName) {
+  var results = [];
+  doc.descendants(function (node, pos) {
+    if (node.type && node.type.name === typeName) {
+      var index = getAttrIndex(node);
+      if (index != null) results.push({
+        index: index,
+        pos: pos,
+        node: node
+      });
+    }
+
+    return true;
+  });
+  return results;
+};
+
+var countNodesOfType = function countNodesOfType(doc, typeName) {
+  var count = 0;
+  doc.descendants(function (node) {
+    if (node.type && node.type.name === typeName) count += 1;
+    return true;
+  });
+  return count;
+};
+
+var getDefaultNode = function getDefaultNode(_ref) {
+  var schema = _ref.schema,
+      typeName = _ref.typeName,
+      index = _ref.index;
+  var nodeType = schema.nodes[typeName];
+  if (!nodeType) return null; // mirror your Slate "getDefaultElement(opts, newIndex)"
+  // customize attrs as needed:
+
+  return nodeType.create({
+    index: String(index),
+    id: String(index),
+    value: ''
+  });
+}; // Find a good cursor position *after* an inserted node.
+
+
+var selectionAfterPos = function selectionAfterPos(doc, pos) {
+  var $pos = doc.resolve(Math.min(pos, doc.content.size));
+  return _prosemirrorState.TextSelection.near($pos, 1);
+};
+
 var ResponseAreaExtension = _core.Extension.create({
   name: 'responseArea',
+  addOptions: function addOptions() {
+    return {
+      maxResponseAreas: null,
+      error: null,
+      options: null,
+      respAreaToolbar: null,
+      onHandleAreaChange: null
+    };
+  },
+  addProseMirrorPlugins: function addProseMirrorPlugins() {
+    var _this = this;
+
+    if (!this.options.type) {
+      return [];
+    }
+
+    var typeName = normalizeType(this.options.type);
+    var key = new _prosemirrorState.PluginKey("response-area-watcher:".concat(typeName));
+    return [new _prosemirrorState.Plugin({
+      key: key,
+      view: function view(_view) {
+        // Lazy init lastIndexMap[typeName]
+        if (lastIndexMap[typeName] === undefined) {
+          lastIndexMap[typeName] = 0;
+
+          _view.state.doc.descendants(function (node) {
+            if (node.type && node.type.name === typeName) {
+              var idx = getAttrIndex(node);
+
+              if (idx != null) {
+                var n = parseInt(idx, 10);
+
+                if (!Number.isNaN(n) && n > lastIndexMap[typeName]) {
+                  lastIndexMap[typeName] = n;
+                }
+              }
+            }
+
+            return true;
+          });
+        }
+
+        return {
+          update: function update(view, prevState) {
+            var state = view.state;
+            if (prevState.doc.eq(state.doc)) return;
+            var currentList = collectNodesOfType(state.doc, typeName);
+            var oldList = collectNodesOfType(prevState.doc, typeName);
+
+            if (_this.options.toolbar) {
+              _this.options.toolbar.disabled = currentList.length >= _this.options.maxResponseAreas;
+            } // Removed elements (same logic as Slate)
+
+
+            if (oldList.length > currentList.length) {
+              var currentIndexSet = new Set(currentList.map(function (x) {
+                return x.index;
+              }));
+              var removed = oldList.filter(function (x) {
+                return !currentIndexSet.has(x.index);
+              });
+
+              if (removed.length && typeof _this.options.onHandleAreaChange === 'function') {
+                _this.options.onHandleAreaChange(removed);
+              }
+            }
+          }
+        };
+      }
+    })];
+  },
   addCommands: function addCommands() {
+    var _this2 = this;
+
     return {
       insertResponseArea: function insertResponseArea(type) {
-        return function (_ref) {
-          var tr = _ref.tr,
-              state = _ref.state,
-              dispatch = _ref.dispatch;
-          var schema = state.schema,
-              selection = state.selection;
-          var position = selection.$from.pos;
-          var RESP_MAP = {
-            'drag-in-the-blank': 'drag_in_the_blank',
-            'explicit-constructed-response': 'explicit_constructed_response',
-            'inline-dropdown': 'inline_dropdown'
-          };
-          var node = schema.nodes[RESP_MAP[type]].create({
-            index: '1',
-            id: '1',
-            value: ''
+        return function (_ref2) {
+          var tr = _ref2.tr,
+              state = _ref2.state,
+              dispatch = _ref2.dispatch,
+              commands = _ref2.commands;
+          var typeName = normalizeType(type); // --- Slate: currentRespAreaList + max check ---
+
+          var currentCount = countNodesOfType(state.doc, typeName);
+
+          if (currentCount >= _this2.options.maxResponseAreas) {
+            return false;
+          } // --- Slate: indexing logic (kept identical) ---
+
+
+          if (lastIndexMap[typeName] === undefined) lastIndexMap[typeName] = 0;
+          var prevIndex = lastIndexMap[typeName];
+          var newIndex = prevIndex === 0 ? prevIndex : prevIndex + 1; // Slate increments map even if newIndex === 0
+
+          lastIndexMap[typeName] += 1;
+          var newInline = getDefaultNode({
+            schema: state.schema,
+            typeName: typeName,
+            index: newIndex
           });
+          if (!newInline) return false; // --- Insert logic ---
+
+          var selection = state.selection;
+          var insertPos = selection.from; // If we're in a NodeSelection, insert before/after is ambiguous;
+          // We'll insert at its "from" (like your current code).
+          // If insertion fails, we fallback to end of doc.
+
+          var tryInsertAt = function tryInsertAt(pos) {
+            try {
+              tr.insert(pos, newInline);
+              return pos;
+            } catch (e) {
+              return null;
+            }
+          };
+
+          var usedPos = tryInsertAt(insertPos); // Slate branch: "markup empty and there's no focus"
+          // ProseMirror doesn't expose "no focus" the same way, so the closest
+          // equivalent fallback is inserting at end of document.
+
+          if (usedPos == null) {
+            usedPos = tryInsertAt(tr.doc.content.size);
+          }
+
+          if (usedPos == null) return false; // Optionally select the node you just inserted (like your original command)
+          // tr.setSelection(NodeSelection.create(tr.doc, usedPos))
+          // --- Cursor move behavior for certain types (Slate: moveFocusTo next text) ---
+
+          if (typeName === 'drag_in_the_blank' || typeName === 'math_templated') {
+            var after = usedPos + newInline.nodeSize;
+            tr.setSelection(selectionAfterPos(tr.doc, after));
+          } else {
+            // Default: put cursor after inserted node
+            var _after = usedPos + newInline.nodeSize;
+
+            tr.setSelection(selectionAfterPos(tr.doc, _after));
+          }
 
           if (dispatch) {
-            tr.insert(position, node);
+            commands.focus();
             dispatch(tr);
           }
 
@@ -92,8 +270,8 @@ var ExplicitConstructedResponseNode = _react2.Node.create({
       }
     }];
   },
-  renderHTML: function renderHTML(_ref2) {
-    var HTMLAttributes = _ref2.HTMLAttributes;
+  renderHTML: function renderHTML(_ref3) {
+    var HTMLAttributes = _ref3.HTMLAttributes;
     return ['span', {
       'data-type': 'explicit_constructed_response',
       'data-index': HTMLAttributes.index,
@@ -101,11 +279,11 @@ var ExplicitConstructedResponseNode = _react2.Node.create({
     }];
   },
   addNodeView: function addNodeView() {
-    var _this = this;
+    var _this3 = this;
 
     return (0, _react2.ReactNodeViewRenderer)(function (props) {
       return /*#__PURE__*/_react["default"].createElement(_ExplicitConstructedResponse["default"], _objectSpread(_objectSpread({}, props), {}, {
-        options: _this.options
+        options: _this3.options
       }));
     });
   }
@@ -143,8 +321,8 @@ var MathTemplatedNode = _react2.Node.create({
       }
     }];
   },
-  renderHTML: function renderHTML(_ref3) {
-    var HTMLAttributes = _ref3.HTMLAttributes;
+  renderHTML: function renderHTML(_ref4) {
+    var HTMLAttributes = _ref4.HTMLAttributes;
     return ['span', {
       'data-type': 'math_templated',
       'data-index': HTMLAttributes.index,
@@ -198,8 +376,8 @@ var DragInTheBlankNode = _react2.Node.create({
       }
     }];
   },
-  renderHTML: function renderHTML(_ref4) {
-    var HTMLAttributes = _ref4.HTMLAttributes;
+  renderHTML: function renderHTML(_ref5) {
+    var HTMLAttributes = _ref5.HTMLAttributes;
     return ['span', {
       'data-type': 'drag_in_the_blank',
       'data-index': HTMLAttributes.index,
@@ -209,11 +387,11 @@ var DragInTheBlankNode = _react2.Node.create({
     }];
   },
   addNodeView: function addNodeView() {
-    var _this2 = this;
+    var _this4 = this;
 
     return (0, _react2.ReactNodeViewRenderer)(function (props) {
       return /*#__PURE__*/_react["default"].createElement(_DragInTheBlank["default"], _objectSpread(_objectSpread({}, props), {}, {
-        options: _this2.options
+        options: _this4.options
       }));
     });
   }
@@ -251,8 +429,8 @@ var InlineDropdownNode = _react2.Node.create({
       }
     }];
   },
-  renderHTML: function renderHTML(_ref5) {
-    var HTMLAttributes = _ref5.HTMLAttributes;
+  renderHTML: function renderHTML(_ref6) {
+    var HTMLAttributes = _ref6.HTMLAttributes;
     return ['span', {
       'data-type': 'inline_dropdown',
       'data-index': HTMLAttributes.index,
@@ -260,15 +438,15 @@ var InlineDropdownNode = _react2.Node.create({
     }];
   },
   addNodeView: function addNodeView() {
-    var _this3 = this;
+    var _this5 = this;
 
     return (0, _react2.ReactNodeViewRenderer)(function (props) {
       return /*#__PURE__*/_react["default"].createElement(_InlineDropdown["default"], _objectSpread(_objectSpread({}, props), {}, {
-        options: _this3.options
+        options: _this5.options
       }));
     });
   }
 });
 
 exports.InlineDropdownNode = InlineDropdownNode;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/extensions/responseArea.js"],"names":["ResponseAreaExtension","Extension","create","name","addCommands","insertResponseArea","type","tr","state","dispatch","schema","selection","position","$from","pos","RESP_MAP","node","nodes","index","id","value","insert","ExplicitConstructedResponseNode","Node","group","inline","atom","addAttributes","parseHTML","tag","getAttrs","el","dataset","renderHTML","HTMLAttributes","addNodeView","props","options","MathTemplatedNode","DragInTheBlankNode","inTable","InlineDropdownNode"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEO,IAAMA,qBAAqB,GAAGC,gBAAUC,MAAV,CAAiB;AACpDC,EAAAA,IAAI,EAAE,cAD8C;AAEpDC,EAAAA,WAFoD,yBAEtC;AACZ,WAAO;AACLC,MAAAA,kBAAkB,EAAE,4BAACC,IAAD;AAAA,eAAU,gBAA6B;AAAA,cAA1BC,EAA0B,QAA1BA,EAA0B;AAAA,cAAtBC,KAAsB,QAAtBA,KAAsB;AAAA,cAAfC,QAAe,QAAfA,QAAe;AACzD,cAAQC,MAAR,GAA8BF,KAA9B,CAAQE,MAAR;AAAA,cAAgBC,SAAhB,GAA8BH,KAA9B,CAAgBG,SAAhB;AACA,cAAMC,QAAQ,GAAGD,SAAS,CAACE,KAAV,CAAgBC,GAAjC;AACA,cAAMC,QAAQ,GAAG;AACf,iCAAqB,mBADN;AAEf,6CAAiC,+BAFlB;AAGf,+BAAmB;AAHJ,WAAjB;AAMA,cAAMC,IAAI,GAAGN,MAAM,CAACO,KAAP,CAAaF,QAAQ,CAACT,IAAD,CAArB,EAA6BJ,MAA7B,CAAoC;AAC/CgB,YAAAA,KAAK,EAAE,GADwC;AAE/CC,YAAAA,EAAE,EAAE,GAF2C;AAG/CC,YAAAA,KAAK,EAAE;AAHwC,WAApC,CAAb;;AAMA,cAAIX,QAAJ,EAAc;AACZF,YAAAA,EAAE,CAACc,MAAH,CAAUT,QAAV,EAAoBI,IAApB;AACAP,YAAAA,QAAQ,CAACF,EAAD,CAAR;AACD;;AAED,iBAAO,IAAP;AACD,SArBmB;AAAA;AADf,KAAP;AAwBD;AA3BmD,CAAjB,CAA9B;AA8BP;AACA;AACA;;;;;AACO,IAAMe,+BAA+B,GAAGC,aAAKrB,MAAL,CAAY;AACzDC,EAAAA,IAAI,EAAE,+BADmD;AAEzDqB,EAAAA,KAAK,EAAE,QAFkD;AAGzDC,EAAAA,MAAM,EAAE,IAHiD;AAIzDC,EAAAA,IAAI,EAAE,IAJmD;AAKzDC,EAAAA,aALyD,2BAKzC;AACd,WAAO;AACLT,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELE,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAVwD;AAWzDQ,EAAAA,SAXyD,uBAW7C;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,iDADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjBb,UAAAA,KAAK,EAAEa,EAAE,CAACC,OAAH,CAAWd,KADD;AAEjBE,UAAAA,KAAK,EAAEW,EAAE,CAACC,OAAH,CAAWZ;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArBwD;AAsBzDa,EAAAA,UAtByD,6BAsB1B;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,+BADf;AAEE,oBAAcA,cAAc,CAAChB,KAF/B;AAGE,oBAAcgB,cAAc,CAACd;AAH/B,KAFK,CAAP;AAQD,GA/BwD;AAgCzDe,EAAAA,WAhCyD,yBAgC3C;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,uCAAD,kCAAsCA,KAAtC;AAA6CC,QAAAA,OAAO,EAAE,KAAI,CAACA;AAA3D,SAAX;AAAA,KAAtB,CAAP;AACD;AAlCwD,CAAZ,CAAxC;AAqCP;AACA;AACA;;;;;AACO,IAAMC,iBAAiB,GAAGf,aAAKrB,MAAL,CAAY;AAC3CC,EAAAA,IAAI,EAAE,gBADqC;AAE3CqB,EAAAA,KAAK,EAAE,QAFoC;AAG3CC,EAAAA,MAAM,EAAE,IAHmC;AAI3CC,EAAAA,IAAI,EAAE,IAJqC;AAK3CC,EAAAA,aAL2C,2BAK3B;AACd,WAAO;AACLT,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELE,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAV0C;AAW3CQ,EAAAA,SAX2C,uBAW/B;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,kCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjBb,UAAAA,KAAK,EAAEa,EAAE,CAACC,OAAH,CAAWd,KADD;AAEjBE,UAAAA,KAAK,EAAEW,EAAE,CAACC,OAAH,CAAWZ;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArB0C;AAsB3Ca,EAAAA,UAtB2C,6BAsBZ;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,gBADf;AAEE,oBAAcA,cAAc,CAAChB,KAF/B;AAGE,oBAAcgB,cAAc,CAACd;AAH/B,KAFK,CAAP;AAQD,GA/B0C;AAgC3Ce,EAAAA,WAhC2C,yBAgC7B;AACZ,WAAO,mCAAsB;AAAA,0BAAM,4CAAN;AAAA,KAAtB,CAAP;AACD;AAlC0C,CAAZ,CAA1B;AAqCP;AACA;AACA;;;;;AACO,IAAMI,kBAAkB,GAAGhB,aAAKrB,MAAL,CAAY;AAC5CC,EAAAA,IAAI,EAAE,mBADsC;AAE5CqB,EAAAA,KAAK,EAAE,QAFqC;AAG5CC,EAAAA,MAAM,EAAE,IAHoC;AAI5CC,EAAAA,IAAI,EAAE,IAJsC;AAK5CC,EAAAA,aAL4C,2BAK5B;AACd,WAAO;AACLT,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELC,MAAAA,EAAE,EAAE;AAAE,mBAAS;AAAX,OAFC;AAGLC,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OAHF;AAILoB,MAAAA,OAAO,EAAE;AAAE,mBAAS;AAAX;AAJJ,KAAP;AAMD,GAZ2C;AAa5CZ,EAAAA,SAb4C,uBAahC;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,qCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjBb,UAAAA,KAAK,EAAEa,EAAE,CAACC,OAAH,CAAWd,KADD;AAEjBC,UAAAA,EAAE,EAAEY,EAAE,CAACC,OAAH,CAAWb,EAFE;AAGjBC,UAAAA,KAAK,EAAEW,EAAE,CAACC,OAAH,CAAWZ,KAHD;AAIjBoB,UAAAA,OAAO,EAAET,EAAE,CAACC,OAAH,CAAWQ;AAJH,SAAT;AAAA;AAFZ,KADK,CAAP;AAWD,GAzB2C;AA0B5CP,EAAAA,UA1B4C,6BA0Bb;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,mBADf;AAEE,oBAAcA,cAAc,CAAChB,KAF/B;AAGE,iBAAWgB,cAAc,CAACf,EAH5B;AAIE,oBAAce,cAAc,CAACd,KAJ/B;AAKE,uBAAiBc,cAAc,CAACM;AALlC,KAFK,CAAP;AAUD,GArC2C;AAsC5CL,EAAAA,WAtC4C,yBAsC9B;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,0BAAD,kCAAyBA,KAAzB;AAAgCC,QAAAA,OAAO,EAAE,MAAI,CAACA;AAA9C,SAAX;AAAA,KAAtB,CAAP;AACD;AAxC2C,CAAZ,CAA3B;AA2CP;AACA;AACA;;;;;AACO,IAAMI,kBAAkB,GAAGlB,aAAKrB,MAAL,CAAY;AAC5CC,EAAAA,IAAI,EAAE,iBADsC;AAE5CqB,EAAAA,KAAK,EAAE,QAFqC;AAG5CC,EAAAA,MAAM,EAAE,IAHoC;AAI5CC,EAAAA,IAAI,EAAE,IAJsC;AAK5CC,EAAAA,aAL4C,2BAK5B;AACd,WAAO;AACLT,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELE,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAV2C;AAW5CQ,EAAAA,SAX4C,uBAWhC;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,mCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjBb,UAAAA,KAAK,EAAEa,EAAE,CAACC,OAAH,CAAWd,KADD;AAEjBE,UAAAA,KAAK,EAAEW,EAAE,CAACC,OAAH,CAAWZ;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArB2C;AAsB5Ca,EAAAA,UAtB4C,6BAsBb;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,iBADf;AAEE,oBAAcA,cAAc,CAAChB,KAF/B;AAGE,oBAAcgB,cAAc,CAACd;AAH/B,KAFK,CAAP;AAQD,GA/B2C;AAgC5Ce,EAAAA,WAhC4C,yBAgC9B;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,0BAAD,kCAAyBA,KAAzB;AAAgCC,QAAAA,OAAO,EAAE,MAAI,CAACA;AAA9C,SAAX;AAAA,KAAtB,CAAP;AACD;AAlC2C,CAAZ,CAA3B","sourcesContent":["import React from 'react';\nimport { Node, ReactNodeViewRenderer, ReactRenderer } from '@tiptap/react';\nimport ExplicitConstructedResponse from '../components/respArea/ExplicitConstructedResponse';\nimport DragInTheBlank from '../components/respArea/DragInTheBlank/DragInTheBlank';\nimport InlineDropdown from '../components/respArea/InlineDropdown';\nimport { Extension } from '@tiptap/core';\n\nexport const ResponseAreaExtension = Extension.create({\n  name: 'responseArea',\n  addCommands() {\n    return {\n      insertResponseArea: (type) => ({ tr, state, dispatch }) => {\n        const { schema, selection } = state;\n        const position = selection.$from.pos;\n        const RESP_MAP = {\n          'drag-in-the-blank': 'drag_in_the_blank',\n          'explicit-constructed-response': 'explicit_constructed_response',\n          'inline-dropdown': 'inline_dropdown',\n        };\n\n        const node = schema.nodes[RESP_MAP[type]].create({\n          index: '1',\n          id: '1',\n          value: '',\n        });\n\n        if (dispatch) {\n          tr.insert(position, node);\n          dispatch(tr);\n        }\n\n        return true;\n      },\n    };\n  },\n});\n\n/**\n * ExplicitConstructedResponse Node\n */\nexport const ExplicitConstructedResponseNode = Node.create({\n  name: 'explicit_constructed_response',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"explicit_constructed_response\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'explicit_constructed_response',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <ExplicitConstructedResponse {...{ ...props, options: this.options }} />);\n  },\n});\n\n/**\n * MathTemplated Node\n */\nexport const MathTemplatedNode = Node.create({\n  name: 'math_templated',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"math_templated\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'math_templated',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer(() => <div></div>);\n  },\n});\n\n/**\n * DragInTheBlank Node\n */\nexport const DragInTheBlankNode = Node.create({\n  name: 'drag_in_the_blank',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      id: { default: null },\n      value: { default: '' },\n      inTable: { default: null },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"drag_in_the_blank\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          id: el.dataset.id,\n          value: el.dataset.value,\n          inTable: el.dataset.inTable,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'drag_in_the_blank',\n        'data-index': HTMLAttributes.index,\n        'data-id': HTMLAttributes.id,\n        'data-value': HTMLAttributes.value,\n        'data-in-table': HTMLAttributes.inTable,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <DragInTheBlank {...{ ...props, options: this.options }} />);\n  },\n});\n\n/**\n * InlineDropdown Node\n */\nexport const InlineDropdownNode = Node.create({\n  name: 'inline_dropdown',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"inline_dropdown\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'inline_dropdown',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <InlineDropdown {...{ ...props, options: this.options }} />);\n  },\n});\n"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/extensions/responseArea.js"],"names":["lastIndexMap","normalizeType","type","String","replace","getAttrIndex","node","attrs","index","collectNodesOfType","doc","typeName","results","descendants","pos","name","push","countNodesOfType","count","getDefaultNode","schema","nodeType","nodes","create","id","value","selectionAfterPos","$pos","resolve","Math","min","content","size","TextSelection","near","ResponseAreaExtension","Extension","addOptions","maxResponseAreas","error","options","respAreaToolbar","onHandleAreaChange","addProseMirrorPlugins","key","PluginKey","Plugin","view","undefined","state","idx","n","parseInt","Number","isNaN","update","prevState","eq","currentList","oldList","toolbar","disabled","length","currentIndexSet","Set","map","x","removed","filter","has","addCommands","insertResponseArea","tr","dispatch","commands","currentCount","prevIndex","newIndex","newInline","selection","insertPos","from","tryInsertAt","insert","e","usedPos","after","nodeSize","setSelection","focus","ExplicitConstructedResponseNode","Node","group","inline","atom","addAttributes","parseHTML","tag","getAttrs","el","dataset","renderHTML","HTMLAttributes","addNodeView","props","MathTemplatedNode","DragInTheBlankNode","inTable","InlineDropdownNode"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAEA,IAAMA,YAAY,GAAG,EAArB;;AAEA,IAAMC,aAAa,GAAG,SAAhBA,aAAgB,CAACC,IAAD;AAAA,SAAUC,MAAM,CAACD,IAAI,IAAI,EAAT,CAAN,CAAmBE,OAAnB,CAA2B,IAA3B,EAAiC,GAAjC,CAAV;AAAA,CAAtB;;AAEA,IAAMC,YAAY,GAAG,SAAfA,YAAe,CAACC,IAAD;AAAA,SAAWA,IAAI,IAAIA,IAAI,CAACC,KAAb,IAAsBD,IAAI,CAACC,KAAL,CAAWC,KAAX,IAAoB,IAA1C,GAAiDL,MAAM,CAACG,IAAI,CAACC,KAAL,CAAWC,KAAZ,CAAvD,GAA4E,IAAvF;AAAA,CAArB;;AAEA,IAAMC,kBAAkB,GAAG,SAArBA,kBAAqB,CAACC,GAAD,EAAMC,QAAN,EAAmB;AAC5C,MAAMC,OAAO,GAAG,EAAhB;AAEAF,EAAAA,GAAG,CAACG,WAAJ,CAAgB,UAACP,IAAD,EAAOQ,GAAP,EAAe;AAC7B,QAAIR,IAAI,CAACJ,IAAL,IAAaI,IAAI,CAACJ,IAAL,CAAUa,IAAV,KAAmBJ,QAApC,EAA8C;AAC5C,UAAMH,KAAK,GAAGH,YAAY,CAACC,IAAD,CAA1B;AACA,UAAIE,KAAK,IAAI,IAAb,EAAmBI,OAAO,CAACI,IAAR,CAAa;AAAER,QAAAA,KAAK,EAALA,KAAF;AAASM,QAAAA,GAAG,EAAHA,GAAT;AAAcR,QAAAA,IAAI,EAAJA;AAAd,OAAb;AACpB;;AACD,WAAO,IAAP;AACD,GAND;AAQA,SAAOM,OAAP;AACD,CAZD;;AAcA,IAAMK,gBAAgB,GAAG,SAAnBA,gBAAmB,CAACP,GAAD,EAAMC,QAAN,EAAmB;AAC1C,MAAIO,KAAK,GAAG,CAAZ;AACAR,EAAAA,GAAG,CAACG,WAAJ,CAAgB,UAACP,IAAD,EAAU;AACxB,QAAIA,IAAI,CAACJ,IAAL,IAAaI,IAAI,CAACJ,IAAL,CAAUa,IAAV,KAAmBJ,QAApC,EAA8CO,KAAK,IAAI,CAAT;AAC9C,WAAO,IAAP;AACD,GAHD;AAIA,SAAOA,KAAP;AACD,CAPD;;AASA,IAAMC,cAAc,GAAG,SAAjBA,cAAiB,OAAiC;AAAA,MAA9BC,MAA8B,QAA9BA,MAA8B;AAAA,MAAtBT,QAAsB,QAAtBA,QAAsB;AAAA,MAAZH,KAAY,QAAZA,KAAY;AACtD,MAAMa,QAAQ,GAAGD,MAAM,CAACE,KAAP,CAAaX,QAAb,CAAjB;AACA,MAAI,CAACU,QAAL,EAAe,OAAO,IAAP,CAFuC,CAItD;AACA;;AACA,SAAOA,QAAQ,CAACE,MAAT,CAAgB;AACrBf,IAAAA,KAAK,EAAEL,MAAM,CAACK,KAAD,CADQ;AAErBgB,IAAAA,EAAE,EAAErB,MAAM,CAACK,KAAD,CAFW;AAGrBiB,IAAAA,KAAK,EAAE;AAHc,GAAhB,CAAP;AAKD,CAXD,C,CAaA;;;AACA,IAAMC,iBAAiB,GAAG,SAApBA,iBAAoB,CAAChB,GAAD,EAAMI,GAAN,EAAc;AACtC,MAAMa,IAAI,GAAGjB,GAAG,CAACkB,OAAJ,CAAYC,IAAI,CAACC,GAAL,CAAShB,GAAT,EAAcJ,GAAG,CAACqB,OAAJ,CAAYC,IAA1B,CAAZ,CAAb;AACA,SAAOC,gCAAcC,IAAd,CAAmBP,IAAnB,EAAyB,CAAzB,CAAP;AACD,CAHD;;AAKO,IAAMQ,qBAAqB,GAAGC,gBAAUb,MAAV,CAAiB;AACpDR,EAAAA,IAAI,EAAE,cAD8C;AAGpDsB,EAAAA,UAHoD,wBAGvC;AACX,WAAO;AACLC,MAAAA,gBAAgB,EAAE,IADb;AAELC,MAAAA,KAAK,EAAE,IAFF;AAGLC,MAAAA,OAAO,EAAE,IAHJ;AAILC,MAAAA,eAAe,EAAE,IAJZ;AAKLC,MAAAA,kBAAkB,EAAE;AALf,KAAP;AAOD,GAXmD;AAapDC,EAAAA,qBAboD,mCAa5B;AAAA;;AACtB,QAAI,CAAC,KAAKH,OAAL,CAAatC,IAAlB,EAAwB;AACtB,aAAO,EAAP;AACD;;AAED,QAAMS,QAAQ,GAAGV,aAAa,CAAC,KAAKuC,OAAL,CAAatC,IAAd,CAA9B;AACA,QAAM0C,GAAG,GAAG,IAAIC,2BAAJ,iCAAuClC,QAAvC,EAAZ;AAEA,WAAO,CACL,IAAImC,wBAAJ,CAAW;AACTF,MAAAA,GAAG,EAAHA,GADS;AAGTG,MAAAA,IAAI,EAAE,cAACA,KAAD,EAAU;AACd;AACA,YAAI/C,YAAY,CAACW,QAAD,CAAZ,KAA2BqC,SAA/B,EAA0C;AACxChD,UAAAA,YAAY,CAACW,QAAD,CAAZ,GAAyB,CAAzB;;AAEAoC,UAAAA,KAAI,CAACE,KAAL,CAAWvC,GAAX,CAAeG,WAAf,CAA2B,UAACP,IAAD,EAAU;AACnC,gBAAIA,IAAI,CAACJ,IAAL,IAAaI,IAAI,CAACJ,IAAL,CAAUa,IAAV,KAAmBJ,QAApC,EAA8C;AAC5C,kBAAMuC,GAAG,GAAG7C,YAAY,CAACC,IAAD,CAAxB;;AACA,kBAAI4C,GAAG,IAAI,IAAX,EAAiB;AACf,oBAAMC,CAAC,GAAGC,QAAQ,CAACF,GAAD,EAAM,EAAN,CAAlB;;AACA,oBAAI,CAACG,MAAM,CAACC,KAAP,CAAaH,CAAb,CAAD,IAAoBA,CAAC,GAAGnD,YAAY,CAACW,QAAD,CAAxC,EAAoD;AAClDX,kBAAAA,YAAY,CAACW,QAAD,CAAZ,GAAyBwC,CAAzB;AACD;AACF;AACF;;AACD,mBAAO,IAAP;AACD,WAXD;AAYD;;AAED,eAAO;AACLI,UAAAA,MAAM,EAAE,gBAACR,IAAD,EAAOS,SAAP,EAAqB;AAC3B,gBAAMP,KAAK,GAAGF,IAAI,CAACE,KAAnB;AACA,gBAAIO,SAAS,CAAC9C,GAAV,CAAc+C,EAAd,CAAiBR,KAAK,CAACvC,GAAvB,CAAJ,EAAiC;AAEjC,gBAAMgD,WAAW,GAAGjD,kBAAkB,CAACwC,KAAK,CAACvC,GAAP,EAAYC,QAAZ,CAAtC;AACA,gBAAMgD,OAAO,GAAGlD,kBAAkB,CAAC+C,SAAS,CAAC9C,GAAX,EAAgBC,QAAhB,CAAlC;;AAEA,gBAAI,KAAI,CAAC6B,OAAL,CAAaoB,OAAjB,EAA0B;AACxB,cAAA,KAAI,CAACpB,OAAL,CAAaoB,OAAb,CAAqBC,QAArB,GAAgCH,WAAW,CAACI,MAAZ,IAAsB,KAAI,CAACtB,OAAL,CAAaF,gBAAnE;AACD,aAT0B,CAW3B;;;AACA,gBAAIqB,OAAO,CAACG,MAAR,GAAiBJ,WAAW,CAACI,MAAjC,EAAyC;AACvC,kBAAMC,eAAe,GAAG,IAAIC,GAAJ,CAAQN,WAAW,CAACO,GAAZ,CAAgB,UAACC,CAAD;AAAA,uBAAOA,CAAC,CAAC1D,KAAT;AAAA,eAAhB,CAAR,CAAxB;AAEA,kBAAM2D,OAAO,GAAGR,OAAO,CAACS,MAAR,CAAe,UAACF,CAAD;AAAA,uBAAO,CAACH,eAAe,CAACM,GAAhB,CAAoBH,CAAC,CAAC1D,KAAtB,CAAR;AAAA,eAAf,CAAhB;;AAEA,kBAAI2D,OAAO,CAACL,MAAR,IAAkB,OAAO,KAAI,CAACtB,OAAL,CAAaE,kBAApB,KAA2C,UAAjE,EAA6E;AAC3E,gBAAA,KAAI,CAACF,OAAL,CAAaE,kBAAb,CAAgCyB,OAAhC;AACD;AACF;AACF;AAtBI,SAAP;AAwBD;AA9CQ,KAAX,CADK,CAAP;AAkDD,GAvEmD;AAyEpDG,EAAAA,WAzEoD,yBAyEtC;AAAA;;AACZ,WAAO;AACLC,MAAAA,kBAAkB,EAAE,4BAACrE,IAAD;AAAA,eAAU,iBAAuC;AAAA,cAApCsE,EAAoC,SAApCA,EAAoC;AAAA,cAAhCvB,KAAgC,SAAhCA,KAAgC;AAAA,cAAzBwB,QAAyB,SAAzBA,QAAyB;AAAA,cAAfC,QAAe,SAAfA,QAAe;AACnE,cAAM/D,QAAQ,GAAGV,aAAa,CAACC,IAAD,CAA9B,CADmE,CAGnE;;AACA,cAAMyE,YAAY,GAAG1D,gBAAgB,CAACgC,KAAK,CAACvC,GAAP,EAAYC,QAAZ,CAArC;;AACA,cAAIgE,YAAY,IAAI,MAAI,CAACnC,OAAL,CAAaF,gBAAjC,EAAmD;AACjD,mBAAO,KAAP;AACD,WAPkE,CASnE;;;AACA,cAAItC,YAAY,CAACW,QAAD,CAAZ,KAA2BqC,SAA/B,EAA0ChD,YAAY,CAACW,QAAD,CAAZ,GAAyB,CAAzB;AAE1C,cAAMiE,SAAS,GAAG5E,YAAY,CAACW,QAAD,CAA9B;AACA,cAAMkE,QAAQ,GAAGD,SAAS,KAAK,CAAd,GAAkBA,SAAlB,GAA8BA,SAAS,GAAG,CAA3D,CAbmE,CAenE;;AACA5E,UAAAA,YAAY,CAACW,QAAD,CAAZ,IAA0B,CAA1B;AAEA,cAAMmE,SAAS,GAAG3D,cAAc,CAAC;AAC/BC,YAAAA,MAAM,EAAE6B,KAAK,CAAC7B,MADiB;AAE/BT,YAAAA,QAAQ,EAARA,QAF+B;AAG/BH,YAAAA,KAAK,EAAEqE;AAHwB,WAAD,CAAhC;AAMA,cAAI,CAACC,SAAL,EAAgB,OAAO,KAAP,CAxBmD,CA0BnE;;AACA,cAAQC,SAAR,GAAsB9B,KAAtB,CAAQ8B,SAAR;AACA,cAAIC,SAAS,GAAGD,SAAS,CAACE,IAA1B,CA5BmE,CA8BnE;AACA;AACA;;AACA,cAAMC,WAAW,GAAG,SAAdA,WAAc,CAACpE,GAAD,EAAS;AAC3B,gBAAI;AACF0D,cAAAA,EAAE,CAACW,MAAH,CAAUrE,GAAV,EAAegE,SAAf;AACA,qBAAOhE,GAAP;AACD,aAHD,CAGE,OAAOsE,CAAP,EAAU;AACV,qBAAO,IAAP;AACD;AACF,WAPD;;AASA,cAAIC,OAAO,GAAGH,WAAW,CAACF,SAAD,CAAzB,CA1CmE,CA4CnE;AACA;AACA;;AACA,cAAIK,OAAO,IAAI,IAAf,EAAqB;AACnBA,YAAAA,OAAO,GAAGH,WAAW,CAACV,EAAE,CAAC9D,GAAH,CAAOqB,OAAP,CAAeC,IAAhB,CAArB;AACD;;AACD,cAAIqD,OAAO,IAAI,IAAf,EAAqB,OAAO,KAAP,CAlD8C,CAoDnE;AACA;AAEA;;AACA,cAAI1E,QAAQ,KAAK,mBAAb,IAAoCA,QAAQ,KAAK,gBAArD,EAAuE;AACrE,gBAAM2E,KAAK,GAAGD,OAAO,GAAGP,SAAS,CAACS,QAAlC;AACAf,YAAAA,EAAE,CAACgB,YAAH,CAAgB9D,iBAAiB,CAAC8C,EAAE,CAAC9D,GAAJ,EAAS4E,KAAT,CAAjC;AACD,WAHD,MAGO;AACL;AACA,gBAAMA,MAAK,GAAGD,OAAO,GAAGP,SAAS,CAACS,QAAlC;;AACAf,YAAAA,EAAE,CAACgB,YAAH,CAAgB9D,iBAAiB,CAAC8C,EAAE,CAAC9D,GAAJ,EAAS4E,MAAT,CAAjC;AACD;;AAED,cAAIb,QAAJ,EAAc;AACZC,YAAAA,QAAQ,CAACe,KAAT;AACAhB,YAAAA,QAAQ,CAACD,EAAD,CAAR;AACD;;AAED,iBAAO,IAAP;AACD,SAvEmB;AAAA;AADf,KAAP;AA0ED;AApJmD,CAAjB,CAA9B;AAuJP;AACA;AACA;;;;;AACO,IAAMkB,+BAA+B,GAAGC,aAAKpE,MAAL,CAAY;AACzDR,EAAAA,IAAI,EAAE,+BADmD;AAEzD6E,EAAAA,KAAK,EAAE,QAFkD;AAGzDC,EAAAA,MAAM,EAAE,IAHiD;AAIzDC,EAAAA,IAAI,EAAE,IAJmD;AAKzDC,EAAAA,aALyD,2BAKzC;AACd,WAAO;AACLvF,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELiB,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAVwD;AAWzDuE,EAAAA,SAXyD,uBAW7C;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,iDADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjB3F,UAAAA,KAAK,EAAE2F,EAAE,CAACC,OAAH,CAAW5F,KADD;AAEjBiB,UAAAA,KAAK,EAAE0E,EAAE,CAACC,OAAH,CAAW3E;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArBwD;AAsBzD4E,EAAAA,UAtByD,6BAsB1B;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,+BADf;AAEE,oBAAcA,cAAc,CAAC9F,KAF/B;AAGE,oBAAc8F,cAAc,CAAC7E;AAH/B,KAFK,CAAP;AAQD,GA/BwD;AAgCzD8E,EAAAA,WAhCyD,yBAgC3C;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,uCAAD,kCAAsCA,KAAtC;AAA6ChE,QAAAA,OAAO,EAAE,MAAI,CAACA;AAA3D,SAAX;AAAA,KAAtB,CAAP;AACD;AAlCwD,CAAZ,CAAxC;AAqCP;AACA;AACA;;;;;AACO,IAAMiE,iBAAiB,GAAGd,aAAKpE,MAAL,CAAY;AAC3CR,EAAAA,IAAI,EAAE,gBADqC;AAE3C6E,EAAAA,KAAK,EAAE,QAFoC;AAG3CC,EAAAA,MAAM,EAAE,IAHmC;AAI3CC,EAAAA,IAAI,EAAE,IAJqC;AAK3CC,EAAAA,aAL2C,2BAK3B;AACd,WAAO;AACLvF,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELiB,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAV0C;AAW3CuE,EAAAA,SAX2C,uBAW/B;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,kCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjB3F,UAAAA,KAAK,EAAE2F,EAAE,CAACC,OAAH,CAAW5F,KADD;AAEjBiB,UAAAA,KAAK,EAAE0E,EAAE,CAACC,OAAH,CAAW3E;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArB0C;AAsB3C4E,EAAAA,UAtB2C,6BAsBZ;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,gBADf;AAEE,oBAAcA,cAAc,CAAC9F,KAF/B;AAGE,oBAAc8F,cAAc,CAAC7E;AAH/B,KAFK,CAAP;AAQD,GA/B0C;AAgC3C8E,EAAAA,WAhC2C,yBAgC7B;AACZ,WAAO,mCAAsB;AAAA,0BAAM,4CAAN;AAAA,KAAtB,CAAP;AACD;AAlC0C,CAAZ,CAA1B;AAqCP;AACA;AACA;;;;;AACO,IAAMG,kBAAkB,GAAGf,aAAKpE,MAAL,CAAY;AAC5CR,EAAAA,IAAI,EAAE,mBADsC;AAE5C6E,EAAAA,KAAK,EAAE,QAFqC;AAG5CC,EAAAA,MAAM,EAAE,IAHoC;AAI5CC,EAAAA,IAAI,EAAE,IAJsC;AAK5CC,EAAAA,aAL4C,2BAK5B;AACd,WAAO;AACLvF,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELgB,MAAAA,EAAE,EAAE;AAAE,mBAAS;AAAX,OAFC;AAGLC,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OAHF;AAILkF,MAAAA,OAAO,EAAE;AAAE,mBAAS;AAAX;AAJJ,KAAP;AAMD,GAZ2C;AAa5CX,EAAAA,SAb4C,uBAahC;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,qCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjB3F,UAAAA,KAAK,EAAE2F,EAAE,CAACC,OAAH,CAAW5F,KADD;AAEjBgB,UAAAA,EAAE,EAAE2E,EAAE,CAACC,OAAH,CAAW5E,EAFE;AAGjBC,UAAAA,KAAK,EAAE0E,EAAE,CAACC,OAAH,CAAW3E,KAHD;AAIjBkF,UAAAA,OAAO,EAAER,EAAE,CAACC,OAAH,CAAWO;AAJH,SAAT;AAAA;AAFZ,KADK,CAAP;AAWD,GAzB2C;AA0B5CN,EAAAA,UA1B4C,6BA0Bb;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,mBADf;AAEE,oBAAcA,cAAc,CAAC9F,KAF/B;AAGE,iBAAW8F,cAAc,CAAC9E,EAH5B;AAIE,oBAAc8E,cAAc,CAAC7E,KAJ/B;AAKE,uBAAiB6E,cAAc,CAACK;AALlC,KAFK,CAAP;AAUD,GArC2C;AAsC5CJ,EAAAA,WAtC4C,yBAsC9B;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,0BAAD,kCAAyBA,KAAzB;AAAgChE,QAAAA,OAAO,EAAE,MAAI,CAACA;AAA9C,SAAX;AAAA,KAAtB,CAAP;AACD;AAxC2C,CAAZ,CAA3B;AA2CP;AACA;AACA;;;;;AACO,IAAMoE,kBAAkB,GAAGjB,aAAKpE,MAAL,CAAY;AAC5CR,EAAAA,IAAI,EAAE,iBADsC;AAE5C6E,EAAAA,KAAK,EAAE,QAFqC;AAG5CC,EAAAA,MAAM,EAAE,IAHoC;AAI5CC,EAAAA,IAAI,EAAE,IAJsC;AAK5CC,EAAAA,aAL4C,2BAK5B;AACd,WAAO;AACLvF,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX,OADF;AAELiB,MAAAA,KAAK,EAAE;AAAE,mBAAS;AAAX;AAFF,KAAP;AAID,GAV2C;AAW5CuE,EAAAA,SAX4C,uBAWhC;AACV,WAAO,CACL;AACEC,MAAAA,GAAG,EAAE,mCADP;AAEEC,MAAAA,QAAQ,EAAE,kBAACC,EAAD;AAAA,eAAS;AACjB3F,UAAAA,KAAK,EAAE2F,EAAE,CAACC,OAAH,CAAW5F,KADD;AAEjBiB,UAAAA,KAAK,EAAE0E,EAAE,CAACC,OAAH,CAAW3E;AAFD,SAAT;AAAA;AAFZ,KADK,CAAP;AASD,GArB2C;AAsB5C4E,EAAAA,UAtB4C,6BAsBb;AAAA,QAAlBC,cAAkB,SAAlBA,cAAkB;AAC7B,WAAO,CACL,MADK,EAEL;AACE,mBAAa,iBADf;AAEE,oBAAcA,cAAc,CAAC9F,KAF/B;AAGE,oBAAc8F,cAAc,CAAC7E;AAH/B,KAFK,CAAP;AAQD,GA/B2C;AAgC5C8E,EAAAA,WAhC4C,yBAgC9B;AAAA;;AACZ,WAAO,mCAAsB,UAACC,KAAD;AAAA,0BAAW,gCAAC,0BAAD,kCAAyBA,KAAzB;AAAgChE,QAAAA,OAAO,EAAE,MAAI,CAACA;AAA9C,SAAX;AAAA,KAAtB,CAAP;AACD;AAlC2C,CAAZ,CAA3B","sourcesContent":["import React from 'react';\nimport { Plugin, PluginKey, TextSelection } from 'prosemirror-state';\nimport { Extension } from '@tiptap/core';\nimport { Node, ReactNodeViewRenderer } from '@tiptap/react';\nimport ExplicitConstructedResponse from '../components/respArea/ExplicitConstructedResponse';\nimport DragInTheBlank from '../components/respArea/DragInTheBlank/DragInTheBlank';\nimport InlineDropdown from '../components/respArea/InlineDropdown';\nimport PropTypes from 'prop-types';\n\nconst lastIndexMap = {};\n\nconst normalizeType = (type) => String(type || '').replace(/-/g, '_');\n\nconst getAttrIndex = (node) => (node && node.attrs && node.attrs.index != null ? String(node.attrs.index) : null);\n\nconst collectNodesOfType = (doc, typeName) => {\n  const results = [];\n\n  doc.descendants((node, pos) => {\n    if (node.type && node.type.name === typeName) {\n      const index = getAttrIndex(node);\n      if (index != null) results.push({ index, pos, node });\n    }\n    return true;\n  });\n\n  return results;\n};\n\nconst countNodesOfType = (doc, typeName) => {\n  let count = 0;\n  doc.descendants((node) => {\n    if (node.type && node.type.name === typeName) count += 1;\n    return true;\n  });\n  return count;\n};\n\nconst getDefaultNode = ({ schema, typeName, index }) => {\n  const nodeType = schema.nodes[typeName];\n  if (!nodeType) return null;\n\n  // mirror your Slate \"getDefaultElement(opts, newIndex)\"\n  // customize attrs as needed:\n  return nodeType.create({\n    index: String(index),\n    id: String(index),\n    value: '',\n  });\n};\n\n// Find a good cursor position *after* an inserted node.\nconst selectionAfterPos = (doc, pos) => {\n  const $pos = doc.resolve(Math.min(pos, doc.content.size));\n  return TextSelection.near($pos, 1);\n};\n\nexport const ResponseAreaExtension = Extension.create({\n  name: 'responseArea',\n\n  addOptions() {\n    return {\n      maxResponseAreas: null,\n      error: null,\n      options: null,\n      respAreaToolbar: null,\n      onHandleAreaChange: null,\n    };\n  },\n\n  addProseMirrorPlugins() {\n    if (!this.options.type) {\n      return [];\n    }\n\n    const typeName = normalizeType(this.options.type);\n    const key = new PluginKey(`response-area-watcher:${typeName}`);\n\n    return [\n      new Plugin({\n        key,\n\n        view: (view) => {\n          // Lazy init lastIndexMap[typeName]\n          if (lastIndexMap[typeName] === undefined) {\n            lastIndexMap[typeName] = 0;\n\n            view.state.doc.descendants((node) => {\n              if (node.type && node.type.name === typeName) {\n                const idx = getAttrIndex(node);\n                if (idx != null) {\n                  const n = parseInt(idx, 10);\n                  if (!Number.isNaN(n) && n > lastIndexMap[typeName]) {\n                    lastIndexMap[typeName] = n;\n                  }\n                }\n              }\n              return true;\n            });\n          }\n\n          return {\n            update: (view, prevState) => {\n              const state = view.state;\n              if (prevState.doc.eq(state.doc)) return;\n\n              const currentList = collectNodesOfType(state.doc, typeName);\n              const oldList = collectNodesOfType(prevState.doc, typeName);\n\n              if (this.options.toolbar) {\n                this.options.toolbar.disabled = currentList.length >= this.options.maxResponseAreas;\n              }\n\n              // Removed elements (same logic as Slate)\n              if (oldList.length > currentList.length) {\n                const currentIndexSet = new Set(currentList.map((x) => x.index));\n\n                const removed = oldList.filter((x) => !currentIndexSet.has(x.index));\n\n                if (removed.length && typeof this.options.onHandleAreaChange === 'function') {\n                  this.options.onHandleAreaChange(removed);\n                }\n              }\n            },\n          };\n        },\n      }),\n    ];\n  },\n\n  addCommands() {\n    return {\n      insertResponseArea: (type) => ({ tr, state, dispatch, commands }) => {\n        const typeName = normalizeType(type);\n\n        // --- Slate: currentRespAreaList + max check ---\n        const currentCount = countNodesOfType(state.doc, typeName);\n        if (currentCount >= this.options.maxResponseAreas) {\n          return false;\n        }\n\n        // --- Slate: indexing logic (kept identical) ---\n        if (lastIndexMap[typeName] === undefined) lastIndexMap[typeName] = 0;\n\n        const prevIndex = lastIndexMap[typeName];\n        const newIndex = prevIndex === 0 ? prevIndex : prevIndex + 1;\n\n        // Slate increments map even if newIndex === 0\n        lastIndexMap[typeName] += 1;\n\n        const newInline = getDefaultNode({\n          schema: state.schema,\n          typeName,\n          index: newIndex,\n        });\n\n        if (!newInline) return false;\n\n        // --- Insert logic ---\n        const { selection } = state;\n        let insertPos = selection.from;\n\n        // If we're in a NodeSelection, insert before/after is ambiguous;\n        // We'll insert at its \"from\" (like your current code).\n        // If insertion fails, we fallback to end of doc.\n        const tryInsertAt = (pos) => {\n          try {\n            tr.insert(pos, newInline);\n            return pos;\n          } catch (e) {\n            return null;\n          }\n        };\n\n        let usedPos = tryInsertAt(insertPos);\n\n        // Slate branch: \"markup empty and there's no focus\"\n        // ProseMirror doesn't expose \"no focus\" the same way, so the closest\n        // equivalent fallback is inserting at end of document.\n        if (usedPos == null) {\n          usedPos = tryInsertAt(tr.doc.content.size);\n        }\n        if (usedPos == null) return false;\n\n        // Optionally select the node you just inserted (like your original command)\n        // tr.setSelection(NodeSelection.create(tr.doc, usedPos))\n\n        // --- Cursor move behavior for certain types (Slate: moveFocusTo next text) ---\n        if (typeName === 'drag_in_the_blank' || typeName === 'math_templated') {\n          const after = usedPos + newInline.nodeSize;\n          tr.setSelection(selectionAfterPos(tr.doc, after));\n        } else {\n          // Default: put cursor after inserted node\n          const after = usedPos + newInline.nodeSize;\n          tr.setSelection(selectionAfterPos(tr.doc, after));\n        }\n\n        if (dispatch) {\n          commands.focus();\n          dispatch(tr);\n        }\n\n        return true;\n      },\n    };\n  },\n});\n\n/**\n * ExplicitConstructedResponse Node\n */\nexport const ExplicitConstructedResponseNode = Node.create({\n  name: 'explicit_constructed_response',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"explicit_constructed_response\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'explicit_constructed_response',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <ExplicitConstructedResponse {...{ ...props, options: this.options }} />);\n  },\n});\n\n/**\n * MathTemplated Node\n */\nexport const MathTemplatedNode = Node.create({\n  name: 'math_templated',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"math_templated\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'math_templated',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer(() => <div></div>);\n  },\n});\n\n/**\n * DragInTheBlank Node\n */\nexport const DragInTheBlankNode = Node.create({\n  name: 'drag_in_the_blank',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      id: { default: null },\n      value: { default: '' },\n      inTable: { default: null },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"drag_in_the_blank\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          id: el.dataset.id,\n          value: el.dataset.value,\n          inTable: el.dataset.inTable,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'drag_in_the_blank',\n        'data-index': HTMLAttributes.index,\n        'data-id': HTMLAttributes.id,\n        'data-value': HTMLAttributes.value,\n        'data-in-table': HTMLAttributes.inTable,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <DragInTheBlank {...{ ...props, options: this.options }} />);\n  },\n});\n\n/**\n * InlineDropdown Node\n */\nexport const InlineDropdownNode = Node.create({\n  name: 'inline_dropdown',\n  group: 'inline',\n  inline: true,\n  atom: true,\n  addAttributes() {\n    return {\n      index: { default: null },\n      value: { default: '' },\n    };\n  },\n  parseHTML() {\n    return [\n      {\n        tag: 'span[data-type=\"inline_dropdown\"]',\n        getAttrs: (el) => ({\n          index: el.dataset.index,\n          value: el.dataset.value,\n        }),\n      },\n    ];\n  },\n  renderHTML({ HTMLAttributes }) {\n    return [\n      'span',\n      {\n        'data-type': 'inline_dropdown',\n        'data-index': HTMLAttributes.index,\n        'data-value': HTMLAttributes.value,\n      },\n    ];\n  },\n  addNodeView() {\n    return ReactNodeViewRenderer((props) => <InlineDropdown {...{ ...props, options: this.options }} />);\n  },\n});\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pie-lib/editable-html-tip-tap",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "",
   "license": "ISC",
   "main": "lib/index.js",
@@ -18,20 +18,19 @@
     "@tiptap/core": "3.0.9",
     "@tiptap/extension-character-count": "3.0.9",
     "@tiptap/extension-color": "3.0.9",
+    "@tiptap/extension-image": "3.0.9",
     "@tiptap/extension-list-item": "3.0.9",
+    "@tiptap/extension-subscript": "3.0.9",
+    "@tiptap/extension-superscript": "3.0.9",
     "@tiptap/extension-table": "3.0.9",
     "@tiptap/extension-table-cell": "3.0.9",
     "@tiptap/extension-table-header": "3.0.9",
     "@tiptap/extension-table-row": "3.0.9",
-    "@tiptap/extension-text-style": "3.0.9",
-    "@tiptap/extension-superscript": "3.0.9",
-    "@tiptap/extension-subscript": "3.0.9",
     "@tiptap/extension-text-align": "3.0.9",
-    "@tiptap/extension-image": "3.0.9",
+    "@tiptap/extension-text-style": "3.0.9",
     "@tiptap/pm": "3.0.9",
     "@tiptap/react": "3.0.9",
     "@tiptap/starter-kit": "3.0.9",
-    "tippy.js": "latest",
     "change-case": "^3.0.2",
     "classnames": "^2.2.6",
     "debug": "^4.1.1",
@@ -52,6 +51,7 @@
     "slate-react": "^0.14.3",
     "slate-schema-violations": "^0.1.39",
     "slate-soft-break": "^0.8.1",
+    "tippy.js": "latest",
     "to-style": "^1.3.3"
   },
   "devDependencies": {

package/src/components/EditableHtml.jsx

@@ -101,11 +101,17 @@ export const EditableHtml = (props) => {
   };
 
   const activePluginsToUse = useMemo(() => {
-    let { customPlugins } = props.pluginProps || {};
+    let { customPlugins, ...otherPluginProps } = props.pluginProps || {};
 
     customPlugins = customPlugins || [];
 
-    return buildExtensions(props.activePlugins, customPlugins, {
+    const filteredActivePlugins = (props.activePlugins || DEFAULT_ACTIVE_PLUGINS)?.filter((pluginName) => {
+      const pluginInfo = otherPluginProps[pluginName] || {};
+
+      return !pluginInfo || !pluginInfo.disabled;
+    });
+
+    return buildExtensions(filteredActivePlugins, customPlugins, {
       math: {},
       textAlign: {},
       html: {},
@@ -133,7 +139,7 @@ export const EditableHtml = (props) => {
     TableRow,
     TableHeader,
     TableCell,
-    ResponseAreaExtension,
+    ResponseAreaExtension.configure(props.responseAreaProps),
     ExplicitConstructedResponseNode.configure(props.responseAreaProps),
     DragInTheBlankNode.configure(props.responseAreaProps),
     InlineDropdownNode.configure(props.responseAreaProps),
@@ -234,7 +240,15 @@ export const EditableHtml = (props) => {
     },
     editable: !props.disabled,
     content: props.markup,
-    onUpdate: ({ editor, transaction }) => transaction.isDone && props.onChange?.(editor.getHTML()),
+    onUpdate: ({ editor, transaction }) => {
+      if (transaction.isDone) {
+        props.onChange?.(editor.getHTML());
+      }
+
+      if (props.responseAreaProps?.onHandleAreaChange) {
+        // props.responseAreaProps.onHandleAreaChange(editor.getHTML());
+      }
+    },
     onBlur: ({ editor }) => {
       if (toolbarOptsToUse.doneOn === 'blur') {
         props.onDone?.(editor.getHTML());

package/src/components/MenuBar.jsx

@@ -511,12 +511,14 @@ function MenuBar({ editor, classes, activePlugins, toolbarOpts: toolOpts, respon
             </button>
           )}
 
-          <DoneButton
-            onClick={() => {
-              onChange?.(editor.getHTML());
-              editor.commands.blur();
-            }}
-          />
+          {toolbarOpts.showDone && (
+            <DoneButton
+              onClick={() => {
+                onChange?.(editor.getHTML());
+                editor.commands.blur();
+              }}
+            />
+          )}
         </div>
       )}
       {showPicker && (

package/src/components/respArea/ExplicitConstructedResponse.jsx

@@ -5,12 +5,22 @@ import PropTypes from 'prop-types';
 const ExplicitConstructedResponse = (props) => {
   const { editor, node, getPos, options, selected } = props;
   const { attrs: attributes } = node;
-  const { value, error } = attributes;
+  const { value } = attributes;
+  const { respAreaToolbar, error: errorFn } = options;
   const pos = getPos();
   const [showToolbar, setShowToolbar] = useState(false);
-  const EcrToolbar = options.respAreaToolbar(node, editor, () => {});
+  const EcrToolbar = respAreaToolbar(node, editor, () => {});
   const toolbarRef = useRef(null);
 
+  let error;
+
+  if (errorFn) {
+    const errorValue = errorFn();
+    const respIndex = parseInt(attributes.index, 10);
+
+    error = !!errorValue?.[respIndex]?.[0];
+  }
+
   const handleDone = (newLatex) => {
     updateAttributes({ latex: newLatex });
     setShowToolbar(false);
@@ -75,6 +85,7 @@ const ExplicitConstructedResponse = (props) => {
           overflow: 'hidden',
           padding: '12px 21px',
           margin: '0 4px',
+          minWidth: '178px',
           visibility: showToolbar ? 'hidden' : 'visible',
         }}
         onClick={() => setShowToolbar(true)}

package/src/components/respArea/InlineDropdown.jsx

@@ -2,6 +2,8 @@ import React, { useEffect, useRef, useState } from "react";
 import PropTypes from 'prop-types';
 import { NodeViewWrapper } from '@tiptap/react';
 import { Chevron } from '../icons/RespArea';
+import ReactDOM from "react-dom";
+import { MathToolbar } from "@pie-lib/math-toolbar";
 
 const InlineDropdown = (props) => {
   const { editor, node, getPos, options, selected } = props;
@@ -12,6 +14,7 @@ const InlineDropdown = (props) => {
   const html = value || '<div>&nbsp</div>';
   const toolbarRef = useRef(null);
   const [showToolbar, setShowToolbar] = useState(false);
+  const [position, setPosition] = useState({ top: 0, left: 0 });
   const InlineDropdownToolbar = options.respAreaToolbar(node, editor, () => {});
 
   useEffect(() => {
@@ -28,6 +31,16 @@ const InlineDropdown = (props) => {
   }, [editor, node, selected]);
 
   useEffect(() => {
+    // Calculate position relative to selection
+    const bodyRect = document.body.getBoundingClientRect();
+    const { from } = editor.state.selection;
+    const start = editor.view.coordsAtPos(from);
+
+    setPosition({
+      top: start.top + Math.abs(bodyRect.top) + 40, // shift above
+      left: start.left,
+    });
+
     const handleClickOutside = (event) => {
       if (
         toolbarRef.current &&
@@ -100,11 +113,13 @@ const InlineDropdown = (props) => {
           }}
         />
       </div>
-      {showToolbar && (
-        <div ref={toolbarRef} className="absolute z-50 bg-white shadow-lg rounded p-2" style={{ zIndex: 1 }}>
-          <InlineDropdownToolbar />
-        </div>
-      )}
+      {showToolbar &&
+        ReactDOM.createPortal(
+          <div ref={toolbarRef} style={{ zIndex: 1 }}>
+            <InlineDropdownToolbar />
+          </div>,
+          document.body,
+        )}
     </NodeViewWrapper>
   );
 };

package/src/extensions/index.js

@@ -57,10 +57,10 @@ export const buildExtensions = (activeExtensions, customExtensions, opts) => {
     addIf('superscript'),
     // icon should be modifies accordingly
     addIf('subscript'),
-    addIf('image', imagePlugin),
+    addIf('image', !!imagePlugin),
     addIf('video'),
     addIf('audio'),
-    addIf('math', mathPlugin),
+    addIf('math', !!mathPlugin),
     ...languageCharactersPlugins.map((plugin) => addIf('languageCharacters', plugin)),
     addIf('text-align'),
     addIf('blockquote'),
@@ -69,8 +69,8 @@ export const buildExtensions = (activeExtensions, customExtensions, opts) => {
     addIf('numbered-list'),
     addIf('undo'),
     addIf('redo'),
-    addIf('responseArea', respAreaPlugin),
-    addIf('css', cssPlugin),
+    addIf('responseArea', !!respAreaPlugin),
+    addIf('css', !!cssPlugin),
     addIf('html', !!opts.html),
   ]);
 };

package/src/extensions/math.js

@@ -1,11 +1,10 @@
 import React, { useState, useEffect, useRef } from 'react';
+import ReactDOM from 'react-dom';
 import { Extension, Node, mergeAttributes } from '@tiptap/core';
 import { NodeViewWrapper, ReactRenderer, ReactNodeViewRenderer } from '@tiptap/react';
 import { Plugin, PluginKey, NodeSelection, TextSelection } from 'prosemirror-state';
 import { MathPreview, MathToolbar } from '@pie-lib/math-toolbar';
 import { wrapMath, mmlToLatex, renderMath } from '@pie-lib/math-rendering';
-import ReactDOM from 'react-dom';
-import CustomPopper from '../components/characters/custom-popper';
 
 const ensureTextAfterMathPluginKey = new PluginKey('ensureTextAfterMath');