@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/atom/atom_operator.cpp

@@ -0,0 +1,51 @@
+#include "atom/atom_operator.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_row.h"
+#include "atom/atom_scripts.h"
+#include "atom/atom_sideset.h"
+#include "atom/atom_stack.h"
+#include "env/env.h"
+
+using namespace microtex;
+
+sptr<Box> OperatorAtom::createBox(Env& env) {
+  // case 1: side sets
+  if (auto ss = dynamic_cast<SideSetsAtom*>(_base.get()); ss != nullptr) {
+    ss->_under = _under;
+    ss->_over = _over;
+    return ss->createBox(env);
+  }
+
+  // case 2: limits are shown as scripts
+  // clang-format off
+  if ((_limitsType == LimitsType::noLimits)
+      || (_limitsType == LimitsType::normal && env.style() >= TexStyle::text)
+    ) {
+    // clang-format on
+    RowAtom* row = nullptr;
+    auto base = _base;
+    // special case: the base atom is a row that composed by other atoms
+    // we should take out the last atom in the row to place scripts
+    if (auto typed = dynamic_cast<TypedAtom*>(_base.get()); typed != nullptr) {
+      const auto& atom = typed->base();
+      const auto ra = dynamic_cast<RowAtom*>(atom.get());
+      if (ra != nullptr && ra->_lookAtLastAtom) {
+        base = ra->popBack();
+        row = ra;
+      } else {
+        base = atom;
+      }
+    }
+    if (row != nullptr) {
+      row->add(sptrOf<ScriptsAtom>(base, _under, _over));
+      return row->createBox(env);
+    }
+    return ScriptsAtom(base, _under, _over).createBox(env);
+  }
+
+  // case 3: limits are put over/under the base
+  const StackArgs& over = StackArgs::autoSpace(_over);
+  const StackArgs& under = StackArgs::autoSpace(_under);
+  return StackAtom(_base, over, under).createBox(env);
+}

package/native/vendor/microtex/lib/atom/atom_operator.h

@@ -0,0 +1,41 @@
+#ifndef MICROTEX_ATOM_OPERATOR_H
+#define MICROTEX_ATOM_OPERATOR_H
+
+#include "atom/atom.h"
+
+namespace microtex {
+
+/**
+ * An atom representing a "big operator" (or an atom that acts as one) together
+ * with its limits
+ */
+class OperatorAtom : public Atom {
+private:
+  sptr<Atom> _base, _under, _over;
+
+public:
+  OperatorAtom() = delete;
+
+  /**
+   * Create a new OperatorAtom from the given atoms. The default rules the
+   * positioning of the limits will be applied.
+   *
+   * @param base atom representing the big operator
+   * @param under atom representing the under limit
+   * @param over atom representing the over limit
+   */
+  OperatorAtom(const sptr<Atom>& base, const sptr<Atom>& under, const sptr<Atom>& over)
+      : _base(base), _under(under), _over(over) {
+    _limitsType = _base->_limitsType;
+  }
+
+  sptr<Box> createBox(Env& env) override;
+
+  AtomType leftType() const override { return _base->leftType(); }
+
+  AtomType rightType() const override { return _base->rightType(); }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_OPERATOR_H

package/native/vendor/microtex/lib/atom/atom_root.cpp

@@ -0,0 +1,61 @@
+#include "atom/atom_root.h"
+
+#include "box/box_factory.h"
+#include "box/box_group.h"
+#include "env/env.h"
+
+using namespace microtex;
+
+sptr<Box> NthRoot::createBox(Env& env) {
+  // clang-format off
+  const auto base = (
+    _base == nullptr
+    ? StrutBox::empty()
+    : env.withStyle(env.crampStyle(), [&](Env& cramp) { return _base->createBox(cramp); })
+  );
+  // clang-format on
+
+  const auto& math = env.mathConsts();
+  const auto gap = env.style() <= TexStyle::display1 ? math.radicalDisplayStyleVerticalGap()
+                                                     : math.radicalVerticalGap();
+  const auto theta = math.radicalRuleThickness() * env.scale();
+  auto radical = microtex::createVDelim("sqrt", env, base->vlen() + gap + theta);
+
+  const auto delta = (radical->vlen() - (base->vlen() + gap + theta)) / 2.f;
+  const auto rule = sptrOf<RuleBox>(theta, base->_width, 0.f);
+
+  auto vbox = sptrOf<VBox>();
+  const auto asc = math.radicalExtraAscender() * env.scale();
+  vbox->add(sptrOf<StrutBox>(0.f, asc, 0.f, 0.f));
+  vbox->add(rule);
+  vbox->add(sptrOf<StrutBox>(0.f, gap + delta, 0.f, 0.f));
+  vbox->add(base);
+  const auto h = vbox->vlen();
+  vbox->_height = h - base->_depth;
+  vbox->_depth = base->_depth;
+
+  auto hbox = sptrOf<HBox>();
+  radical->_shift = radical->_height - vbox->_height + asc;
+  hbox->add(radical);
+  hbox->add(vbox);
+
+  // degree
+  if (_root == nullptr) {
+    return hbox;
+  }
+
+  const auto degree =
+    env.withStyle(env.rootStyle(), [&](Env& root) { return _root->createBox(root); });
+  const auto hd = sptrOf<HBox>();
+  const auto bk = math.radicalKernBeforeDegree() * env.scale();
+  hd->add(StrutBox::create(bk));
+  hd->add(degree);
+  const auto br = math.radicalDegreeBottomRaisePercent() / 100.f * hbox->vlen();
+  hd->_shift = hbox->_depth - hd->_depth - br + asc + theta;
+
+  hbox->add(0, hd);
+  const auto ak = math.radicalKernAfterDegree() * env.scale();
+  hbox->add(1, StrutBox::create(ak));
+
+  return hbox;
+}

package/native/vendor/microtex/lib/atom/atom_root.h

@@ -0,0 +1,27 @@
+#ifndef MICROTEX_ATOM_ROOT_H
+#define MICROTEX_ATOM_ROOT_H
+
+#include "atom/atom.h"
+#include "atom/atom_basic.h"
+
+namespace microtex {
+
+/** An atom representing an nth-root construction */
+class NthRoot : public Atom {
+private:
+  // base atom to be put under the root sign
+  sptr<Atom> _base;
+  // root atom to be put in the upper left corner above the root sign
+  sptr<Atom> _root;
+
+public:
+  NthRoot() = delete;
+
+  NthRoot(const sptr<Atom>& base, const sptr<Atom>& root) : _base(base), _root(root) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_ROOT_H

package/native/vendor/microtex/lib/atom/atom_row.cpp

@@ -0,0 +1,334 @@
+#include "atom/atom_row.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_char.h"
+#include "atom/atom_space.h"
+#include "atom/atom_text.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "core/glue.h"
+#include "env/env.h"
+#include "utils/utf.h"
+
+using namespace std;
+using namespace microtex;
+
+bool AtomDecor::isChar() const {
+  return _atom->isChar();
+}
+
+bool AtomDecor::isMathMode() const {
+  if (!isChar()) return false;
+  return static_cast<CharSymbol*>(_atom.get())->isMathMode();
+}
+
+Char AtomDecor::getChar(Env& env) const {
+  if (!isChar()) return {};
+  return ((CharSymbol*)_atom.get())->getChar(env);
+}
+
+void AtomDecor::changeAtom(const sptr<FixedCharAtom>& atom) {
+  _textSymbol = false;
+  _atom = atom;
+  _type = AtomType::none;
+}
+
+sptr<Box> AtomDecor::createBox(Env& env) {
+  if (_textSymbol) ((CharSymbol*)_atom.get())->markAsText();
+  auto box = _atom->createBox(env);
+  if (_textSymbol) ((CharSymbol*)_atom.get())->removeMark();
+  return box;
+}
+
+bool AtomDecor::isKern() const {
+  auto* x = dynamic_cast<SpaceAtom*>(_atom.get());
+  return (x != nullptr);
+}
+
+void AtomDecor::setPreviousAtom(const sptr<AtomDecor>& prev) {
+  auto* row = dynamic_cast<Row*>(_atom.get());
+  if (row != nullptr) row->setPreviousAtom(prev);
+}
+
+bool RowAtom::_breakEverywhere = false;
+
+// clang-format off
+bitset<16> RowAtom::_binSet = bitset<16>()
+  .set(static_cast<i8>(AtomType::binaryOperator))
+  .set(static_cast<i8>(AtomType::bigOperator))
+  .set(static_cast<i8>(AtomType::relation))
+  .set(static_cast<i8>(AtomType::opening))
+  .set(static_cast<i8>(AtomType::punctuation));
+
+bitset<16> RowAtom::_ligKernSet = bitset<16>()
+  .set(static_cast<i8>(AtomType::ordinary))
+  .set(static_cast<i8>(AtomType::bigOperator))
+  .set(static_cast<i8>(AtomType::binaryOperator))
+  .set(static_cast<i8>(AtomType::relation))
+  .set(static_cast<i8>(AtomType::opening))
+  .set(static_cast<i8>(AtomType::closing))
+  .set(static_cast<i8>(AtomType::punctuation));
+// clang-format on
+
+RowAtom::RowAtom(const sptr<Atom>& atom)
+    : _lookAtLastAtom(false), _previousAtom(nullptr), _breakable(true) {
+  if (atom != nullptr) {
+    auto* x = dynamic_cast<RowAtom*>(atom.get());
+    if (x != nullptr) {
+      // no need to make a row, the only element of a row
+      _elements.insert(_elements.end(), x->_elements.begin(), x->_elements.end());
+    } else {
+      _elements.push_back(atom);
+    }
+  }
+}
+
+sptr<Atom> RowAtom::getFirstAtom() {
+  if (!_elements.empty()) return _elements.front();
+  return nullptr;
+}
+
+sptr<Atom> RowAtom::popBack() {
+  if (!_elements.empty()) {
+    sptr<Atom> x = _elements.back();
+    _elements.pop_back();
+    return x;
+  }
+  return SpaceAtom::empty();
+}
+
+sptr<Atom> RowAtom::get(size_t pos) {
+  if (pos >= _elements.size()) return SpaceAtom::empty();
+  return _elements[pos];
+}
+
+void RowAtom::add(const sptr<Atom>& atom) {
+  if (atom != nullptr) _elements.push_back(atom);
+}
+
+void RowAtom::changeToOrd(AtomDecor* cur, AtomDecor* prev, Atom* next) {
+  AtomType type = cur->leftType();
+  // clang-format off
+  if ((type == AtomType::binaryOperator)
+      && ((prev == nullptr || _binSet[static_cast<i8>(prev->rightType())]) || next == nullptr)
+    ) {
+    // clang-format on
+    cur->_type = AtomType::ordinary;
+  } else if (next != nullptr && cur->rightType() == AtomType::binaryOperator) {
+    AtomType nextType = next->leftType();
+    // clang-format off
+    if (nextType == AtomType::relation
+        || nextType == AtomType::closing
+        || nextType == AtomType::punctuation
+      ) {
+      // clang-format on
+      cur->_type = AtomType::ordinary;
+    }
+  }
+}
+
+AtomType RowAtom::leftType() const {
+  if (_elements.empty()) return AtomType::ordinary;
+  return _elements.front()->leftType();
+}
+
+AtomType RowAtom::rightType() const {
+  if (_elements.empty()) return AtomType::ordinary;
+  return _elements.back()->rightType();
+}
+
+sptr<CharSymbol> RowAtom::currentChar(int i) {
+  if (i >= _elements.size()) return nullptr;
+  const auto a = _elements[i];
+  if (!a->isChar()) return nullptr;
+  return static_pointer_cast<CharSymbol>(a);
+}
+
+int RowAtom::processInvalid(const sptr<TextAtom>& txt, bool isMathMode, int i, Env& env) {
+  const auto a = currentChar(i);
+  if (a == nullptr || a->isMathMode() != isMathMode) return i;
+  const auto& chr = a->getChar(env);
+  if (chr.isValid()) return i;
+  txt->append(chr.mappedCode);
+  return processInvalid(txt, isMathMode, i + 1, env);
+}
+
+sptr<TextAtom> RowAtom::processContinues(int& i, bool isMathMode) {
+  if (i >= _elements.size()) return nullptr;
+  int cnt = 0;
+  auto txt = sptrOf<TextAtom>(isMathMode);
+  const auto next = [&]() {
+    auto a = currentChar(i + cnt);
+    return a == nullptr || a->isMathMode() != isMathMode ? 0 : a->unicode();
+  };
+  const auto collect = [&](c32 code) {
+    txt->append(code);
+    ++cnt;
+  };
+  microtex::scanContinuedUnicodes(next, collect);
+  if (cnt <= 1) return nullptr;
+  i += cnt - 1;
+  return txt;
+}
+
+sptr<Box> RowAtom::createBox(Env& env) {
+  auto hbox = new HBox();
+  // convert atoms to boxes and add to the horizontal box
+  const int end = _elements.size() - 1;
+  for (int i = -1; i < end;) {
+    auto raw = _elements[++i];
+
+    // 1. Skip break marks
+    bool hasBreak = false;
+    auto ba = dynamic_cast<BreakMarkAtom*>(raw.get());
+    while (ba != nullptr) {
+      hasBreak = true;
+      if (i < end) {
+        raw = _elements[++i];
+        ba = dynamic_cast<BreakMarkAtom*>(raw.get());
+      } else {
+        break;
+      }
+    }
+
+    auto curr = sptrOf<AtomDecor>(raw);
+    auto tmp = curr;
+
+    // 2. process continued and invalid chars
+    auto t = processContinues(i, curr->isMathMode());
+    if (t != nullptr) {
+      curr = sptrOf<AtomDecor>(t);
+      tmp = i < end ? sptrOf<AtomDecor>(_elements[i + 1]) : sptrOf<AtomDecor>(EmptyAtom::create());
+    }
+    Char c = tmp->getChar(env);
+    if (tmp->isChar() && !c.isValid()) {
+      const auto isMathMode = tmp->isMathMode();
+      if (t == nullptr)
+        t = sptrOf<TextAtom>(isMathMode);
+      else
+        ++i;
+      t->append(c.mappedCode);
+      i = processInvalid(t, isMathMode, i + 1, env) - 1;
+      curr = sptrOf<AtomDecor>(t);
+    }
+
+    // 3. Change atom type
+    // if necessary, change BIN to ORD
+    // i.e. for formula: $+ e - f$, the plus sign should be treated as an ordinary atom
+    sptr<Atom> nextAtom = nullptr;
+    if (i < end) nextAtom = _elements[i + 1];
+    changeToOrd(curr.get(), _previousAtom.get(), nextAtom.get());
+
+    // 4. Check for ligatures and kerning
+    float kern = 0.f;
+    if (nextAtom != nullptr && curr->rightType() == AtomType::ordinary && curr->isChar()) {
+      curr->markAsTextSymbol();
+      // initialize
+      const auto& chr = c;
+      const auto font = chr.fontId;
+      auto ligs = FontContext::getFont(font)->otf().ligatures();
+      auto lig = ligs == nullptr ? nullptr : (*ligs)[chr.glyphId];
+      // find target from the ligatures table
+      int index = i;
+      const LigaTable* target = nullptr;
+      i32 nextGlyph = -1;
+      while (i < end && lig != nullptr) {
+        auto next = _elements[++i];
+        if (!next->isChar() || !_ligKernSet[static_cast<i8>(next->leftType())]) {
+          break;
+        }
+        // is safe to cast the atom to CharSymbol since it is a char
+        auto nextChar = static_cast<CharSymbol*>(next.get());
+        auto c = nextChar->getChar(env);
+        // not in same font, break the iteration
+        if (c.fontId != font) {
+          break;
+        }
+        // record the first following glyph
+        if (nextGlyph == -1) nextGlyph = c.glyphId;
+        // is ligature found?
+        lig = (*lig)[c.glyphId];
+        if (lig != nullptr && lig->value() > 0) {
+          target = lig;
+          index = i;
+        }
+      }
+      // reset the current index
+      i = index;
+      auto rawKern = [](const Char& p, i32 q) {
+        // The glyph is guaranteed to be valid
+        auto kern = FontContext::getFont(p.fontId)->otf().glyph(p.glyphId)->kernRecord()[q];
+        if (kern == 0) {
+          // Try find from class-kerning
+          kern = FontContext::getFont(p.fontId)->otf().classKerning(p.glyphId, q);
+        }
+        return kern;
+      };
+      if (target != nullptr) {
+        // We found it! Replace with ligature char
+        const auto& fixed = Char::onlyGlyph(chr.fontId, target->value(), chr.scale);
+        curr->changeAtom(sptrOf<FixedCharAtom>(fixed));
+        // TODO record the original code-points?
+      } else if (nextGlyph != -1) {
+        kern = rawKern(chr, nextGlyph) * chr.scale;
+      } else if (nextAtom->isChar() && _ligKernSet[static_cast<i8>(nextAtom->leftType())]) {
+        auto nextChar = static_cast<CharSymbol*>(nextAtom.get());
+        kern = rawKern(chr, nextChar->getChar(env).glyphId) * chr.scale;
+      }
+    }
+
+    // 5. Insert glue, unless it's the first element of the row
+    //    or the previous element or the current is a kerning
+    if (i != 0 && _previousAtom != nullptr && !_previousAtom->isKern() && !curr->isKern()) {
+      const auto glue = Glue::get(_previousAtom->rightType(), curr->leftType(), env);
+      if (std::abs(glue->_width) > PREC) {
+        hbox->add(glue);
+      }
+    }
+
+    // 6. Add break mark to box
+    if (_breakable) {
+      if (_breakEverywhere) {
+        hbox->addBreakPosition(hbox->size());
+      } else {
+        if (hasBreak) {
+          hbox->addBreakPosition(hbox->size());
+        } else {
+          auto charAtom = dynamic_cast<CharAtom*>(raw.get());
+          if (charAtom != nullptr && isUnicodeDigit(charAtom->unicode())) {
+            hbox->addBreakPosition(hbox->size());
+          }
+        }
+      }
+    }
+
+    // 7. Add italic
+    curr->setPreviousAtom(_previousAtom);
+    auto box = curr->createBox(env);
+    /* FIXME
+     * In most cases we don't care the italic corrections
+     * on math environment, although it is looks crappy
+    if (auto cb = dynamic_cast<CharBox*>(box.get());
+      cb != nullptr
+      && curr->isMathMode()
+      && nextAtom != nullptr
+      && nextAtom->isChar()) {
+      kern += cb->italic();
+    }*/
+
+    // 8. Append atom's box and kerning to horizontal box
+    hbox->add(box);
+    if (std::abs(kern) > PREC) hbox->add(StrutBox::create(kern));
+
+    env.setLastFontId(box->lastFontId());
+    // kerning do not interfere with the normal glue-rules without kerning
+    if (!curr->isKern()) _previousAtom = curr;
+  }
+  // reset previous atom
+  _previousAtom = nullptr;
+  return sptr<Box>(hbox);
+}
+
+void RowAtom::setPreviousAtom(const sptr<AtomDecor>& prev) {
+  _previousAtom = prev;
+}

package/native/vendor/microtex/lib/atom/atom_row.h

@@ -0,0 +1,176 @@
+#ifndef MICROTEX_ATOM_ROW_H
+#define MICROTEX_ATOM_ROW_H
+
+#include <bitset>
+
+#include "atom/atom.h"
+#include "atom/atom_text.h"
+#include "box/box.h"
+#include "unimath/uni_char.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+class AtomDecor;
+
+class FixedCharAtom;
+
+class CharSymbol;
+
+class Env;
+
+/**
+ * A "composed atom": An atom that consists of child atoms that will be
+ * displayed next to each other horizontally with glue between them.
+ */
+class Row {
+public:
+  /**
+   * Sets the given "decor" containing the atom that comes just before the first
+   * child atom of this "composed atom". This method will always be called by
+   * another composed atom, so this composed atom will be a child of it
+   * (nested). This is necessary to determine the glue to insert between the
+   * first child atom of this nested composed atom and the atom that the "decor"
+   * contains.
+   *
+   * @param decor
+   *      the atom that comes just before this "composed atom"
+   */
+  virtual void setPreviousAtom(const sptr<AtomDecor>& decor) = 0;
+};
+
+/**
+ * Used by RowAtom. The "textSymbol"-property and the type of an atom can changed
+ * (according to the TeX-algorithms used). Or this atom can be replaced by a
+ * ligature, (if it was a CharAtom). But atoms cannot be changed, otherwise
+ * different boxes could be made from the same formula, and that is not
+ * desired! This "atom decor" makes sure that changes to an atom (during the
+ * createBox-method of a RowAtom) will be reset.
+ */
+class AtomDecor {
+private:
+  sptr<Atom> _atom;
+  bool _textSymbol = false;
+
+public:
+  AtomType _type = AtomType::none;
+
+  AtomDecor() = delete;
+
+  explicit AtomDecor(const sptr<Atom>& atom) {
+    _textSymbol = false;
+    _atom = atom;
+    _type = AtomType::none;
+  }
+
+  /** @return the changed type, or the old left type if it has not been changed */
+  inline AtomType leftType() const { return (_type != AtomType::none ? _type : _atom->leftType()); }
+
+  /** @return the changed type, or the old right type if it has not been changed */
+  inline AtomType rightType() const {
+    return (_type != AtomType::none ? _type : _atom->rightType());
+  }
+
+  /** Test if this atom is a char-symbol. */
+  bool isChar() const;
+
+  /** Test if this char is in math mode. */
+  bool isMathMode() const;
+
+  /** This method will only be called if #isChar returns true. */
+  Char getChar(Env& env) const;
+
+  /** Changes this atom into the given "ligature atom". */
+  void changeAtom(const sptr<FixedCharAtom>& atom);
+
+  sptr<Box> createBox(Env& env);
+
+  inline void markAsTextSymbol() { _textSymbol = true; }
+
+  /** Test if this atom is a kern. */
+  bool isKern() const;
+
+  /** Only for row-elements, for nested rows */
+  void setPreviousAtom(const sptr<AtomDecor>& prev);
+};
+
+/**
+ * An atom representing a horizontal row of other atoms, to be separated by
+ * glue. It's also responsible for inserting kerns and ligature.
+ */
+class RowAtom : public Atom, public Row {
+private:
+  // set of atom types that make a previous bin atom change to ord
+  static std::bitset<16> _binSet;
+  // set of atom types that can possibly need a kern or, together
+  // with the previous atom, be replaced by a ligature
+  static std::bitset<16> _ligKernSet;
+
+  // whether the box generated can be broken
+  bool _breakable;
+  // atoms to be displayed horizontally next to each-other
+  std::vector<sptr<Atom>> _elements;
+  // previous atom (for nested Row atoms)
+  sptr<AtomDecor> _previousAtom;
+
+  /**
+   * Change the atom-type to ORD if necessary
+   * <p>
+   * i.e. for formula: `$+ e - f$`, the plus sign should be treat as
+   * an ordinary type
+   */
+  static void changeToOrd(AtomDecor* cur, AtomDecor* prev, Atom* next);
+
+  sptr<CharSymbol> currentChar(int i);
+
+  int processInvalid(const sptr<TextAtom>& txt, bool isMathMode, int i, Env& env);
+
+  sptr<TextAtom> processContinues(int& i, bool isMathMode);
+
+public:
+  static bool _breakEverywhere;
+
+  bool _lookAtLastAtom;
+
+  RowAtom() : _lookAtLastAtom(false), _breakable(true) {}
+
+  explicit RowAtom(const sptr<Atom>& atom);
+
+  /** Get the atom at the front in the elements */
+  sptr<Atom> getFirstAtom();
+
+  /** Get and remove the atom at the tail in the elements */
+  sptr<Atom> popBack();
+
+  /**
+   * Get the atom at position
+   *
+   * @param pos the position of the atom to retrieve
+   */
+  sptr<Atom> get(size_t pos);
+
+  /**
+   * Indicate the box generated by this atom can be broken or not
+   *
+   * @param breakable indicate whether the box can be broken
+   */
+  inline void setBreakable(bool breakable) { _breakable = breakable; }
+
+  /** Get the size of the elements */
+  inline size_t size() const { return _elements.size(); }
+
+  /** Push an atom to back */
+  void add(const sptr<Atom>& atom);
+
+  sptr<Box> createBox(Env& env) override;
+
+  void setPreviousAtom(const sptr<AtomDecor>& prev) override;
+
+  AtomType leftType() const override;
+
+  AtomType rightType() const override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_ROW_H