unified-latex-util-catcode

What is this?

Functions to identify regions of a unified-latex Abstract Syntax Tree (AST) that need to be reparsed because of different category codes. For example, regions between \makeatletter and \makeatother.

When should I use this?

If you need to identify regions of the AST that need to be reparsed.

Install

npm install @unified-latex/unified-latex-util-catcode

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.

Functions

findExpl3AndAtLetterRegionsInArray(tree)

Find regions between \ExplSyntaxOn...\ExplSyntaxOff and \makeatletter...\makeatother. Returns an object containing regions where one or both syntax's apply.

function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {
  explOnly: Region[];
  atLetterOnly: Region[];
  both: Region[];
};

Parameters

| Param | Type | | :---- | :----------- | | tree | Ast.Node[] |

findRegionInArray(tree, start, end)

Find all contiguous segments in the array that are between start and end blocks. The start and end are functions that determine when a region starts and ends.

function findRegionInArray(
  tree: Ast.Node[],
  start: (node: Ast.Node) => boolean,
  end: (node: Ast.Node) => boolean
): Region[];

Parameters

| Param | Type | | :---- | :---------------------------- | | tree | Ast.Node[] | | start | (node: Ast.Node) => boolean | | end | (node: Ast.Node) => boolean |

hasReparsableMacroNames(tree, allowedTokens)

Checks whether tree has a macro that could be reparsed given the allowedTokens but do not do any reparsing. This function can be used in auto-detection schemes to determine if macro names should actually be reparsed.

function hasReparsableMacroNames(
  tree: Ast.Ast,
  allowedTokens: string | Set<string>
): boolean;

Parameters

| Param | Type | | :------------ | :---------------------- | | tree | Ast.Ast | | allowedTokens | string \| Set<string> |

hasReparsableMacroNamesInArray(tree, allowedTokens)

Checks whether the array has a macro that could be reparsed given the allowedTokens but do not do any reparsing. This function can be used in auto-detection schemes to determine if macro names should actually be reparsed.

function hasReparsableMacroNamesInArray(
  tree: Ast.Node[],
  allowedTokens: Set<string>
): boolean;

Parameters

| Param | Type | | :------------ | :------------ | | tree | Ast.Node[] | | allowedTokens | Set<string> |

reparseExpl3AndAtLetterRegions(tree)

Find regions between \ExplSyntaxOn...\ExplSyntaxOff and \makeatletter...\makeatother and reparse their contents so that the relevant characters (e.g., @, _, and :) become part of the macro names.

function reparseExpl3AndAtLetterRegions(tree: Ast.Ast): void;

Parameters

| Param | Type | | :---- | :-------- | | tree | Ast.Ast |

reparseMacroNames(tree, allowedTokens)

Reparses all macro names so that they may optionally include characters listed in allowedTokens. This is used, for example, when parsing expl3 syntax which allows _ to be used in a macro name (even though _ is normally stops the parsing for a macro name). Thus, a macro \foo_bar:Nn would be parsed as having the name foo_bar:Nn rather than as foo followed by the strings _, bar, :, Nn.

function reparseMacroNames(
  tree: Ast.Ast,
  allowedTokens: string | Set<string>
): void;

Parameters

| Param | Type | | :------------ | :---------------------- | | tree | Ast.Ast | | allowedTokens | string \| Set<string> |

reparseMacroNamesInArray(tree, allowedTokens)

Reparses all macro names in the array so that they may optionally include characters listed in allowedTokens. This is used, for example, when parsing expl3 syntax which allows _ to be used in a macro name (even though _ is normally stops the parsing for a macro name).

function reparseMacroNamesInArray(
  tree: Ast.Node[],
  allowedTokens: Set<string>
): void;

Parameters

| Param | Type | | :------------ | :------------ | | tree | Ast.Node[] | | allowedTokens | Set<string> |