unified-latex-util-parse

What is this?

Functions parse strings to a unified-latex Abstract Syntax Tree (AST).

When should I use this?

If you have a string that you would like to parse to a unified-latex Ast.Ast, or if you are building a plugin for unified() that manipulates LaTeX.

Install

npm install @unified-latex/unified-latex-util-parse
Copy

This package contains both esm and commonjs exports. To explicitly access the esm export, import the .js file. To explicitly access the commonjs export, import the .cjs file.

Plugins

unifiedLatexAstComplier

Unified complier plugin that passes through a LaTeX AST without modification.

Usage

unified().use(unifiedLatexAstComplier)

Type

Plugin<void[], Ast.Root, Ast.Root>

function unifiedLatexAstComplier(): void;
Copy

unifiedLatexFromString

Parse a string to a LaTeX AST.

Usage

unified().use(unifiedLatexFromString[, options])

options

{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; }
Copy

Type

Plugin<{ mode?: "math" | "regular"; macros?: Ast.MacroInfoRecord; environments?: Ast.EnvInfoRecord; flags?: { atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }; }[], string, Ast.Root>

function unifiedLatexFromString(options: {
  mode?: "math" | "regular";
  macros?: Ast.MacroInfoRecord;
  environments?: Ast.EnvInfoRecord;
  flags?: {
    atLetter?: boolean;
    expl3?: boolean;
    autodetectExpl3AndAtLetter?: boolean;
  };
}): void;
Copy

unifiedLatexFromStringMinimal

Parse a string to a LaTeX AST with no post processing. For example, no macro arguments will be attached, etc.

Usage

unified().use(unifiedLatexFromStringMinimal[, options])

options

PluginOptions
Copy

Type

Plugin<PluginOptions[], string, Ast.Root>

function unifiedLatexFromStringMinimal(options: PluginOptions): void;
Copy

Functions

getParser(options)

Returns the default unified-latex parser, or create a new one with the provided unifiedLatexFromString options

function getParser(options: {
  mode?: "math" | "regular";
  macros?: Ast.MacroInfoRecord;
  environments?: Ast.EnvInfoRecord;
  flags?: {
    atLetter?: boolean;
    expl3?: boolean;
    autodetectExpl3AndAtLetter?: boolean;
  };
}): FrozenProcessor<Ast.Root, Ast.Root, Ast.Root, void>;
Copy

Parameters

parse(str)

Parse the string into an AST.

function parse(str: String): Ast.Root;
Copy

Parameters

parseMath(str)

Parse str into an AST. Parsing starts in math mode and a list of nodes is returned (instead of a "root" node).

function parseMath(str: string | Ast.Ast): Ast.Node[];
Copy

Parameters

parseMathMinimal(str)

Parse str to an AST with minimal processing. E.g., macro arguments are not attached to macros, etc. when parsed with this function.

The parsing assumes a math-mode context, so, for example, ^ and _ are parsed as macros (even though arguments are not attached to them).

function parseMathMinimal(str: String): Ast.Node[];
Copy

Parameters

parseMinimal(str)

Parse str to an AST with minimal processing. E.g., macro arguments are not attached to macros, etc. when parsed with this function.

function parseMinimal(str: String): Ast.Root;
Copy

Parameters

Types

PluginOptions

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;
Copy