@unified-latex/unified-latex-util-catcode 1.1.0

package/README.md

@@ -0,0 +1,162 @@
+<!-- DO NOT MODIFY -->
+<!-- This file was autogenerated by build-docs.ts -->
+<!-- Edit the docstring in index.ts and regenerate -->
+<!-- rather than editing this file directly. -->
+# 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<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.
+
+```typescript
+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.
+
+```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<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).
+
+```typescript
+function reparseMacroNamesInArray(
+  tree: Ast.Node[],
+  allowedTokens: Set<string>
+): void;
+```
+
+**Parameters**
+
+| Param         | Type          |
+| :------------ | :------------ |
+| tree          | `Ast.Node[]`  |
+| allowedTokens | `Set<string>` |

package/index.cjs

@@ -0,0 +1,327 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var unified_latex_util_catcode_exports = {};
+__export(unified_latex_util_catcode_exports, {
+  findExpl3AndAtLetterRegionsInArray: () => findExpl3AndAtLetterRegionsInArray,
+  findRegionInArray: () => findRegionInArray,
+  hasReparsableMacroNames: () => hasReparsableMacroNames,
+  hasReparsableMacroNamesInArray: () => hasReparsableMacroNamesInArray,
+  reparseExpl3AndAtLetterRegions: () => reparseExpl3AndAtLetterRegions,
+  reparseMacroNames: () => reparseMacroNames,
+  reparseMacroNamesInArray: () => reparseMacroNamesInArray
+});
+module.exports = __toCommonJS(unified_latex_util_catcode_exports);
+
+// libs/find-region.ts
+function findRegionInArray(tree, start, end) {
+  const ret = [];
+  let currRegion = { start: void 0, end: tree.length };
+  for (let i = 0; i < tree.length; i++) {
+    const node = tree[i];
+    if (start(node)) {
+      currRegion.start = i;
+    }
+    if (end(node)) {
+      currRegion.end = i + 1;
+      ret.push(currRegion);
+      currRegion = { start: void 0, end: tree.length };
+    }
+  }
+  if (currRegion.start != null) {
+    ret.push(currRegion);
+  }
+  return ret;
+}
+
+// libs/special-regions.ts
+var import_unified_latex_util_match2 = require("@unified-latex/unified-latex-util-match");
+
+// libs/regions.ts
+function refineRegions(regions) {
+  const _regions = [...regions];
+  _regions.sort((a, b) => a.start - b.start);
+  const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));
+  const cutPoints = Array.from(cutPointsSet);
+  cutPoints.sort((a, b) => a - b);
+  const retRegions = [];
+  const retRegionsContainedIn = [];
+  let seekIndex = 0;
+  for (let i = 0; i < cutPoints.length - 1; i++) {
+    const start = cutPoints[i];
+    const end = cutPoints[i + 1];
+    const region = { start, end };
+    const regionContainedIn = /* @__PURE__ */ new Set();
+    let encounteredEndPastStart = false;
+    for (let j = seekIndex; j < _regions.length; j++) {
+      const superRegion = _regions[j];
+      if (superRegion.end >= region.start) {
+        encounteredEndPastStart = true;
+      }
+      if (!encounteredEndPastStart && superRegion.end < region.start) {
+        seekIndex = j + 1;
+        continue;
+      }
+      if (superRegion.start > end) {
+        break;
+      }
+      if (superRegion.start <= region.start && superRegion.end >= region.end) {
+        encounteredEndPastStart = true;
+        regionContainedIn.add(superRegion);
+      }
+    }
+    if (regionContainedIn.size > 0) {
+      retRegions.push(region);
+      retRegionsContainedIn.push(regionContainedIn);
+    }
+  }
+  return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };
+}
+function splitByRegions(array, regionsRecord) {
+  const ret = [];
+  const indices = [0, array.length];
+  const reverseMap = {};
+  for (const [key, records] of Object.entries(regionsRecord)) {
+    indices.push(
+      ...records.flatMap((r) => {
+        reverseMap["" + [r.start, r.end]] = key;
+        return [r.start, r.end];
+      })
+    );
+  }
+  indices.sort((a, b) => a - b);
+  for (let i = 0; i < indices.length - 1; i++) {
+    const start = indices[i];
+    const end = indices[i + 1];
+    if (start === end) {
+      continue;
+    }
+    const regionKey = reverseMap["" + [start, end]];
+    ret.push([regionKey || null, array.slice(start, end)]);
+  }
+  return ret;
+}
+
+// libs/special-regions.ts
+var import_unified_latex_util_visit2 = require("@unified-latex/unified-latex-util-visit");
+
+// libs/reparse-macro-names.ts
+var import_unified_latex_util_match = require("@unified-latex/unified-latex-util-match");
+var import_unified_latex_util_visit = require("@unified-latex/unified-latex-util-visit");
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildWordRegex(allowedSet) {
+  const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`;
+  return new RegExp(regexpStr, "u");
+}
+function hasReparsableMacroNamesInArray(tree, allowedTokens) {
+  for (let i = 0; i < tree.length; i++) {
+    const macro = tree[i];
+    const string = tree[i + 1];
+    if (import_unified_latex_util_match.match.anyMacro(macro) && import_unified_latex_util_match.match.anyString(string)) {
+      if (allowedTokens.has(
+        macro.content.charAt(macro.content.length - 1)
+      ) || allowedTokens.has(string.content.charAt(0))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasReparsableMacroNames(tree, allowedTokens) {
+  if (typeof allowedTokens === "string") {
+    allowedTokens = new Set(allowedTokens.split(""));
+  }
+  const _allowedTokens = allowedTokens;
+  for (const v of _allowedTokens) {
+    if (v.length > 1) {
+      throw new Error(
+        `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.`
+      );
+    }
+  }
+  let ret = false;
+  (0, import_unified_latex_util_visit.visit)(
+    tree,
+    (nodes) => {
+      if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {
+        ret = true;
+        return import_unified_latex_util_visit.EXIT;
+      }
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+  return ret;
+}
+function reparseMacroNamesInArray(tree, allowedTokens) {
+  var _a, _b, _c;
+  const regex = buildWordRegex(allowedTokens);
+  let i = 0;
+  while (i < tree.length) {
+    const macro = tree[i];
+    const string = tree[i + 1];
+    if (import_unified_latex_util_match.match.anyMacro(macro) && (macro.escapeToken == null || macro.escapeToken === "\\") && import_unified_latex_util_match.match.anyString(string) && (allowedTokens.has(
+      macro.content.charAt(macro.content.length - 1)
+    ) || allowedTokens.has(string.content.charAt(0)))) {
+      const match3 = string.content.match(regex);
+      const takeable = match3 ? match3[0] : "";
+      if (takeable.length > 0) {
+        if (takeable.length === string.content.length) {
+          macro.content += string.content;
+          tree.splice(i + 1, 1);
+          if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) {
+            macro.position.end = string.position.end;
+          }
+        } else {
+          macro.content += takeable;
+          string.content = string.content.slice(takeable.length);
+          if ((_b = macro.position) == null ? void 0 : _b.end) {
+            macro.position.end.offset += takeable.length;
+            macro.position.end.column += takeable.length;
+          }
+          if ((_c = string.position) == null ? void 0 : _c.start) {
+            string.position.start.offset += takeable.length;
+            string.position.start.column += takeable.length;
+          }
+        }
+      } else {
+        i++;
+      }
+    } else {
+      ++i;
+    }
+  }
+}
+function reparseMacroNames(tree, allowedTokens) {
+  if (typeof allowedTokens === "string") {
+    allowedTokens = new Set(allowedTokens.split(""));
+  }
+  const _allowedTokens = allowedTokens;
+  for (const v of _allowedTokens) {
+    if (v.length > 1) {
+      throw new Error(
+        `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.`
+      );
+    }
+  }
+  (0, import_unified_latex_util_visit.visit)(
+    tree,
+    (nodes) => {
+      reparseMacroNamesInArray(nodes, _allowedTokens);
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+}
+
+// libs/special-regions.ts
+var expl3Find = {
+  start: import_unified_latex_util_match2.match.createMacroMatcher(["ExplSyntaxOn"]),
+  end: import_unified_latex_util_match2.match.createMacroMatcher(["ExplSyntaxOff"])
+};
+var atLetterFind = {
+  start: import_unified_latex_util_match2.match.createMacroMatcher(["makeatletter"]),
+  end: import_unified_latex_util_match2.match.createMacroMatcher(["makeatother"])
+};
+function findExpl3AndAtLetterRegionsInArray(tree) {
+  const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);
+  const atLetter = findRegionInArray(
+    tree,
+    atLetterFind.start,
+    atLetterFind.end
+  );
+  const regionMap = new Map([
+    ...expl3.map((x) => [x, "expl"]),
+    ...atLetter.map((x) => [x, "atLetter"])
+  ]);
+  const all = refineRegions([...expl3, ...atLetter]);
+  const ret = {
+    explOnly: [],
+    atLetterOnly: [],
+    both: []
+  };
+  for (let i = 0; i < all.regions.length; i++) {
+    const region = all.regions[i];
+    const containedIn = all.regionsContainedIn[i];
+    if (containedIn.size === 2) {
+      ret.both.push(region);
+      continue;
+    }
+    for (const v of containedIn.values()) {
+      if (regionMap.get(v) === "expl") {
+        ret.explOnly.push(region);
+      }
+      if (regionMap.get(v) === "atLetter") {
+        ret.atLetterOnly.push(region);
+      }
+    }
+  }
+  ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);
+  ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);
+  ret.both = ret.both.filter((r) => r.end - r.start > 1);
+  return ret;
+}
+var atLetterSet = /* @__PURE__ */ new Set(["@"]);
+var explSet = /* @__PURE__ */ new Set(["_", ":"]);
+var bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]);
+function reparseExpl3AndAtLetterRegions(tree) {
+  (0, import_unified_latex_util_visit2.visit)(
+    tree,
+    {
+      leave: (nodes) => {
+        const regions = findExpl3AndAtLetterRegionsInArray(nodes);
+        const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length;
+        if (totalNumRegions === 0) {
+          return;
+        }
+        const splits = splitByRegions(nodes, regions);
+        const processed = [];
+        for (const [key, slice] of splits) {
+          switch (key) {
+            case null:
+              processed.push(...slice);
+              continue;
+            case "atLetterOnly":
+              reparseMacroNames(slice, atLetterSet);
+              processed.push(...slice);
+              continue;
+            case "explOnly":
+              reparseMacroNames(slice, explSet);
+              processed.push(...slice);
+              continue;
+            case "both":
+              reparseMacroNames(slice, bothSet);
+              processed.push(...slice);
+              continue;
+            default:
+              throw new Error(
+                `Unexpected case when splitting ${key}`
+              );
+          }
+        }
+        nodes.length = 0;
+        nodes.push(...processed);
+        return import_unified_latex_util_visit2.SKIP;
+      }
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+}
+//# sourceMappingURL=index.cjs.map

package/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../index.ts", "../libs/find-region.ts", "../libs/special-regions.ts", "../libs/regions.ts", "../libs/reparse-macro-names.ts"],
+  "sourcesContent": ["export * from \"./libs/find-region\";\nexport * from \"./libs/special-regions\";\nexport * from \"./libs/reparse-macro-names\";\n\n// NOTE: The docstring comment must be the last item in the index.ts file!\n/**\n * ## What is this?\n *\n * Functions to identify regions of a `unified-latex` Abstract Syntax Tree (AST) that need to be reparsed because of different\n * category codes. For example, regions between `\\makeatletter` and `\\makeatother`.\n *\n * ## When should I use this?\n *\n * If you need to identify regions of the AST that need to be reparsed.\n */\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Region } from \"./regions\";\n\n/**\n * Find all contiguous segments in the array that are between start and end blocks.\n * The `start` and `end` are functions that determine when a region starts and ends.\n */\nexport function findRegionInArray(\n    tree: Ast.Node[],\n    start: (node: Ast.Node) => boolean,\n    end: (node: Ast.Node) => boolean\n): Region[] {\n    const ret: Region[] = [];\n    let currRegion: Region = { start: undefined as any, end: tree.length };\n    for (let i = 0; i < tree.length; i++) {\n        const node = tree[i];\n        if (start(node)) {\n            currRegion.start = i;\n        }\n        if (end(node)) {\n            currRegion.end = i + 1;\n            ret.push(currRegion);\n            currRegion = { start: undefined as any, end: tree.length };\n        }\n    }\n\n    if (currRegion.start != null) {\n        // Regions don't necessarily have to encounter an `end` to end.\n        ret.push(currRegion);\n    }\n    return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { findRegionInArray } from \"./find-region\";\nimport { refineRegions, Region, splitByRegions } from \"./regions\";\nimport { SKIP, visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { reparseMacroNames } from \"./reparse-macro-names\";\n\nconst expl3Find = {\n    start: match.createMacroMatcher([\"ExplSyntaxOn\"]),\n    end: match.createMacroMatcher([\"ExplSyntaxOff\"]),\n};\nconst atLetterFind = {\n    start: match.createMacroMatcher([\"makeatletter\"]),\n    end: match.createMacroMatcher([\"makeatother\"]),\n};\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`.\n * Returns an object containing regions where one or both syntax's apply.\n */\nexport function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {\n    explOnly: Region[];\n    atLetterOnly: Region[];\n    both: Region[];\n} {\n    const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n    const atLetter = findRegionInArray(\n        tree,\n        atLetterFind.start,\n        atLetterFind.end\n    );\n\n    const regionMap = new Map([\n        ...(expl3.map((x) => [x, \"expl\"]) as [Region, \"expl\"][]),\n        ...(atLetter.map((x) => [x, \"atLetter\"]) as [Region, \"atLetter\"][]),\n    ]);\n    const all = refineRegions([...expl3, ...atLetter]);\n\n    const ret = {\n        explOnly: [] as Region[],\n        atLetterOnly: [] as Region[],\n        both: [] as Region[],\n    };\n\n    for (let i = 0; i < all.regions.length; i++) {\n        const region = all.regions[i];\n        const containedIn = all.regionsContainedIn[i];\n        if (containedIn.size === 2) {\n            ret.both.push(region);\n            continue;\n        }\n        for (const v of containedIn.values()) {\n            if (regionMap.get(v) === \"expl\") {\n                ret.explOnly.push(region);\n            }\n            if (regionMap.get(v) === \"atLetter\") {\n                ret.atLetterOnly.push(region);\n            }\n        }\n    }\n\n    // Regions of size 1 only contain the starting/stopping macro, so they should be discarded\n    ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n    ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n    ret.both = ret.both.filter((r) => r.end - r.start > 1);\n\n    return ret;\n}\n\nconst atLetterSet = new Set([\"@\"]);\nconst explSet = new Set([\"_\", \":\"]);\nconst bothSet = new Set([\"_\", \":\", \"@\"]);\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`\n * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become\n * part of the macro names.\n */\nexport function reparseExpl3AndAtLetterRegions(tree: Ast.Ast) {\n    visit(\n        tree,\n        {\n            leave: (nodes) => {\n                const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n                // In all likelihood, we don't need to do any reparsing, so bail early here\n                const totalNumRegions =\n                    regions.both.length +\n                    regions.atLetterOnly.length +\n                    regions.explOnly.length;\n                if (totalNumRegions === 0) {\n                    return;\n                }\n\n                const splits = splitByRegions(nodes, regions);\n                const processed: typeof nodes = [];\n                for (const [key, slice] of splits) {\n                    switch (key) {\n                        case null:\n                            processed.push(...slice);\n                            continue;\n                        case \"atLetterOnly\":\n                            reparseMacroNames(slice, atLetterSet);\n                            processed.push(...slice);\n                            continue;\n                        case \"explOnly\":\n                            reparseMacroNames(slice, explSet);\n                            processed.push(...slice);\n                            continue;\n                        case \"both\":\n                            reparseMacroNames(slice, bothSet);\n                            processed.push(...slice);\n                            continue;\n                        default:\n                            throw new Error(\n                                `Unexpected case when splitting ${key}`\n                            );\n                    }\n                }\n\n                nodes.length = 0;\n                nodes.push(...processed);\n                return SKIP;\n            },\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport type Region = { start: number; end: number };\n\n/**\n * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,\n * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region\n * is a subset of.\n */\nexport function refineRegions(regions: Region[]): {\n    regions: Region[];\n    regionsContainedIn: Set<Region>[];\n} {\n    const _regions = [...regions];\n    _regions.sort((a, b) => a.start - b.start);\n    const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n    const cutPoints = Array.from(cutPointsSet);\n    cutPoints.sort((a, b) => a - b);\n\n    const retRegions: Region[] = [];\n    const retRegionsContainedIn: Set<Region>[] = [];\n\n    // We will be checking what regions we are completely contained in.\n    // Because `_regions` is sorted by start, `seekIndex` will be incremented\n    // by end, so that we don't do too much array testing.\n    let seekIndex = 0;\n    for (let i = 0; i < cutPoints.length - 1; i++) {\n        const start = cutPoints[i];\n        const end = cutPoints[i + 1];\n        const region = { start, end };\n        const regionContainedIn: Set<Region> = new Set();\n\n        let encounteredEndPastStart = false;\n        for (let j = seekIndex; j < _regions.length; j++) {\n            const superRegion = _regions[j];\n            if (superRegion.end >= region.start) {\n                encounteredEndPastStart = true;\n            }\n            if (!encounteredEndPastStart && superRegion.end < region.start) {\n                // In this case, the region (and all regions that came before)\n                // end before the region we are testing, so we may safely skip past it\n                // from here on out.\n                seekIndex = j + 1;\n                continue;\n            }\n\n            if (superRegion.start > end) {\n                // Because `_regions` is sorted, we can stop here\n                break;\n            }\n            if (\n                superRegion.start <= region.start &&\n                superRegion.end >= region.end\n            ) {\n                encounteredEndPastStart = true;\n                regionContainedIn.add(superRegion);\n            }\n        }\n\n        if (regionContainedIn.size > 0) {\n            // We only count if we are contained in a subregion\n            retRegions.push(region);\n            retRegionsContainedIn.push(regionContainedIn);\n        }\n    }\n\n    return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\n\n/**\n * Split an array up into the disjoint regions specified by `regionRecord`.\n * Returned is a list of tuples, the first item being the key of `regionRecord` if there\n * was a corresponding region, or `null` if there was no corresponding region.\n *\n * This function assumes that the regions in `regionRecord` are disjoint and fully contained\n * within the bounds of `array`.\n */\nexport function splitByRegions<\n    T extends unknown,\n    RegionRecord extends Record<string, Region[]>\n>(array: T[], regionsRecord: RegionRecord) {\n    const ret: [keyof RegionRecord | null, T[]][] = [];\n\n    const indices = [0, array.length];\n    const reverseMap: Record<string, keyof RegionRecord> = {};\n    for (const [key, records] of Object.entries(regionsRecord)) {\n        indices.push(\n            ...records.flatMap((r) => {\n                reverseMap[\"\" + [r.start, r.end]] = key;\n                return [r.start, r.end];\n            })\n        );\n    }\n    indices.sort((a, b) => a - b);\n\n    for (let i = 0; i < indices.length - 1; i++) {\n        const start = indices[i];\n        const end = indices[i + 1];\n        if (start === end) {\n            continue;\n        }\n        const regionKey = reverseMap[\"\" + [start, end]];\n\n        ret.push([regionKey || null, array.slice(start, end)]);\n    }\n\n    return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Escape a string so that it can be used to build a regular expression.\n *\n * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n */\nfunction escapeRegExp(str: string) {\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * Build a regular expression that matches everything up to the first non-allowed symbol.\n */\nfunction buildWordRegex(allowedSet: Set<string>): RegExp {\n    // /\\p{L}/ matches all letters, including unicode letters. We join this with\n    // everything allowed in our set to form a regexp like\n    //   /(\\p{L}|_|:)*/u\n    // The `u` at the end allows unicode characters to be matched.\n    const regexpStr = `^(${[\"\\\\p{L}\"]\n        .concat(Array.from(allowedSet).map(escapeRegExp))\n        .join(\"|\")})*`;\n    return new RegExp(regexpStr, \"u\");\n}\n\n/**\n * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNamesInArray(\n    tree: Ast.Node[],\n    allowedTokens: Set<string>\n): boolean {\n    for (let i = 0; i < tree.length; i++) {\n        const macro = tree[i];\n        const string = tree[i + 1];\n        if (match.anyMacro(macro) && match.anyString(string)) {\n            // There are two options. Either the macro ends with the special character,\n            // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n            if (\n                allowedTokens.has(\n                    macro.content.charAt(macro.content.length - 1)\n                ) ||\n                allowedTokens.has(string.content.charAt(0))\n            ) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n\n/**\n * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNames(\n    tree: Ast.Ast,\n    allowedTokens: string | Set<string>\n): boolean {\n    if (typeof allowedTokens === \"string\") {\n        allowedTokens = new Set(allowedTokens.split(\"\"));\n    }\n    // Recast so typescript doesn't complain\n    const _allowedTokens = allowedTokens;\n    for (const v of _allowedTokens) {\n        if (v.length > 1) {\n            throw new Error(\n                `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n            );\n        }\n    }\n\n    let ret = false;\n    visit(\n        tree,\n        (nodes) => {\n            if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n                ret = true;\n                return EXIT;\n            }\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n    return ret;\n}\n\n/**\n * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name).\n */\nexport function reparseMacroNamesInArray(\n    tree: Ast.Node[],\n    allowedTokens: Set<string>\n) {\n    const regex = buildWordRegex(allowedTokens);\n    let i = 0;\n    while (i < tree.length) {\n        const macro = tree[i];\n        const string = tree[i + 1];\n        if (\n            match.anyMacro(macro) &&\n            // The _^ macros in math mode should not be extended no-matter what;\n            // So we check to make sure that the macro we're dealing with has the default escape token.\n            (macro.escapeToken == null || macro.escapeToken === \"\\\\\") &&\n            match.anyString(string) &&\n            // There are two options. Either the macro ends with the special character,\n            // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n            (allowedTokens.has(\n                macro.content.charAt(macro.content.length - 1)\n            ) ||\n                allowedTokens.has(string.content.charAt(0)))\n        ) {\n            // There might be a number somewhere in the string. If so, we should\n            // break the string apart at that number\n            const match = string.content.match(regex);\n            const takeable = match ? match[0] : \"\";\n            if (takeable.length > 0) {\n                if (takeable.length === string.content.length) {\n                    // The whole string can be appended to the macro name\n                    macro.content += string.content;\n                    tree.splice(i + 1, 1);\n\n                    // Preserve the source location if available\n                    if (macro.position && string.position?.end) {\n                        macro.position.end = string.position.end;\n                    }\n                } else {\n                    // Only part of the string can be appended to the macro name\n                    macro.content += takeable;\n                    string.content = string.content.slice(takeable.length);\n\n                    // Preserve the source location if available\n                    if (macro.position?.end) {\n                        macro.position.end.offset += takeable.length;\n                        macro.position.end.column += takeable.length;\n                    }\n                    if (string.position?.start) {\n                        string.position.start.offset += takeable.length;\n                        string.position.start.column += takeable.length;\n                    }\n                }\n            } else {\n                i++;\n            }\n        } else {\n            ++i;\n        }\n    }\n}\n\n/**\n * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name). Thus, a macro `\\foo_bar:Nn` would be parsed as having\n * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`.\n */\nexport function reparseMacroNames(\n    tree: Ast.Ast,\n    allowedTokens: string | Set<string>\n) {\n    if (typeof allowedTokens === \"string\") {\n        allowedTokens = new Set(allowedTokens.split(\"\"));\n    }\n    // Recast so typescript doesn't complain\n    const _allowedTokens = allowedTokens;\n    for (const v of _allowedTokens) {\n        if (v.length > 1) {\n            throw new Error(\n                `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n            );\n        }\n    }\n\n    visit(\n        tree,\n        (nodes) => {\n            reparseMacroNamesInArray(nodes, _allowedTokens);\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n}\n"],
+  "mappings": "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",
+  "names": ["import_unified_latex_util_match", "import_unified_latex_util_visit", "match"]
+}

package/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./libs/find-region";
+export * from "./libs/special-regions";
+export * from "./libs/reparse-macro-names";
+/**
+ * ## 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.
+ */
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAG3C;;;;;;;;;GASG"}

package/index.js

@@ -0,0 +1,304 @@
+// libs/find-region.ts
+function findRegionInArray(tree, start, end) {
+  const ret = [];
+  let currRegion = { start: void 0, end: tree.length };
+  for (let i = 0; i < tree.length; i++) {
+    const node = tree[i];
+    if (start(node)) {
+      currRegion.start = i;
+    }
+    if (end(node)) {
+      currRegion.end = i + 1;
+      ret.push(currRegion);
+      currRegion = { start: void 0, end: tree.length };
+    }
+  }
+  if (currRegion.start != null) {
+    ret.push(currRegion);
+  }
+  return ret;
+}
+
+// libs/special-regions.ts
+import { match as match2 } from "@unified-latex/unified-latex-util-match";
+
+// libs/regions.ts
+function refineRegions(regions) {
+  const _regions = [...regions];
+  _regions.sort((a, b) => a.start - b.start);
+  const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));
+  const cutPoints = Array.from(cutPointsSet);
+  cutPoints.sort((a, b) => a - b);
+  const retRegions = [];
+  const retRegionsContainedIn = [];
+  let seekIndex = 0;
+  for (let i = 0; i < cutPoints.length - 1; i++) {
+    const start = cutPoints[i];
+    const end = cutPoints[i + 1];
+    const region = { start, end };
+    const regionContainedIn = /* @__PURE__ */ new Set();
+    let encounteredEndPastStart = false;
+    for (let j = seekIndex; j < _regions.length; j++) {
+      const superRegion = _regions[j];
+      if (superRegion.end >= region.start) {
+        encounteredEndPastStart = true;
+      }
+      if (!encounteredEndPastStart && superRegion.end < region.start) {
+        seekIndex = j + 1;
+        continue;
+      }
+      if (superRegion.start > end) {
+        break;
+      }
+      if (superRegion.start <= region.start && superRegion.end >= region.end) {
+        encounteredEndPastStart = true;
+        regionContainedIn.add(superRegion);
+      }
+    }
+    if (regionContainedIn.size > 0) {
+      retRegions.push(region);
+      retRegionsContainedIn.push(regionContainedIn);
+    }
+  }
+  return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };
+}
+function splitByRegions(array, regionsRecord) {
+  const ret = [];
+  const indices = [0, array.length];
+  const reverseMap = {};
+  for (const [key, records] of Object.entries(regionsRecord)) {
+    indices.push(
+      ...records.flatMap((r) => {
+        reverseMap["" + [r.start, r.end]] = key;
+        return [r.start, r.end];
+      })
+    );
+  }
+  indices.sort((a, b) => a - b);
+  for (let i = 0; i < indices.length - 1; i++) {
+    const start = indices[i];
+    const end = indices[i + 1];
+    if (start === end) {
+      continue;
+    }
+    const regionKey = reverseMap["" + [start, end]];
+    ret.push([regionKey || null, array.slice(start, end)]);
+  }
+  return ret;
+}
+
+// libs/special-regions.ts
+import { SKIP, visit as visit2 } from "@unified-latex/unified-latex-util-visit";
+
+// libs/reparse-macro-names.ts
+import { match } from "@unified-latex/unified-latex-util-match";
+import { EXIT, visit } from "@unified-latex/unified-latex-util-visit";
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildWordRegex(allowedSet) {
+  const regexpStr = `^(${["\\p{L}"].concat(Array.from(allowedSet).map(escapeRegExp)).join("|")})*`;
+  return new RegExp(regexpStr, "u");
+}
+function hasReparsableMacroNamesInArray(tree, allowedTokens) {
+  for (let i = 0; i < tree.length; i++) {
+    const macro = tree[i];
+    const string = tree[i + 1];
+    if (match.anyMacro(macro) && match.anyString(string)) {
+      if (allowedTokens.has(
+        macro.content.charAt(macro.content.length - 1)
+      ) || allowedTokens.has(string.content.charAt(0))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasReparsableMacroNames(tree, allowedTokens) {
+  if (typeof allowedTokens === "string") {
+    allowedTokens = new Set(allowedTokens.split(""));
+  }
+  const _allowedTokens = allowedTokens;
+  for (const v of _allowedTokens) {
+    if (v.length > 1) {
+      throw new Error(
+        `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.`
+      );
+    }
+  }
+  let ret = false;
+  visit(
+    tree,
+    (nodes) => {
+      if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {
+        ret = true;
+        return EXIT;
+      }
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+  return ret;
+}
+function reparseMacroNamesInArray(tree, allowedTokens) {
+  var _a, _b, _c;
+  const regex = buildWordRegex(allowedTokens);
+  let i = 0;
+  while (i < tree.length) {
+    const macro = tree[i];
+    const string = tree[i + 1];
+    if (match.anyMacro(macro) && (macro.escapeToken == null || macro.escapeToken === "\\") && match.anyString(string) && (allowedTokens.has(
+      macro.content.charAt(macro.content.length - 1)
+    ) || allowedTokens.has(string.content.charAt(0)))) {
+      const match3 = string.content.match(regex);
+      const takeable = match3 ? match3[0] : "";
+      if (takeable.length > 0) {
+        if (takeable.length === string.content.length) {
+          macro.content += string.content;
+          tree.splice(i + 1, 1);
+          if (macro.position && ((_a = string.position) == null ? void 0 : _a.end)) {
+            macro.position.end = string.position.end;
+          }
+        } else {
+          macro.content += takeable;
+          string.content = string.content.slice(takeable.length);
+          if ((_b = macro.position) == null ? void 0 : _b.end) {
+            macro.position.end.offset += takeable.length;
+            macro.position.end.column += takeable.length;
+          }
+          if ((_c = string.position) == null ? void 0 : _c.start) {
+            string.position.start.offset += takeable.length;
+            string.position.start.column += takeable.length;
+          }
+        }
+      } else {
+        i++;
+      }
+    } else {
+      ++i;
+    }
+  }
+}
+function reparseMacroNames(tree, allowedTokens) {
+  if (typeof allowedTokens === "string") {
+    allowedTokens = new Set(allowedTokens.split(""));
+  }
+  const _allowedTokens = allowedTokens;
+  for (const v of _allowedTokens) {
+    if (v.length > 1) {
+      throw new Error(
+        `Only single characters are allowed as \`allowedTokens\` when reparsing macro names, not \`${v}\`.`
+      );
+    }
+  }
+  visit(
+    tree,
+    (nodes) => {
+      reparseMacroNamesInArray(nodes, _allowedTokens);
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+}
+
+// libs/special-regions.ts
+var expl3Find = {
+  start: match2.createMacroMatcher(["ExplSyntaxOn"]),
+  end: match2.createMacroMatcher(["ExplSyntaxOff"])
+};
+var atLetterFind = {
+  start: match2.createMacroMatcher(["makeatletter"]),
+  end: match2.createMacroMatcher(["makeatother"])
+};
+function findExpl3AndAtLetterRegionsInArray(tree) {
+  const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);
+  const atLetter = findRegionInArray(
+    tree,
+    atLetterFind.start,
+    atLetterFind.end
+  );
+  const regionMap = new Map([
+    ...expl3.map((x) => [x, "expl"]),
+    ...atLetter.map((x) => [x, "atLetter"])
+  ]);
+  const all = refineRegions([...expl3, ...atLetter]);
+  const ret = {
+    explOnly: [],
+    atLetterOnly: [],
+    both: []
+  };
+  for (let i = 0; i < all.regions.length; i++) {
+    const region = all.regions[i];
+    const containedIn = all.regionsContainedIn[i];
+    if (containedIn.size === 2) {
+      ret.both.push(region);
+      continue;
+    }
+    for (const v of containedIn.values()) {
+      if (regionMap.get(v) === "expl") {
+        ret.explOnly.push(region);
+      }
+      if (regionMap.get(v) === "atLetter") {
+        ret.atLetterOnly.push(region);
+      }
+    }
+  }
+  ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);
+  ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);
+  ret.both = ret.both.filter((r) => r.end - r.start > 1);
+  return ret;
+}
+var atLetterSet = /* @__PURE__ */ new Set(["@"]);
+var explSet = /* @__PURE__ */ new Set(["_", ":"]);
+var bothSet = /* @__PURE__ */ new Set(["_", ":", "@"]);
+function reparseExpl3AndAtLetterRegions(tree) {
+  visit2(
+    tree,
+    {
+      leave: (nodes) => {
+        const regions = findExpl3AndAtLetterRegionsInArray(nodes);
+        const totalNumRegions = regions.both.length + regions.atLetterOnly.length + regions.explOnly.length;
+        if (totalNumRegions === 0) {
+          return;
+        }
+        const splits = splitByRegions(nodes, regions);
+        const processed = [];
+        for (const [key, slice] of splits) {
+          switch (key) {
+            case null:
+              processed.push(...slice);
+              continue;
+            case "atLetterOnly":
+              reparseMacroNames(slice, atLetterSet);
+              processed.push(...slice);
+              continue;
+            case "explOnly":
+              reparseMacroNames(slice, explSet);
+              processed.push(...slice);
+              continue;
+            case "both":
+              reparseMacroNames(slice, bothSet);
+              processed.push(...slice);
+              continue;
+            default:
+              throw new Error(
+                `Unexpected case when splitting ${key}`
+              );
+          }
+        }
+        nodes.length = 0;
+        nodes.push(...processed);
+        return SKIP;
+      }
+    },
+    { includeArrays: true, test: Array.isArray }
+  );
+}
+export {
+  findExpl3AndAtLetterRegionsInArray,
+  findRegionInArray,
+  hasReparsableMacroNames,
+  hasReparsableMacroNamesInArray,
+  reparseExpl3AndAtLetterRegions,
+  reparseMacroNames,
+  reparseMacroNamesInArray
+};
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../libs/find-region.ts", "../libs/special-regions.ts", "../libs/regions.ts", "../libs/reparse-macro-names.ts"],
+  "sourcesContent": ["import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { Region } from \"./regions\";\n\n/**\n * Find all contiguous segments in the array that are between start and end blocks.\n * The `start` and `end` are functions that determine when a region starts and ends.\n */\nexport function findRegionInArray(\n    tree: Ast.Node[],\n    start: (node: Ast.Node) => boolean,\n    end: (node: Ast.Node) => boolean\n): Region[] {\n    const ret: Region[] = [];\n    let currRegion: Region = { start: undefined as any, end: tree.length };\n    for (let i = 0; i < tree.length; i++) {\n        const node = tree[i];\n        if (start(node)) {\n            currRegion.start = i;\n        }\n        if (end(node)) {\n            currRegion.end = i + 1;\n            ret.push(currRegion);\n            currRegion = { start: undefined as any, end: tree.length };\n        }\n    }\n\n    if (currRegion.start != null) {\n        // Regions don't necessarily have to encounter an `end` to end.\n        ret.push(currRegion);\n    }\n    return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { findRegionInArray } from \"./find-region\";\nimport { refineRegions, Region, splitByRegions } from \"./regions\";\nimport { SKIP, visit } from \"@unified-latex/unified-latex-util-visit\";\nimport { reparseMacroNames } from \"./reparse-macro-names\";\n\nconst expl3Find = {\n    start: match.createMacroMatcher([\"ExplSyntaxOn\"]),\n    end: match.createMacroMatcher([\"ExplSyntaxOff\"]),\n};\nconst atLetterFind = {\n    start: match.createMacroMatcher([\"makeatletter\"]),\n    end: match.createMacroMatcher([\"makeatother\"]),\n};\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`.\n * Returns an object containing regions where one or both syntax's apply.\n */\nexport function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {\n    explOnly: Region[];\n    atLetterOnly: Region[];\n    both: Region[];\n} {\n    const expl3 = findRegionInArray(tree, expl3Find.start, expl3Find.end);\n    const atLetter = findRegionInArray(\n        tree,\n        atLetterFind.start,\n        atLetterFind.end\n    );\n\n    const regionMap = new Map([\n        ...(expl3.map((x) => [x, \"expl\"]) as [Region, \"expl\"][]),\n        ...(atLetter.map((x) => [x, \"atLetter\"]) as [Region, \"atLetter\"][]),\n    ]);\n    const all = refineRegions([...expl3, ...atLetter]);\n\n    const ret = {\n        explOnly: [] as Region[],\n        atLetterOnly: [] as Region[],\n        both: [] as Region[],\n    };\n\n    for (let i = 0; i < all.regions.length; i++) {\n        const region = all.regions[i];\n        const containedIn = all.regionsContainedIn[i];\n        if (containedIn.size === 2) {\n            ret.both.push(region);\n            continue;\n        }\n        for (const v of containedIn.values()) {\n            if (regionMap.get(v) === \"expl\") {\n                ret.explOnly.push(region);\n            }\n            if (regionMap.get(v) === \"atLetter\") {\n                ret.atLetterOnly.push(region);\n            }\n        }\n    }\n\n    // Regions of size 1 only contain the starting/stopping macro, so they should be discarded\n    ret.explOnly = ret.explOnly.filter((r) => r.end - r.start > 1);\n    ret.atLetterOnly = ret.atLetterOnly.filter((r) => r.end - r.start > 1);\n    ret.both = ret.both.filter((r) => r.end - r.start > 1);\n\n    return ret;\n}\n\nconst atLetterSet = new Set([\"@\"]);\nconst explSet = new Set([\"_\", \":\"]);\nconst bothSet = new Set([\"_\", \":\", \"@\"]);\n\n/**\n * Find regions between `\\ExplSyntaxOn...\\ExplSyntaxOff` and `\\makeatletter...\\makeatother`\n * and reparse their contents so that the relevant characters (e.g., `@`, `_`, and `:`) become\n * part of the macro names.\n */\nexport function reparseExpl3AndAtLetterRegions(tree: Ast.Ast) {\n    visit(\n        tree,\n        {\n            leave: (nodes) => {\n                const regions = findExpl3AndAtLetterRegionsInArray(nodes);\n                // In all likelihood, we don't need to do any reparsing, so bail early here\n                const totalNumRegions =\n                    regions.both.length +\n                    regions.atLetterOnly.length +\n                    regions.explOnly.length;\n                if (totalNumRegions === 0) {\n                    return;\n                }\n\n                const splits = splitByRegions(nodes, regions);\n                const processed: typeof nodes = [];\n                for (const [key, slice] of splits) {\n                    switch (key) {\n                        case null:\n                            processed.push(...slice);\n                            continue;\n                        case \"atLetterOnly\":\n                            reparseMacroNames(slice, atLetterSet);\n                            processed.push(...slice);\n                            continue;\n                        case \"explOnly\":\n                            reparseMacroNames(slice, explSet);\n                            processed.push(...slice);\n                            continue;\n                        case \"both\":\n                            reparseMacroNames(slice, bothSet);\n                            processed.push(...slice);\n                            continue;\n                        default:\n                            throw new Error(\n                                `Unexpected case when splitting ${key}`\n                            );\n                    }\n                }\n\n                nodes.length = 0;\n                nodes.push(...processed);\n                return SKIP;\n            },\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\n\nexport type Region = { start: number; end: number };\n\n/**\n * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,\n * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region\n * is a subset of.\n */\nexport function refineRegions(regions: Region[]): {\n    regions: Region[];\n    regionsContainedIn: Set<Region>[];\n} {\n    const _regions = [...regions];\n    _regions.sort((a, b) => a.start - b.start);\n    const cutPointsSet = new Set(_regions.flatMap((r) => [r.start, r.end]));\n    const cutPoints = Array.from(cutPointsSet);\n    cutPoints.sort((a, b) => a - b);\n\n    const retRegions: Region[] = [];\n    const retRegionsContainedIn: Set<Region>[] = [];\n\n    // We will be checking what regions we are completely contained in.\n    // Because `_regions` is sorted by start, `seekIndex` will be incremented\n    // by end, so that we don't do too much array testing.\n    let seekIndex = 0;\n    for (let i = 0; i < cutPoints.length - 1; i++) {\n        const start = cutPoints[i];\n        const end = cutPoints[i + 1];\n        const region = { start, end };\n        const regionContainedIn: Set<Region> = new Set();\n\n        let encounteredEndPastStart = false;\n        for (let j = seekIndex; j < _regions.length; j++) {\n            const superRegion = _regions[j];\n            if (superRegion.end >= region.start) {\n                encounteredEndPastStart = true;\n            }\n            if (!encounteredEndPastStart && superRegion.end < region.start) {\n                // In this case, the region (and all regions that came before)\n                // end before the region we are testing, so we may safely skip past it\n                // from here on out.\n                seekIndex = j + 1;\n                continue;\n            }\n\n            if (superRegion.start > end) {\n                // Because `_regions` is sorted, we can stop here\n                break;\n            }\n            if (\n                superRegion.start <= region.start &&\n                superRegion.end >= region.end\n            ) {\n                encounteredEndPastStart = true;\n                regionContainedIn.add(superRegion);\n            }\n        }\n\n        if (regionContainedIn.size > 0) {\n            // We only count if we are contained in a subregion\n            retRegions.push(region);\n            retRegionsContainedIn.push(regionContainedIn);\n        }\n    }\n\n    return { regions: retRegions, regionsContainedIn: retRegionsContainedIn };\n}\n\n/**\n * Split an array up into the disjoint regions specified by `regionRecord`.\n * Returned is a list of tuples, the first item being the key of `regionRecord` if there\n * was a corresponding region, or `null` if there was no corresponding region.\n *\n * This function assumes that the regions in `regionRecord` are disjoint and fully contained\n * within the bounds of `array`.\n */\nexport function splitByRegions<\n    T extends unknown,\n    RegionRecord extends Record<string, Region[]>\n>(array: T[], regionsRecord: RegionRecord) {\n    const ret: [keyof RegionRecord | null, T[]][] = [];\n\n    const indices = [0, array.length];\n    const reverseMap: Record<string, keyof RegionRecord> = {};\n    for (const [key, records] of Object.entries(regionsRecord)) {\n        indices.push(\n            ...records.flatMap((r) => {\n                reverseMap[\"\" + [r.start, r.end]] = key;\n                return [r.start, r.end];\n            })\n        );\n    }\n    indices.sort((a, b) => a - b);\n\n    for (let i = 0; i < indices.length - 1; i++) {\n        const start = indices[i];\n        const end = indices[i + 1];\n        if (start === end) {\n            continue;\n        }\n        const regionKey = reverseMap[\"\" + [start, end]];\n\n        ret.push([regionKey || null, array.slice(start, end)]);\n    }\n\n    return ret;\n}\n", "import * as Ast from \"@unified-latex/unified-latex-types\";\nimport { match } from \"@unified-latex/unified-latex-util-match\";\nimport { EXIT, visit } from \"@unified-latex/unified-latex-util-visit\";\n\n/**\n * Escape a string so that it can be used to build a regular expression.\n *\n * From: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions\n */\nfunction escapeRegExp(str: string) {\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\"); // $& means the whole matched string\n}\n\n/**\n * Build a regular expression that matches everything up to the first non-allowed symbol.\n */\nfunction buildWordRegex(allowedSet: Set<string>): RegExp {\n    // /\\p{L}/ matches all letters, including unicode letters. We join this with\n    // everything allowed in our set to form a regexp like\n    //   /(\\p{L}|_|:)*/u\n    // The `u` at the end allows unicode characters to be matched.\n    const regexpStr = `^(${[\"\\\\p{L}\"]\n        .concat(Array.from(allowedSet).map(escapeRegExp))\n        .join(\"|\")})*`;\n    return new RegExp(regexpStr, \"u\");\n}\n\n/**\n * Checks whether the array has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNamesInArray(\n    tree: Ast.Node[],\n    allowedTokens: Set<string>\n): boolean {\n    for (let i = 0; i < tree.length; i++) {\n        const macro = tree[i];\n        const string = tree[i + 1];\n        if (match.anyMacro(macro) && match.anyString(string)) {\n            // There are two options. Either the macro ends with the special character,\n            // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n            if (\n                allowedTokens.has(\n                    macro.content.charAt(macro.content.length - 1)\n                ) ||\n                allowedTokens.has(string.content.charAt(0))\n            ) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\n\n/**\n * Checks whether `tree` has a macro that could be reparsed given the `allowedTokens` but\n * do not do any reparsing. This function can be used in auto-detection schemes to determine if\n * macro names should actually be reparsed.\n */\nexport function hasReparsableMacroNames(\n    tree: Ast.Ast,\n    allowedTokens: string | Set<string>\n): boolean {\n    if (typeof allowedTokens === \"string\") {\n        allowedTokens = new Set(allowedTokens.split(\"\"));\n    }\n    // Recast so typescript doesn't complain\n    const _allowedTokens = allowedTokens;\n    for (const v of _allowedTokens) {\n        if (v.length > 1) {\n            throw new Error(\n                `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n            );\n        }\n    }\n\n    let ret = false;\n    visit(\n        tree,\n        (nodes) => {\n            if (hasReparsableMacroNamesInArray(nodes, _allowedTokens)) {\n                ret = true;\n                return EXIT;\n            }\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n    return ret;\n}\n\n/**\n * Reparses all macro names in the array so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name).\n */\nexport function reparseMacroNamesInArray(\n    tree: Ast.Node[],\n    allowedTokens: Set<string>\n) {\n    const regex = buildWordRegex(allowedTokens);\n    let i = 0;\n    while (i < tree.length) {\n        const macro = tree[i];\n        const string = tree[i + 1];\n        if (\n            match.anyMacro(macro) &&\n            // The _^ macros in math mode should not be extended no-matter what;\n            // So we check to make sure that the macro we're dealing with has the default escape token.\n            (macro.escapeToken == null || macro.escapeToken === \"\\\\\") &&\n            match.anyString(string) &&\n            // There are two options. Either the macro ends with the special character,\n            // e.g. `\\@foo` or the special character starts the next string, e.g. `\\foo@`.\n            (allowedTokens.has(\n                macro.content.charAt(macro.content.length - 1)\n            ) ||\n                allowedTokens.has(string.content.charAt(0)))\n        ) {\n            // There might be a number somewhere in the string. If so, we should\n            // break the string apart at that number\n            const match = string.content.match(regex);\n            const takeable = match ? match[0] : \"\";\n            if (takeable.length > 0) {\n                if (takeable.length === string.content.length) {\n                    // The whole string can be appended to the macro name\n                    macro.content += string.content;\n                    tree.splice(i + 1, 1);\n\n                    // Preserve the source location if available\n                    if (macro.position && string.position?.end) {\n                        macro.position.end = string.position.end;\n                    }\n                } else {\n                    // Only part of the string can be appended to the macro name\n                    macro.content += takeable;\n                    string.content = string.content.slice(takeable.length);\n\n                    // Preserve the source location if available\n                    if (macro.position?.end) {\n                        macro.position.end.offset += takeable.length;\n                        macro.position.end.column += takeable.length;\n                    }\n                    if (string.position?.start) {\n                        string.position.start.offset += takeable.length;\n                        string.position.start.column += takeable.length;\n                    }\n                }\n            } else {\n                i++;\n            }\n        } else {\n            ++i;\n        }\n    }\n}\n\n/**\n * Reparses all macro names so that they may optionally include characters listed in `allowedTokens`.\n * This is used, for example, when parsing expl3 syntax which allows `_` to be used in a macro name (even though\n * `_` is normally stops the parsing for a macro name). Thus, a macro `\\foo_bar:Nn` would be parsed as having\n * the name `foo_bar:Nn` rather than as `foo` followed by the strings `_`, `bar`, `:`, `Nn`.\n */\nexport function reparseMacroNames(\n    tree: Ast.Ast,\n    allowedTokens: string | Set<string>\n) {\n    if (typeof allowedTokens === \"string\") {\n        allowedTokens = new Set(allowedTokens.split(\"\"));\n    }\n    // Recast so typescript doesn't complain\n    const _allowedTokens = allowedTokens;\n    for (const v of _allowedTokens) {\n        if (v.length > 1) {\n            throw new Error(\n                `Only single characters are allowed as \\`allowedTokens\\` when reparsing macro names, not \\`${v}\\`.`\n            );\n        }\n    }\n\n    visit(\n        tree,\n        (nodes) => {\n            reparseMacroNamesInArray(nodes, _allowedTokens);\n        },\n        { includeArrays: true, test: Array.isArray }\n    );\n}\n"],
+  "mappings": "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",
+  "names": ["match", "visit", "match", "match", "visit"]
+}

package/libs/find-region.d.ts

@@ -0,0 +1,8 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+import { Region } from "./regions";
+/**
+ * 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.
+ */
+export declare function findRegionInArray(tree: Ast.Node[], start: (node: Ast.Node) => boolean, end: (node: Ast.Node) => boolean): Region[];
+//# sourceMappingURL=find-region.d.ts.map

package/libs/find-region.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-region.d.ts","sourceRoot":"","sources":["../../libs/find-region.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAEnC;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,EAChB,KAAK,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,KAAK,OAAO,EAClC,GAAG,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,KAAK,OAAO,GACjC,MAAM,EAAE,CAoBV"}

package/libs/regions.d.ts

@@ -0,0 +1,23 @@
+export declare type Region = {
+    start: number;
+    end: number;
+};
+/**
+ * Given `regions`, a list of `Region`s (not necessarily ordered, possibly overlapping), return a list of in-order,
+ * non-overlapping regions and a corresponding list containing a set of the original `Region`s that the new region
+ * is a subset of.
+ */
+export declare function refineRegions(regions: Region[]): {
+    regions: Region[];
+    regionsContainedIn: Set<Region>[];
+};
+/**
+ * Split an array up into the disjoint regions specified by `regionRecord`.
+ * Returned is a list of tuples, the first item being the key of `regionRecord` if there
+ * was a corresponding region, or `null` if there was no corresponding region.
+ *
+ * This function assumes that the regions in `regionRecord` are disjoint and fully contained
+ * within the bounds of `array`.
+ */
+export declare function splitByRegions<T extends unknown, RegionRecord extends Record<string, Region[]>>(array: T[], regionsRecord: RegionRecord): [keyof RegionRecord | null, T[]][];
+//# sourceMappingURL=regions.d.ts.map

package/libs/regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regions.d.ts","sourceRoot":"","sources":["../../libs/regions.ts"],"names":[],"mappings":"AAEA,oBAAY,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG;IAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC;CACrC,CAuDA;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC1B,CAAC,SAAS,OAAO,EACjB,YAAY,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC/C,KAAK,EAAE,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,sCA2BxC"}

package/libs/reparse-macro-names.d.ts

@@ -0,0 +1,27 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+/**
+ * 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.
+ */
+export declare function hasReparsableMacroNamesInArray(tree: Ast.Node[], allowedTokens: Set<string>): boolean;
+/**
+ * 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.
+ */
+export declare function hasReparsableMacroNames(tree: Ast.Ast, allowedTokens: string | Set<string>): boolean;
+/**
+ * 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).
+ */
+export declare function reparseMacroNamesInArray(tree: Ast.Node[], allowedTokens: Set<string>): void;
+/**
+ * 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`.
+ */
+export declare function reparseMacroNames(tree: Ast.Ast, allowedTokens: string | Set<string>): void;
+//# sourceMappingURL=reparse-macro-names.d.ts.map

package/libs/reparse-macro-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparse-macro-names.d.ts","sourceRoot":"","sources":["../../libs/reparse-macro-names.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AA2B1D;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC1C,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,EAChB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,OAAO,CAkBT;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,GAAG,CAAC,GAAG,EACb,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GACpC,OAAO,CA0BT;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACpC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,EAChB,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,QAwD7B;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,IAAI,EAAE,GAAG,CAAC,GAAG,EACb,aAAa,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,QAsBtC"}

package/libs/special-regions.d.ts

@@ -0,0 +1,18 @@
+import * as Ast from "@unified-latex/unified-latex-types";
+import { Region } from "./regions";
+/**
+ * Find regions between `\ExplSyntaxOn...\ExplSyntaxOff` and `\makeatletter...\makeatother`.
+ * Returns an object containing regions where one or both syntax's apply.
+ */
+export declare function findExpl3AndAtLetterRegionsInArray(tree: Ast.Node[]): {
+    explOnly: Region[];
+    atLetterOnly: Region[];
+    both: Region[];
+};
+/**
+ * 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.
+ */
+export declare function reparseExpl3AndAtLetterRegions(tree: Ast.Ast): void;
+//# sourceMappingURL=special-regions.d.ts.map

package/libs/special-regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special-regions.d.ts","sourceRoot":"","sources":["../../libs/special-regions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,oCAAoC,CAAC;AAG1D,OAAO,EAAiB,MAAM,EAAkB,MAAM,WAAW,CAAC;AAalE;;;GAGG;AACH,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG;IAClE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;CAClB,CA2CA;AAMD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,QAgD3D"}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@unified-latex/unified-latex-util-catcode",
+    "version": "1.1.0",
+    "description": "Tools for manipulating unified-latex ASTs",
+    "main": "index.js",
+    "type": "module",
+    "dependencies": {
+        "@unified-latex/unified-latex-types": "^1.1.0",
+        "@unified-latex/unified-latex-util-match": "^1.1.0",
+        "@unified-latex/unified-latex-util-visit": "^1.1.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/siefkenj/unified-latex.git"
+    },
+    "keywords": [
+        "pegjs",
+        "latex",
+        "parser",
+        "prettier",
+        "unified-latex",
+        "unified"
+    ],
+    "author": "Jason Siefken",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/siefkenj/unified-latex/issues"
+    },
+    "homepage": "https://github.com/siefkenj/unified-latex#readme",
+    "exports": {
+        ".": {
+            "import": "./index.js",
+            "require": "./index.cjs"
+        },
+        "./*js": "./*js",
+        "./*": {
+            "import": "./*/index.js",
+            "require": "./*/index.cjs",
+            "types": "./*/index.d.ts"
+        },
+        "./*/index": {
+            "import": "./*/index.js",
+            "require": "./*/index.cjs"
+        }
+    },
+    "files": [
+        "**/*ts",
+        "**/*js",
+        "**/*.map",
+        "**/*.json"
+    ]
+}