@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,182 @@
+#include "atom/atom_scripts.h"
+
+#include "atom/atom_accent.h"
+#include "atom/atom_basic.h"
+#include "atom/atom_char.h"
+#include "atom/atom_stack.h"
+
+using namespace microtex;
+using namespace std;
+
+sptr<Box> ScriptsAtom::createBox(Env& env) {
+  // if no base was given, use a phantom 'M' to place scripts
+  if (_base == nullptr) {
+    auto in = sptrOf<CharAtom>('M', FontStyle::rm, false);
+    _base = sptrOf<PhantomAtom>(in, false, true, true);
+  }
+
+  // no scripts
+  if (_sub == nullptr && _sup == nullptr) {
+    return _base->createBox(env);
+  }
+
+  // display as limits
+  // clang-format off
+  if (_base->_limitsType == LimitsType::limits ||
+      (_base->_limitsType == LimitsType::normal && env.style() == TexStyle::display)
+    ) {
+    // clang-format on
+    const auto& over = StackArgs::autoSpace(_sup);
+    const auto& under = StackArgs::autoSpace(_sub);
+    return StackAtom(_base, over, under).createBox(env);
+  }
+
+  const auto& [base, scripts, space, kern, reduce, italic] = createScripts(env);
+  const auto hbox = sptrOf<HBox>();
+  if (_onRight) {
+    hbox->add(base);
+    if (std::abs(reduce + kern) > PREC) hbox->add(StrutBox::create(reduce + kern));
+    hbox->add(scripts);
+    hbox->add(StrutBox::create(space));
+  } else {
+    hbox->add(StrutBox::create(space));
+    hbox->add(scripts);
+    if (std::abs(reduce + kern) > PREC) hbox->add(StrutBox::create(reduce + kern));
+    hbox->add(base);
+  }
+
+  return hbox;
+}
+
+ScriptResult ScriptsAtom::createScripts(Env& env) {
+  // params to place scripts
+  sptr<Box> kernel, base;
+  float delta = 0.f;
+  bool isText = false, isOperator = false;
+  const MathKernRecord* kernRecord = nullptr;
+
+  const auto checkAtom = [&](const sptr<Atom>& atom, Env& targetEnv) {
+    if (auto cs = dynamic_cast<CharSymbol*>(atom.get()); cs != nullptr) {
+      const auto& chr = cs->getChar(targetEnv);
+      kernRecord = &(chr.glyph()->math().kernRecord());
+      if (!cs->isText()) delta = chr.italic();
+      isText = atom->_type != AtomType::bigOperator;
+      isOperator = atom->_type == AtomType::bigOperator;
+    }
+  };
+  const auto getMathKern = [&](float height, bool isTop) {
+    if (kernRecord == nullptr) return 0.f;
+    const auto& mathKern = _onRight ? (isTop ? kernRecord->topRight() : kernRecord->bottomRight())
+                                    : (isTop ? kernRecord->topLeft() : kernRecord->bottomLeft());
+    const auto i = mathKern.indexOf(height);
+    return mathKern.value(i) * env.scale();
+  };
+
+  if (auto acc = dynamic_cast<AccentedAtom*>(_base.get()); acc != nullptr) {
+    // 1. special case: accent
+    // the scripts are placed around the accentee
+    // clang-format off
+    kernel = env.withStyle(
+      env.crampStyle(),
+      [&](Env& cramp) {
+        checkAtom(acc->_base, cramp);
+        return (acc->_base == nullptr ? sptrOf<EmptyAtom>() : acc->_base)->createBox(cramp);
+      }
+    );
+    // clang-format on
+    base = _base->createBox(env);
+  } else {
+    // 2. char symbol or boxed
+    checkAtom(_base, env);
+    kernel = base = _base->createBox(env);
+  }
+
+  const auto& math = env.mathConsts();
+
+  auto u = 0.f, v = 0.f;
+  if (!isText) {
+    u = kernel->_height - math.superscriptBaselineDropMax() * env.scale();
+    v = kernel->_depth + math.subscriptBaselineDropMin() * env.scale();
+  }
+
+  const auto compose = [&](const sptr<Box>& box, float extra = 0) -> ScriptResult {
+    const auto scriptSpace = math.spaceAfterScript() * env.scale();
+    const auto kern = kernel->_width - base->_width + extra;
+    const auto widthReduce = isOperator && delta > PREC ? -delta : 0.f;
+    return {base, box, scriptSpace, kern, widthReduce, delta};
+  };
+
+  if (_sup == nullptr) {
+    // case 1. only subscript
+    auto x = env.withStyle(env.subStyle(), [&](Env& sub) { return _sub->createBox(sub); });
+    x->_shift = maxOf<float>(
+      v,
+      math.subscriptShiftDown() * env.scale(),
+      x->_height - math.subscriptTopMax() * env.scale()
+    );
+    const auto kern = getMathKern(-x->_shift, false);
+    return compose(x, kern);
+  }
+
+  auto x = env.withStyle(env.supStyle(), [&](Env& sup) { return _sup->createBox(sup); });
+  // clang-format off
+  u = maxOf<float>(
+    u,
+    (float) (
+      env.isCrampedStyle()
+      ? math.superscriptShiftUpCramped()
+      : math.superscriptShiftUp()
+    ) * env.scale(),
+    x->_depth + math.superscriptBottomMin() * env.scale()
+  );
+  // clang-format on
+
+  if (_sub == nullptr) {
+    // case 2. only superscript
+    x->_shift = -u;
+    const auto kern = getMathKern(-x->_shift, true);
+    return compose(x, kern + delta);
+  }
+
+  // case 3. both super & sub scripts
+  auto y = env.withStyle(env.subStyle(), [&](Env& sub) { return _sub->createBox(sub); });
+  v = maxOf<float>(v, math.subscriptShiftDown() * env.scale());
+
+  const auto theta = math.subSuperscriptGapMin() * env.scale();
+  auto sigma = (u - x->_depth) - (y->_height - v);
+  if (sigma < theta) {
+    v = theta + y->_height + x->_depth - u;
+    const auto psi = math.superscriptBottomMaxWithSubscript() * env.scale() - (u - x->_depth);
+    if (psi > 0 && (v - psi + y->_depth) > kernel->_depth) {
+      u += psi;
+      v -= psi;
+    }
+    sigma = theta;
+  }
+
+  // clang-format off
+  const auto topKern =
+    (
+      _onRight
+      ? 0
+      : std::max(0.f, y->_width - x->_width)
+    ) + getMathKern(u, true) + delta;
+  const auto bottomKern =
+    (
+      _onRight
+      ? 0
+      : std::max(0.f, x->_width - y->_width)
+    ) + getMathKern(-v, false);
+  // clang-format on
+  const auto kern = _onRight ? std::min(topKern, bottomKern) : 0;
+
+  auto vbox = sptrOf<VBox>();
+  x->_shift = topKern - kern;
+  vbox->add(x);
+  y->_shift = bottomKern - kern;
+  vbox->add(y, sigma);
+  vbox->_height = x->_height + u;
+  vbox->_depth = y->_depth + v;
+
+  return compose(vbox, kern);
+}

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

@@ -0,0 +1,52 @@
+#ifndef MICROTEX_ATOM_SCRIPTS_H
+#define MICROTEX_ATOM_SCRIPTS_H
+
+#include "atom/atom.h"
+#include "atom/atom_space.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+struct ScriptResult {
+  sptr<Box> base = nullptr;
+  sptr<Box> scripts = nullptr;
+  float space = 0.f;
+  float kern = 0.f;
+  float widthReduce = 0.f;
+  float italic = 0.f;
+};
+
+/** An atom representing scripts to be attached to another atom */
+class ScriptsAtom : public Atom {
+public:
+  // base atom
+  sptr<Atom> _base;
+  // subscript and superscript to be attached to the base
+  sptr<Atom> _sub;
+  sptr<Atom> _sup;
+  bool _onRight = true;
+
+  ScriptsAtom() = delete;
+
+  ScriptsAtom(
+    const sptr<Atom>& base,
+    const sptr<Atom>& sub,
+    const sptr<Atom>& sup,
+    bool onRight = true
+  )
+      : _base(base), _sub(sub), _sup(sup), _onRight(onRight) {}
+
+  AtomType leftType() const override { return _base == nullptr ? _type : _base->leftType(); }
+
+  AtomType rightType() const override { return _base == nullptr ? _type : _base->rightType(); }
+
+  sptr<Box> createBox(Env& env) override;
+
+  ScriptResult createScripts(Env& env);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_SCRIPTS_H

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

@@ -0,0 +1,92 @@
+#include "atom/atom_sideset.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_scripts.h"
+#include "atom/atom_stack.h"
+#include "atom/atom_zstack.h"
+
+using namespace microtex;
+
+SideSetsAtom::SideSetsAtom(const sptr<Atom>& base, const sptr<Atom>& left, const sptr<Atom>& right) {
+  _base = base == nullptr ? sptrOf<EmptyAtom>() : base;
+  _left = left == nullptr ? sptrOf<EmptyAtom>() : left;
+  _right = right == nullptr ? sptrOf<EmptyAtom>() : right;
+  _type = AtomType::bigOperator;
+  _limitsType = LimitsType::noLimits;
+}
+
+sptr<Box> SideSetsAtom::createBox(Env& env) {
+  _base->_limitsType = LimitsType::noLimits;
+  sptr<Box> l, m, r;
+  sptr<PlaceholderAtom> pa;
+  auto italic = 0.f;
+
+  ScriptResult right;
+  if (auto sr = dynamic_cast<ScriptsAtom*>(_right.get()); sr != nullptr && sr->_base == nullptr) {
+    right = ScriptsAtom(_base, sr->_sub, sr->_sup).createScripts(env);
+    m = right.base;
+    pa = _base->isChar() ? nullptr
+                         : sptrOf<PlaceholderAtom>(m->_width, m->_height, m->_depth, right.italic);
+    italic = right.italic;
+  } else {
+    _right = _right == nullptr ? sptrOf<EmptyAtom>() : _right;
+    r = _right->createBox(env);
+  }
+
+  ScriptResult left;
+  if (auto sl = dynamic_cast<ScriptsAtom*>(_left.get()); sl != nullptr && sl->_base == nullptr) {
+    const auto base = pa == nullptr ? _base : pa;
+    left = ScriptsAtom(base, sl->_sub, sl->_sup, false).createScripts(env);
+    if (m == nullptr) m = left.base;
+    italic = left.italic;
+  } else {
+    l = _left->createBox(env);
+  }
+
+  if (m == nullptr) {
+    m = _base->createBox(env);
+  }
+
+  const auto hbox = sptrOf<HBox>();
+  if (l != nullptr) {
+    hbox->add(l);
+  } else {
+    const auto& [_1, scripts, space, kern, widthReduce, _2] = left;
+    hbox->add(StrutBox::create(space));
+    hbox->add(scripts);
+    const auto d = kern + widthReduce;
+    if (std::abs(d) > PREC) hbox->add(StrutBox::create(d));
+  }
+
+  const auto ml = hbox->_width;
+  hbox->add(m);
+
+  if (r != nullptr) {
+    hbox->add(r);
+  } else {
+    const auto& [_1, scripts, space, kern, widthReduce, _2] = right;
+    const auto d = kern + widthReduce;
+    if (std::abs(d) > PREC) hbox->add(StrutBox::create(d));
+    hbox->add(scripts);
+    hbox->add(StrutBox::create(space));
+  }
+
+  sptr<Box> limits;
+  float shift = 0.f;
+  if (_under != nullptr || _over != nullptr) {
+    const auto k = sptrOf<PlaceholderAtom>(m->_width, hbox->_height, hbox->_depth, italic);
+    const auto& result =
+      StackAtom(k, StackArgs::autoSpace(_over), StackArgs::autoSpace(_under)).createStack(env);
+    limits = result.box;
+    shift = result.kernelShift;
+  }
+
+  if (limits == nullptr) return hbox;
+
+  const ZStackArgs hargs{Alignment::left, ml - shift, UnitType::none};
+  const ZStackArgs vargs{Alignment::none};
+  const auto anchor = sptrOf<PlaceholderAtom>(hbox);
+  const auto atom = sptrOf<PlaceholderAtom>(limits);
+
+  return ZStackAtom(hargs, vargs, atom, anchor).createBox(env);
+}

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

@@ -0,0 +1,24 @@
+#ifndef MICROTEX_ATOM_SIDESET_H
+#define MICROTEX_ATOM_SIDESET_H
+
+#include "atom/atom.h"
+
+namespace microtex {
+
+/** An atom representing scripts around of a base atom */
+class SideSetsAtom : public Atom {
+public:
+  // _base is guaranteed to be valid
+  sptr<Atom> _left, _right, _base;
+  sptr<Atom> _under, _over;
+
+  SideSetsAtom() = delete;
+
+  SideSetsAtom(const sptr<Atom>& base, const sptr<Atom>& left, const sptr<Atom>& right);
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_SIDESET_H

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

@@ -0,0 +1,22 @@
+#include "atom/atom_space.h"
+
+#include "box/box_single.h"
+#include "core/glue.h"
+#include "env/env.h"
+#include "env/units.h"
+
+using namespace std;
+using namespace microtex;
+
+sptr<Box> SpaceAtom::createBox(Env& env) {
+  if (!_blankSpace) {
+    float w = Units::fsize(_unit, _width, env);
+    float h = Units::fsize(_unit, _height, env);
+    float d = Units::fsize(_unit, _depth, env);
+    return sptrOf<StrutBox>(w, h, d, 0.f);
+  }
+  if (_blankType == SpaceType::none) {
+    return sptrOf<StrutBox>(env.space(_isMathMode), 0.f, 0.f, 0.f);
+  }
+  return Glue::get(_blankType, env);
+}

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

@@ -0,0 +1,38 @@
+#ifndef MICROTEX_ATOM_SPACE_H
+#define MICROTEX_ATOM_SPACE_H
+
+#include "atom/atom.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+/** An atom representing whitespace. */
+class SpaceAtom : public Atom {
+private:
+  bool _isMathMode = true;
+  // whether a hard space should be represented
+  bool _blankSpace = false;
+  // thin-mu-skip, med-mu-skip, thick-mu-skip
+  SpaceType _blankType{};
+  // dimensions
+  float _width = 0, _height = 0, _depth = 0;
+  // units of the dimensions
+  UnitType _unit{};
+
+public:
+  explicit SpaceAtom(bool isMathMode = true) noexcept
+      : _blankSpace(true), _isMathMode(isMathMode) {}
+
+  explicit SpaceAtom(SpaceType type) noexcept : _blankSpace(true), _blankType(type) {}
+
+  SpaceAtom(UnitType unit, float width, float height, float depth) noexcept
+      : _unit(unit), _width(width), _height(height), _depth(depth) {}
+
+  sptr<Box> createBox(Env& env) override;
+
+  static sptr<SpaceAtom> empty() { return sptrOf<SpaceAtom>(UnitType::em, 0.f, 0.f, 0.f); }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_SPACE_H

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

@@ -0,0 +1,117 @@
+#include "atom/atom_stack.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_char.h"
+#include "atom/atom_space.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+
+using namespace microtex;
+using namespace std;
+
+const std::vector<StackElement> StackAtom::_defaultOrder = {
+  StackElement::over,
+  StackElement::under,
+  StackElement::base,
+};
+
+sptr<Box> StackAtom::createBox(Env& env) {
+  const auto& [box, _] = createStack(env);
+  return box;
+}
+
+StackResult StackAtom::createStack(Env& env) {
+  // over and under
+  sptr<Box> o, u, b;
+  const auto createOverUnder = [&](const StackArgs& args, TexStyle style) -> sptr<Box> {
+    if (!args.isPresent()) return nullptr;
+    auto x = args.isScript ? env.withStyle(style, [&](Env& e) { return args.atom->createBox(e); })
+                           : args.atom->createBox(env);
+    _maxWidth = std::max(_maxWidth, x->_width);
+    return x;
+  };
+  for (auto elem : _order) {
+    switch (elem) {
+      case StackElement::over: o = createOverUnder(_over, env.supStyle()); break;
+      case StackElement::under: u = createOverUnder(_under, env.subStyle()); break;
+      case StackElement::base:
+        b = _base == nullptr ? StrutBox::empty() : _base->createBox(env);
+        _maxWidth = std::max(_maxWidth, b->_width);
+        break;
+    }
+  }
+
+  auto delta = 0.f;
+  if (auto cs = dynamic_cast<CharSymbol*>(_base.get()); cs != nullptr) {
+    delta = cs->getChar(env).italic();
+  } else if (auto pa = dynamic_cast<PlaceholderAtom*>(_base.get()); pa != nullptr) {
+    delta = pa->italic();
+  }
+
+  const auto wrap = [&](const sptr<Box>& box, float bias) -> sptr<Box> {
+    box->_shift = (_maxWidth - box->_width) / 2 + bias;
+    return box;
+  };
+
+  // vertical box
+  auto vbox = sptrOf<VBox>();
+
+  // last font used by base (for mono-space atoms following)
+  env.setLastFontId(b->lastFontId());
+
+  // params to layout limits
+  const auto& math = env.mathConsts();
+
+  // over script + space
+  if (o != nullptr && !o->isSpace()) {
+    auto ob = wrap(o, delta / 2);
+    vbox->add(ob);
+    float space = 0.f;
+    if (_over.isAutoSpace) {
+      const auto gapMin = math.upperLimitGapMin() * env.scale();
+      const auto baselineRiseMin = math.upperLimitBaselineRiseMin() * env.scale();
+      space = std::max(baselineRiseMin - o->_depth, gapMin);
+    } else {
+      space = Units::fsize(_over.spaceUnit, _over.space, env);
+    }
+    const auto kern = sptrOf<StrutBox>(0.f, space, 0.f, 0.f);
+    kern->_shift = delta / 2;
+    vbox->add(kern);
+  }
+
+  // base
+  auto center = wrap(b, 0.f);
+  vbox->add(center);
+
+  // calculate future height of the vertical box, to make sure that the
+  // base stays on the baseline
+  const auto h = vbox->_height + vbox->_depth - center->_depth;
+
+  // under script + space
+  if (u != nullptr && !u->isSpace()) {
+    float space = 0.f;
+    if (_under.isAutoSpace) {
+      const auto gapMin = math.lowerLimitGapMin() * env.scale();
+      const auto baselineDropMin = math.lowerLimitBaselineDropMin() * env.scale();
+      space = std::max(baselineDropMin - u->_height, gapMin);
+    } else {
+      space = Units::fsize(_under.spaceUnit, _under.space, env);
+    }
+    const auto kern = sptrOf<StrutBox>(0.f, space, 0.f, 0.f);
+    kern->_shift = delta / 2;
+    vbox->add(kern);
+    auto ub = wrap(u, -delta / 2);
+    vbox->add(ub);
+  }
+
+  // calculate height and depth
+  vbox->_depth = vbox->_height + vbox->_depth - h;
+  vbox->_height = h;
+
+  // if is under accent, adjust with kerning
+  if (_adjustBottom) {
+    vbox->add(sptrOf<StrutBox>(0.f, -env.mathConsts().accentBaseHeight(), 0.f, 0.f));
+  }
+
+  return {vbox, center->_shift - vbox->leftMostPos()};
+}

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

@@ -0,0 +1,103 @@
+#ifndef MICROTEX_ATOM_STACK_H
+#define MICROTEX_ATOM_STACK_H
+
+#include <utility>
+
+#include "atom/atom.h"
+#include "env/units.h"
+
+namespace microtex {
+
+/** Arguments to place stacked atoms */
+struct StackArgs {
+  sptr<Atom> atom = nullptr;
+  UnitType spaceUnit = UnitType::none;
+  float space = 0.f;
+  bool isScript = false;
+  bool isAutoSpace = false;
+
+  inline bool isPresent() const { return atom != nullptr; }
+
+  static inline StackArgs autoSpace(const sptr<Atom>& atom, bool isScript = true) {
+    return {atom, UnitType::none, 0.f, isScript, true};
+  }
+};
+
+struct StackResult {
+  sptr<Box> box;
+  float kernelShift;
+};
+
+enum class StackElement { over, under, base };
+
+/**
+ * An atom representing another atom with an atom above it (if not null)
+ * separated by a kern and in a smaller size depending on "overScriptSize"
+ * and/or an atom under it (if not null) separated by a kern and in a smaller
+ * size depending on "underScriptSize"
+ */
+class StackAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  StackArgs _over;
+  StackArgs _under;
+  float _maxWidth = 0.f;
+  bool _adjustBottom = false;
+  std::vector<StackElement> _order;
+
+  static const std::vector<StackElement> _defaultOrder;
+
+public:
+  explicit StackAtom(std::vector<StackElement> order = _defaultOrder) : _order(std::move(order)) {}
+
+  StackAtom(
+    const sptr<Atom>& base,
+    const StackArgs& args,
+    bool isOver,
+    std::vector<StackElement> order = _defaultOrder
+  )
+      : _base(base), _order(std::move(order)) {
+    if (isOver) {
+      _over = args;
+    } else {
+      _under = args;
+    }
+  }
+
+  StackAtom(
+    const sptr<Atom>& base,
+    StackArgs overArgs,
+    StackArgs underArgs,
+    std::vector<StackElement> order = _defaultOrder
+  )
+      : _base(base),
+        _over(std::move(overArgs)),
+        _under(std::move(underArgs)),
+        _order(std::move(order)) {}
+
+  inline void setBaseAtom(const sptr<Atom>& base) { _base = base; }
+
+  inline void setAdjustBottom(bool adjust) { _adjustBottom = adjust; }
+
+  inline void setOver(StackArgs over) { _over = std::move(over); }
+
+  inline void setUnder(StackArgs under) { _under = std::move(under); }
+
+  inline float getMaxWidth() { return _maxWidth; }
+
+  AtomType leftType() const override {
+    return _base == nullptr ? AtomType::ordinary : _base->leftType();
+  }
+
+  AtomType rightType() const override {
+    return _base == nullptr ? AtomType::ordinary : _base->rightType();
+  }
+
+  sptr<Box> createBox(Env& env) override;
+
+  StackResult createStack(Env& env);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_STACK_H

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

@@ -0,0 +1,17 @@
+#include "atom/atom_text.h"
+
+#include "box/box_single.h"
+#include "env/env.h"
+#include "utils/utf.h"
+
+using namespace std;
+using namespace microtex;
+
+void TextAtom::append(c32 code) {
+  appendToUtf8(_txt, code);
+}
+
+sptr<Box> TextAtom::createBox(Env& env) {
+  auto style = (_mathMode ? env.mathFontStyle() : env.textFontStyle());
+  return sptrOf<TextBox>(_txt, style, Env::fixedTextSize() * env.scale());
+}

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

@@ -0,0 +1,33 @@
+#ifndef MICROTEX_ATOM_TEXT_H
+#define MICROTEX_ATOM_TEXT_H
+
+#include <string>
+
+#include "atom/atom.h"
+
+namespace microtex {
+
+class TextAtom : public Atom {
+private:
+  std::string _txt;
+  bool _mathMode;
+
+public:
+  TextAtom(bool isMathMode) : _mathMode(isMathMode) {}
+
+  TextAtom(std::string str, bool isMathMode) : _txt(std::move(str)), _mathMode(isMathMode) {}
+
+  void append(c32 code);
+
+  inline bool isMathMode() const { return _mathMode; }
+
+  sptr<Box> createBox(Env& env) override;
+
+  AtomType leftType() const override { return AtomType::ordinary; }
+
+  AtomType rightType() const override { return AtomType::ordinary; }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_TEXT_H