figureone 1.0.7 → 1.0.8

package/index.js

@@ -12280,7 +12280,7 @@ var FigureElement = /*#__PURE__*/function () {
       this.stop();
       this.notifications.cleanup();
       this.animations.notifications.cleanup();
-      this.figure = {};
+      this.figure = null;
       this.parent = null;
       // this.textureAtlases = {};
     }
@@ -14960,7 +14960,14 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   return _createClass(FigureElementCollection, [{
     key: "cleanup",
     value: function cleanup() {
+      var _this0 = this;
       _superPropGet(FigureElementCollection, "cleanup", this, 3)([]);
+      Object.keys(this.textureAtlases).forEach(function (id) {
+        var ta = _this0.textureAtlases[id];
+        if (ta.notif != null && ta.atlas && ta.atlas.notifications) {
+          ta.atlas.notifications.remove('updated2', ta.notif);
+        }
+      });
       this.textureAtlases = {};
       this.cleanupChildren();
     }
@@ -14968,11 +14975,12 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
     key: "cleanupChildren",
     value: function cleanupChildren() {
       for (var i = 0; i < this.drawOrder.length; i += 1) {
-        this.elements[this.drawOrder[i]].cleanup();
-        delete this.elements[this.drawOrder[i]];
-        this.elements = {};
-        this.drawOrder = [];
+        var _name = this.drawOrder[i];
+        this.elements[_name].cleanup();
+        delete this["_".concat(_name)];
       }
+      this.elements = {};
+      this.drawOrder = [];
     }
   }, {
     key: "init",
@@ -15028,8 +15036,8 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       });
       (0,_tools_tools__WEBPACK_IMPORTED_MODULE_9__.duplicateFromTo)(this, collection, ['elements', 'drawOrder', 'parent', 'recorder', 'figure', 'collections', 'pulseDefault.centerOn'].concat(_toConsumableArray(doNotDuplicate), _toConsumableArray(exceptions)));
       for (var i = 0; i < this.drawOrder.length; i += 1) {
-        var _name = this.drawOrder[i];
-        collection.add(_name, this.elements[_name]._dup());
+        var _name2 = this.drawOrder[i];
+        collection.add(_name2, this.elements[_name2]._dup());
       }
       collection.recorder = this.recorder;
       if (typeof this.pulseDefault !== 'string' && typeof this.pulseDefault !== 'function') {
@@ -15192,7 +15200,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "add",
     value: function add(nameOrElementOrElementDefinition) {
-      var _this0 = this;
+      var _this1 = this;
       var elementToAdd = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       if (typeof nameOrElementOrElementDefinition === 'string') {
         if (elementToAdd == null) {
@@ -15210,7 +15218,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       var addedElements = [];
       elements.forEach(function (elementDefinition, index) {
         if (elementDefinition instanceof FigureElement) {
-          addedElements.push(_this0.add(elementDefinition.name, elementDefinition));
+          addedElements.push(_this1.add(elementDefinition.name, elementDefinition));
           return;
         }
         // Extract the parameters from the layout object
@@ -15248,7 +15256,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
           throw new Error("Figure addElement ERROR at index ".concat(index, " in collection ").concat(rootCollection.name, ": missing or incorrect path property in ").concat(elementDefinition));
         }
         var methodPath = methodPathToUse.split('/');
-        var method = _this0.getMethod(methodPathToUse);
+        var method = _this1.getMethod(methodPathToUse);
         if (typeof method !== 'function') {
           return;
         }
@@ -15604,7 +15612,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "exec",
     value: function exec(execFunctionAndArgs) {
-      var _this1 = this;
+      var _this10 = this;
       var elementsToExec = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       if (elementsToExec == null) {
         _superPropGet(FigureElementCollection, "exec", this, 3)([execFunctionAndArgs]);
@@ -15616,7 +15624,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       elementsToExec.forEach(function (elementToExec) {
         var element;
         if (typeof elementToExec === 'string') {
-          element = _this1.getElement(elementToExec);
+          element = _this10.getElement(elementToExec);
         } else {
           element = elementToExec;
         }
@@ -15628,7 +15636,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "pulse",
     value: function pulse() {
-      var _this10 = this;
+      var _this11 = this;
       var optionsOrElementsOrDone = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
       var done = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       if (optionsOrElementsOrDone == null || typeof optionsOrElementsOrDone === 'function' || typeof optionsOrElementsOrDone === 'string') {
@@ -15684,7 +15692,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       elements.forEach(function (elementToPulse) {
         var element;
         if (typeof elementToPulse === 'string') {
-          element = _this10.getElement(elementToPulse);
+          element = _this11.getElement(elementToPulse);
         } else {
           element = elementToPulse;
         }
@@ -15802,7 +15810,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "getElements",
     value: function getElements(children) {
-      var _this11 = this;
+      var _this12 = this;
       // const paths = [];
       if (children == null) {
         return [];
@@ -15831,7 +15839,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       var paths = _processPath(children);
       var elements = [];
       paths.forEach(function (child) {
-        var element = _this11.getElement(child);
+        var element = _this12.getElement(child);
         if (element != null) {
           elements.push(element);
         }
@@ -15841,13 +15849,13 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "getShown",
     value: function getShown() {
-      var _this12 = this;
+      var _this13 = this;
       if (this.isShown === false) {
         return [];
       }
       var shown = [[this.getPath(), this.uid, this]];
       this.drawOrder.forEach(function (elementName) {
-        var element = _this12.elements[elementName];
+        var element = _this13.elements[elementName];
         shown.push.apply(shown, _toConsumableArray(element.getShown()));
       });
       return shown;
@@ -16002,7 +16010,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "getBorderPoints",
     value: function getBorderPoints() {
-      var _this13 = this;
+      var _this14 = this;
       var border = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'border';
       var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
       var shownOnly = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
@@ -16010,13 +16018,13 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
         var childrenBorder = [];
         var childrenToUse = children;
         if (childrenToUse == null) {
-          childrenToUse = Object.keys(_this13.elements);
+          childrenToUse = Object.keys(_this14.elements);
         }
         if (childrenToUse.length === 0) {
           return [[]];
         }
         childrenToUse.forEach(function (child) {
-          var e = _this13.getElement(child);
+          var e = _this14.getElement(child);
           if (e == null || shownOnly && e.isShown === false) {
             return;
           }
@@ -16290,7 +16298,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "undim",
     value: function undim() {
-      var _this14 = this;
+      var _this15 = this;
       var children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
       var elements;
       if (children != null) {
@@ -16298,7 +16306,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       } else {
         this.color = this.defaultColor.slice();
         elements = this.drawOrder.map(function (name) {
-          return _this14.elements[name];
+          return _this15.elements[name];
         });
       }
       elements.forEach(function (element) {
@@ -16308,7 +16316,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "dim",
     value: function dim() {
-      var _this15 = this;
+      var _this16 = this;
       var children = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
       var elements;
       if (children != null) {
@@ -16316,7 +16324,7 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       } else {
         this.color = this.dimColor.slice();
         elements = this.drawOrder.map(function (name) {
-          return _this15.elements[name];
+          return _this16.elements[name];
         });
       }
       elements.forEach(function (element) {
@@ -16384,10 +16392,10 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "reorder",
     value: function reorder() {
-      var _this16 = this;
+      var _this17 = this;
       this.drawOrder.sort(function (a, b) {
-        var elemA = _this16.elements[a];
-        var elemB = _this16.elements[b];
+        var elemA = _this17.elements[a];
+        var elemB = _this17.elements[b];
         return elemB.drawPriority - elemA.drawPriority;
       });
       for (var i = 0; i < this.drawOrder.length; i += 1) {
@@ -16530,11 +16538,11 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "getAtlases",
     value: function getAtlases() {
-      var _this17 = this;
+      var _this18 = this;
       var callback = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
       Object.keys(this.textureAtlases).forEach(function (id) {
-        if (_this17.textureAtlases[id].notif != null) {
-          _this17.textureAtlases[id].atlas.notifications.remove('updated2', _this17.textureAtlases[id].notif);
+        if (_this18.textureAtlases[id].notif != null) {
+          _this18.textureAtlases[id].atlas.notifications.remove('updated2', _this18.textureAtlases[id].notif);
         }
       });
       this.textureAtlases = {};
@@ -16542,8 +16550,8 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
       primitives.forEach(function (e) {
         if (e.atlas != null) {
           var id = e.atlas.font.getTextureID();
-          if (_this17.textureAtlases[id] == null) {
-            _this17.textureAtlases[id] = {
+          if (_this18.textureAtlases[id] == null) {
+            _this18.textureAtlases[id] = {
               atlas: e.atlas,
               notif: callback ? e.atlas.notifications.add('updated2', callback) : null
             };
@@ -16558,10 +16566,10 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
   }, {
     key: "recreateAtlases",
     value: function recreateAtlases() {
-      var _this18 = this;
+      var _this19 = this;
       this.getAtlases();
       Object.keys(this.textureAtlases).forEach(function (id) {
-        return _this18.textureAtlases[id].atlas.recreate();
+        return _this19.textureAtlases[id].atlas.recreate();
       });
     }
 
@@ -16903,13 +16911,15 @@ var FigureElementCollection = /*#__PURE__*/function (_FigureElement2) {
         return;
       }
       var element = this.elements[elementName];
+      // Freeze animations at current values before cleanup
       element.animations.cancelAll('freeze', true);
-      element.stop();
-      element.parent = null;
+      // cleanup() handles: stop, notifications, drawing objects, children, textureAtlases, figure, parent
+      element.cleanup();
+      // Null out remaining references that cleanup() doesn't handle
       element.animations = null;
       element.move.element = null;
       element.recorder = null;
-      element.figure = null;
+      // Remove from parent's data structures
       delete this["_".concat(elementName)];
       delete this.elements[elementName];
       var index = this.drawOrder.indexOf(elementName);
@@ -33025,6 +33035,1125 @@ var Vinculum = /*#__PURE__*/function (_Symbol2) {
 }(_SymbolNew__WEBPACK_IMPORTED_MODULE_1__["default"]);
 
 
+/***/ },
+
+/***/ "./src/js/figure/Equation/latexToFigureOne.ts"
+/*!****************************************************!*\
+  !*** ./src/js/figure/Equation/latexToFigureOne.ts ***!
+  \****************************************************/
+(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
+/* harmony export */   latexToFigureOne: () => (/* binding */ latexToFigureOne)
+/* harmony export */ });
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * LaTeX to FigureOne equation form converter.
+ *
+ * Converts a LaTeX math expression string into FigureOne `elements` and `form`
+ * objects that can be passed directly to `figure.add({ make: 'equation', ... })`.
+ *
+ * Supported LaTeX constructs:
+ *   - Fractions: \frac{a}{b}
+ *   - Superscripts / subscripts: x^2, x_{ij}, x_i^2
+ *   - Square roots: \sqrt{x}, \sqrt[n]{x}
+ *   - Integrals: \int, \int_{a}^{b} f(x)\,dx
+ *   - Sums / products: \sum_{i=1}^{n}, \prod_{k=0}^{n}
+ *   - Brackets: \left( ... \right), \left[ ... \right], \left\{ ... \right\}
+ *   - Overline / underline: \overline{x}, \underline{x}
+ *   - Accents: \hat{x}, \tilde{x}, \dot{x}, \vec{x}
+ *   - Greek letters: \alpha, \Beta, etc.
+ *   - Operators: \sin, \cos, \lim, \log, etc.
+ *   - Symbols: \cdot, \times, \pm, \infty, \to, \partial, etc.
+ *   - Spacing: \,  \;  \quad  \qquad
+ *   - Text mode: \text{...}, \mathrm{...}
+ *
+ * @module latexToFigureOne
+ */
+
+// ---------------------------------------------------------------------------
+// Greek letter → Unicode mappings
+// ---------------------------------------------------------------------------
+var GREEK_LETTERS = {
+  // lowercase
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  varepsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  vartheta: "\u03D1",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigma: "\u03C3",
+  varsigma: "\u03C2",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  varphi: "\u03D5",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  // uppercase
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Theta: "\u0398",
+  Lambda: "\u039B",
+  Xi: "\u039E",
+  Pi: "\u03A0",
+  Sigma: "\u03A3",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Psi: "\u03A8",
+  Omega: "\u03A9"
+};
+
+// ---------------------------------------------------------------------------
+// Symbol command → Unicode mappings
+// ---------------------------------------------------------------------------
+var SYMBOLS = {
+  // binary operators
+  cdot: "\xB7",
+  times: "\xD7",
+  pm: "\xB1",
+  mp: "\u2213",
+  div: "\xF7",
+  ast: '*',
+  star: "\u2605",
+  circ: "\u2218",
+  // relations
+  leq: "\u2264",
+  le: "\u2264",
+  geq: "\u2265",
+  ge: "\u2265",
+  neq: "\u2260",
+  ne: "\u2260",
+  approx: "\u2248",
+  equiv: "\u2261",
+  sim: "\u223C",
+  simeq: "\u2243",
+  propto: "\u221D",
+  prec: "\u227A",
+  succ: "\u227B",
+  ll: "\u226A",
+  gg: "\u226B",
+  // arrows
+  to: "\u2192",
+  rightarrow: "\u2192",
+  leftarrow: "\u2190",
+  Rightarrow: "\u21D2",
+  Leftarrow: "\u21D0",
+  leftrightarrow: "\u2194",
+  Leftrightarrow: "\u21D4",
+  mapsto: "\u21A6",
+  uparrow: "\u2191",
+  downarrow: "\u2193",
+  // misc math
+  partial: "\u2202",
+  nabla: "\u2207",
+  infty: "\u221E",
+  forall: "\u2200",
+  exists: "\u2203",
+  neg: "\xAC",
+  // set theory
+  "in": "\u2208",
+  notin: "\u2209",
+  subset: "\u2282",
+  supset: "\u2283",
+  subseteq: "\u2286",
+  supseteq: "\u2287",
+  cup: "\u222A",
+  cap: "\u2229",
+  emptyset: "\u2205",
+  varnothing: "\u2205",
+  // dots
+  ldots: "\u2026",
+  cdots: "\u22EF",
+  vdots: "\u22EE",
+  ddots: "\u22F1",
+  dots: "\u2026",
+  // misc
+  ell: "\u2113",
+  hbar: "\u210F",
+  Re: "\u211C",
+  Im: "\u2111",
+  aleph: "\u2135",
+  prime: "\u2032"
+};
+
+// ---------------------------------------------------------------------------
+// Text-mode operators (rendered upright / roman style)
+// ---------------------------------------------------------------------------
+var TEXT_OPERATORS = new Set(['sin', 'cos', 'tan', 'cot', 'sec', 'csc', 'arcsin', 'arccos', 'arctan', 'sinh', 'cosh', 'tanh', 'coth', 'log', 'ln', 'exp', 'lim', 'limsup', 'liminf', 'max', 'min', 'sup', 'inf', 'det', 'dim', 'ker', 'deg', 'gcd', 'hom', 'arg', 'Pr']);
+
+// ---------------------------------------------------------------------------
+// Binary operator characters (get spaces around them in output)
+// ---------------------------------------------------------------------------
+var BINARY_OPS = new Set(['+', '-', '=', '<', '>']);
+var OPERATOR_NAMES = {
+  '+': 'plus',
+  '-': 'minus',
+  '=': 'equals',
+  '<': 'lt',
+  '>': 'gt'
+};
+
+// ---------------------------------------------------------------------------
+// Tokeniser
+// ---------------------------------------------------------------------------
+
+function tokenize(latex) {
+  var tokens = [];
+  var i = 0;
+  while (i < latex.length) {
+    var ch = latex[i];
+
+    // ----- backslash commands -------------------------------------------------
+    if (ch === '\\') {
+      i++;
+      if (i >= latex.length) break;
+      var next = latex[i];
+
+      // Single-character commands  \, \; \: \! \  \{ \}
+      if (',;:! '.includes(next)) {
+        tokens.push({
+          type: 'command',
+          value: next
+        });
+        i++;
+        continue;
+      }
+      if (next === '{') {
+        // \{ is an escaped brace — treat as text
+        tokens.push({
+          type: 'command',
+          value: '\\{'
+        });
+        i++;
+        continue;
+      }
+      if (next === '}') {
+        tokens.push({
+          type: 'command',
+          value: '\\}'
+        });
+        i++;
+        continue;
+      }
+      if (next === '\\') {
+        // \\ line break — ignore for equation parsing
+        i++;
+        continue;
+      }
+
+      // Multi-character command:  \frac, \alpha, etc.
+      var cmd = '';
+      while (i < latex.length && /[a-zA-Z]/.test(latex[i])) {
+        cmd += latex[i];
+        i++;
+      }
+      if (cmd.length > 0) {
+        tokens.push({
+          type: 'command',
+          value: cmd
+        });
+      }
+      continue;
+    }
+
+    // ----- braces & brackets --------------------------------------------------
+    if (ch === '{') {
+      tokens.push({
+        type: 'lbrace',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+    if (ch === '}') {
+      tokens.push({
+        type: 'rbrace',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+    if (ch === '[') {
+      tokens.push({
+        type: 'lbracket',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+    if (ch === ']') {
+      tokens.push({
+        type: 'rbracket',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+
+    // ----- super / subscript --------------------------------------------------
+    if (ch === '^') {
+      tokens.push({
+        type: 'caret',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+    if (ch === '_') {
+      tokens.push({
+        type: 'underscore',
+        value: ch
+      });
+      i++;
+      continue;
+    }
+
+    // ----- whitespace (ignored in math mode) ----------------------------------
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+
+    // ----- everything else is literal text ------------------------------------
+    tokens.push({
+      type: 'text',
+      value: ch
+    });
+    i++;
+  }
+  return tokens;
+}
+
+// ---------------------------------------------------------------------------
+// AST node types
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Parser (recursive descent)
+// ---------------------------------------------------------------------------
+var Parser = /*#__PURE__*/function () {
+  function Parser(tokens) {
+    _classCallCheck(this, Parser);
+    this.tokens = tokens;
+    this.pos = 0;
+  }
+  return _createClass(Parser, [{
+    key: "peek",
+    value: function peek() {
+      return this.pos < this.tokens.length ? this.tokens[this.pos] : null;
+    }
+  }, {
+    key: "advance",
+    value: function advance() {
+      return this.tokens[this.pos++];
+    }
+  }, {
+    key: "expect",
+    value: function expect(type) {
+      var tok = this.peek();
+      if (!tok || tok.type !== type) {
+        throw new Error("LaTeX parse error: expected ".concat(type, " but got ").concat(tok ? "".concat(tok.type, "(").concat(tok.value, ")") : 'EOF', " at token ").concat(this.pos));
+      }
+      return this.advance();
+    }
+
+    /** Entry point. */
+  }, {
+    key: "parse",
+    value: function parse() {
+      return this.parseSequence();
+    }
+
+    // ---- sequence of items (stops at }, ], \right, or EOF) -------------------
+  }, {
+    key: "parseSequence",
+    value: function parseSequence() {
+      var items = [];
+      while (this.pos < this.tokens.length) {
+        var tok = this.peek();
+        if (!tok) break;
+        // Stop tokens
+        if (tok.type === 'rbrace' || tok.type === 'rbracket') break;
+        if (tok.type === 'command' && tok.value === 'right') break;
+
+        // Large operators consume the rest of the current scope as content
+        if (tok.type === 'command' && (tok.value === 'int' || tok.value === 'sum' || tok.value === 'prod')) {
+          items.push(this.parseLargeOperator());
+          continue;
+        }
+        var item = this.parseItem();
+        if (item) items.push(item);
+      }
+      if (items.length === 0) return {
+        type: 'text',
+        value: ''
+      };
+      if (items.length === 1) return items[0];
+      return {
+        type: 'sequence',
+        children: items
+      };
+    }
+
+    // ---- single item (atom + optional ^/_ ) -----------------------------------
+  }, {
+    key: "parseItem",
+    value: function parseItem() {
+      var atom = this.parseAtom();
+      if (!atom) return null;
+      return this.attachSupSub(atom);
+    }
+  }, {
+    key: "attachSupSub",
+    value: function attachSupSub(base) {
+      var superscript;
+      var subscript;
+
+      // ^ and _ can appear in either order, at most once each
+      for (var i = 0; i < 2; i++) {
+        var tok = this.peek();
+        if (!tok) break;
+        if (tok.type === 'caret' && !superscript) {
+          this.advance();
+          superscript = this.parseAtom();
+        } else if (tok.type === 'underscore' && !subscript) {
+          this.advance();
+          subscript = this.parseAtom();
+        } else {
+          break;
+        }
+      }
+      if (superscript && subscript) return {
+        type: 'supsub',
+        base: base,
+        superscript: superscript,
+        subscript: subscript
+      };
+      if (superscript) return {
+        type: 'sup',
+        base: base,
+        superscript: superscript
+      };
+      if (subscript) return {
+        type: 'sub',
+        base: base,
+        subscript: subscript
+      };
+      return base;
+    }
+
+    // ---- atom (single indivisible piece) --------------------------------------
+  }, {
+    key: "parseAtom",
+    value: function parseAtom() {
+      var tok = this.peek();
+      if (!tok) return null;
+      if (tok.type === 'lbrace') return this.parseGroup();
+      if (tok.type === 'text') {
+        this.advance();
+        return {
+          type: 'text',
+          value: tok.value
+        };
+      }
+      if (tok.type === 'command') return this.parseCommand();
+      return null;
+    }
+  }, {
+    key: "parseGroup",
+    value: function parseGroup() {
+      this.expect('lbrace');
+      var content = this.parseSequence();
+      this.expect('rbrace');
+      return content;
+    }
+
+    // ---- command dispatch -----------------------------------------------------
+  }, {
+    key: "parseCommand",
+    value: function parseCommand() {
+      var tok = this.advance(); // consume command token
+      var cmd = tok.value;
+
+      // ---- structural commands ----
+      if (cmd === 'frac') return this.parseFrac();
+      if (cmd === 'sqrt') return this.parseSqrt();
+      if (cmd === 'left') return this.parseBrackets();
+
+      // ---- accents / decorations ----
+      if (cmd === 'overline' || cmd === 'bar') return {
+        type: 'overline',
+        content: this.parseAtom()
+      };
+      if (cmd === 'underline') return {
+        type: 'underline',
+        content: this.parseAtom()
+      };
+      if (cmd === 'hat' || cmd === 'tilde' || cmd === 'dot' || cmd === 'vec' || cmd === 'ddot' || cmd === 'breve' || cmd === 'check' || cmd === 'acute' || cmd === 'grave') {
+        return {
+          type: 'accent',
+          accent: cmd,
+          content: this.parseAtom()
+        };
+      }
+
+      // ---- text mode ----
+      if (cmd === 'text' || cmd === 'mathrm' || cmd === 'textrm' || cmd === 'textit' || cmd === 'mathit') {
+        return this.parseTextBlock();
+      }
+
+      // ---- spacing ----
+      if (cmd === ',') return {
+        type: 'space',
+        size: 'thin'
+      };
+      if (cmd === ';' || cmd === ':') return {
+        type: 'space',
+        size: 'medium'
+      };
+      if (cmd === '!') return {
+        type: 'space',
+        size: 'neg'
+      };
+      if (cmd === ' ') return {
+        type: 'space',
+        size: 'normal'
+      };
+      if (cmd === 'quad') return {
+        type: 'space',
+        size: 'quad'
+      };
+      if (cmd === 'qquad') return {
+        type: 'space',
+        size: 'qquad'
+      };
+
+      // ---- escaped braces as text ----
+      if (cmd === '\\{') return {
+        type: 'text',
+        value: '{'
+      };
+      if (cmd === '\\}') return {
+        type: 'text',
+        value: '}'
+      };
+
+      // ---- Greek letters ----
+      if (GREEK_LETTERS[cmd]) return {
+        type: 'text',
+        value: GREEK_LETTERS[cmd]
+      };
+
+      // ---- math symbols ----
+      if (SYMBOLS[cmd]) return {
+        type: 'text',
+        value: SYMBOLS[cmd]
+      };
+
+      // ---- text operators ----
+      if (TEXT_OPERATORS.has(cmd)) return {
+        type: 'textOp',
+        name: cmd
+      };
+
+      // ---- unknown command → pass through as text ----
+      return {
+        type: 'text',
+        value: "\\".concat(cmd)
+      };
+    }
+  }, {
+    key: "parseFrac",
+    value: function parseFrac() {
+      var numerator = this.parseAtom();
+      var denominator = this.parseAtom();
+      return {
+        type: 'frac',
+        numerator: numerator,
+        denominator: denominator
+      };
+    }
+  }, {
+    key: "parseSqrt",
+    value: function parseSqrt() {
+      var _this$peek;
+      var index;
+      // optional index: \sqrt[n]{...}
+      if (((_this$peek = this.peek()) === null || _this$peek === void 0 ? void 0 : _this$peek.type) === 'lbracket') {
+        this.advance(); // consume [
+        var items = [];
+        while (this.peek() && this.peek().type !== 'rbracket') {
+          var item = this.parseItem();
+          if (item) items.push(item);
+        }
+        this.expect('rbracket');
+        index = items.length === 1 ? items[0] : {
+          type: 'sequence',
+          children: items
+        };
+      }
+      var content = this.parseAtom();
+      return {
+        type: 'sqrt',
+        content: content,
+        index: index
+      };
+    }
+  }, {
+    key: "parseLargeOperator",
+    value: function parseLargeOperator() {
+      var tok = this.advance(); // \int, \sum, \prod
+      var op = tok.value;
+
+      // Parse optional limits (^ and _ in any order)
+      var from;
+      var to;
+      for (var i = 0; i < 2; i++) {
+        var p = this.peek();
+        if (!p) break;
+        if (p.type === 'underscore' && !from) {
+          this.advance();
+          from = this.parseAtom();
+        } else if (p.type === 'caret' && !to) {
+          this.advance();
+          to = this.parseAtom();
+        } else {
+          break;
+        }
+      }
+
+      // Content is the rest of the current scope
+      var content = this.parseSequence();
+      return {
+        type: 'largeOp',
+        op: op,
+        from: from,
+        to: to,
+        content: content
+      };
+    }
+  }, {
+    key: "parseBrackets",
+    value: function parseBrackets() {
+      var _this$peek2, _this$peek3;
+      // \left has already been consumed. Next token is the delimiter.
+      var leftDelim = this.readDelimiter();
+      var content = this.parseSequence(); // stops at \right
+      // consume \right
+      if (((_this$peek2 = this.peek()) === null || _this$peek2 === void 0 ? void 0 : _this$peek2.type) === 'command' && ((_this$peek3 = this.peek()) === null || _this$peek3 === void 0 ? void 0 : _this$peek3.value) === 'right') {
+        this.advance();
+      }
+      var rightDelim = this.readDelimiter();
+      return {
+        type: 'brac',
+        left: leftDelim,
+        right: rightDelim,
+        content: content
+      };
+    }
+  }, {
+    key: "readDelimiter",
+    value: function readDelimiter() {
+      var tok = this.peek();
+      if (!tok) return '(';
+      if (tok.type === 'text') {
+        this.advance();
+        return tok.value;
+      }
+      if (tok.type === 'command') {
+        this.advance();
+        if (tok.value === '\\{' || tok.value === 'lbrace') return '{';
+        if (tok.value === '\\}' || tok.value === 'rbrace') return '}';
+        if (tok.value === 'langle') return '<';
+        if (tok.value === 'rangle') return '>';
+        if (tok.value === 'vert' || tok.value === '|') return '|';
+        return tok.value;
+      }
+      // [ and ] can be delimiters too
+      if (tok.type === 'lbracket' || tok.type === 'rbracket') {
+        this.advance();
+        return tok.value;
+      }
+      return '(';
+    }
+  }, {
+    key: "parseTextBlock",
+    value: function parseTextBlock() {
+      this.expect('lbrace');
+      var text = '';
+      while (this.peek() && this.peek().type !== 'rbrace') {
+        var t = this.advance();
+        if (t.type === 'command') {
+          text += "\\".concat(t.value);
+        } else {
+          text += t.value;
+        }
+      }
+      this.expect('rbrace');
+      return {
+        type: 'text',
+        value: text
+      };
+    }
+  }]);
+}(); // ---------------------------------------------------------------------------
+// Code generator — converts AST to FigureOne elements + form
+// ---------------------------------------------------------------------------
+var CodeGenerator = /*#__PURE__*/function () {
+  function CodeGenerator() {
+    _classCallCheck(this, CodeGenerator);
+    /** Accumulated element definitions (symbols, styled text, operators). */
+    _defineProperty(this, "elements", {});
+    /**
+     * Track how many times a given *display text* has been emitted so we can
+     * generate unique element names via the `name_N` convention.
+     */
+    _defineProperty(this, "textUsage", {});
+    /** Counter per symbol type so each gets a unique name. */
+    _defineProperty(this, "symbolCounters", {});
+  }
+  return _createClass(CodeGenerator, [{
+    key: "nextTextName",
+    value:
+    // ---- element name helpers -------------------------------------------------
+
+    /**
+     * Return a unique FigureOne element name for the given display text.
+     * First occurrence of "x" → "x"; second → "x_1"; third → "x_2"; etc.
+     */
+    function nextTextName(text) {
+      var _this$textUsage$text;
+      var count = (_this$textUsage$text = this.textUsage[text]) !== null && _this$textUsage$text !== void 0 ? _this$textUsage$text : 0;
+      this.textUsage[text] = count + 1;
+      if (count === 0) return text;
+      return "".concat(text, "_").concat(count);
+    }
+
+    /** Add a symbol element and return its unique name. */
+  }, {
+    key: "addSymbol",
+    value: function addSymbol(symbolType, extra) {
+      var _this$symbolCounters$, _baseNames$symbolType;
+      var counter = (_this$symbolCounters$ = this.symbolCounters[symbolType]) !== null && _this$symbolCounters$ !== void 0 ? _this$symbolCounters$ : 0;
+      this.symbolCounters[symbolType] = counter + 1;
+
+      // Derive a readable base name from symbol type
+      var baseNames = {
+        vinculum: 'v',
+        "int": 'int_sym',
+        sum: 'sum_sym',
+        prod: 'prod_sym',
+        radical: 'rad',
+        bracket: 'bk',
+        squareBracket: 'sqbk',
+        brace: 'br',
+        angleBracket: 'abk',
+        bar: 'bar_sym'
+      };
+      var base = (_baseNames$symbolType = baseNames[symbolType]) !== null && _baseNames$symbolType !== void 0 ? _baseNames$symbolType : symbolType;
+      var name = counter === 0 ? base : "".concat(base, "_").concat(counter);
+      var def = {
+        symbol: symbolType
+      };
+      if (extra) Object.assign(def, extra);
+      this.elements[name] = def;
+      return name;
+    }
+
+    /**
+     * Register a text element that needs an explicit definition (e.g. styled
+     * operators, multi-char text with special properties).
+     */
+  }, {
+    key: "addTextElement",
+    value: function addTextElement(displayText, props) {
+      var name = this.nextTextName(displayText);
+      this.elements[name] = _objectSpread({
+        text: displayText
+      }, props);
+      return name;
+    }
+
+    /** Register an operator element (e.g. ' + ') and return its name. */
+  }, {
+    key: "addOperator",
+    value: function addOperator(_char) {
+      var _OPERATOR_NAMES$_char, _this$textUsage$baseN;
+      var paddedText = " ".concat(_char, " ");
+      var baseName = (_OPERATOR_NAMES$_char = OPERATOR_NAMES[_char]) !== null && _OPERATOR_NAMES$_char !== void 0 ? _OPERATOR_NAMES$_char : "op_".concat(_char);
+      var count = (_this$textUsage$baseN = this.textUsage[baseName]) !== null && _this$textUsage$baseN !== void 0 ? _this$textUsage$baseN : 0;
+      this.textUsage[baseName] = count + 1;
+      var name = count === 0 ? baseName : "".concat(baseName, "_").concat(count);
+      this.elements[name] = paddedText;
+      return name;
+    }
+
+    // ---- main generation ------------------------------------------------------
+  }, {
+    key: "generate",
+    value: function generate(node) {
+      switch (node.type) {
+        case 'text':
+          return this.genText(node.value);
+        case 'sequence':
+          return this.genSequence(node.children);
+        case 'frac':
+          return this.genFrac(node);
+        case 'sup':
+          return this.genSup(node);
+        case 'sub':
+          return this.genSub(node);
+        case 'supsub':
+          return this.genSupSub(node);
+        case 'sqrt':
+          return this.genSqrt(node);
+        case 'largeOp':
+          return this.genLargeOp(node);
+        case 'brac':
+          return this.genBrac(node);
+        case 'overline':
+          return this.genOverline(node);
+        case 'underline':
+          return this.genUnderline(node);
+        case 'accent':
+          return this.genAccent(node);
+        case 'textOp':
+          return this.genTextOp(node.name);
+        case 'space':
+          return this.genSpace(node.size);
+        default:
+          return '';
+      }
+    }
+  }, {
+    key: "genText",
+    value: function genText(text) {
+      if (text === '') return '';
+      if (BINARY_OPS.has(text)) return this.addOperator(text);
+      return this.nextTextName(text);
+    }
+  }, {
+    key: "genSequence",
+    value: function genSequence(children) {
+      var _this = this;
+      var items = children.map(function (c) {
+        return _this.generate(c);
+      }).filter(function (x) {
+        return x !== '';
+      });
+      if (items.length === 0) return '';
+      if (items.length === 1) return items[0];
+      // Flatten nested arrays one level for cleaner FigureOne forms
+      var flat = [];
+      var _iterator = _createForOfIteratorHelper(items),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          if (Array.isArray(item)) {
+            flat.push.apply(flat, _toConsumableArray(item));
+          } else {
+            flat.push(item);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return flat;
+    }
+  }, {
+    key: "genFrac",
+    value: function genFrac(node) {
+      var vName = this.addSymbol('vinculum');
+      var num = this.generate(node.numerator);
+      var den = this.generate(node.denominator);
+      return {
+        frac: [num, vName, den]
+      };
+    }
+  }, {
+    key: "genSup",
+    value: function genSup(node) {
+      return {
+        sup: [this.generate(node.base), this.generate(node.superscript)]
+      };
+    }
+  }, {
+    key: "genSub",
+    value: function genSub(node) {
+      return {
+        sub: [this.generate(node.base), this.generate(node.subscript)]
+      };
+    }
+  }, {
+    key: "genSupSub",
+    value: function genSupSub(node) {
+      return {
+        supSub: [this.generate(node.base), this.generate(node.superscript), this.generate(node.subscript)]
+      };
+    }
+  }, {
+    key: "genSqrt",
+    value: function genSqrt(node) {
+      var radName = this.addSymbol('radical');
+      var content = this.generate(node.content);
+      if (node.index) {
+        var idx = this.generate(node.index);
+        return {
+          root: {
+            symbol: radName,
+            content: content,
+            root: idx
+          }
+        };
+      }
+      return {
+        root: [radName, content]
+      };
+    }
+  }, {
+    key: "genLargeOp",
+    value: function genLargeOp(node) {
+      var content = this.generate(node.content);
+      var from = node.from ? this.generate(node.from) : undefined;
+      var to = node.to ? this.generate(node.to) : undefined;
+      if (node.op === 'int') {
+        var _symName = this.addSymbol('int');
+        var _def = {
+          symbol: _symName,
+          content: content
+        };
+        if (from !== undefined) _def.from = from;
+        if (to !== undefined) _def.to = to;
+        return {
+          "int": _def
+        };
+      }
+
+      // sum and prod
+      var symType = node.op === 'sum' ? 'sum' : 'prod';
+      var fnName = node.op === 'sum' ? 'sumOf' : 'prodOf';
+      var symName = this.addSymbol(symType);
+      var def = {
+        symbol: symName,
+        content: content
+      };
+      if (from !== undefined) def.from = from;
+      if (to !== undefined) def.to = to;
+      return _defineProperty({}, fnName, def);
+    }
+  }, {
+    key: "delimiterToSymbol",
+    value: function delimiterToSymbol(delim) {
+      var isLeft = '(<[{'.includes(delim) || delim === '|';
+      var side = isLeft ? 'left' : 'right';
+      switch (delim) {
+        case '(':
+        case ')':
+          return {
+            type: 'bracket',
+            side: side
+          };
+        case '[':
+        case ']':
+          return {
+            type: 'squareBracket',
+            side: side
+          };
+        case '{':
+        case '}':
+          return {
+            type: 'brace',
+            side: side
+          };
+        case '<':
+          return {
+            type: 'angleBracket',
+            side: 'left'
+          };
+        case '>':
+          return {
+            type: 'angleBracket',
+            side: 'right'
+          };
+        case '|':
+          return {
+            type: 'bar',
+            side: side
+          };
+        case '.':
+          return {
+            type: 'bracket',
+            side: side
+          };
+        // invisible delimiter
+        default:
+          return {
+            type: 'bracket',
+            side: side
+          };
+      }
+    }
+  }, {
+    key: "genBrac",
+    value: function genBrac(node) {
+      var leftInfo = this.delimiterToSymbol(node.left);
+      var rightInfo = this.delimiterToSymbol(node.right);
+      var lbName = this.addSymbol(leftInfo.type, {
+        side: 'left'
+      });
+      var rbName = this.addSymbol(rightInfo.type, {
+        side: 'right'
+      });
+      var content = this.generate(node.content);
+      return {
+        brac: [lbName, content, rbName]
+      };
+    }
+  }, {
+    key: "genOverline",
+    value: function genOverline(node) {
+      var barName = this.addSymbol('bar', {
+        side: 'top'
+      });
+      var content = this.generate(node.content);
+      return {
+        bar: {
+          content: content,
+          symbol: barName,
+          side: 'top'
+        }
+      };
+    }
+  }, {
+    key: "genUnderline",
+    value: function genUnderline(node) {
+      var barName = this.addSymbol('bar', {
+        side: 'bottom'
+      });
+      var content = this.generate(node.content);
+      return {
+        bar: {
+          content: content,
+          symbol: barName,
+          side: 'bottom'
+        }
+      };
+    }
+  }, {
+    key: "genAccent",
+    value: function genAccent(node) {
+      var _accentChars$node$acc;
+      var content = this.generate(node.content);
+      var accentChars = {
+        hat: "\u0302",
+        tilde: "\u0303",
+        dot: "\u0307",
+        ddot: "\u0308",
+        vec: "\u2192",
+        breve: "\u0306",
+        check: "\u030C",
+        acute: "\u0301",
+        grave: "\u0300"
+      };
+      var accentChar = (_accentChars$node$acc = accentChars[node.accent]) !== null && _accentChars$node$acc !== void 0 ? _accentChars$node$acc : '^';
+      var commentName = this.nextTextName(accentChar);
+      return {
+        topComment: {
+          content: content,
+          comment: commentName,
+          scale: 0.6
+        }
+      };
+    }
+  }, {
+    key: "genTextOp",
+    value: function genTextOp(name) {
+      return this.addTextElement(name, {
+        style: 'normal'
+      });
+    }
+  }, {
+    key: "genSpace",
+    value: function genSpace(size) {
+      switch (size) {
+        case 'thin':
+          return ' ';
+        case 'medium':
+          return ' ';
+        case 'normal':
+          return ' ';
+        case 'quad':
+          return '    ';
+        case 'qquad':
+          return '        ';
+        case 'neg':
+          return '';
+        default:
+          return ' ';
+      }
+    }
+  }]);
+}(); // ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Result of converting a LaTeX expression to FigureOne form. */
+/**
+ * Convert a LaTeX math expression into a FigureOne equation form.
+ *
+ * @example
+ * const { elements, form } = Fig.latexToFigureOne('\\frac{a}{b} = c');
+ * figure.add({
+ *   make: 'equation',
+ *   elements,
+ *   forms: { base: form },
+ * });
+ */
+function latexToFigureOne(latex) {
+  var tokens = tokenize(latex);
+  var parser = new Parser(tokens);
+  var ast = parser.parse();
+  var generator = new CodeGenerator();
+  var form = generator.generate(ast);
+  return {
+    elements: generator.elements,
+    form: form
+  };
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (latexToFigureOne);
+
 /***/ },
 
 /***/ "./src/js/figure/Figure.ts"
@@ -33410,8 +34539,10 @@ var Figure = /*#__PURE__*/function () {
         this.backgroundColor = optionsToUse.backgroundColor;
         var webglLow = new _webgl_webgl__WEBPACK_IMPORTED_MODULE_0__["default"](this.canvasLow, this.backgroundColor, optionsToUse.antialias, optionsToUse.atlasScale);
         this.webglLow = webglLow;
-        this.canvasLow.addEventListener('webglcontextlost', this.contextLost.bind(this), false);
-        this.canvasLow.addEventListener('webglcontextrestored', this.contextRestored.bind(this), false);
+        this._boundContextLost = this.contextLost.bind(this);
+        this._boundContextRestored = this.contextRestored.bind(this);
+        this.canvasLow.addEventListener('webglcontextlost', this._boundContextLost, false);
+        this.canvasLow.addEventListener('webglcontextrestored', this._boundContextRestored, false);
         // TODO in future, if still using canvasOffScreen then need to have it
         // handle context lost and restored events
         if (this.canvasOffscreen) {
@@ -33614,9 +34745,12 @@ var Figure = /*#__PURE__*/function () {
     // this.updateFontSize = optionsToUse.updateFontSize;
 
     this.focused = true;
-    window.addEventListener('resize', this.resize.bind(this));
-    window.addEventListener('focus', this.focusGained.bind(this));
-    window.addEventListener('blur', this.focusLost.bind(this));
+    this._boundResize = this.resize.bind(this);
+    this._boundFocusGained = this.focusGained.bind(this);
+    this._boundFocusLost = this.focusLost.bind(this);
+    window.addEventListener('resize', this._boundResize);
+    window.addEventListener('focus', this._boundFocusGained);
+    window.addEventListener('blur', this._boundFocusLost);
     // window.addEventListener('resize', this.resize.bind(this));
     this.sizeHtmlText();
     this.isTouchDevice = (0,_tools_tools__WEBPACK_IMPORTED_MODULE_7__.isTouchDevice)();
@@ -34317,7 +35451,33 @@ var Figure = /*#__PURE__*/function () {
   }, {
     key: "destroy",
     value: function destroy() {
+      // Remove gesture listeners (canvas + window)
       this.gesture.destroy();
+
+      // Remove window listeners
+      window.removeEventListener('resize', this._boundResize);
+      window.removeEventListener('focus', this._boundFocusGained);
+      window.removeEventListener('blur', this._boundFocusLost);
+
+      // Remove canvas listeners (only set when webgl !== 'manual')
+      if (this.canvasLow && this._boundContextLost) {
+        this.canvasLow.removeEventListener('webglcontextlost', this._boundContextLost, false);
+        this.canvasLow.removeEventListener('webglcontextrestored', this._boundContextRestored, false);
+      }
+
+      // Clean up all elements recursively (notifications, drawing objects, children)
+      this.elements.cleanup();
+      this.elements = null;
+
+      // Clean up WebGL resources (programs, textures, atlases, framebuffers)
+      if (this.webglLow) {
+        this.webglLow.cleanup();
+      }
+      if (this.webglOffscreen) {
+        this.webglOffscreen.cleanup();
+      }
+
+      // Release the WebGL context
       this.loseContext();
     }
 
@@ -51635,11 +52795,26 @@ var FigureElementPrimitiveGesture = /*#__PURE__*/function (_FigureElementPrimiti
         this.setMovable();
       }
       this.cleanupIDs();
-      this.notificationIDs.push(this.figure.notifications.add('gestureWheel', this.wheelHandler.bind(this)));
-      this.notificationIDs.push(this.figure.notifications.add('mousePosition', this.mousePosition.bind(this)));
-      this.notificationIDs.push(this.figure.notifications.add('gestureStartPinch', this.startPinchZoom.bind(this)));
-      this.notificationIDs.push(this.figure.notifications.add('gesturePinching', this.pinchZoom.bind(this)));
-      this.notificationIDs.push(this.figure.notifications.add('gesturePinchEnd', this.endPinchZoom.bind(this)));
+      this.notificationIDs.push({
+        event: 'gestureWheel',
+        id: this.figure.notifications.add('gestureWheel', this.wheelHandler.bind(this))
+      });
+      this.notificationIDs.push({
+        event: 'mousePosition',
+        id: this.figure.notifications.add('mousePosition', this.mousePosition.bind(this))
+      });
+      this.notificationIDs.push({
+        event: 'gestureStartPinch',
+        id: this.figure.notifications.add('gestureStartPinch', this.startPinchZoom.bind(this))
+      });
+      this.notificationIDs.push({
+        event: 'gesturePinching',
+        id: this.figure.notifications.add('gesturePinching', this.pinchZoom.bind(this))
+      });
+      this.notificationIDs.push({
+        event: 'gesturePinchEnd',
+        id: this.figure.notifications.add('gesturePinchEnd', this.endPinchZoom.bind(this))
+      });
       this.reset();
       this.notifications.publish('setFigure');
     }
@@ -51647,11 +52822,21 @@ var FigureElementPrimitiveGesture = /*#__PURE__*/function (_FigureElementPrimiti
     key: "cleanupIDs",
     value: function cleanupIDs() {
       var _this2 = this;
-      this.notificationIDs.forEach(function (id) {
-        return _this2.figure.notifications.remove(id);
-      });
+      if (this.figure && this.figure.notifications) {
+        this.notificationIDs.forEach(function (_ref) {
+          var event = _ref.event,
+            id = _ref.id;
+          _this2.figure.notifications.remove(event, id);
+        });
+      }
       this.notificationIDs = [];
     }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      this.cleanupIDs();
+      _superPropGet(FigureElementPrimitiveGesture, "cleanup", this, 3)([]);
+    }
   }]);
 }(_Element__WEBPACK_IMPORTED_MODULE_0__.FigureElementPrimitive); // Let's say we have a rectangular scene of width 4 and height 2 from [-2, -1]
 // to [2, 1].
@@ -55190,17 +56375,22 @@ var Gesture = /*#__PURE__*/function () {
   return _createClass(Gesture, [{
     key: "addEvent",
     value: function addEvent(event, method, flag) {
-      this.figure.gestureCanvas.addEventListener(event, method.bind(this), flag);
+      this.figure.gestureCanvas.addEventListener(event, method, flag);
     }
   }, {
     key: "addWindowEvent",
     value: function addWindowEvent(event, method, flag) {
-      window.addEventListener(event, method.bind(this), flag);
+      window.addEventListener(event, method, flag);
     }
   }, {
     key: "removeEvent",
     value: function removeEvent(event, method, flag) {
-      this.figure.gestureCanvas.removeEventListener(event, method.bind(this), flag);
+      this.figure.gestureCanvas.removeEventListener(event, method, flag);
+    }
+  }, {
+    key: "removeWindowEvent",
+    value: function removeWindowEvent(event, method, flag) {
+      window.removeEventListener(event, method, flag);
     }
   }, {
     key: "startHandler",
@@ -55293,10 +56483,10 @@ var Gesture = /*#__PURE__*/function () {
     key: "destroy",
     value: function destroy() {
       this.removeEvent('mousedown', this.binds.mouseDownHandler, false);
-      this.removeEvent('mouseup', this.binds.mouseUpHandler, false);
+      this.removeWindowEvent('mouseup', this.binds.mouseUpHandler, false);
       this.removeEvent('mousemove', this.binds.mouseMoveHandler, false);
       this.removeEvent('touchstart', this.binds.touchStartHandler, false);
-      this.removeEvent('touchend', this.binds.touchEndHandler, false);
+      this.removeWindowEvent('touchend', this.binds.touchEndHandler, false);
       this.removeEvent('touchmove', this.binds.touchMoveHandler, false);
       this.removeEvent('wheel', this.binds.wheelHandler, false);
     }
@@ -63993,8 +65183,8 @@ var TargetTexture = /*#__PURE__*/function () {
     gl.bindRenderbuffer(gl.RENDERBUFFER, this.depthBuffer);
 
     // Create and bind the framebuffer
-    var fb = gl.createFramebuffer();
-    gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
+    this.fb = gl.createFramebuffer();
+    gl.bindFramebuffer(gl.FRAMEBUFFER, this.fb);
 
     // attach the texture as the first color attachment
     var attachmentPoint = gl.COLOR_ATTACHMENT0;
@@ -64022,6 +65212,23 @@ var TargetTexture = /*#__PURE__*/function () {
       gl.bindRenderbuffer(gl.RENDERBUFFER, this.depthBuffer);
       gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, width, height);
     }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      var gl = this.webgl.gl;
+      if (this.target) {
+        gl.deleteTexture(this.target);
+        this.target = null;
+      }
+      if (this.depthBuffer) {
+        gl.deleteRenderbuffer(this.depthBuffer);
+        this.depthBuffer = null;
+      }
+      if (this.fb) {
+        gl.deleteFramebuffer(this.fb);
+        this.fb = null;
+      }
+    }
   }]);
 }();
 
@@ -64172,7 +65379,12 @@ function createProgramFromScripts(gl, vertexShaderSource, fragmentShaderSource)
 
   // Link the two shaders into a program
   if (vertexShader && fragmentShader) {
-    return createProgram(gl, vertexShader, fragmentShader);
+    var program = createProgram(gl, vertexShader, fragmentShader);
+    // Shaders can be safely deleted after linking — they're flagged for
+    // deletion and freed when the program is deleted
+    gl.deleteShader(vertexShader);
+    gl.deleteShader(fragmentShader);
+    return program;
   }
   return null;
 }
@@ -64388,6 +65600,32 @@ var WebGLInstance = /*#__PURE__*/function () {
         _this3.textures[id].glTexture = null;
       });
     }
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      var _this4 = this;
+      var gl = this.gl;
+      // Delete all programs
+      this.programs.forEach(function (p) {
+        if (p.program) {
+          gl.deleteProgram(p.program);
+        }
+      });
+      this.programs = [];
+      // Delete all textures
+      Object.keys(this.textures).forEach(function (id) {
+        _this4.deleteTexture(id);
+      });
+      this.textures = {};
+      // Clean up atlases
+      this.atlases = {};
+      // Clean up target texture
+      if (this.targetTexture) {
+        this.targetTexture.cleanup();
+        this.targetTexture = null;
+      }
+      this.lastUsedProgram = null;
+    }
   }, {
     key: "setTextureData",
     value: function setTextureData(id, image) {
@@ -64472,18 +65710,18 @@ var WebGLInstance = /*#__PURE__*/function () {
   }, {
     key: "onLoad",
     value: function onLoad(id) {
-      var _this4 = this;
+      var _this5 = this;
       this.textures[id].onLoad.forEach(function (f) {
-        return _this4.fnMap.exec(f, true, _this4.textures[id].index);
+        return _this5.fnMap.exec(f, true, _this5.textures[id].index);
       });
       this.textures[id].onLoad = [];
     }
   }, {
     key: "cancel",
     value: function cancel(id) {
-      var _this5 = this;
+      var _this6 = this;
       this.textures[id].onLoad.forEach(function (f) {
-        return _this5.fnMap.exec(f, false, _this5.textures[id].index);
+        return _this6.fnMap.exec(f, false, _this6.textures[id].index);
       });
       this.textures[id].onLoad = [];
     }
@@ -64559,6 +65797,7 @@ var WebGLInstance = /*#__PURE__*/function () {
       this.gl.blendFunc(this.gl.ONE, this.gl.ONE_MINUS_SRC_ALPHA);
       this.gl.enable(this.gl.BLEND);
       this.targetTexture = new _target__WEBPACK_IMPORTED_MODULE_1__["default"](this);
+      this.targetTexture.setFramebufferAttachmentSizes(this.gl.canvas.width, this.gl.canvas.height);
     }
   }, {
     key: "resize",
@@ -79091,8 +80330,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _js_figure_FigureCollections_EquationLabel__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./js/figure/FigureCollections/EquationLabel */ "./src/js/figure/FigureCollections/EquationLabel.ts");
 /* harmony import */ var _js_figure_Equation_Equation__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./js/figure/Equation/Equation */ "./src/js/figure/Equation/Equation.ts");
 /* harmony import */ var _js_figure_Equation_EquationForm__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./js/figure/Equation/EquationForm */ "./src/js/figure/Equation/EquationForm.ts");
-/* harmony import */ var _js_figure_SlideNavigator__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./js/figure/SlideNavigator */ "./src/js/figure/SlideNavigator.ts");
-/* harmony import */ var _js_figure_Animation_Animation__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./js/figure/Animation/Animation */ "./src/js/figure/Animation/Animation.ts");
+/* harmony import */ var _js_figure_Equation_latexToFigureOne__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./js/figure/Equation/latexToFigureOne */ "./src/js/figure/Equation/latexToFigureOne.ts");
+/* harmony import */ var _js_figure_SlideNavigator__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./js/figure/SlideNavigator */ "./src/js/figure/SlideNavigator.ts");
+/* harmony import */ var _js_figure_Animation_Animation__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./js/figure/Animation/Animation */ "./src/js/figure/Animation/Animation.ts");
 
 
 
@@ -79126,6 +80366,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 // This helps the docgen find the types file
 // eslint-disable-next-line
 
@@ -79158,14 +80399,14 @@ var tools = {
  */
 
 var Fig = {
-  version: "1.0.7",
-  gitHash: "9c0a1c7fa",
+  version: "1.0.8",
+  gitHash: "48b41c1bd",
   tools: tools,
   Figure: _js_figure_Figure__WEBPACK_IMPORTED_MODULE_5__["default"],
   Recorder: _js_figure_Recorder_Recorder__WEBPACK_IMPORTED_MODULE_7__.Recorder,
   FunctionMap: _js_tools_FunctionMap__WEBPACK_IMPORTED_MODULE_8__.FunctionMap,
   GlobalFunctionMap: _js_tools_FunctionMap__WEBPACK_IMPORTED_MODULE_8__.GlobalFunctionMap,
-  SlideNavigator: _js_figure_SlideNavigator__WEBPACK_IMPORTED_MODULE_29__["default"],
+  SlideNavigator: _js_figure_SlideNavigator__WEBPACK_IMPORTED_MODULE_30__["default"],
   //
   FigureElement: _js_figure_Element__WEBPACK_IMPORTED_MODULE_14__.FigureElement,
   FigureElementCollection: _js_figure_Element__WEBPACK_IMPORTED_MODULE_14__.FigureElementCollection,
@@ -79188,8 +80429,9 @@ var Fig = {
   Equation: _js_figure_Equation_Equation__WEBPACK_IMPORTED_MODULE_27__.Equation,
   //
   HTMLEquation: _js_figure_Equation_HTMLEquation__WEBPACK_IMPORTED_MODULE_22__["default"],
+  latexToFigureOne: _js_figure_Equation_latexToFigureOne__WEBPACK_IMPORTED_MODULE_29__.latexToFigureOne,
   //
-  Animation: _js_figure_Animation_Animation__WEBPACK_IMPORTED_MODULE_30__,
+  Animation: _js_figure_Animation_Animation__WEBPACK_IMPORTED_MODULE_31__,
   //
   Scene: _js_tools_geometry_scene__WEBPACK_IMPORTED_MODULE_15__["default"],
   Point: _js_tools_g2__WEBPACK_IMPORTED_MODULE_0__.Point,