@unified-latex/unified-latex-util-parse 1.0.12 → 1.2.0

package/README.md

@@ -51,18 +51,23 @@ Parse a string to a LaTeX AST.
 #### options
 
 ```typescript
-{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; }
+{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; }
 ```
 
 ### Type
 
-`Plugin<{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; }[], string, Ast.Root>`
+`Plugin<{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; }[], string, Ast.Root>`
 
 ```typescript
 function unifiedLatexFromString(options: {
   mode?: "math" | "regular";
   macros?: Ast.MacroInfoRecord;
   environments?: Ast.EnvInfoRecord;
+  flags?: {
+    atLetter?: boolean;
+    expl3?: boolean;
+    autodetectExpl3AndAtLetter?: boolean;
+  };
 }): void;
 ```
 
@@ -165,6 +170,21 @@ export type PluginOptions =
           mode?: "math" | "regular";
           macros?: MacroInfoRecord;
           environments?: EnvInfoRecord;
+          flags?: {
+              /**
+               * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character)
+               */
+              atLetter?: boolean;
+              /**
+               * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)
+               */
+              expl3?: boolean;
+              /**
+               * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.
+               * Defaults to `false`.
+               */
+              autodetectExpl3AndAtLetter?: boolean;
+          };
       }
     | undefined;
 ```

package/index.cjs

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -79,41 +80,57 @@ function unifiedLatexReparseMathConstructPlugin({
   const isMathEnvironment = import_unified_latex_util_match.match.createEnvironmentMatcher(mathEnvs);
   const isMathMacro = import_unified_latex_util_match.match.createMacroMatcher(mathMacros);
   return (tree) => {
-    (0, import_unified_latex_util_visit.visit)(tree, (node) => {
-      if (import_unified_latex_util_match.match.anyMacro(node)) {
-        for (const arg of node.args || []) {
-          if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) {
-            arg.content = parseMathMinimal((0, import_unified_latex_util_print_raw.printRaw)(arg.content));
+    (0, import_unified_latex_util_visit.visit)(
+      tree,
+      (node) => {
+        if (import_unified_latex_util_match.match.anyMacro(node)) {
+          for (const arg of node.args || []) {
+            if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) {
+              arg.content = parseMathMinimal(
+                (0, import_unified_latex_util_print_raw.printRaw)(arg.content)
+              );
+            }
           }
         }
-      }
-      if (import_unified_latex_util_match.match.anyEnvironment(node)) {
-        if (!wasParsedInMathMode(node.content)) {
-          node.content = parseMathMinimal((0, import_unified_latex_util_print_raw.printRaw)(node.content));
+        if (import_unified_latex_util_match.match.anyEnvironment(node)) {
+          if (!wasParsedInMathMode(node.content)) {
+            node.content = parseMathMinimal((0, import_unified_latex_util_print_raw.printRaw)(node.content));
+          }
         }
+      },
+      {
+        test: (node) => isMathEnvironment(node) || isMathMacro(node)
       }
-    }, {
-      test: (node) => isMathEnvironment(node) || isMathMacro(node)
-    });
+    );
   };
 }
 function wasParsedInMathMode(nodes) {
-  return !nodes.some((node) => import_unified_latex_util_match.match.anyString(node) && node.content.length > 1 || import_unified_latex_util_match.match.string(node, "^") || import_unified_latex_util_match.match.string(node, "_"));
+  return !nodes.some(
+    (node) => import_unified_latex_util_match.match.anyString(node) && node.content.length > 1 || import_unified_latex_util_match.match.string(node, "^") || import_unified_latex_util_match.match.string(node, "_")
+  );
 }
 
 // libs/process-macros-and-environments.ts
 var import_unified_latex_util_arguments = require("@unified-latex/unified-latex-util-arguments");
 var import_unified_latex_util_environments = require("@unified-latex/unified-latex-util-environments");
-var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexAttachMacroArguments(options) {
+var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) {
   const { environments = {}, macros = {} } = options || {};
-  const mathMacros = Object.fromEntries(Object.entries(macros).filter(([_, info]) => {
-    var _a;
-    return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
-  }));
-  const mathEnvs = Object.fromEntries(Object.entries(environments).filter(([_, info]) => {
-    var _a;
-    return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
-  }));
+  const mathMacros = Object.fromEntries(
+    Object.entries(macros).filter(
+      ([_, info]) => {
+        var _a;
+        return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
+      }
+    )
+  );
+  const mathEnvs = Object.fromEntries(
+    Object.entries(environments).filter(
+      ([_, info]) => {
+        var _a;
+        return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
+      }
+    )
+  );
   const mathReparser = unifiedLatexReparseMathConstructPlugin({
     mathEnvs: Object.keys(mathEnvs),
     mathMacros: Object.keys(mathMacros)
@@ -121,45 +138,89 @@ var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLa
   const isRelevantEnvironment = import_unified_latex_util_match2.match.createEnvironmentMatcher(environments);
   const isRelevantMathEnvironment = import_unified_latex_util_match2.match.createEnvironmentMatcher(mathEnvs);
   return (tree) => {
-    (0, import_unified_latex_util_visit2.visit)(tree, {
-      enter: (nodes) => {
-        if (!Array.isArray(nodes)) {
-          return;
+    (0, import_unified_latex_util_visit2.visit)(
+      tree,
+      {
+        enter: (nodes) => {
+          if (!Array.isArray(nodes)) {
+            return;
+          }
+          (0, import_unified_latex_util_arguments.attachMacroArgsInArray)(nodes, mathMacros);
+        },
+        leave: (node) => {
+          if (!isRelevantMathEnvironment(node)) {
+            return;
+          }
+          const envName = (0, import_unified_latex_util_print_raw2.printRaw)(node.env);
+          const envInfo = environments[envName];
+          if (!envInfo) {
+            throw new Error(
+              `Could not find environment info for environment "${envName}"`
+            );
+          }
+          (0, import_unified_latex_util_environments.processEnvironment)(node, envInfo);
         }
-        (0, import_unified_latex_util_arguments.attachMacroArgsInArray)(nodes, mathMacros);
       },
-      leave: (node) => {
-        if (!isRelevantMathEnvironment(node)) {
-          return;
-        }
-        const envName = (0, import_unified_latex_util_print_raw2.printRaw)(node.env);
-        const envInfo = environments[envName];
-        if (!envInfo) {
-          throw new Error(`Could not find environment info for environment "${envName}"`);
-        }
-        (0, import_unified_latex_util_environments.processEnvironment)(node, envInfo);
-      }
-    }, { includeArrays: true });
+      { includeArrays: true }
+    );
     mathReparser(tree);
-    (0, import_unified_latex_util_visit2.visit)(tree, {
-      enter: (nodes) => {
-        if (!Array.isArray(nodes)) {
-          return;
+    (0, import_unified_latex_util_visit2.visit)(
+      tree,
+      {
+        enter: (nodes) => {
+          if (!Array.isArray(nodes)) {
+            return;
+          }
+          (0, import_unified_latex_util_arguments.attachMacroArgsInArray)(nodes, macros);
+        },
+        leave: (node) => {
+          if (!isRelevantEnvironment(node)) {
+            return;
+          }
+          const envName = (0, import_unified_latex_util_print_raw2.printRaw)(node.env);
+          const envInfo = environments[envName];
+          if (!envInfo) {
+            throw new Error(
+              `Could not find environment info for environment "${envName}"`
+            );
+          }
+          (0, import_unified_latex_util_environments.processEnvironment)(node, envInfo);
         }
-        (0, import_unified_latex_util_arguments.attachMacroArgsInArray)(nodes, macros);
       },
-      leave: (node) => {
-        if (!isRelevantEnvironment(node)) {
-          return;
-        }
-        const envName = (0, import_unified_latex_util_print_raw2.printRaw)(node.env);
-        const envInfo = environments[envName];
-        if (!envInfo) {
-          throw new Error(`Could not find environment info for environment "${envName}"`);
-        }
-        (0, import_unified_latex_util_environments.processEnvironment)(node, envInfo);
-      }
-    }, { includeArrays: true });
+      { includeArrays: true }
+    );
+  };
+};
+
+// libs/process-at-letter-and-expl-macros.ts
+var import_unified_latex_util_catcode = require("@unified-latex/unified-latex-util-catcode");
+var import_unified_latex_util_catcode2 = require("@unified-latex/unified-latex-util-catcode");
+var unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) {
+  let {
+    atLetter = false,
+    expl3 = false,
+    autodetectExpl3AndAtLetter = false
+  } = options || {};
+  return (tree) => {
+    (0, import_unified_latex_util_catcode.reparseExpl3AndAtLetterRegions)(tree);
+    if (atLetter || expl3) {
+      autodetectExpl3AndAtLetter = false;
+    }
+    if (autodetectExpl3AndAtLetter) {
+      atLetter = (0, import_unified_latex_util_catcode2.hasReparsableMacroNames)(tree, "@");
+      expl3 = (0, import_unified_latex_util_catcode2.hasReparsableMacroNames)(tree, "_");
+    }
+    const charSet = /* @__PURE__ */ new Set();
+    if (atLetter) {
+      charSet.add("@");
+    }
+    if (expl3) {
+      charSet.add(":");
+      charSet.add("_");
+    }
+    if (charSet.size > 0) {
+      (0, import_unified_latex_util_catcode2.reparseMacroNames)(tree, charSet);
+    }
   };
 };
 
@@ -168,11 +229,28 @@ var unifiedLatexFromString = function unifiedLatexFromString2(options) {
   const {
     mode = "regular",
     macros = {},
-    environments = {}
+    environments = {},
+    flags: {
+      atLetter = false,
+      expl3 = false,
+      autodetectExpl3AndAtLetter = false
+    } = {}
   } = options || {};
-  const allMacroInfo = Object.assign({}, macros, ...Object.values(import_unified_latex_ctan.macroInfo));
-  const allEnvInfo = Object.assign({}, environments, ...Object.values(import_unified_latex_ctan.environmentInfo));
-  const fullParser = (0, import_unified.unified)().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {
+  const allMacroInfo = Object.assign(
+    {},
+    macros,
+    ...Object.values(import_unified_latex_ctan.macroInfo)
+  );
+  const allEnvInfo = Object.assign(
+    {},
+    environments,
+    ...Object.values(import_unified_latex_ctan.environmentInfo)
+  );
+  const fullParser = (0, import_unified.unified)().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, {
+    atLetter,
+    expl3,
+    autodetectExpl3AndAtLetter
+  }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {
     macros: allMacroInfo,
     environments: allEnvInfo
   }).use(import_unified_latex_util_trim.unifiedLatexTrimEnvironmentContents).use(import_unified_latex_util_trim.unifiedLatexTrimRoot).use(unifiedLatexAstComplier);

package/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../index.ts", "../libs/compiler-ast.ts", "../libs/plugin-from-string.ts", "../libs/parse-minimal.ts", "../libs/plugin-from-string-minimal.ts", "../libs/process-macros-and-environments.ts", "../libs/reparse-math.ts", "../libs/parse.ts", "../libs/parse-math.ts"],
-  "sourcesContent": ["export * from \"./libs/compiler-ast\";\nexport * from \"./libs/plugin-from-string\";\nexport * from \"./libs/plugin-from-string-minimal\";\nexport * from \"./libs/parse-minimal\";\nexport * from \"./libs/parse\";\nexport * from \"./libs/parse-math\";\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions parse strings to a `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you have a string that you would like to parse to a `unified-latex` `Ast.Ast`, or\n * if you are building a plugin for `unified()` that manipulates LaTeX.\n */\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin<void[], Ast.Root, Ast.Root> =\n    function unifiedLatexAstComplier() {\n        Object.assign(this, { Compiler: (x: Ast.Root) => x });\n    };\n", "import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport {\n    unifiedLatexTrimEnvironmentContents,\n    unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\n\nexport type PluginOptions =\n    | {\n          mode?: \"math\" | \"regular\";\n          macros?: MacroInfoRecord;\n          environments?: EnvInfoRecord;\n      }\n    | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin<PluginOptions[], string, Ast.Root> =\n    function unifiedLatexFromString(options) {\n        const {\n            mode = \"regular\",\n            macros = {},\n            environments = {},\n        } = options || {};\n\n        // Build up a parsing plugin with only unified components\n        const allMacroInfo: MacroInfoRecord = Object.assign(\n            {},\n            macros,\n            ...Object.values(macroInfo)\n        );\n        const allEnvInfo: EnvInfoRecord = Object.assign(\n            {},\n            environments,\n            ...Object.values(environmentInfo)\n        );\n\n        // Build up a parser that will perform all the needed steps\n        const fullParser = unified()\n            .use(unifiedLatexFromStringMinimal, { mode })\n            // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n            // so do a minimal pass first with just those environments.\n            .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n                macros: allMacroInfo,\n                environments: allEnvInfo,\n            })\n            .use(unifiedLatexTrimEnvironmentContents)\n            .use(unifiedLatexTrimRoot)\n            .use(unifiedLatexAstComplier);\n\n        const parser: Parser<Ast.Root> = (str) => {\n            const file = fullParser.processSync({ value: str });\n            return file.result;\n        };\n\n        Object.assign(this, { Parser: parser });\n    };\n", "import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n    return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n    return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n", "import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n    /**\n     * Whether the text will be parsed assuming math mode or not.\n     */\n    mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n    PluginOptions[],\n    string,\n    Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n    const parser: Parser<Ast.Root> = (str) => {\n        if (options?.mode === \"math\") {\n            return {\n                type: \"root\",\n                content: parseMathMinimal(str),\n                _renderInfo: { inMathMode: true },\n            };\n        }\n        return parseMinimal(str);\n    };\n\n    Object.assign(this, { Parser: parser });\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport {\n    unifiedLatexReparseMathConstructPlugin,\n} from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n    | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n    | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n    const { environments = {}, macros = {} } = options || {};\n\n    const mathMacros = Object.fromEntries(\n        Object.entries(macros).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n    const mathEnvs = Object.fromEntries(\n        Object.entries(environments).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n\n    const mathReparser = unifiedLatexReparseMathConstructPlugin({\n        mathEnvs: Object.keys(mathEnvs),\n        mathMacros: Object.keys(mathMacros),\n    });\n\n    const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n    const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n    return (tree) => {\n        // First we attach all arguments/process all nodes/environments that have math content\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, mathMacros);\n                },\n                leave: (node) => {\n                    if (!isRelevantMathEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n\n        // Next we reparse macros/envs that may not have been parsed in math mode\n        mathReparser(tree);\n\n        // Now we attach all arguments/process all environment bodies\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, macros);\n                },\n                leave: (node) => {\n                    if (!isRelevantEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n    };\n};\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n    | {\n          /**\n           * List of environments whose body should be parsed in math mode\n           */\n          mathEnvs: string[];\n          /**\n           * List of macros whose bodies should be parsed in math mode\n           */\n          mathMacros: string[];\n      }\n    | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexReparseMath(options) {\n    const { mathEnvs = [], mathMacros = [] } = options || {};\n\n    return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n    mathEnvs,\n    mathMacros,\n}: {\n    mathEnvs: string[];\n    mathMacros: string[];\n}) {\n    const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n    const isMathMacro = match.createMacroMatcher(mathMacros);\n\n    return (tree: Ast.Root) => {\n        visit(\n            tree,\n            (node) => {\n                if (match.anyMacro(node)) {\n                    for (const arg of node.args || []) {\n                        if (\n                            arg.content.length > 0 &&\n                            !wasParsedInMathMode(arg.content)\n                        ) {\n                            arg.content = parseMathMinimal(\n                                printRaw(arg.content)\n                            );\n                        }\n                    }\n                }\n                if (match.anyEnvironment(node)) {\n                    if (!wasParsedInMathMode(node.content)) {\n                        node.content = parseMathMinimal(printRaw(node.content));\n                    }\n                }\n            },\n            {\n                test: (node) => isMathEnvironment(node) || isMathMacro(node),\n            }\n        );\n    };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n    return !nodes.some(\n        (node) =>\n            // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n            // that we were not parsed in math mode.\n            (match.anyString(node) && node.content.length > 1) ||\n            match.string(node, \"^\") ||\n            match.string(node, \"_\")\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\nconst parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n    return parser.parse(str);\n}\n", "import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n    if (typeof str !== \"string\") {\n        str = printRaw(str);\n    }\n    const file = unified()\n        .use(unifiedLatexFromString, { mode: \"math\" })\n        .use(unifiedLatexAstComplier)\n        .processSync({ value: str });\n    return (file.result as Ast.Root).content;\n}\n"],
-  "mappings": "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",
-  "names": []
+  "sources": ["../index.ts", "../libs/compiler-ast.ts", "../libs/plugin-from-string.ts", "../libs/parse-minimal.ts", "../libs/plugin-from-string-minimal.ts", "../libs/process-macros-and-environments.ts", "../libs/reparse-math.ts", "../libs/process-at-letter-and-expl-macros.ts", "../libs/parse.ts", "../libs/parse-math.ts"],
+  "sourcesContent": ["export * from \"./libs/compiler-ast\";\nexport * from \"./libs/plugin-from-string\";\nexport * from \"./libs/plugin-from-string-minimal\";\nexport * from \"./libs/parse-minimal\";\nexport * from \"./libs/parse\";\nexport * from \"./libs/parse-math\";\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions parse strings to a `unified-latex` Abstract Syntax Tree (AST).\n *\n * ## When should I use this?\n *\n * If you have a string that you would like to parse to a `unified-latex` `Ast.Ast`, or\n * if you are building a plugin for `unified()` that manipulates LaTeX.\n */\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin<void[], Ast.Root, Ast.Root> =\n    function unifiedLatexAstComplier() {\n        Object.assign(this, { Compiler: (x: Ast.Root) => x });\n    };\n", "import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n    EnvInfoRecord,\n    MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n    unifiedLatexTrimEnvironmentContents,\n    unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n    | {\n          mode?: \"math\" | \"regular\";\n          macros?: MacroInfoRecord;\n          environments?: EnvInfoRecord;\n          flags?: {\n              /**\n               * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n               */\n              atLetter?: boolean;\n              /**\n               * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n               */\n              expl3?: boolean;\n              /**\n               * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n               * Defaults to `false`.\n               */\n              autodetectExpl3AndAtLetter?: boolean;\n          };\n      }\n    | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin<PluginOptions[], string, Ast.Root> =\n    function unifiedLatexFromString(options) {\n        const {\n            mode = \"regular\",\n            macros = {},\n            environments = {},\n            flags: {\n                atLetter = false,\n                expl3 = false,\n                autodetectExpl3AndAtLetter = false,\n            } = {},\n        } = options || {};\n\n        // Build up a parsing plugin with only unified components\n        const allMacroInfo: MacroInfoRecord = Object.assign(\n            {},\n            macros,\n            ...Object.values(macroInfo)\n        );\n        const allEnvInfo: EnvInfoRecord = Object.assign(\n            {},\n            environments,\n            ...Object.values(environmentInfo)\n        );\n\n        // Build up a parser that will perform all the needed steps\n        const fullParser = unified()\n            .use(unifiedLatexFromStringMinimal, { mode })\n            .use(unifiedLatexProcessAtLetterAndExplMacros, {\n                atLetter,\n                expl3,\n                autodetectExpl3AndAtLetter,\n            })\n            // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n            // so do a minimal pass first with just those environments.\n            .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n                macros: allMacroInfo,\n                environments: allEnvInfo,\n            })\n            .use(unifiedLatexTrimEnvironmentContents)\n            .use(unifiedLatexTrimRoot)\n            .use(unifiedLatexAstComplier);\n\n        const parser: Parser<Ast.Root> = (str) => {\n            const file = fullParser.processSync({ value: str });\n            return file.result;\n        };\n\n        Object.assign(this, { Parser: parser });\n    };\n", "import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n    return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n    return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n", "import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n    /**\n     * Whether the text will be parsed assuming math mode or not.\n     */\n    mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n    PluginOptions[],\n    string,\n    Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n    const parser: Parser<Ast.Root> = (str) => {\n        if (options?.mode === \"math\") {\n            return {\n                type: \"root\",\n                content: parseMathMinimal(str),\n                _renderInfo: { inMathMode: true },\n            };\n        }\n        return parseMinimal(str);\n    };\n\n    Object.assign(this, { Parser: parser });\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport {\n    unifiedLatexReparseMathConstructPlugin,\n} from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n    | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n    | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n    const { environments = {}, macros = {} } = options || {};\n\n    const mathMacros = Object.fromEntries(\n        Object.entries(macros).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n    const mathEnvs = Object.fromEntries(\n        Object.entries(environments).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n\n    const mathReparser = unifiedLatexReparseMathConstructPlugin({\n        mathEnvs: Object.keys(mathEnvs),\n        mathMacros: Object.keys(mathMacros),\n    });\n\n    const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n    const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n    return (tree) => {\n        // First we attach all arguments/process all nodes/environments that have math content\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, mathMacros);\n                },\n                leave: (node) => {\n                    if (!isRelevantMathEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n\n        // Next we reparse macros/envs that may not have been parsed in math mode\n        mathReparser(tree);\n\n        // Now we attach all arguments/process all environment bodies\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, macros);\n                },\n                leave: (node) => {\n                    if (!isRelevantEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n    };\n};\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n    | {\n          /**\n           * List of environments whose body should be parsed in math mode\n           */\n          mathEnvs: string[];\n          /**\n           * List of macros whose bodies should be parsed in math mode\n           */\n          mathMacros: string[];\n      }\n    | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexReparseMath(options) {\n    const { mathEnvs = [], mathMacros = [] } = options || {};\n\n    return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n    mathEnvs,\n    mathMacros,\n}: {\n    mathEnvs: string[];\n    mathMacros: string[];\n}) {\n    const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n    const isMathMacro = match.createMacroMatcher(mathMacros);\n\n    return (tree: Ast.Root) => {\n        visit(\n            tree,\n            (node) => {\n                if (match.anyMacro(node)) {\n                    for (const arg of node.args || []) {\n                        if (\n                            arg.content.length > 0 &&\n                            !wasParsedInMathMode(arg.content)\n                        ) {\n                            arg.content = parseMathMinimal(\n                                printRaw(arg.content)\n                            );\n                        }\n                    }\n                }\n                if (match.anyEnvironment(node)) {\n                    if (!wasParsedInMathMode(node.content)) {\n                        node.content = parseMathMinimal(printRaw(node.content));\n                    }\n                }\n            },\n            {\n                test: (node) => isMathEnvironment(node) || isMathMacro(node),\n            }\n        );\n    };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n    return !nodes.some(\n        (node) =>\n            // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n            // that we were not parsed in math mode.\n            (match.anyString(node) && node.content.length > 1) ||\n            match.string(node, \"^\") ||\n            match.string(node, \"_\")\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n    hasReparsableMacroNames,\n    reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n    | {\n          /**\n           * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n           * If this option is true, it disables autodetect.\n           */\n          atLetter?: boolean;\n          /**\n           * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n           * If this option is true, it disables autodetect.\n           */\n          expl3?: boolean;\n          /**\n           * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n           * Defaults to `true`.\n           */\n          autodetectExpl3AndAtLetter?: boolean;\n      }\n    | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n    let {\n        atLetter = false,\n        expl3 = false,\n        autodetectExpl3AndAtLetter = false,\n    } = options || {};\n\n    return (tree) => {\n        // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n        reparseExpl3AndAtLetterRegions(tree);\n        if (atLetter || expl3) {\n            autodetectExpl3AndAtLetter = false;\n        }\n        if (autodetectExpl3AndAtLetter) {\n            atLetter = hasReparsableMacroNames(tree, \"@\");\n            // We don't check for the `:` here because it could be prone to misidentification.\n            expl3 = hasReparsableMacroNames(tree, \"_\");\n        }\n        const charSet: Set<string> = new Set();\n        if (atLetter) {\n            charSet.add(\"@\");\n        }\n        if (expl3) {\n            charSet.add(\":\");\n            charSet.add(\"_\");\n        }\n\n        if (charSet.size > 0) {\n            reparseMacroNames(tree, charSet);\n        }\n    };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\nconst parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n    return parser.parse(str);\n}\n", "import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n    if (typeof str !== \"string\") {\n        str = printRaw(str);\n    }\n    const file = unified()\n        .use(unifiedLatexFromString, { mode: \"math\" })\n        .use(unifiedLatexAstComplier)\n        .processSync({ value: str });\n    return (file.result as Ast.Root).content;\n}\n"],
+  "mappings": "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",
+  "names": ["unifiedLatexAstComplier", "unifiedLatexFromStringMinimal", "parser", "import_unified_latex_util_visit", "import_unified_latex_util_match", "import_unified_latex_util_print_raw", "unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse", "import_unified_latex_util_catcode", "unifiedLatexProcessAtLetterAndExplMacros", "unifiedLatexFromString", "parser", "import_unified", "import_unified", "import_unified_latex_util_print_raw"]
 }

package/index.js

@@ -51,41 +51,57 @@ function unifiedLatexReparseMathConstructPlugin({
   const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);
   const isMathMacro = match.createMacroMatcher(mathMacros);
   return (tree) => {
-    visit(tree, (node) => {
-      if (match.anyMacro(node)) {
-        for (const arg of node.args || []) {
-          if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) {
-            arg.content = parseMathMinimal(printRaw(arg.content));
+    visit(
+      tree,
+      (node) => {
+        if (match.anyMacro(node)) {
+          for (const arg of node.args || []) {
+            if (arg.content.length > 0 && !wasParsedInMathMode(arg.content)) {
+              arg.content = parseMathMinimal(
+                printRaw(arg.content)
+              );
+            }
           }
         }
-      }
-      if (match.anyEnvironment(node)) {
-        if (!wasParsedInMathMode(node.content)) {
-          node.content = parseMathMinimal(printRaw(node.content));
+        if (match.anyEnvironment(node)) {
+          if (!wasParsedInMathMode(node.content)) {
+            node.content = parseMathMinimal(printRaw(node.content));
+          }
         }
+      },
+      {
+        test: (node) => isMathEnvironment(node) || isMathMacro(node)
       }
-    }, {
-      test: (node) => isMathEnvironment(node) || isMathMacro(node)
-    });
+    );
   };
 }
 function wasParsedInMathMode(nodes) {
-  return !nodes.some((node) => match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_"));
+  return !nodes.some(
+    (node) => match.anyString(node) && node.content.length > 1 || match.string(node, "^") || match.string(node, "_")
+  );
 }
 
 // libs/process-macros-and-environments.ts
 import { attachMacroArgsInArray } from "@unified-latex/unified-latex-util-arguments";
 import { processEnvironment } from "@unified-latex/unified-latex-util-environments";
-var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexAttachMacroArguments(options) {
+var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse2(options) {
   const { environments = {}, macros = {} } = options || {};
-  const mathMacros = Object.fromEntries(Object.entries(macros).filter(([_, info]) => {
-    var _a;
-    return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
-  }));
-  const mathEnvs = Object.fromEntries(Object.entries(environments).filter(([_, info]) => {
-    var _a;
-    return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
-  }));
+  const mathMacros = Object.fromEntries(
+    Object.entries(macros).filter(
+      ([_, info]) => {
+        var _a;
+        return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
+      }
+    )
+  );
+  const mathEnvs = Object.fromEntries(
+    Object.entries(environments).filter(
+      ([_, info]) => {
+        var _a;
+        return ((_a = info.renderInfo) == null ? void 0 : _a.inMathMode) === true;
+      }
+    )
+  );
   const mathReparser = unifiedLatexReparseMathConstructPlugin({
     mathEnvs: Object.keys(mathEnvs),
     mathMacros: Object.keys(mathMacros)
@@ -93,45 +109,92 @@ var unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse = function unifiedLa
   const isRelevantEnvironment = match2.createEnvironmentMatcher(environments);
   const isRelevantMathEnvironment = match2.createEnvironmentMatcher(mathEnvs);
   return (tree) => {
-    visit2(tree, {
-      enter: (nodes) => {
-        if (!Array.isArray(nodes)) {
-          return;
+    visit2(
+      tree,
+      {
+        enter: (nodes) => {
+          if (!Array.isArray(nodes)) {
+            return;
+          }
+          attachMacroArgsInArray(nodes, mathMacros);
+        },
+        leave: (node) => {
+          if (!isRelevantMathEnvironment(node)) {
+            return;
+          }
+          const envName = printRaw2(node.env);
+          const envInfo = environments[envName];
+          if (!envInfo) {
+            throw new Error(
+              `Could not find environment info for environment "${envName}"`
+            );
+          }
+          processEnvironment(node, envInfo);
         }
-        attachMacroArgsInArray(nodes, mathMacros);
       },
-      leave: (node) => {
-        if (!isRelevantMathEnvironment(node)) {
-          return;
-        }
-        const envName = printRaw2(node.env);
-        const envInfo = environments[envName];
-        if (!envInfo) {
-          throw new Error(`Could not find environment info for environment "${envName}"`);
-        }
-        processEnvironment(node, envInfo);
-      }
-    }, { includeArrays: true });
+      { includeArrays: true }
+    );
     mathReparser(tree);
-    visit2(tree, {
-      enter: (nodes) => {
-        if (!Array.isArray(nodes)) {
-          return;
+    visit2(
+      tree,
+      {
+        enter: (nodes) => {
+          if (!Array.isArray(nodes)) {
+            return;
+          }
+          attachMacroArgsInArray(nodes, macros);
+        },
+        leave: (node) => {
+          if (!isRelevantEnvironment(node)) {
+            return;
+          }
+          const envName = printRaw2(node.env);
+          const envInfo = environments[envName];
+          if (!envInfo) {
+            throw new Error(
+              `Could not find environment info for environment "${envName}"`
+            );
+          }
+          processEnvironment(node, envInfo);
         }
-        attachMacroArgsInArray(nodes, macros);
       },
-      leave: (node) => {
-        if (!isRelevantEnvironment(node)) {
-          return;
-        }
-        const envName = printRaw2(node.env);
-        const envInfo = environments[envName];
-        if (!envInfo) {
-          throw new Error(`Could not find environment info for environment "${envName}"`);
-        }
-        processEnvironment(node, envInfo);
-      }
-    }, { includeArrays: true });
+      { includeArrays: true }
+    );
+  };
+};
+
+// libs/process-at-letter-and-expl-macros.ts
+import { reparseExpl3AndAtLetterRegions } from "@unified-latex/unified-latex-util-catcode";
+import {
+  hasReparsableMacroNames,
+  reparseMacroNames
+} from "@unified-latex/unified-latex-util-catcode";
+var unifiedLatexProcessAtLetterAndExplMacros = function unifiedLatexProcessAtLetterAndExplMacros2(options) {
+  let {
+    atLetter = false,
+    expl3 = false,
+    autodetectExpl3AndAtLetter = false
+  } = options || {};
+  return (tree) => {
+    reparseExpl3AndAtLetterRegions(tree);
+    if (atLetter || expl3) {
+      autodetectExpl3AndAtLetter = false;
+    }
+    if (autodetectExpl3AndAtLetter) {
+      atLetter = hasReparsableMacroNames(tree, "@");
+      expl3 = hasReparsableMacroNames(tree, "_");
+    }
+    const charSet = /* @__PURE__ */ new Set();
+    if (atLetter) {
+      charSet.add("@");
+    }
+    if (expl3) {
+      charSet.add(":");
+      charSet.add("_");
+    }
+    if (charSet.size > 0) {
+      reparseMacroNames(tree, charSet);
+    }
   };
 };
 
@@ -140,11 +203,28 @@ var unifiedLatexFromString = function unifiedLatexFromString2(options) {
   const {
     mode = "regular",
     macros = {},
-    environments = {}
+    environments = {},
+    flags: {
+      atLetter = false,
+      expl3 = false,
+      autodetectExpl3AndAtLetter = false
+    } = {}
   } = options || {};
-  const allMacroInfo = Object.assign({}, macros, ...Object.values(macroInfo));
-  const allEnvInfo = Object.assign({}, environments, ...Object.values(environmentInfo));
-  const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {
+  const allMacroInfo = Object.assign(
+    {},
+    macros,
+    ...Object.values(macroInfo)
+  );
+  const allEnvInfo = Object.assign(
+    {},
+    environments,
+    ...Object.values(environmentInfo)
+  );
+  const fullParser = unified().use(unifiedLatexFromStringMinimal, { mode }).use(unifiedLatexProcessAtLetterAndExplMacros, {
+    atLetter,
+    expl3,
+    autodetectExpl3AndAtLetter
+  }).use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {
     macros: allMacroInfo,
     environments: allEnvInfo
   }).use(unifiedLatexTrimEnvironmentContents).use(unifiedLatexTrimRoot).use(unifiedLatexAstComplier);

package/index.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
-  "sources": ["../libs/compiler-ast.ts", "../libs/plugin-from-string.ts", "../libs/parse-minimal.ts", "../libs/plugin-from-string-minimal.ts", "../libs/process-macros-and-environments.ts", "../libs/reparse-math.ts", "../libs/parse.ts", "../libs/parse-math.ts"],
-  "sourcesContent": ["import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin<void[], Ast.Root, Ast.Root> =\n    function unifiedLatexAstComplier() {\n        Object.assign(this, { Compiler: (x: Ast.Root) => x });\n    };\n", "import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport {\n    unifiedLatexTrimEnvironmentContents,\n    unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\n\nexport type PluginOptions =\n    | {\n          mode?: \"math\" | \"regular\";\n          macros?: MacroInfoRecord;\n          environments?: EnvInfoRecord;\n      }\n    | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin<PluginOptions[], string, Ast.Root> =\n    function unifiedLatexFromString(options) {\n        const {\n            mode = \"regular\",\n            macros = {},\n            environments = {},\n        } = options || {};\n\n        // Build up a parsing plugin with only unified components\n        const allMacroInfo: MacroInfoRecord = Object.assign(\n            {},\n            macros,\n            ...Object.values(macroInfo)\n        );\n        const allEnvInfo: EnvInfoRecord = Object.assign(\n            {},\n            environments,\n            ...Object.values(environmentInfo)\n        );\n\n        // Build up a parser that will perform all the needed steps\n        const fullParser = unified()\n            .use(unifiedLatexFromStringMinimal, { mode })\n            // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n            // so do a minimal pass first with just those environments.\n            .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n                macros: allMacroInfo,\n                environments: allEnvInfo,\n            })\n            .use(unifiedLatexTrimEnvironmentContents)\n            .use(unifiedLatexTrimRoot)\n            .use(unifiedLatexAstComplier);\n\n        const parser: Parser<Ast.Root> = (str) => {\n            const file = fullParser.processSync({ value: str });\n            return file.result;\n        };\n\n        Object.assign(this, { Parser: parser });\n    };\n", "import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n    return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n    return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n", "import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n    /**\n     * Whether the text will be parsed assuming math mode or not.\n     */\n    mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n    PluginOptions[],\n    string,\n    Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n    const parser: Parser<Ast.Root> = (str) => {\n        if (options?.mode === \"math\") {\n            return {\n                type: \"root\",\n                content: parseMathMinimal(str),\n                _renderInfo: { inMathMode: true },\n            };\n        }\n        return parseMinimal(str);\n    };\n\n    Object.assign(this, { Parser: parser });\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport {\n    unifiedLatexReparseMathConstructPlugin,\n} from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n    | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n    | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexAttachMacroArguments(options) {\n    const { environments = {}, macros = {} } = options || {};\n\n    const mathMacros = Object.fromEntries(\n        Object.entries(macros).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n    const mathEnvs = Object.fromEntries(\n        Object.entries(environments).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n\n    const mathReparser = unifiedLatexReparseMathConstructPlugin({\n        mathEnvs: Object.keys(mathEnvs),\n        mathMacros: Object.keys(mathMacros),\n    });\n\n    const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n    const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n    return (tree) => {\n        // First we attach all arguments/process all nodes/environments that have math content\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, mathMacros);\n                },\n                leave: (node) => {\n                    if (!isRelevantMathEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n\n        // Next we reparse macros/envs that may not have been parsed in math mode\n        mathReparser(tree);\n\n        // Now we attach all arguments/process all environment bodies\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, macros);\n                },\n                leave: (node) => {\n                    if (!isRelevantEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n    };\n};\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n    | {\n          /**\n           * List of environments whose body should be parsed in math mode\n           */\n          mathEnvs: string[];\n          /**\n           * List of macros whose bodies should be parsed in math mode\n           */\n          mathMacros: string[];\n      }\n    | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexReparseMath(options) {\n    const { mathEnvs = [], mathMacros = [] } = options || {};\n\n    return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n    mathEnvs,\n    mathMacros,\n}: {\n    mathEnvs: string[];\n    mathMacros: string[];\n}) {\n    const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n    const isMathMacro = match.createMacroMatcher(mathMacros);\n\n    return (tree: Ast.Root) => {\n        visit(\n            tree,\n            (node) => {\n                if (match.anyMacro(node)) {\n                    for (const arg of node.args || []) {\n                        if (\n                            arg.content.length > 0 &&\n                            !wasParsedInMathMode(arg.content)\n                        ) {\n                            arg.content = parseMathMinimal(\n                                printRaw(arg.content)\n                            );\n                        }\n                    }\n                }\n                if (match.anyEnvironment(node)) {\n                    if (!wasParsedInMathMode(node.content)) {\n                        node.content = parseMathMinimal(printRaw(node.content));\n                    }\n                }\n            },\n            {\n                test: (node) => isMathEnvironment(node) || isMathMacro(node),\n            }\n        );\n    };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n    return !nodes.some(\n        (node) =>\n            // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n            // that we were not parsed in math mode.\n            (match.anyString(node) && node.content.length > 1) ||\n            match.string(node, \"^\") ||\n            match.string(node, \"_\")\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\nconst parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n    return parser.parse(str);\n}\n", "import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n    if (typeof str !== \"string\") {\n        str = printRaw(str);\n    }\n    const file = unified()\n        .use(unifiedLatexFromString, { mode: \"math\" })\n        .use(unifiedLatexAstComplier)\n        .processSync({ value: str });\n    return (file.result as Ast.Root).content;\n}\n"],
-  "mappings": "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",
-  "names": []
+  "sources": ["../libs/compiler-ast.ts", "../libs/plugin-from-string.ts", "../libs/parse-minimal.ts", "../libs/plugin-from-string-minimal.ts", "../libs/process-macros-and-environments.ts", "../libs/reparse-math.ts", "../libs/process-at-letter-and-expl-macros.ts", "../libs/parse.ts", "../libs/parse-math.ts"],
+  "sourcesContent": ["import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Unified complier plugin that passes through a LaTeX AST without modification.\n */\nexport const unifiedLatexAstComplier: Plugin<void[], Ast.Root, Ast.Root> =\n    function unifiedLatexAstComplier() {\n        Object.assign(this, { Compiler: (x: Ast.Root) => x });\n    };\n", "import { Plugin, Parser, unified } from \"unified\";\nimport { environmentInfo, macroInfo } from \"@unified-latex/unified-latex-ctan\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport {\n    EnvInfoRecord,\n    MacroInfoRecord,\n} from \"@unified-latex/unified-latex-types\";\nimport {\n    unifiedLatexTrimEnvironmentContents,\n    unifiedLatexTrimRoot,\n} from \"@unified-latex/unified-latex-util-trim\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromStringMinimal } from \"./plugin-from-string-minimal\";\nimport { unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse } from \"./process-macros-and-environments\";\nimport { unifiedLatexProcessAtLetterAndExplMacros } from \"./process-at-letter-and-expl-macros\";\n\nexport type PluginOptions =\n    | {\n          mode?: \"math\" | \"regular\";\n          macros?: MacroInfoRecord;\n          environments?: EnvInfoRecord;\n          flags?: {\n              /**\n               * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character)\n               */\n              atLetter?: boolean;\n              /**\n               * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n               */\n              expl3?: boolean;\n              /**\n               * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n               * Defaults to `false`.\n               */\n              autodetectExpl3AndAtLetter?: boolean;\n          };\n      }\n    | undefined;\n\n/**\n * Parse a string to a LaTeX AST.\n */\nexport const unifiedLatexFromString: Plugin<PluginOptions[], string, Ast.Root> =\n    function unifiedLatexFromString(options) {\n        const {\n            mode = \"regular\",\n            macros = {},\n            environments = {},\n            flags: {\n                atLetter = false,\n                expl3 = false,\n                autodetectExpl3AndAtLetter = false,\n            } = {},\n        } = options || {};\n\n        // Build up a parsing plugin with only unified components\n        const allMacroInfo: MacroInfoRecord = Object.assign(\n            {},\n            macros,\n            ...Object.values(macroInfo)\n        );\n        const allEnvInfo: EnvInfoRecord = Object.assign(\n            {},\n            environments,\n            ...Object.values(environmentInfo)\n        );\n\n        // Build up a parser that will perform all the needed steps\n        const fullParser = unified()\n            .use(unifiedLatexFromStringMinimal, { mode })\n            .use(unifiedLatexProcessAtLetterAndExplMacros, {\n                atLetter,\n                expl3,\n                autodetectExpl3AndAtLetter,\n            })\n            // Math environments that aren't hardcoded into the PEG grammar need to be re-parsed,\n            // so do a minimal pass first with just those environments.\n            .use(unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse, {\n                macros: allMacroInfo,\n                environments: allEnvInfo,\n            })\n            .use(unifiedLatexTrimEnvironmentContents)\n            .use(unifiedLatexTrimRoot)\n            .use(unifiedLatexAstComplier);\n\n        const parser: Parser<Ast.Root> = (str) => {\n            const file = fullParser.processSync({ value: str });\n            return file.result;\n        };\n\n        Object.assign(this, { Parser: parser });\n    };\n", "import { LatexPegParser } from \"@unified-latex/unified-latex-util-pegjs\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n */\nexport function parseMinimal(str: string): Ast.Root {\n    return LatexPegParser.parse(str);\n}\n\n/**\n * Parse `str` to an AST with minimal processing. E.g., macro\n * arguments are not attached to macros, etc. when parsed with this\n * function.\n *\n * The parsing assumes a math-mode context, so, for example, `^` and `_` are\n * parsed as macros (even though arguments are not attached to them).\n */\nexport function parseMathMinimal(str: string): Ast.Node[] {\n    return LatexPegParser.parse(str, { startRule: \"math\" });\n}\n", "import { Plugin, Parser } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { parseMathMinimal, parseMinimal } from \"./parse-minimal\";\n\ntype PluginOptions = {\n    /**\n     * Whether the text will be parsed assuming math mode or not.\n     */\n    mode: \"math\" | \"regular\";\n} | void;\n\n/**\n * Parse a string to a LaTeX AST with no post processing. For example,\n * no macro arguments will be attached, etc.\n */\nexport const unifiedLatexFromStringMinimal: Plugin<\n    PluginOptions[],\n    string,\n    Ast.Root\n> = function unifiedLatexFromStringMinimal(options) {\n    const parser: Parser<Ast.Root> = (str) => {\n        if (options?.mode === \"math\") {\n            return {\n                type: \"root\",\n                content: parseMathMinimal(str),\n                _renderInfo: { inMathMode: true },\n            };\n        }\n        return parseMinimal(str);\n    };\n\n    Object.assign(this, { Parser: parser });\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { EnvInfoRecord, MacroInfoRecord } from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport {\n    unifiedLatexReparseMathConstructPlugin,\n} from \"./reparse-math\";\nimport { attachMacroArgsInArray } from \"@unified-latex/unified-latex-util-arguments\";\nimport { processEnvironment } from \"@unified-latex/unified-latex-util-environments\";\n\ntype PluginOptions =\n    | { environments: EnvInfoRecord; macros: MacroInfoRecord }\n    | undefined;\n\n/**\n * Unified plugin to process macros and environments. Any environments that contain math content\n * are reparsed (if needed) in math mode.\n */\nexport const unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options) {\n    const { environments = {}, macros = {} } = options || {};\n\n    const mathMacros = Object.fromEntries(\n        Object.entries(macros).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n    const mathEnvs = Object.fromEntries(\n        Object.entries(environments).filter(\n            ([_, info]) => info.renderInfo?.inMathMode === true\n        )\n    );\n\n    const mathReparser = unifiedLatexReparseMathConstructPlugin({\n        mathEnvs: Object.keys(mathEnvs),\n        mathMacros: Object.keys(mathMacros),\n    });\n\n    const isRelevantEnvironment = match.createEnvironmentMatcher(environments);\n    const isRelevantMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n\n    return (tree) => {\n        // First we attach all arguments/process all nodes/environments that have math content\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, mathMacros);\n                },\n                leave: (node) => {\n                    if (!isRelevantMathEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n\n        // Next we reparse macros/envs that may not have been parsed in math mode\n        mathReparser(tree);\n\n        // Now we attach all arguments/process all environment bodies\n        visit(\n            tree,\n            {\n                enter: (nodes) => {\n                    if (!Array.isArray(nodes)) {\n                        return;\n                    }\n                    attachMacroArgsInArray(nodes, macros);\n                },\n                leave: (node) => {\n                    if (!isRelevantEnvironment(node)) {\n                        return;\n                    }\n                    const envName = printRaw(node.env);\n                    const envInfo = environments[envName];\n                    if (!envInfo) {\n                        throw new Error(\n                            `Could not find environment info for environment \"${envName}\"`\n                        );\n                    }\n                    processEnvironment(node, envInfo);\n                },\n            },\n            { includeArrays: true }\n        );\n    };\n};\n", "import { Plugin } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { parseMathMinimal } from \"./parse-minimal\";\n\ntype PluginOptions =\n    | {\n          /**\n           * List of environments whose body should be parsed in math mode\n           */\n          mathEnvs: string[];\n          /**\n           * List of macros whose bodies should be parsed in math mode\n           */\n          mathMacros: string[];\n      }\n    | undefined;\n\n/**\n * Reparse math environments/macro contents that should have been parsed in math mode but weren't.\n */\nexport const unifiedLatexReparseMath: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexReparseMath(options) {\n    const { mathEnvs = [], mathMacros = [] } = options || {};\n\n    return unifiedLatexReparseMathConstructPlugin({ mathMacros, mathEnvs });\n};\n\n/**\n * Construct the inner function for the `unifiedLatexReparseMath` plugin. This function should not be used by libraries.\n */\nexport function unifiedLatexReparseMathConstructPlugin({\n    mathEnvs,\n    mathMacros,\n}: {\n    mathEnvs: string[];\n    mathMacros: string[];\n}) {\n    const isMathEnvironment = match.createEnvironmentMatcher(mathEnvs);\n    const isMathMacro = match.createMacroMatcher(mathMacros);\n\n    return (tree: Ast.Root) => {\n        visit(\n            tree,\n            (node) => {\n                if (match.anyMacro(node)) {\n                    for (const arg of node.args || []) {\n                        if (\n                            arg.content.length > 0 &&\n                            !wasParsedInMathMode(arg.content)\n                        ) {\n                            arg.content = parseMathMinimal(\n                                printRaw(arg.content)\n                            );\n                        }\n                    }\n                }\n                if (match.anyEnvironment(node)) {\n                    if (!wasParsedInMathMode(node.content)) {\n                        node.content = parseMathMinimal(printRaw(node.content));\n                    }\n                }\n            },\n            {\n                test: (node) => isMathEnvironment(node) || isMathMacro(node),\n            }\n        );\n    };\n}\n\n/**\n * Use a heuristic to decide whether a string was parsed in math mode. The heuristic\n * looks for strings of length greater than 1 or the failure for \"_\" and \"^\" to be parsed\n * as a macro.\n */\nfunction wasParsedInMathMode(nodes: Ast.Node[]): boolean {\n    return !nodes.some(\n        (node) =>\n            // If there are multi-char strings or ^ and _ have been parsed as strings, we know\n            // that we were not parsed in math mode.\n            (match.anyString(node) && node.content.length > 1) ||\n            match.string(node, \"^\") ||\n            match.string(node, \"_\")\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Plugin } from \"unified\";\nimport { reparseExpl3AndAtLetterRegions } from \"@unified-latex/unified-latex-util-catcode\";\nimport {\n    hasReparsableMacroNames,\n    reparseMacroNames,\n} from \"@unified-latex/unified-latex-util-catcode\";\n\ntype PluginOptions =\n    | {\n          /**\n           * Whether to parse macros as if `\\makeatletter` is set (i.e., parse `@` as a regular macro character).\n           * If this option is true, it disables autodetect.\n           */\n          atLetter?: boolean;\n          /**\n           * Whether to parse macros as if `\\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)\n           * If this option is true, it disables autodetect.\n           */\n          expl3?: boolean;\n          /**\n           * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.\n           * Defaults to `true`.\n           */\n          autodetectExpl3AndAtLetter?: boolean;\n      }\n    | undefined;\n\n/**\n * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.\n * This plugin detects the `\\makeatletter` and `\\ExplSyntaxOn` commands and reprocesses macro names\n * inside of those blocks to include those characters.\n */\nexport const unifiedLatexProcessAtLetterAndExplMacros: Plugin<\n    PluginOptions[],\n    Ast.Root,\n    Ast.Root\n> = function unifiedLatexProcessAtLetterAndExplMacros(options) {\n    let {\n        atLetter = false,\n        expl3 = false,\n        autodetectExpl3AndAtLetter = false,\n    } = options || {};\n\n    return (tree) => {\n        // First we reparse based on explicit \\makeatletter and \\ExplSyntaxOn macros\n        reparseExpl3AndAtLetterRegions(tree);\n        if (atLetter || expl3) {\n            autodetectExpl3AndAtLetter = false;\n        }\n        if (autodetectExpl3AndAtLetter) {\n            atLetter = hasReparsableMacroNames(tree, \"@\");\n            // We don't check for the `:` here because it could be prone to misidentification.\n            expl3 = hasReparsableMacroNames(tree, \"_\");\n        }\n        const charSet: Set<string> = new Set();\n        if (atLetter) {\n            charSet.add(\"@\");\n        }\n        if (expl3) {\n            charSet.add(\":\");\n            charSet.add(\"_\");\n        }\n\n        if (charSet.size > 0) {\n            reparseMacroNames(tree, charSet);\n        }\n    };\n};\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { unified } from \"unified\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\nconst parser = unified().use(unifiedLatexFromString).freeze();\n\n/**\n * Parse the string into an AST.\n */\nexport function parse(str: string): Ast.Root {\n    return parser.parse(str);\n}\n", "import { unified } from \"unified\";\nimport * as Ast from \"@unified-latex/unified-latex-types\";\nimport { printRaw } from \"@unified-latex/unified-latex-util-print-raw\";\nimport { unifiedLatexAstComplier } from \"./compiler-ast\";\nimport { unifiedLatexFromString } from \"./plugin-from-string\";\n\n/**\n * Parse `str` into an AST. Parsing starts in math mode and a list of\n * nodes is returned (instead of a \"root\" node).\n */\nexport function parseMath(str: string | Ast.Ast): Ast.Node[] {\n    if (typeof str !== \"string\") {\n        str = printRaw(str);\n    }\n    const file = unified()\n        .use(unifiedLatexFromString, { mode: \"math\" })\n        .use(unifiedLatexAstComplier)\n        .processSync({ value: str });\n    return (file.result as Ast.Root).content;\n}\n"],
+  "mappings": "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",
+  "names": ["unifiedLatexAstComplier", "unifiedLatexFromStringMinimal", "parser", "visit", "match", "printRaw", "unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse", "match", "visit", "printRaw", "unifiedLatexProcessAtLetterAndExplMacros", "unifiedLatexFromString", "parser", "unified", "unified", "unified", "printRaw", "printRaw", "unified"]
 }

package/libs/plugin-from-string.d.ts

@@ -5,6 +5,21 @@ export declare type PluginOptions = {
     mode?: "math" | "regular";
     macros?: MacroInfoRecord;
     environments?: EnvInfoRecord;
+    flags?: {
+        /**
+         * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character)
+         */
+        atLetter?: boolean;
+        /**
+         * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)
+         */
+        expl3?: boolean;
+        /**
+         * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.
+         * Defaults to `false`.
+         */
+        autodetectExpl3AndAtLetter?: boolean;
+    };
 } | undefined;
 /**
  * Parse a string to a LaTeX AST.

package/libs/plugin-from-string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-from-string.d.ts","sourceRoot":"","sources":["../../libs/plugin-from-string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAmB,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AASpF,oBAAY,aAAa,GACnB;IACI,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,YAAY,CAAC,EAAE,aAAa,CAAC;CAChC,GACD,SAAS,CAAC;AAEhB;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAuCxE,CAAC"}
+{"version":3,"file":"plugin-from-string.d.ts","sourceRoot":"","sources":["../../libs/plugin-from-string.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAmB,MAAM,SAAS,CAAC;AAElD,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EACH,aAAa,EACb,eAAe,EAClB,MAAM,oCAAoC,CAAC;AAU5C,oBAAY,aAAa,GACnB;IACI,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,KAAK,CAAC,EAAE;QACJ;;WAEG;QACH,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB;;WAEG;QACH,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB;;;WAGG;QACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;KACxC,CAAC;CACL,GACD,SAAS,CAAC;AAEhB;;GAEG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,aAAa,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAiDxE,CAAC"}

package/libs/process-at-letter-and-expl-macros.d.ts

@@ -0,0 +1,27 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+import { Plugin } from "unified";
+declare type PluginOptions = {
+    /**
+     * Whether to parse macros as if `\makeatletter` is set (i.e., parse `@` as a regular macro character).
+     * If this option is true, it disables autodetect.
+     */
+    atLetter?: boolean;
+    /**
+     * Whether to parse macros as if `\ExplSyntaxOn` is set (i.e., parse `_` and `:` as a regular macro character)
+     * If this option is true, it disables autodetect.
+     */
+    expl3?: boolean;
+    /**
+     * Attempt to autodetect whether there are macros that look like they should contain `@`, `_`, or `:`.
+     * Defaults to `true`.
+     */
+    autodetectExpl3AndAtLetter?: boolean;
+} | undefined;
+/**
+ * Unified plugin to reprocess macros names to possibly include `@`, `_`, or `:`.
+ * This plugin detects the `\makeatletter` and `\ExplSyntaxOn` commands and reprocesses macro names
+ * inside of those blocks to include those characters.
+ */
+export declare const unifiedLatexProcessAtLetterAndExplMacros: Plugin<PluginOptions[], Ast.Root, Ast.Root>;
+export {};
+//# sourceMappingURL=process-at-letter-and-expl-macros.d.ts.map

package/libs/process-at-letter-and-expl-macros.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-at-letter-and-expl-macros.d.ts","sourceRoot":"","sources":["../../libs/process-at-letter-and-expl-macros.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAOjC,aAAK,aAAa,GACZ;IACI;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACxC,GACD,SAAS,CAAC;AAEhB;;;;GAIG;AACH,eAAO,MAAM,wCAAwC,EAAE,MAAM,CACzD,aAAa,EAAE,EACf,GAAG,CAAC,IAAI,EACR,GAAG,CAAC,IAAI,CAgCX,CAAC"}

package/package.json

@@ -1,19 +1,20 @@
 {
     "name": "@unified-latex/unified-latex-util-parse",
-    "version": "1.0.12",
+    "version": "1.2.0",
     "description": "Tools for manipulating unified-latex ASTs",
     "main": "index.js",
     "type": "module",
     "dependencies": {
-        "@unified-latex/unified-latex-ctan": "^1.0.12",
-        "@unified-latex/unified-latex-types": "^1.0.12",
-        "@unified-latex/unified-latex-util-arguments": "^1.0.12",
-        "@unified-latex/unified-latex-util-environments": "^1.0.12",
-        "@unified-latex/unified-latex-util-match": "^1.0.12",
-        "@unified-latex/unified-latex-util-pegjs": "^1.0.12",
-        "@unified-latex/unified-latex-util-print-raw": "^1.0.12",
-        "@unified-latex/unified-latex-util-trim": "^1.0.12",
-        "@unified-latex/unified-latex-util-visit": "^1.0.12",
+        "@unified-latex/unified-latex-ctan": "^1.2.0",
+        "@unified-latex/unified-latex-types": "^1.2.0",
+        "@unified-latex/unified-latex-util-arguments": "^1.2.0",
+        "@unified-latex/unified-latex-util-catcode": "^1.2.0",
+        "@unified-latex/unified-latex-util-environments": "^1.2.0",
+        "@unified-latex/unified-latex-util-match": "^1.2.0",
+        "@unified-latex/unified-latex-util-pegjs": "^1.2.0",
+        "@unified-latex/unified-latex-util-print-raw": "^1.2.0",
+        "@unified-latex/unified-latex-util-trim": "^1.2.0",
+        "@unified-latex/unified-latex-util-visit": "^1.2.0",
         "unified": "^10.1.2"
     },
     "repository": {