tex2typst 0.0.16 → 0.0.18

package/dist/index.js

@@ -1,27 +1,837 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tex2typst = tex2typst;
-const parser_1 = require("./parser");
-const writer_1 = require("./writer");
-function tex2typst(tex, options) {
-    const opt = {
-        nonStrict: false,
-        preferTypstIntrinsic: true,
-        customTexMacros: {}
-    };
-    if (options) {
-        if (options.nonStrict) {
-            opt.nonStrict = options.nonStrict;
+// src/parser.ts
+import katex from "katex";
+function katexNodeToTexNode(node) {
+  try {
+    if (node.loc) {
+      delete node.loc;
+    }
+    let res = {};
+    switch (node.type) {
+      case "atom":
+        res.type = "atom";
+        res.content = node.text;
+        if (node.text === "\\{" || node.text === "\\}") {
+          res.content = node.text.substring(1);
+        } else if (node.text.startsWith("\\")) {
+          res.type = "symbol";
+        }
+        break;
+      case "mathord":
+      case "textord":
+      case "op":
+      case "cr":
+        res.type = "symbol";
+        res.content = node.text;
+        if (node.type === "op") {
+          res.content = node["name"];
+        } else if (node.type === "cr") {
+          res.content = "\\\\";
+        }
+        break;
+      case "genfrac":
+        res.type = "binaryFunc";
+        if (node["leftDelim"] === "(" && node["rightDelim"] === ")") {
+          res.content = "\\binom";
+        } else {
+          res.content = "\\frac";
+        }
+        res.args = [
+          katexNodeToTexNode(node["numer"]),
+          katexNodeToTexNode(node["denom"])
+        ];
+        break;
+      case "supsub":
+        res.type = "supsub";
+        res.irregularData = {};
+        if (node["base"]) {
+          res.irregularData.base = katexNodeToTexNode(node["base"]);
+        }
+        if (node["sup"]) {
+          res.irregularData.sup = katexNodeToTexNode(node["sup"]);
+        }
+        if (node["sub"]) {
+          res.irregularData.sub = katexNodeToTexNode(node["sub"]);
+        }
+        break;
+      case "mclass":
+      case "ordgroup":
+        res.type = "ordgroup";
+        res.args = node.body.map((n) => katexNodeToTexNode(n));
+        if (res.args.length === 1) {
+          res = res.args[0];
+        }
+        break;
+      case "leftright": {
+        const body = katexNodeToTexNode({
+          type: "ordgroup",
+          mode: "math",
+          body: node.body
+        });
+        res.type = "leftright";
+        let left = node["left"];
+        if (left === "\\{") {
+          left = "{";
         }
-        if (options.preferTypstIntrinsic) {
-            opt.preferTypstIntrinsic = options.preferTypstIntrinsic;
+        let right = node["right"];
+        if (right === "\\}") {
+          right = "}";
         }
-        if (options.customTexMacros) {
-            opt.customTexMacros = options.customTexMacros;
+        const is_atom = (str) => ["(", ")", "[", "]", "{", "}"].includes(str);
+        res.args = [
+          { type: is_atom(left) ? "atom" : "symbol", content: left },
+          body,
+          { type: is_atom(right) ? "atom" : "symbol", content: right }
+        ];
+        break;
+      }
+      case "underline":
+      case "overline":
+        res.type = "unaryFunc";
+        res.content = "\\" + node.type;
+        res.args = [
+          katexNodeToTexNode(node["body"])
+        ];
+        break;
+      case "accent": {
+        res.type = "unaryFunc";
+        res.content = node["label"];
+        res.args = [
+          katexNodeToTexNode(node["base"])
+        ];
+        break;
+      }
+      case "sqrt":
+        if (node["index"]) {
+          res.irregularData = katexNodeToTexNode(node["index"]);
         }
+      case "font":
+      case "operatorname":
+        res.type = "unaryFunc";
+        res.content = "\\" + node.type;
+        if (node.type === "font") {
+          res.content = "\\" + node["font"];
+        }
+        if (Array.isArray(node.body)) {
+          const obj = {
+            type: "ordgroup",
+            mode: "math",
+            body: node.body
+          };
+          res.args = [
+            katexNodeToTexNode(obj)
+          ];
+        } else {
+          res.args = [
+            katexNodeToTexNode(node.body)
+          ];
+        }
+        break;
+      case "horizBrace":
+        res.type = "unaryFunc";
+        res.content = node["label"];
+        res.args = [
+          katexNodeToTexNode(node["base"])
+        ];
+        break;
+      case "array":
+        if (node["colSeparationType"] === "align") {
+          res.type = "align";
+        } else {
+          res.type = "matrix";
+        }
+        res.irregularData = node.body.map((row) => {
+          return row.map((cell) => {
+            if (cell.type !== "styling" || cell.body.length !== 1) {
+              throw new KatexNodeToTexNodeError("Expecting cell.type==='\\styling' and cell.body.length===1", cell);
+            }
+            return katexNodeToTexNode(cell.body[0]);
+          });
+        });
+        break;
+      case "text": {
+        res.type = "text";
+        let str = "";
+        node.body.forEach((n) => {
+          if (n.mode !== "text") {
+            throw new KatexNodeToTexNodeError("Expecting node.mode==='text'", node);
+          }
+          str += n.text;
+        });
+        res.content = str;
+        break;
+      }
+      case "spacing":
+      case "kern":
+        res.type = "empty";
+        res.content = " ";
+        break;
+      case "htmlmathml": {
+        const element = node["mathml"][0]["body"][0];
+        if (element && element.type === "textord" && element.text === "\u2260") {
+          res.type = "symbol";
+          res.content = "\\neq";
+          break;
+        } else {
+        }
+      }
+      case "color":
+        if (Array.isArray(node.body) && node.body.length === 1) {
+          const sub_body = node.body[0];
+          if (sub_body.type === "text") {
+            res.type = "unknownMacro";
+            const joined = sub_body.body.map((n) => n.text).join("");
+            if (/^\\[a-zA-Z]+$/.test(joined)) {
+              res.content = joined.substring(1);
+              break;
+            }
+          }
+        }
+        throw new KatexNodeToTexNodeError(`Unknown error type in parsed result:`, node);
+      default:
+        throw new KatexNodeToTexNodeError(`Unknown node type: ${node.type}`, node);
+        break;
+    }
+    return res;
+  } catch (e) {
+    throw e;
+  }
+}
+function parseTex(tex, customTexMacros) {
+  const macros = {
+    "\\mod": "\\operatorname{SyMb01-mod}",
+    "\\liminf": "\\operatorname{SyMb01-liminf}",
+    "\\limsup": "\\operatorname{SyMb01-limsup}",
+    "\\qquad": "\\operatorname{SyMb01-qquad}",
+    "\\quad": "\\operatorname{SyMb01-quad}",
+    "\\cdots": "\\operatorname{SyMb01-cdots}",
+    "\\colon": "\\operatorname{SyMb01-colon}",
+    "\\imath": "\\operatorname{SyMb01-imath}",
+    "\\iiiint": "\\operatorname{SyMb01-iiiint}",
+    "\\jmath": "\\operatorname{SyMb01-jmath}",
+    "\\vdots": "\\operatorname{SyMb01-vdots}",
+    "\\notin": "\\operatorname{SyMb01-notin}",
+    "\\slash": "\\operatorname{SyMb01-slash}",
+    "\\LaTeX": "\\operatorname{SyMb01-LaTeX}",
+    "\\TeX": "\\operatorname{SyMb01-TeX}",
+    ...customTexMacros
+  };
+  const options = {
+    macros,
+    displayMode: true,
+    strict: "ignore",
+    throwOnError: false
+  };
+  let treeArray = generateParseTree(tex, options);
+  let t = {
+    type: "ordgroup",
+    mode: "math",
+    body: treeArray,
+    loc: {}
+  };
+  return katexNodeToTexNode(t);
+}
+var generateParseTree = katex.__parse;
+
+class KatexNodeToTexNodeError extends Error {
+  node;
+  constructor(message, node) {
+    super(message);
+    this.name = "KatexNodeToTexNodeError";
+    this.node = node;
+  }
+}
+
+// src/map.ts
+var symbolMap = new Map([
+  ["gets", "arrow.l"],
+  ["nonumber", ""],
+  ["vec", "arrow"],
+  ["mathbf", "bold"],
+  ["boldsymbol", "bold"],
+  ["mathfrak", "frak"],
+  ["neq", "eq.not"],
+  ["dot", "dot"],
+  ["ddot", "dot.double"],
+  ["doteq", "dot(eq)"],
+  ["dots", "dots.h"],
+  ["ldots", "dots.h"],
+  ["vdots", "dots.v"],
+  ["ddots", "dots.down"],
+  ["widehat", "hat"],
+  ["widetilde", "tilde"],
+  ["quad", "quad"],
+  ["qquad", "wide"],
+  ["overbrace", "overbrace"],
+  ["underbrace", "underbrace"],
+  ["overline", "overline"],
+  ["underline", "underline"],
+  ["bar", "macron"],
+  ["mathbb", "bb"],
+  ["mathcal", "cal"],
+  ["mathrm", "upright"],
+  ["rm", "upright"],
+  ["pmb", "bold"],
+  ["pm", "plus.minus"],
+  ["mp", "minus.plus"],
+  ["oplus", "xor"],
+  ["boxplus", "plus.square"],
+  ["otimes", "times.circle"],
+  ["boxtimes", "times.square"],
+  ["sim", "tilde"],
+  ["approx", "approx"],
+  ["cong", "tilde.equiv"],
+  ["simeq", "tilde.eq"],
+  ["asymp", "\u224D"],
+  ["equiv", "equiv"],
+  ["propto", "prop"],
+  ["implies", "arrow.r.double.long"],
+  ["Longrightarrow", "arrow.r.double.long"],
+  ["iff", "arrow.l.r.double.long"],
+  ["Longleftrightarrow", "arrow.l.r.double.long"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["longleftrightarrow", "arrow.l.r.long"],
+  ["rightrightarrows", "arrows.rr"],
+  ["lfloor", "\u230A"],
+  ["rfloor", "\u230B"],
+  ["lceil", "\u2308"],
+  ["rceil", "\u2309"],
+  ["Cap", "sect.double"],
+  ["Cup", "union.double"],
+  ["Delta", "Delta"],
+  ["Gamma", "Gamma"],
+  ["Join", "join"],
+  ["Lambda", "Lambda"],
+  ["Longrightarrow", "arrow.r.double.long"],
+  ["Omega", "Omega"],
+  ["Phi", "Phi"],
+  ["Pi", "Pi"],
+  ["Psi", "Psi"],
+  ["Rightarrow", "arrow.double"],
+  ["Sigma", "Sigma"],
+  ["Theta", "Theta"],
+  ["aleph", "alef"],
+  ["alpha", "alpha"],
+  ["angle", "angle"],
+  ["approx", "approx"],
+  ["approxeq", "approx.eq"],
+  ["ast", "ast"],
+  ["beta", "beta"],
+  ["bigcap", "sect.big"],
+  ["bigcirc", "circle.big"],
+  ["bigcup", "union.big"],
+  ["bigodot", "dot.circle.big"],
+  ["bigoplus", "xor.big"],
+  ["bigotimes", "times.circle.big"],
+  ["bigsqcup", "union.sq.big"],
+  ["bigtriangledown", "triangle.b"],
+  ["bigtriangleup", "triangle.t"],
+  ["biguplus", "union.plus.big"],
+  ["bigvee", "or.big"],
+  ["bigwedge", "and.big"],
+  ["bullet", "bullet"],
+  ["cap", "sect"],
+  ["cdot", "dot.op"],
+  ["cdots", "dots.c"],
+  ["checkmark", "checkmark"],
+  ["chi", "chi"],
+  ["circ", "circle.small"],
+  ["colon", "colon"],
+  ["cong", "tilde.equiv"],
+  ["coprod", "product.co"],
+  ["cup", "union"],
+  ["curlyvee", "or.curly"],
+  ["curlywedge", "and.curly"],
+  ["dagger", "dagger"],
+  ["dashv", "tack.l"],
+  ["ddagger", "dagger.double"],
+  ["delta", "delta"],
+  ["ddots", "dots.down"],
+  ["diamond", "diamond"],
+  ["div", "div"],
+  ["divideontimes", "times.div"],
+  ["dotplus", "plus.dot"],
+  ["downarrow", "arrow.b"],
+  ["ell", "ell"],
+  ["emptyset", "nothing"],
+  ["epsilon", "epsilon.alt"],
+  ["equiv", "equiv"],
+  ["eta", "eta"],
+  ["exists", "exists"],
+  ["forall", "forall"],
+  ["gamma", "gamma"],
+  ["ge", "gt.eq"],
+  ["geq", "gt.eq"],
+  ["geqslant", "gt.eq.slant"],
+  ["gg", "gt.double"],
+  ["hbar", "planck.reduce"],
+  ["imath", "dotless.i"],
+  ["iiiint", "intgral.quad"],
+  ["iiint", "integral.triple"],
+  ["iint", "integral.double"],
+  ["in", "in"],
+  ["infty", "infinity"],
+  ["int", "integral"],
+  ["intercal", "top"],
+  ["iota", "iota"],
+  ["jmath", "dotless.j"],
+  ["kappa", "kappa"],
+  ["lambda", "lambda"],
+  ["land", "and"],
+  ["langle", "angle.l"],
+  ["lbrace", "brace.l"],
+  ["lbrack", "bracket.l"],
+  ["ldots", "dots.l"],
+  ["le", "lt.eq"],
+  ["leadsto", "arrow.squiggly"],
+  ["leftarrow", "arrow.l"],
+  ["leftthreetimes", "times.three.l"],
+  ["leftrightarrow", "arrow.l.r"],
+  ["leq", "lt.eq"],
+  ["leqslant", "lt.eq.slant"],
+  ["lhd", "triangle.l"],
+  ["ll", "lt.double"],
+  ["longmapsto", "arrow.long.bar"],
+  ["longrightarrow", "arrow.long"],
+  ["lor", "or"],
+  ["ltimes", "times.l"],
+  ["mapsto", "arrow.bar"],
+  ["measuredangle", "angle.arc"],
+  ["mid", "divides"],
+  ["models", "models"],
+  ["mp", "minus.plus"],
+  ["mu", "mu"],
+  ["nRightarrow", "arrow.double.not"],
+  ["nabla", "nabla"],
+  ["ncong", "tilde.nequiv"],
+  ["ne", "eq.not"],
+  ["neg", "not"],
+  ["neq", "eq.not"],
+  ["nexists", "exists.not"],
+  ["ni", "in.rev"],
+  ["nleftarrow", "arrow.l.not"],
+  ["nleq", "lt.eq.not"],
+  ["nparallel", "parallel.not"],
+  ["ngeq", "gt.eq.not"],
+  ["nmid", "divides.not"],
+  ["notin", "in.not"],
+  ["nrightarrow", "arrow.not"],
+  ["nsim", "tilde.not"],
+  ["nsubseteq", "subset.eq.not"],
+  ["nu", "nu"],
+  ["ntriangleleft", "lt.tri.not"],
+  ["ntriangleright", "gt.tri.not"],
+  ["nwarrow", "arrow.tl"],
+  ["odot", "dot.circle"],
+  ["oint", "integral.cont"],
+  ["oiint", "integral.surf"],
+  ["oiiint", "integral.vol"],
+  ["omega", "omega"],
+  ["ominus", "minus.circle"],
+  ["oplus", "xor"],
+  ["otimes", "times.circle"],
+  ["parallel", "parallel"],
+  ["partial", "diff"],
+  ["perp", "perp"],
+  ["phi", "phi.alt"],
+  ["pi", "pi"],
+  ["pm", "plus.minus"],
+  ["pounds", "pound"],
+  ["prec", "prec"],
+  ["preceq", "prec.eq"],
+  ["prime", "prime"],
+  ["prod", "product"],
+  ["propto", "prop"],
+  ["psi", "psi"],
+  ["rangle", "angle.r"],
+  ["rbrace", "brace.r"],
+  ["rbrack", "bracket.r"],
+  ["rhd", "triangle"],
+  ["rho", "rho"],
+  ["rightarrow", "arrow.r"],
+  ["rightthreetimes", "times.three.r"],
+  ["rtimes", "times.r"],
+  ["setminus", "without"],
+  ["sigma", "sigma"],
+  ["sim", "tilde"],
+  ["simeq", "tilde.eq"],
+  ["slash", "slash"],
+  ["smallsetminus", "without"],
+  ["spadesuit", "suit.spade"],
+  ["sqcap", "sect.sq"],
+  ["sqcup", "union.sq"],
+  ["sqsubseteq", "subset.eq.sq"],
+  ["sqsupseteq", "supset.eq.sq"],
+  ["star", "star"],
+  ["subset", "subset"],
+  ["subseteq", "subset.eq"],
+  ["subsetneq", "subset.neq"],
+  ["succ", "succ"],
+  ["succeq", "succ.eq"],
+  ["sum", "sum"],
+  ["supset", "supset"],
+  ["supseteq", "supset.eq"],
+  ["supsetneq", "supset.neq"],
+  ["swarrow", "arrow.bl"],
+  ["tau", "tau"],
+  ["theta", "theta"],
+  ["times", "times"],
+  ["to", "arrow.r"],
+  ["top", "top"],
+  ["triangle", "triangle.t"],
+  ["triangledown", "triangle.b.small"],
+  ["triangleleft", "triangle.l.small"],
+  ["triangleright", "triangle.r.small"],
+  ["twoheadrightarrow", "arrow.r.twohead"],
+  ["uparrow", "arrow.t"],
+  ["updownarrow", "arrow.t.b"],
+  ["upharpoonright", "harpoon.tr"],
+  ["uplus", "union.plus"],
+  ["upsilon", "upsilon"],
+  ["varepsilon", "epsilon"],
+  ["varnothing", "diameter"],
+  ["varphi", "phi"],
+  ["varpi", "pi.alt"],
+  ["varrho", "rho.alt"],
+  ["varsigma", "sigma.alt"],
+  ["vartheta", "theta.alt"],
+  ["vdash", "tack.r"],
+  ["vdots", "dots.v"],
+  ["vee", "or"],
+  ["wedge", "and"],
+  ["wr", "wreath"],
+  ["xi", "xi"],
+  ["yen", "yen"],
+  ["zeta", "zeta"],
+  ["mathscr", "scr"],
+  ["LaTeX", "#LaTeX"],
+  ["TeX", "#TeX"]
+]);
+
+// src/writer.ts
+function convertToken(token) {
+  if (/^[a-zA-Z0-9]$/.test(token)) {
+    return token;
+  } else if (token === "\\\\") {
+    return "\\\n";
+  } else if (["\\$", "\\#", "\\&", "\\_"].includes(token)) {
+    return token;
+  } else if (token.startsWith("\\")) {
+    const symbol = token.slice(1);
+    if (symbolMap.has(symbol)) {
+      return symbolMap.get(symbol);
+    } else {
+      return symbol;
     }
-    const t = (0, parser_1.parseTex)(tex, opt.customTexMacros);
-    const writer = new writer_1.TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic);
-    writer.append(t);
-    return writer.finalize();
+  }
+  return token;
+}
+var TYPST_INTRINSIC_SYMBOLS = [
+  "dim",
+  "id",
+  "im",
+  "mod",
+  "Pr",
+  "sech",
+  "csch"
+];
+
+class TypstWriterError extends Error {
+  node;
+  constructor(message, node) {
+    super(message);
+    this.name = "TypstWriterError";
+    this.node = node;
+  }
+}
+
+class TypstWriter {
+  nonStrict;
+  preferTypstIntrinsic;
+  buffer = "";
+  queue = [];
+  needSpaceAfterSingleItemScript = false;
+  insideFunctionDepth = 0;
+  constructor(nonStrict, preferTypstIntrinsic) {
+    this.nonStrict = nonStrict;
+    this.preferTypstIntrinsic = preferTypstIntrinsic;
+  }
+  writeBuffer(str) {
+    if (this.needSpaceAfterSingleItemScript && /^[0-9a-zA-Z\(]/.test(str)) {
+      this.buffer += " ";
+    } else {
+      let no_need_space = false;
+      no_need_space ||= /[\(\|]$/.test(this.buffer) && /^\w/.test(str);
+      no_need_space ||= /^[}()_^,;!\|]$/.test(str);
+      no_need_space ||= str === "'";
+      no_need_space ||= /[0-9]$/.test(this.buffer) && /^[0-9]/.test(str);
+      no_need_space ||= /[\(\[{]\s*(-|\+)$/.test(this.buffer) || this.buffer === "-" || this.buffer === "+";
+      no_need_space ||= this.buffer === "";
+      no_need_space ||= /[\s"_^{\(]$/.test(this.buffer);
+      if (!no_need_space) {
+        this.buffer += " ";
+      }
+    }
+    if (this.needSpaceAfterSingleItemScript) {
+      this.needSpaceAfterSingleItemScript = false;
+    }
+    this.buffer += str;
+  }
+  append(node) {
+    if (node.type === "empty") {
+      return;
+    } else if (node.type === "ordgroup") {
+      node.args.forEach((arg) => this.append(arg));
+    } else if (node.type === "atom") {
+      let content = node.content;
+      if (node.content === "," && this.insideFunctionDepth > 0) {
+        content = "comma";
+      }
+      this.queue.push({ type: "atom", content });
+    } else if (node.type === "symbol") {
+      this.queue.push({ type: "symbol", content: node.content });
+    } else if (node.type === "text") {
+      this.queue.push(node);
+    } else if (node.type === "supsub") {
+      let { base, sup, sub } = node.irregularData;
+      if (base && base.type === "unaryFunc" && base.content === "\\overbrace" && sup) {
+        this.append({ type: "binaryFunc", content: "\\overbrace", args: [base.args[0], sup] });
+        return;
+      } else if (base && base.type === "unaryFunc" && base.content === "\\underbrace" && sub) {
+        this.append({ type: "binaryFunc", content: "\\underbrace", args: [base.args[0], sub] });
+        return;
+      }
+      if (!base) {
+        this.queue.push({ type: "text", content: "" });
+      } else {
+        this.appendWithBracketsIfNeeded(base);
+      }
+      let trailing_space_needed = false;
+      const has_prime = sup && sup.type === "symbol" && sup.content === "\\prime";
+      if (has_prime) {
+        this.queue.push({ type: "atom", content: "\'" });
+        trailing_space_needed = false;
+      }
+      if (sub) {
+        this.queue.push({ type: "atom", content: "_" });
+        trailing_space_needed = this.appendWithBracketsIfNeeded(sub);
+      }
+      if (sup && !has_prime) {
+        this.queue.push({ type: "atom", content: "^" });
+        trailing_space_needed = this.appendWithBracketsIfNeeded(sup);
+      }
+      if (trailing_space_needed) {
+        this.queue.push({ type: "softSpace", content: "" });
+      }
+    } else if (node.type === "leftright") {
+      const [left, body, right] = node.args;
+      if (["[]", "()", "{}", "\\lfloor\\rfloor", "\\lceil\\rceil"].includes(left.content + right.content)) {
+        this.append(left);
+        this.append(body);
+        this.append(right);
+        return;
+      }
+      const func_symbol = { type: "symbol", content: "lr" };
+      this.queue.push(func_symbol);
+      this.insideFunctionDepth++;
+      this.queue.push({ type: "atom", content: "(" });
+      this.append(left);
+      this.append(body);
+      this.append(right);
+      this.queue.push({ type: "atom", content: ")" });
+      this.insideFunctionDepth--;
+    } else if (node.type === "binaryFunc") {
+      const func_symbol = { type: "symbol", content: node.content };
+      const [arg0, arg1] = node.args;
+      this.queue.push(func_symbol);
+      this.insideFunctionDepth++;
+      this.queue.push({ type: "atom", content: "(" });
+      this.append(arg0);
+      this.queue.push({ type: "atom", content: "," });
+      this.append(arg1);
+      this.queue.push({ type: "atom", content: ")" });
+      this.insideFunctionDepth--;
+    } else if (node.type === "unaryFunc") {
+      const func_symbol = { type: "symbol", content: node.content };
+      const arg0 = node.args[0];
+      if (node.content === "\\sqrt" && node.irregularData) {
+        func_symbol.content = "root";
+        this.queue.push(func_symbol);
+        this.insideFunctionDepth++;
+        this.queue.push({ type: "atom", content: "(" });
+        this.append(node.irregularData);
+        this.queue.push({ type: "atom", content: "," });
+        this.append(arg0);
+        this.queue.push({ type: "atom", content: ")" });
+        this.insideFunctionDepth--;
+        return;
+      } else if (node.content === "\\mathbb") {
+        const body = node.args[0];
+        if (body.type === "symbol" && /^[A-Z]$/.test(body.content)) {
+          this.queue.push({ type: "symbol", content: body.content + body.content });
+          return;
+        }
+      } else if (node.content === "\\operatorname") {
+        let body = node.args;
+        if (body.length === 1 && body[0].type == "ordgroup") {
+          body = body[0].args;
+        }
+        const text = body.reduce((buff, n) => {
+          buff += convertToken(n.content);
+          return buff;
+        }, "");
+        if (this.preferTypstIntrinsic && TYPST_INTRINSIC_SYMBOLS.includes(text)) {
+          this.queue.push({ type: "symbol", content: text });
+        } else if (text.startsWith("SyMb01-")) {
+          this.queue.push({ type: "symbol", content: "\\" + text.substring(7) });
+        } else {
+          this.queue.push({ type: "symbol", content: "op" });
+          this.queue.push({ type: "atom", content: "(" });
+          this.queue.push({ type: "text", content: text });
+          this.queue.push({ type: "atom", content: ")" });
+        }
+        return;
+      }
+      this.queue.push(func_symbol);
+      this.insideFunctionDepth++;
+      this.queue.push({ type: "atom", content: "(" });
+      this.append(arg0);
+      this.queue.push({ type: "atom", content: ")" });
+      this.insideFunctionDepth--;
+    } else if (node.type === "align") {
+      const matrix = node.irregularData;
+      matrix.forEach((row, i) => {
+        row.forEach((cell, j) => {
+          if (j > 0) {
+            this.queue.push({ type: "atom", content: "&" });
+          }
+          this.append(cell);
+        });
+        if (i < matrix.length - 1) {
+          this.queue.push({ type: "symbol", content: "\\\\" });
+        }
+      });
+    } else if (node.type === "matrix") {
+      const matrix = node.irregularData;
+      this.queue.push({ type: "symbol", content: "mat" });
+      this.insideFunctionDepth++;
+      this.queue.push({ type: "atom", content: "(" });
+      this.queue.push({ type: "symbol", content: "delim: #none, " });
+      matrix.forEach((row, i) => {
+        row.forEach((cell, j) => {
+          if (cell.type === "ordgroup" && cell.args.length === 0) {
+            return;
+          }
+          this.append(cell);
+          if (j < row.length - 1) {
+            this.queue.push({ type: "atom", content: "," });
+          } else {
+            if (i < matrix.length - 1) {
+              this.queue.push({ type: "atom", content: ";" });
+            }
+          }
+        });
+      });
+      this.queue.push({ type: "atom", content: ")" });
+      this.insideFunctionDepth--;
+    } else if (node.type === "unknownMacro") {
+      if (this.nonStrict) {
+        this.queue.push({ type: "symbol", content: node.content });
+      } else {
+        throw new TypstWriterError(`Unknown macro: ${node.content}`, node);
+      }
+    } else {
+      throw new TypstWriterError(`Unimplemented node type to append: ${node.type}`, node);
+    }
+  }
+  flushQueue() {
+    this.queue.forEach((node) => {
+      let str = "";
+      switch (node.type) {
+        case "atom":
+          str = node.content;
+          break;
+        case "symbol":
+          str = convertToken(node.content);
+          break;
+        case "text":
+          str = `"${node.content}"`;
+          break;
+        case "softSpace":
+          this.needSpaceAfterSingleItemScript = true;
+          str = "";
+          break;
+        default:
+          throw new TypstWriterError(`Unexpected node type to stringify: ${node.type}`, node);
+      }
+      if (str !== "") {
+        this.writeBuffer(str);
+      }
+    });
+    this.queue = [];
+  }
+  appendWithBracketsIfNeeded(node) {
+    const is_single_atom = node.type === "atom";
+    const is_single_function = node.type === "unaryFunc" || node.type === "binaryFunc" || node.type === "leftright";
+    const is_single = ["atom", "symbol", "unaryFunc", "binaryFunc", "leftright"].includes(node.type);
+    if (is_single) {
+      this.append(node);
+    } else {
+      this.queue.push({
+        type: "atom",
+        content: "("
+      });
+      this.append(node);
+      this.queue.push({
+        type: "atom",
+        content: ")"
+      });
+    }
+    return is_single;
+  }
+  finalize() {
+    this.flushQueue();
+    const smartFloorPass = function(input) {
+      let res = input.replace(/⌊\s*(.*?)\s*⌋/g, "floor($1)");
+      res = res.replace(/floor\(\)/g, 'floor("")');
+      return res;
+    };
+    const smartCeilPass = function(input) {
+      let res = input.replace(/⌈\s*(.*?)\s*⌉/g, "ceil($1)");
+      res = res.replace(/ceil\(\)/g, 'ceil("")');
+      return res;
+    };
+    this.buffer = smartFloorPass(this.buffer);
+    this.buffer = smartCeilPass(this.buffer);
+    return this.buffer;
+  }
+}
+
+// src/index.ts
+function tex2typst(tex, options) {
+  const opt = {
+    nonStrict: false,
+    preferTypstIntrinsic: true,
+    customTexMacros: {}
+  };
+  if (options) {
+    if (options.nonStrict) {
+      opt.nonStrict = options.nonStrict;
+    }
+    if (options.preferTypstIntrinsic) {
+      opt.preferTypstIntrinsic = options.preferTypstIntrinsic;
+    }
+    if (options.customTexMacros) {
+      opt.customTexMacros = options.customTexMacros;
+    }
+  }
+  const t = parseTex(tex, opt.customTexMacros);
+  const writer2 = new TypstWriter(opt.nonStrict, opt.preferTypstIntrinsic);
+  writer2.append(t);
+  return writer2.finalize();
+}
+if (typeof window !== "undefined") {
+  window.tex2typst = tex2typst;
 }
+export {
+  tex2typst
+};