texlite 0.9.1 → 0.9.3

package/dist/server/latexCompletion.js

@@ -1,11 +1,16 @@
 import fs from "node:fs";
 import { listProjectFiles, listProjectFilesAsync, resolveSourcePath } from "./files.js";
+import { commandSnippet, newCommandArguments, xparseCommandArguments, xparseCommandDefinitions } from "../shared/latexCommandSnippets.js";
+import { maskLatexComments, maskLatexLiteralContent } from "../shared/latexLiterals.js";
+import { findLatexReferenceDefinitions } from "../shared/latexReferences.js";
+import { declaredBibliographyPaths, latexDocumentDirectives } from "./latexDocumentGraph.js";
 const textExtensions = /\.(?:tex|sty|cls|def|cfg|bib|bst|fd|dtx|ins)$/i;
 const definitionExtensions = /\.(?:tex|sty|cls|def|cfg|dtx|ins)$/i;
 const maxIndexedFileBytes = 3 * 1024 * 1024;
 const maxIndexedBytes = 24 * 1024 * 1024;
 const maxIndexedFiles = 500;
 const maxCachedProjects = 64;
+const maxCachedRootScopes = 8;
 // Core LaTeX commands are kept in the completion index even when the project
 // has not loaded a package-specific definition yet.  Keep the catalogue
 // grouped by purpose so missing primitives are easy to spot and extend.
@@ -103,11 +108,11 @@ function item(label, detail, kind, source, apply) {
 }
 function createIndex() {
     return {
-        commands: new Map(), environments: new Map(), labels: new Map(), citations: new Map(), packages: new Map(), files: new Map()
+        commands: new Map(), environments: new Map(), labels: new Map(), citations: new Map(), packages: new Map(), classes: new Map(), files: new Map()
     };
 }
 function withoutComments(content) {
-    return content.split("\n").map((line) => line.replace(/(^|[^\\])%.*$/, "$1")).join("\n");
+    return maskLatexComments(maskLatexLiteralContent(content));
 }
 function commandItem(index, name, detail, source, apply) {
     if (!name.startsWith("\\"))
@@ -120,31 +125,23 @@ function commandItem(index, name, detail, source, apply) {
     if (!existing || (existing.source === "LaTeX" && source !== "LaTeX"))
         index.commands.set(name, item(name, detail, "function", source, apply));
 }
-function commandSnippet(name, argumentCount) {
-    if (argumentCount <= 0)
-        return undefined;
-    const placeholder = (index) => `\${${index}}`;
-    return name + Array.from({ length: argumentCount }, (_, index) => `{${placeholder(index + 1)}}`).join("");
-}
-function xparseArgumentCount(specification) {
-    // The common xparse argument types all consume one user supplied value.
-    // Modifiers such as `+` and argument delimiters are intentionally ignored.
-    return [...specification.matchAll(/[moOrRdDsStvb]/g)].length;
-}
 function extractSymbols(index, filePath, original) {
     const content = withoutComments(original);
     const source = filePath;
-    for (const match of content.matchAll(/\\(?:newcommand|renewcommand|providecommand|DeclareRobustCommand)\s*\*?\s*(?:\{\s*)?\\([A-Za-z@][A-Za-z@0-9:_]*)\s*(?:\})?\s*(?:\[(\d+)\])?/g)) {
-        const args = Number.parseInt(match[2] ?? "0", 10);
-        commandItem(index, `\\${match[1]}`, `Project command (${args} argument${args === 1 ? "" : "s"})`, source, commandSnippet(`\\${match[1]}`, args));
+    for (const match of content.matchAll(/\\(?:newcommand|renewcommand|providecommand|DeclareRobustCommand)\s*\*?\s*(?:\{\s*)?\\([A-Za-z@][A-Za-z@0-9:_]*)\s*(?:\})?\s*(?:\[(\d+)\])?(?:\s*(\[[^\]]*\]))?/g)) {
+        const arguments_ = newCommandArguments(Number.parseInt(match[2] ?? "0", 10), Boolean(match[3]));
+        commandItem(index, `\\${match[1]}`, `Project command (${arguments_.length} argument${arguments_.length === 1 ? "" : "s"})`, source, commandSnippet(`\\${match[1]}`, arguments_));
     }
-    for (const match of content.matchAll(/\\(?:NewDocumentCommand|RenewDocumentCommand|ProvideDocumentCommand|DeclareDocumentCommand|DeclareExpandableDocumentCommand|RenewExpandableDocumentCommand|ProvideExpandableDocumentCommand)\s*\{\s*\\([A-Za-z@][A-Za-z@0-9:_]*)\s*\}\s*\{([^}]*)\}/g)) {
-        const args = xparseArgumentCount(match[2]);
-        commandItem(index, `\\${match[1]}`, `Project command (${args} argument${args === 1 ? "" : "s"})`, source, commandSnippet(`\\${match[1]}`, args));
+    for (const definition of xparseCommandDefinitions(content)) {
+        const arguments_ = xparseCommandArguments(definition.specification);
+        const detail = arguments_
+            ? `Project command (${arguments_.length} argument${arguments_.length === 1 ? "" : "s"})`
+            : "Project command";
+        commandItem(index, `\\${definition.name}`, detail, source, arguments_ ? commandSnippet(`\\${definition.name}`, arguments_) : undefined);
     }
     for (const match of content.matchAll(/\\(?:def|gdef|edef|xdef)\s*\\([A-Za-z@][A-Za-z@0-9:_]*)((?:\s*#\d+)*)/g)) {
         const args = [...(match[2] ?? "").matchAll(/#\d+/g)].length;
-        commandItem(index, `\\${match[1]}`, "Project macro", source, commandSnippet(`\\${match[1]}`, args));
+        commandItem(index, `\\${match[1]}`, "Project macro", source, commandSnippet(`\\${match[1]}`, newCommandArguments(args, false)));
     }
     for (const match of content.matchAll(/\\DeclareMathOperator\s*\*?\s*\{?\\([A-Za-z@][A-Za-z@0-9:_]*)\}?/g))
         commandItem(index, `\\${match[1]}`, "Project math operator", source);
@@ -166,8 +163,10 @@ function extractSymbols(index, filePath, original) {
             index.environments.set(name, item(name, "Theorem environment", "keyword", source));
         }
     }
-    for (const match of content.matchAll(/\\(?:label|hypertarget)\s*\{([^}]+)\}/g)) {
-        const label = match[1].trim();
+    for (const definition of findLatexReferenceDefinitions(content, "label")) {
+        if (definition.source !== "label")
+            continue;
+        const label = definition.key;
         if (label && !index.labels.has(label))
             index.labels.set(label, item(label, "Label", "constant", source));
     }
@@ -176,29 +175,24 @@ function extractSymbols(index, filePath, original) {
         if (file)
             index.files.set(file, item(file, "Project file", "text", source));
     }
-    for (const match of content.matchAll(/\\(?:usepackage|RequirePackage|documentclass)\s*(?:\[[^]]*\])?\s*\{([^}]+)\}/g)) {
+    for (const match of content.matchAll(/\\(?:usepackage|RequirePackage|documentclass)\s*(?:\[[^\]]*\])?\s*\{([^}]+)\}/g)) {
         for (const packageName of match[1].split(",").map((value) => value.trim()).filter(Boolean)) {
-            const target = /documentclass|documentstyle/.test(match[0]) ? index.files : index.packages;
+            const target = /documentclass|documentstyle/.test(match[0]) ? index.classes : index.packages;
             if (!target.has(packageName))
-                target.set(packageName, item(packageName, target === index.files ? "Document class" : "Package", "text", source));
+                target.set(packageName, item(packageName, target === index.classes ? "Document class" : "Package", target === index.classes ? "class" : "text", source));
         }
     }
-    for (const match of content.matchAll(/\\(?:cite|citep|citet|parencite|textcite|autocite|footcite)(?:\w*)?\s*(?:\[[^]]*\])?\s*\{([^}]+)\}/g)) {
-        for (const key of match[1].split(",").map((value) => value.trim()).filter(Boolean)) {
-            if (!index.citations.has(key))
-                index.citations.set(key, item(key, "Citation key", "constant", source));
+    // `\\bibitem` suggestions are scoped by the client to the file currently
+    // open in the editor. Keep the server index reserved for standalone
+    // project BibTeX databases, so old cite uses and other source files do
+    // not leak into a citation menu.
+    if (/\.bib$/i.test(filePath)) {
+        for (const definition of findLatexReferenceDefinitions(original, "citation", true)) {
+            const key = definition.key;
+            if (key && !index.citations.has(key))
+                index.citations.set(key, item(key, "BibTeX key", "constant", source));
         }
     }
-    for (const match of content.matchAll(/\\bibitem\s*(?:\[[^]]*\])?\s*\{([^}]+)\}/g)) {
-        const key = match[1].trim();
-        if (key && !index.citations.has(key))
-            index.citations.set(key, item(key, "Bibliography key", "constant", source));
-    }
-    for (const match of content.matchAll(/@(?:\w+)\s*\{\s*([^,\s]+)\s*,/g)) {
-        const key = match[1].trim();
-        if (key && !index.citations.has(key))
-            index.citations.set(key, item(key, "BibTeX key", "constant", source));
-    }
 }
 function sorted(map) {
     return [...map.values()].sort((left, right) => left.label.localeCompare(right.label));
@@ -212,14 +206,21 @@ function standardIndex() {
     for (const packageName of standardPackages)
         index.packages.set(packageName.trim(), item(packageName.trim(), "Package", "text", "LaTeX"));
     for (const className of standardClasses)
-        index.files.set(className, item(className, "Document class", "class", "LaTeX"));
+        index.classes.set(className, item(className, "Document class", "class", "LaTeX"));
     return index;
 }
+function addProjectFile(index, filePath) {
+    index.files.set(filePath, item(filePath, "Project file", "text", "Project"));
+    if (/\.cls$/i.test(filePath)) {
+        const name = filePath.replace(/\.cls$/i, "");
+        index.classes.set(name, item(name, "Document class", "class", filePath));
+    }
+}
 export function buildLatexCompletionIndex(config, projectId) {
     const index = standardIndex();
     const allEntries = listProjectFiles(config, projectId).filter((entry) => entry.type === "file").slice(0, maxIndexedFiles);
     for (const entry of allEntries)
-        index.files.set(entry.path, item(entry.path, "Project file", "text", "Project"));
+        addProjectFile(index, entry.path);
     const entries = allEntries.filter((entry) => textExtensions.test(entry.path));
     let indexedBytes = 0;
     for (const entry of entries) {
@@ -240,33 +241,38 @@ export function buildLatexCompletionIndex(config, projectId) {
     }
     return {
         commands: sorted(index.commands), environments: sorted(index.environments), labels: sorted(index.labels),
-        citations: sorted(index.citations), packages: sorted(index.packages), files: sorted(index.files)
+        citations: sorted(index.citations), packages: sorted(index.packages), classes: sorted(index.classes), files: sorted(index.files)
     };
 }
 /** Reuses extracted symbols for files whose mtime and size did not change. */
 export class LatexCompletionService {
     config;
     cache = new Map();
+    // One project can have several selectable root documents. Keep a small
+    // result cache per project so switching roots does not accidentally reuse
+    // citation keys collected for another manuscript.
     resultCache = new Map();
     pending = new Map();
     constructor(config) {
         this.config = config;
     }
-    build(projectId) {
-        const existing = this.pending.get(projectId);
+    build(projectId, mainFile) {
+        const scope = completionScope(mainFile);
+        const pendingKey = `${projectId}\0${scope}`;
+        const existing = this.pending.get(pendingKey);
         if (existing)
             return existing;
-        const request = this.buildIncremental(projectId)
+        const request = this.buildIncremental(projectId, mainFile)
             // Do not retain a partial per-file cache when a project scan fails.
             .catch((error) => {
             this.invalidate(projectId);
             throw error;
         })
             .finally(() => {
-            if (this.pending.get(projectId) === request)
-                this.pending.delete(projectId);
+            if (this.pending.get(pendingKey) === request)
+                this.pending.delete(pendingKey);
         });
-        this.pending.set(projectId, request);
+        this.pending.set(pendingKey, request);
         return request;
     }
     invalidate(projectId) {
@@ -281,13 +287,14 @@ export class LatexCompletionService {
             cachedFiles: [...this.cache.values()].reduce((total, files) => total + files.size, 0)
         };
     }
-    async buildIncremental(projectId) {
+    async buildIncremental(projectId, mainFile) {
+        const scope = completionScope(mainFile);
         const index = standardIndex();
         const allEntries = (await listProjectFilesAsync(this.config, projectId)).filter((entry) => entry.type === "file").slice(0, maxIndexedFiles);
         const signature = allEntries.map((entry) => `${entry.path}:${entry.size ?? 0}:${entry.mtimeMs ?? 0}`).sort().join("\n");
-        const cachedResult = this.resultCache.get(projectId);
+        const cachedResult = this.resultCache.get(projectId)?.get(scope);
         if (cachedResult?.signature === signature) {
-            this.touch(projectId);
+            this.touch(projectId, scope);
             return cachedResult.index;
         }
         const projectCache = this.cache.get(projectId) ?? new Map();
@@ -297,7 +304,9 @@ export class LatexCompletionService {
             if (!livePaths.has(cachedPath))
                 projectCache.delete(cachedPath);
         for (const entry of allEntries)
-            index.files.set(entry.path, item(entry.path, "Project file", "text", "Project"));
+            addProjectFile(index, entry.path);
+        const indexedFiles = [];
+        const sourceDirectives = new Map();
         let indexedBytes = 0;
         for (const entry of allEntries.filter((candidate) => textExtensions.test(candidate.path))) {
             const size = entry.size ?? 0;
@@ -318,26 +327,68 @@ export class LatexCompletionService {
                 const fileIndex = createIndex();
                 if (definitionExtensions.test(entry.path) || /\.bib$/i.test(entry.path))
                     extractSymbols(fileIndex, entry.path, content);
-                cached = { signature, index: fileIndex };
+                cached = {
+                    signature,
+                    index: fileIndex,
+                    ...(definitionExtensions.test(entry.path) ? { directives: latexDocumentDirectives(content) } : {})
+                };
                 projectCache.set(entry.path, cached);
             }
-            mergeIndex(index, cached.index);
+            if (cached.directives)
+                sourceDirectives.set(entry.path, cached.directives);
+            indexedFiles.push({ path: entry.path, symbols: cached });
+            mergeIndex(index, cached.index, false);
+        }
+        // A project can hold templates, archives, and unrelated bibliography
+        // databases. Citation completion follows the selected root's \input graph
+        // and only includes BibTeX resources it explicitly declares. If a caller
+        // does not provide a root (the backwards-compatible service API), keep the
+        // former project-wide bibliography behavior.
+        const bibPaths = allEntries.filter((entry) => /\.bib$/i.test(entry.path)).map((entry) => entry.path);
+        const selectedBibliographies = mainFile
+            ? declaredBibliographyPaths(sourceDirectives, mainFile, bibPaths)
+            : null;
+        const allowedBibliographies = new Set(selectedBibliographies ?? bibPaths);
+        for (const { path: filePath, symbols } of indexedFiles) {
+            if (!allowedBibliographies.has(filePath))
+                continue;
+            mergeCitations(index, symbols.index);
         }
         const result = {
             commands: sorted(index.commands), environments: sorted(index.environments), labels: sorted(index.labels),
-            citations: sorted(index.citations), packages: sorted(index.packages), files: sorted(index.files)
+            citations: sorted(index.citations), packages: sorted(index.packages), classes: sorted(index.classes), files: sorted(index.files)
         };
-        this.resultCache.set(projectId, { signature, index: result });
-        this.touch(projectId);
+        const projectResults = this.resultCache.get(projectId) ?? new Map();
+        this.resultCache.set(projectId, projectResults);
+        // A root document is user-selectable, so do not let a project with many
+        // standalone examples retain an unbounded number of full completion
+        // result arrays. The per-file symbol cache remains shared by all roots.
+        if (projectResults.has(scope))
+            projectResults.delete(scope);
+        projectResults.set(scope, { signature, index: result });
+        while (projectResults.size > maxCachedRootScopes) {
+            const oldestScope = projectResults.keys().next().value;
+            if (oldestScope === undefined)
+                break;
+            projectResults.delete(oldestScope);
+        }
+        this.touch(projectId, scope);
         this.evictLeastRecentlyUsedProjects();
         return result;
     }
     /** Keep result and per-file symbol caches on the same project-level LRU. */
-    touch(projectId) {
-        const result = this.resultCache.get(projectId);
-        if (result) {
+    touch(projectId, scope) {
+        const results = this.resultCache.get(projectId);
+        if (results) {
+            if (scope !== undefined) {
+                const result = results.get(scope);
+                if (result) {
+                    results.delete(scope);
+                    results.set(scope, result);
+                }
+            }
             this.resultCache.delete(projectId);
-            this.resultCache.set(projectId, result);
+            this.resultCache.set(projectId, results);
         }
         const symbols = this.cache.get(projectId);
         if (symbols) {
@@ -355,10 +406,15 @@ export class LatexCompletionService {
         }
     }
 }
-function mergeIndex(target, source) {
+function completionScope(mainFile) {
+    return mainFile ?? "";
+}
+function mergeIndex(target, source, includeCitations) {
     for (const value of source.commands.values())
         commandItem(target, value.label, value.detail, value.source ?? "Project", value.apply);
-    for (const key of ["environments", "labels", "citations", "packages", "files"]) {
+    for (const key of ["environments", "labels", "citations", "packages", "classes", "files"]) {
+        if (key === "citations" && !includeCitations)
+            continue;
         for (const [label, value] of source[key]) {
             const existing = target[key].get(label);
             if (!existing || (existing.source === "LaTeX" && value.source !== "LaTeX"))
@@ -366,3 +422,10 @@ function mergeIndex(target, source) {
         }
     }
 }
+function mergeCitations(target, source) {
+    for (const [label, value] of source.citations) {
+        const existing = target.citations.get(label);
+        if (!existing || (existing.source === "LaTeX" && value.source !== "LaTeX"))
+            target.citations.set(label, value);
+    }
+}

package/dist/server/latexDocumentGraph.js

@@ -0,0 +1,217 @@
+import path from "node:path";
+import { findLatexBibliographyFiles, findLatexSourceIncludes } from "../shared/latexDependencies.js";
+/**
+ * Extract only the small amount of source information needed for project-level
+ * document graph lookups. Keeping this separate from completion symbols means
+ * cached completion data does not need to retain whole source files.
+ */
+export function latexDocumentDirectives(source) {
+    return {
+        includes: findLatexSourceIncludes(source).map(toLatexIncludeDirective),
+        bibliographies: findLatexBibliographyFiles(source).map((reference) => reference.path)
+    };
+}
+export function toLatexIncludeDirective(reference) {
+    return {
+        path: reference.path,
+        command: reference.command,
+        ...(reference.directory === undefined ? {} : { directory: reference.directory })
+    };
+}
+/** Return the selected root followed by its reachable \input-style sources. */
+export function documentSourceOrder(sources, mainFile) {
+    if (!mainFile || !sources.has(mainFile))
+        return [];
+    const result = [];
+    const queued = [{ path: mainFile, importBase: "" }];
+    // A source can technically be reached under more than one import context.
+    // Keeping its first discovered context mirrors the ordinary project graph
+    // traversal while bounding recursive import-package structures.
+    const seen = new Set();
+    while (queued.length) {
+        const current = queued.shift();
+        if (!current || seen.has(current.path))
+            continue;
+        const directives = sources.get(current.path);
+        if (!directives)
+            continue;
+        seen.add(current.path);
+        result.push(current.path);
+        for (const include of directives.includes) {
+            const resolved = resolveLatexInclude(include, current.importBase, sources);
+            if (resolved && !seen.has(resolved.path))
+                queued.push(resolved);
+        }
+    }
+    return result;
+}
+/**
+ * Return exactly the BibTeX resources declared by a selected root and its
+ * input graph. `null` means the selected root was unavailable to the graph
+ * scanner, so callers can retain a backwards-compatible fallback.
+ */
+export function declaredBibliographyPaths(sources, mainFile, bibPaths) {
+    if (!mainFile || !sources.has(mainFile))
+        return null;
+    const availableBibliographies = new Set(bibPaths);
+    const declared = [];
+    for (const sourcePath of documentSourceOrder(sources, mainFile)) {
+        const directives = sources.get(sourcePath);
+        if (!directives)
+            continue;
+        for (const bibliography of directives.bibliographies) {
+            const resolved = resolveProjectReferencePath(bibliography, sourcePath, ".bib", availableBibliographies, "project-root-then-source-file");
+            if (resolved)
+                declared.push(resolved);
+        }
+    }
+    return uniqueProjectPaths(declared);
+}
+export function resolveProjectReferencePath(rawPath, currentPath, extension, available, resolution) {
+    const raw = normalizeReferenceInput(rawPath);
+    if (!raw)
+        return null;
+    const parent = path.posix.dirname(currentPath);
+    const relative = normalizeProjectPath(parent === "." ? raw : path.posix.join(parent, raw));
+    const root = normalizeProjectPath(raw);
+    const roots = resolution === "project-root"
+        ? [root]
+        : resolution === "source-file"
+            ? [relative]
+            : [root, relative];
+    return resolveCandidatePaths(roots, extension, available);
+}
+/**
+ * Resolve import.sty's dynamic path handling.  `\\import`, `\\inputfrom`,
+ * and `\\includefrom` reset the import path from the compiler root. Their
+ * `sub*` counterparts extend the active path. Plain input-style commands use
+ * the active path first, then the compiler root, matching import.sty's
+ * `\\input@path` fallback behavior.
+ */
+export function resolveLatexInclude(include, importBase, available) {
+    switch (include.command.toLowerCase()) {
+        case "input":
+        case "include": {
+            const resolved = resolveOrdinaryIncludePath(include.path, importBase, available);
+            return resolved ? { path: resolved, importBase } : null;
+        }
+        case "subfile":
+            return resolveSubfilePath(include.path, importBase, available);
+        case "import":
+        case "includefrom":
+        case "inputfrom": {
+            const nextImportBase = normalizeImportBase(include.directory ?? "");
+            if (nextImportBase === null)
+                return null;
+            const resolved = resolveProjectPathAtBase(include.path, "", ".tex", available);
+            return resolved ? { path: resolved, importBase: nextImportBase } : null;
+        }
+        case "subimport":
+        case "subinputfrom":
+        case "subincludefrom": {
+            const nextImportBase = extendImportBase(importBase, include.directory ?? "");
+            if (nextImportBase === null)
+                return null;
+            const resolved = resolveProjectPathAtBase(include.path, importBase, ".tex", available);
+            return resolved ? { path: resolved, importBase: nextImportBase } : null;
+        }
+        default:
+            return null;
+    }
+}
+/** `subfiles` implements \subfile through import.sty's \subimport. */
+function resolveSubfilePath(rawPath, importBase, available) {
+    const raw = normalizeReferenceInput(rawPath);
+    if (!raw)
+        return null;
+    const directory = path.posix.dirname(raw);
+    const file = path.posix.basename(raw);
+    if (!file || file === "." || file === "/")
+        return null;
+    const nextImportBase = extendImportBase(importBase, directory === "." ? "" : directory);
+    if (nextImportBase === null)
+        return null;
+    const resolved = resolveProjectPathAtBase(file, nextImportBase, ".tex", available);
+    return resolved ? { path: resolved, importBase: nextImportBase } : null;
+}
+function resolveOrdinaryIncludePath(rawPath, importBase, available) {
+    if (importBase) {
+        const fromImportPath = resolveProjectPathAtBase(rawPath, importBase, ".tex", available);
+        if (fromImportPath)
+            return fromImportPath;
+    }
+    return resolveProjectPathAtBase(rawPath, "", ".tex", available);
+}
+function resolveProjectPathAtBase(rawPath, base, extension, available) {
+    const raw = normalizeReferenceInput(rawPath);
+    const normalizedBase = normalizeImportBase(base);
+    if (!raw || normalizedBase === null)
+        return null;
+    const candidate = normalizeProjectPath(normalizedBase ? path.posix.join(normalizedBase, raw) : raw);
+    return resolveCandidatePaths(candidate ? [candidate] : [], extension, available);
+}
+function extendImportBase(importBase, extension) {
+    const normalizedBase = normalizeImportBase(importBase);
+    const relativeExtension = normalizeRelativeImportPath(extension);
+    if (normalizedBase === null || relativeExtension === null)
+        return null;
+    return normalizeImportBase(normalizedBase
+        ? path.posix.join(normalizedBase, relativeExtension)
+        : relativeExtension);
+}
+function resolveCandidatePaths(paths, extension, available) {
+    const candidates = paths.flatMap((candidate) => {
+        if (!candidate)
+            return [];
+        return candidate.toLowerCase().endsWith(extension)
+            ? [candidate]
+            : [candidate, candidate + extension];
+    });
+    for (const candidate of uniqueProjectPaths(candidates)) {
+        if (available.has(candidate))
+            return candidate;
+    }
+    return null;
+}
+export function uniqueProjectPaths(paths) {
+    const seen = new Set();
+    return paths.filter((entryPath) => {
+        if (!entryPath || seen.has(entryPath))
+            return false;
+        seen.add(entryPath);
+        return true;
+    });
+}
+function normalizeReferenceInput(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    if (!trimmed || trimmed.startsWith("/") || /^[A-Za-z]:\//.test(trimmed) || trimmed.includes("\0"))
+        return null;
+    return trimmed;
+}
+function normalizeRelativeImportPath(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    if (trimmed.startsWith("/") || /^[A-Za-z]:\//.test(trimmed) || trimmed.includes("\0"))
+        return null;
+    return trimmed || ".";
+}
+function normalizeImportBase(value) {
+    const relative = normalizeRelativeImportPath(value);
+    if (relative === null)
+        return null;
+    const normalized = path.posix.normalize(relative);
+    if (normalized === ".")
+        return "";
+    if (normalized === ".." || normalized.startsWith("../"))
+        return null;
+    if (normalized.split("/").some((segment) => segment.toLowerCase() === ".git"))
+        return null;
+    return normalized;
+}
+function normalizeProjectPath(value) {
+    const normalized = path.posix.normalize(value);
+    if (normalized === "." || normalized === ".." || normalized.startsWith("../"))
+        return null;
+    if (normalized.split("/").some((segment) => segment.toLowerCase() === ".git"))
+        return null;
+    return normalized;
+}

package/dist/server/latexSpellMask.js

@@ -1,11 +1,10 @@
+import { literalEnvironmentNames } from "../shared/latexLiterals.js";
 // This intentionally recognizes only the parts of LaTeX that are clearly not
 // prose. It is a single-pass lexer, not a parser: malformed delimiters remain
 // narrow, so they never hide the rest of a document or cause backtracking.
-const literalEnvironments = new Set([
-    "verbatim", "verbatim*", "bverbatim", "bverbatim*", "lverbatim", "lverbatim*", "saveverbatim", "saveverbatim*", "verbatimout",
-    "lstlisting", "minted", "minted*", "filecontents", "filecontents*", "luacode", "luacodestar", "comment"
-]);
+const literalEnvironments = new Set(literalEnvironmentNames.map((name) => name.toLowerCase()));
 const nonProseEnvironments = new Set([
+    ...literalEnvironments,
     // Display and helper math environments commonly used by amsmath/mathtools.
     "math", "displaymath", "equation", "equation*", "align", "align*", "alignat", "alignat*", "aligned", "alignedat", "gather", "gather*", "gathered", "multline", "multline*", "multlined", "flalign", "flalign*", "split", "cases", "dcases", "rcases", "drcases",
     "array", "matrix", "pmatrix", "bmatrix", "vmatrix", "smallmatrix", "psmallmatrix", "bsmallmatrix", "vsmallmatrix",

package/dist/server/pm2.js

@@ -2,6 +2,7 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import http from "node:http";
 import path from "node:path";
+import { basePathHref, withBasePath } from "../shared/basePath.js";
 import { managedLogPaths } from "./logRotation.js";
 import { defaultConfigPath, packageRootDirectory, packageServerEntry } from "./runtimePaths.js";
 let pm2Client = null;
@@ -197,7 +198,7 @@ export async function processStatus(config) {
         uptimeSeconds: startedAt === null ? null : Math.max(0, Math.floor((Date.now() - startedAt) / 1000)),
         restarts: env?.restart_time ?? 0,
         version: packageVersion(),
-        address: `http://${config.host}:${config.port}`,
+        address: `http://${config.host}:${config.port}${basePathHref(config.basePath)}`,
         dataDir: config.dataDir,
         cwd: env?.pm_cwd ?? packageRootDirectory(),
         outputLog: env?.pm_out_log_path ?? null,
@@ -255,7 +256,7 @@ function probeHost(host) {
 function healthUrl(config) {
     const host = probeHost(config.host);
     const formattedHost = host.includes(":") ? `[${host}]` : host;
-    return `http://${formattedHost}:${config.port}/api/health`;
+    return `http://${formattedHost}:${config.port}${withBasePath(config.basePath, "/api/health")}`;
 }
 function probeService(config, timeoutMs = 1_500) {
     return new Promise((resolve) => {