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

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;

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

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;

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

Type

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

function unifiedLatexFromStringMinimal(options: PluginOptions): void;

unifiedLatexProcessAtLetterAndExplMacros

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.

Usage

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

options

{ atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }

Type

Plugin<{ atLetter?: boolean; expl3?: boolean; autodetectExpl3AndAtLetter?: boolean; }[], Ast.Root, Ast.Root>

function unifiedLatexProcessAtLetterAndExplMacros(options: {
  atLetter?: boolean;
  expl3?: boolean;
  autodetectExpl3AndAtLetter?: boolean;
}): (tree: Ast.Root) => void;

unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse

Unified plugin to process macros and environments. Any environments that contain math content are reparsed (if needed) in math mode.

Usage

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

options

{ environments: Ast.EnvInfoRecord; macros: Ast.MacroInfoRecord; }

Type

Plugin<{ environments: Ast.EnvInfoRecord; macros: Ast.MacroInfoRecord; }[], Ast.Root, Ast.Root>

function unifiedLatexProcessMacrosAndEnvironmentsWithMathReparse(options: {
  environments: Ast.EnvInfoRecord;
  macros: Ast.MacroInfoRecord;
}): (tree: Ast.Root) => void;

unifiedLatexReparseMath

Reparse math environments/macro contents that should have been parsed in math mode but weren't.

Usage

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

options

{ mathEnvs: string[]; mathMacros: string[]; }

Type

Plugin<{ mathEnvs: string[]; mathMacros: string[]; }[], Ast.Root, Ast.Root>

function unifiedLatexReparseMath(options: {
  mathEnvs: string[];
  mathMacros: string[];
}): (tree: Ast.Root) => void;

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

Parameters

| Param | Type | Description | | :------ | :-------------------------------- | -------------------------------------------------- | | options | Omitted | Plugin options of unifiedLatexFromString plugin. |

parse(str)

Parse the string into an AST.

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

Parameters

| Param | Type | | :---- | :------- | | str | String |

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[];

Parameters

| Param | Type | | :---- | :------------------ | | str | string \| Ast.Ast |

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[];

Parameters

| Param | Type | | :---- | :------- | | str | String |

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;

Parameters

| Param | Type | | :---- | :------- | | str | String |

unifiedLatexReparseMathConstructPlugin({ mathEnvs, mathMacros, })

Construct the inner function for the unifiedLatexReparseMath plugin. This function should not be used by libraries.

function unifiedLatexReparseMathConstructPlugin({
  mathEnvs,
  mathMacros,
}: {
  mathEnvs: string[];
  mathMacros: string[];
}): (tree: Ast.Root) => void;

Parameters

| Param | Type | | :-------------------------------------------- | :-------------------------------- | | { mathEnvs, mathMacros, } | Omitted |

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;