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

``bash
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.

`typescript
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.

`typescript
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.

`typescript
function hasReparsableMacroNames(
tree: Ast.Ast,
allowedTokens: string | Set
): boolean;
`

Parameters

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

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.

`typescript
function hasReparsableMacroNamesInArray(
tree: Ast.Node[],
allowedTokens: Set
): boolean;
`

Parameters

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

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.

`typescript
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.

`typescript
function reparseMacroNames(
tree: Ast.Ast,
allowedTokens: string | Set
): void;
`

Parameters

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

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).

`typescript
function reparseMacroNamesInArray(
tree: Ast.Node[],
allowedTokens: Set
): void;
`

Parameters

| Param | Type |
| :------------ | :------------ |
| tree | Ast.Node[] |
| allowedTokens | Set` |