texlite 0.7.8 → 0.8.0

package/dist/client/assets/{minus-BwzSZenU.js → minus-DR-ttrx3.js}

@@ -1 +1 @@
-import{j as e}from"./index-B9n8hfV0.js";const n=e("Maximize2",[["polyline",{points:"15 3 21 3 21 9",key:"mznyad"}],["polyline",{points:"9 21 3 21 3 15",key:"1avn1i"}],["line",{x1:"21",x2:"14",y1:"3",y2:"10",key:"ota7mn"}],["line",{x1:"3",x2:"10",y1:"21",y2:"14",key:"1atl0r"}]]);const a=e("Minus",[["path",{d:"M5 12h14",key:"1ays0h"}]]);export{a as M,n as a};
+import{j as e}from"./index-vpWlpUOr.js";const n=e("Maximize2",[["polyline",{points:"15 3 21 3 21 9",key:"mznyad"}],["polyline",{points:"9 21 3 21 3 15",key:"1avn1i"}],["line",{x1:"21",x2:"14",y1:"3",y2:"10",key:"ota7mn"}],["line",{x1:"3",x2:"10",y1:"21",y2:"14",key:"1atl0r"}]]);const a=e("Minus",[["path",{d:"M5 12h14",key:"1ays0h"}]]);export{a as M,n as a};

package/dist/client/assets/spellCheck-Wn7_eF9j.js

@@ -0,0 +1 @@
+import{a as k}from"./index-vpWlpUOr.js";import"./react-BoEjKzFZ.js";const S=5,u=new Map,x=12;let p=!1,f=null;class h extends Error{constructor(){super("A newer writing check replaced this request."),this.name="HarperLintSupersededError"}}function A(t){return t instanceof h}function v(t){const e=[0];let n=0;for(const r of t)n+=r.length,e.push(n);return e}function L(t){return[...new Set(t.map(e=>e.trim()).filter(Boolean))].sort((e,n)=>e.localeCompare(n)).join("\0")}async function C(t,e,n){return(await k(`/api/projects/${t}/spellcheck`,{method:"POST",body:JSON.stringify({path:e,source:n})})).lints}function R(t,e,n){if(!e.problem)return null;const r={from:e.start,to:e.end},o={from:n[e.start]??-1,to:n[e.end]??-1},i=c=>c.from>=0&&c.to>c.from&&c.to<=t.length,a=c=>i(c)&&t.slice(c.from,c.to)===e.problem;return a(o)?o:a(r)?r:null}function $(t,e,n){const r=R(t,e,n);if(!r)return null;const{from:o,to:i}=r,a=t.slice(o,i);if(!a.trim()||!/[A-Za-z]/.test(a)||e.kind==="Formatting")return null;const c=e.kind==="Spelling"||e.kind==="Typo"?"spelling":"grammar",m=e.suggestions.filter((d,s,l)=>s<S&&l.indexOf(d)===s);return{from:o,to:i,word:a,kind:c,message:e.message,suggestions:m}}function g(t,e){let n=2166136261;for(let r=0;r<e.length;r+=1)n^=e.charCodeAt(r),n=Math.imul(n,16777619);return`${t}\0${e.length}:${n>>>0}`}function y(t,e,n){const r=g(t,e),o=u.get(r);return!o||o.path!==t||o.source!==e||o.dictionary!==n?null:(u.delete(r),u.set(r,o),o.issues)}function j(t,e,n,r){const o=g(t,e);for(u.set(o,{path:t,source:e,dictionary:n,issues:r});u.size>x;){const i=u.keys().next().value;if(i===void 0)break;u.delete(i)}}async function q(t,e,n,r="main.tex"){const o=L(e),i=y(r,t,o);if(i)return i;const a=v(t),c=new Set(e.map(s=>s.trim().toLocaleLowerCase("en-US")).filter(Boolean)),m=new Set,d=n.map(s=>$(t,s,a)).filter(s=>!!s).filter(s=>s.kind!=="spelling"||!c.has(s.word.trim().toLocaleLowerCase("en-US"))).filter(s=>{const l=`${s.from}:${s.to}:${s.kind}`;return m.has(l)?!1:(m.add(l),!0)}).sort((s,l)=>s.from-l.from||s.to-l.to);return j(r,t,o,d),d}async function b(t,e,n,r){const o=L(r),i=y(e,n,o);if(i)return i;const a=await C(t,e,n);return q(n,r,a,e)}async function w(){if(p||!f)return;const t=f;f=null,p=!0;try{t.resolve(await b(t.projectId,t.path,t.source,t.customWords))}catch(e){t.reject(e)}finally{p=!1,w()}}function B(t,e,n,r=[]){return new Promise((o,i)=>{f?.reject(new h),f={projectId:t,path:e,source:n,customWords:[...r],resolve:o,reject:i},w()})}export{h as HarperLintSupersededError,A as isHarperLintSupersededError,B as lintLatex,q as mapLatexLints};

package/dist/client/index.html

@@ -10,9 +10,9 @@
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fontsource/iosevka@5.2.5/400.css" />
     <link rel="icon" type="image/svg+xml" href="/logo.svg" />
     <title>TexLite</title>
-    <script type="module" crossorigin src="/assets/index-B9n8hfV0.js"></script>
+    <script type="module" crossorigin src="/assets/index-vpWlpUOr.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/react-BoEjKzFZ.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-BhyTKMoO.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-CdiutUgf.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/app.js

@@ -50,9 +50,9 @@ export async function buildApp(config, db, options = {}) {
     const latexCompletions = new LatexCompletionService(config);
     const projectOutlines = new ProjectOutlineService(config);
     const harper = new HarperService();
-    // Warm the single server-side runtime without delaying startup. The first
-    // request shares this promise if initialization is still in progress.
-    void harper.preload().catch((error) => app.log.warn({ err: error }, "Harper could not be initialized"));
+    // Probe the optional host Harper CLI without delaying startup. Its absence is
+    // supported: the browser spellchecker remains the writing-check fallback.
+    void harper.preload().catch((error) => app.log.info({ err: error }, "Optional Harper CLI is unavailable"));
     const recordHistory = (projectId, userId, reason, paths) => {
         try {
             return history.record(projectId, userId, reason, paths);

package/dist/server/harper.js

@@ -1,144 +1,235 @@
-import { Worker } from "node:worker_threads";
-const setupTimeoutMs = 45_000;
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { maskLatexSource } from "./latexSpellMask.js";
+const commandProbeTimeoutMs = 5_000;
 const lintTimeoutMs = 30_000;
-function withTimeout(operation, timeoutMs, message) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-        operation.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
-    });
+const maxCommandOutputBytes = 8 * 1024 * 1024;
+const maxCachedSourceBytes = 512 * 1024;
+const maxCachedResults = 24;
+const cacheTtlMs = 15_000;
+const unavailableRetryMs = 15_000;
+export class HarperUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HarperUnavailableError";
+    }
+}
+function lintCacheKey(source, filePath) {
+    // Harper selects its parser from the input suffix, so equivalent text in a
+    // .tex and a .sty file must not share a diagnostic result.
+    return createHash("sha256").update(temporaryFileExtension(filePath)).update("\0").update(source).digest("base64url");
+}
+function temporaryFileExtension(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    // Harper selects its TeX parser by extension. Treat source-like companion
+    // files as TeX too; BibTeX keys are intentionally not grammar-checked.
+    return extension === ".tex" || extension === ".sty" || extension === ".cls" ? extension : ".tex";
+}
+function replacementText(suggestion) {
+    const match = /^Replace with:\s*[“"]([\s\S]*)[”"]$/u.exec(suggestion.trim());
+    return match?.[1] ?? null;
+}
+/** Parse `harper-cli lint --format json` output into the browser API shape. */
+export function parseHarperCliOutput(output) {
+    let documents;
+    try {
+        documents = JSON.parse(output);
+    }
+    catch {
+        throw new Error("Harper returned invalid JSON.");
+    }
+    if (!Array.isArray(documents))
+        throw new Error("Harper returned an unexpected result.");
+    const lints = [];
+    for (const document of documents) {
+        if (!Array.isArray(document.lints))
+            continue;
+        for (const lint of document.lints) {
+            const start = lint.span?.char_start;
+            const end = lint.span?.char_end;
+            if (typeof start !== "number" || typeof end !== "number" || !Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start)
+                continue;
+            const suggestions = Array.isArray(lint.suggestions)
+                ? lint.suggestions.filter((value) => typeof value === "string")
+                    .map(replacementText).filter((value) => value !== null)
+                : [];
+            lints.push({
+                start,
+                end,
+                problem: typeof lint.matched_text === "string" ? lint.matched_text : "",
+                kind: typeof lint.kind === "string" ? lint.kind : "Grammar",
+                message: typeof lint.message === "string" ? lint.message : "Harper found a writing issue.",
+                suggestions: [...new Set(suggestions)].slice(0, 5)
+            });
+        }
+    }
+    return lints;
 }
 /**
- * One Harper runtime per TexLite server process. Production uses one Node
- * Worker so WASM checks cannot block Fastify or collaboration messages. Source
- * mode (tsx/Vitest) uses the same runtime in-process because the emitted worker
- * entry does not exist until the server build has completed.
+ * Optional host-side Harper integration. `harper-cli` is distributed with
+ * Harper/harper-ls and provides native TeX parsing plus structured fixes,
+ * without bundling a WASM runtime into TexLite.
  */
 export class HarperService {
-    useWorker = import.meta.url.endsWith(".js");
-    linter = null;
-    setupPromise = null;
-    worker = null;
-    nextRequestId = 1;
-    pending = new Map();
+    command;
+    availability = "unknown";
+    lastUnavailableAt = 0;
+    probePromise = null;
     queue = Promise.resolve();
+    inFlight = new Map();
+    cache = new Map();
+    activeChild = null;
+    disposed = false;
+    constructor(command = "harper-cli") {
+        this.command = command;
+    }
     async preload() {
-        await this.ensureRuntime();
+        await this.ensureAvailable();
     }
-    async lint(source) {
-        const operation = this.queue.then(async () => {
-            await this.ensureRuntime();
-            try {
-                return await withTimeout(this.useWorker ? this.lintInWorker(source) : this.lintInProcess(source), lintTimeoutMs, "Harper writing check timed out.");
-            }
-            catch (error) {
-                if (error instanceof Error && error.message === "Harper writing check timed out.")
-                    this.stopFailedWorker(error);
-                throw error;
-            }
-        });
+    async lint(source, filePath = "main.tex") {
+        if (this.disposed)
+            throw new HarperUnavailableError("Harper service stopped.");
+        const key = lintCacheKey(source, filePath);
+        const cacheable = Buffer.byteLength(source, "utf8") <= maxCachedSourceBytes;
+        const cached = cacheable ? this.cachedResult(key) : null;
+        if (cached)
+            return cached;
+        const existing = cacheable ? this.inFlight.get(key) : undefined;
+        if (existing)
+            return existing;
+        const operation = this.queue.then(() => this.lintOnce(source, filePath));
         this.queue = operation.then(() => undefined, () => undefined);
+        if (cacheable) {
+            this.inFlight.set(key, operation);
+            void operation.then((lints) => this.cacheResult(key, lints), () => undefined).finally(() => {
+                if (this.inFlight.get(key) === operation)
+                    this.inFlight.delete(key);
+            });
+        }
         return operation;
     }
     async dispose() {
+        this.disposed = true;
+        this.activeChild?.kill("SIGTERM");
         await this.queue.catch(() => undefined);
-        await this.setupPromise?.catch(() => undefined);
-        const worker = this.worker;
-        this.worker = null;
-        if (worker)
-            await worker.terminate().catch(() => undefined);
-        const linter = this.linter;
-        this.linter = null;
-        if (linter)
-            await linter.dispose().catch(() => undefined);
-        this.setupPromise = null;
-        this.rejectPending(new Error("Harper service stopped."));
+        this.inFlight.clear();
+        this.cache.clear();
     }
-    ensureRuntime() {
-        if (this.setupPromise)
-            return this.setupPromise;
-        if (this.worker || this.linter)
-            return Promise.resolve();
-        this.setupPromise = withTimeout(this.useWorker ? this.startWorker() : this.startInProcess(), setupTimeoutMs, "Harper initialization timed out.")
+    async ensureAvailable() {
+        if (this.availability === "available")
+            return;
+        if (this.availability === "unavailable" && Date.now() - this.lastUnavailableAt < unavailableRetryMs) {
+            throw new HarperUnavailableError(`The optional ${this.command} command is not available.`);
+        }
+        if (this.probePromise)
+            return this.probePromise;
+        this.probePromise = this.runCommand(["--version"], commandProbeTimeoutMs, 64 * 1024)
+            .then(({ code }) => {
+            if (code !== 0)
+                throw new Error(`${this.command} exited with code ${code}.`);
+            this.availability = "available";
+        })
             .catch((error) => {
-            this.stopFailedWorker(error instanceof Error ? error : new Error(String(error)));
-            throw error;
+            this.availability = "unavailable";
+            this.lastUnavailableAt = Date.now();
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new HarperUnavailableError(`The optional ${this.command} command is unavailable: ${detail}`);
         })
-            .finally(() => { this.setupPromise = null; });
-        return this.setupPromise;
+            .finally(() => { this.probePromise = null; });
+        return this.probePromise;
     }
-    async startInProcess() {
-        const { createHarperLinter } = await import("./harperRuntime.js");
-        this.linter = await createHarperLinter();
+    async lintOnce(source, filePath) {
+        await this.ensureAvailable();
+        const directory = await mkdtemp(path.join(tmpdir(), "texlite-harper-"));
+        const input = path.join(directory, `document${temporaryFileExtension(filePath)}`);
+        try {
+            await writeFile(input, maskLatexSource(source), { encoding: "utf8", mode: 0o600 });
+            const { code, stdout, stderr } = await this.runCommand([
+                "lint", "--format", "json", "--quiet",
+                "--user-dict-path", path.join(directory, "dictionary.txt"),
+                "--file-dict-path", path.join(directory, "file-dictionaries"),
+                input
+            ], lintTimeoutMs, maxCommandOutputBytes);
+            // Harper exits with one when it found lints. Any other non-zero status is
+            // a command failure, not a spelling result.
+            if (code !== 0 && code !== 1)
+                throw new Error(stderr.trim() || `${this.command} exited with code ${code}.`);
+            return parseHarperCliOutput(stdout);
+        }
+        finally {
+            await rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        }
     }
-    startWorker() {
+    cachedResult(key) {
+        const cached = this.cache.get(key);
+        if (!cached || cached.expiresAt < Date.now()) {
+            this.cache.delete(key);
+            return null;
+        }
+        this.cache.delete(key);
+        this.cache.set(key, cached);
+        return cached.lints;
+    }
+    cacheResult(key, lints) {
+        this.cache.set(key, { expiresAt: Date.now() + cacheTtlMs, lints });
+        while (this.cache.size > maxCachedResults) {
+            const oldest = this.cache.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.cache.delete(oldest);
+        }
+    }
+    runCommand(args, timeoutMs, outputLimit) {
         return new Promise((resolve, reject) => {
-            const worker = new Worker(new URL("./harperWorker.js", import.meta.url), { name: "texlite-harper" });
-            this.worker = worker;
-            const rejectStart = (error) => reject(error);
-            const onInitialMessage = (message) => {
-                if (!("type" in message))
+            let child;
+            try {
+                child = spawn(this.command, args, { stdio: ["ignore", "pipe", "pipe"] });
+            }
+            catch (error) {
+                reject(error);
+                return;
+            }
+            this.activeChild = child;
+            const stdout = [];
+            const stderr = [];
+            let outputBytes = 0;
+            let settled = false;
+            let timer;
+            const finish = (callback) => {
+                if (settled)
                     return;
-                worker.off("message", onInitialMessage);
-                worker.off("error", rejectStart);
-                if (message.type === "ready")
-                    resolve();
-                else
-                    reject(new Error(message.message));
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                if (this.activeChild === child)
+                    this.activeChild = null;
+                callback();
             };
-            worker.on("message", onInitialMessage);
-            worker.once("error", rejectStart);
-            worker.on("message", (message) => this.handleWorkerMessage(message));
-            worker.on("error", (error) => this.stopFailedWorker(error));
-            worker.on("exit", (code) => {
-                if (this.worker !== worker)
+            const fail = (error) => finish(() => reject(error));
+            timer = setTimeout(() => {
+                child.kill("SIGTERM");
+                fail(new Error(`${this.command} timed out after ${Math.ceil(timeoutMs / 1000)} seconds.`));
+            }, timeoutMs);
+            const collect = (target) => (chunk) => {
+                outputBytes += chunk.length;
+                if (outputBytes > outputLimit) {
+                    child.kill("SIGTERM");
+                    fail(new Error(`${this.command} produced too much output.`));
                     return;
-                this.worker = null;
-                this.rejectPending(new Error(`Harper worker exited unexpectedly with code ${code}.`));
-            });
-        });
-    }
-    lintInWorker(source) {
-        const worker = this.worker;
-        if (!worker)
-            return Promise.reject(new Error("Harper worker is not ready."));
-        const id = this.nextRequestId++;
-        return new Promise((resolve, reject) => {
-            this.pending.set(id, { resolve, reject });
-            worker.postMessage({ id, source });
+                }
+                target.push(chunk);
+            };
+            child.stdout.on("data", collect(stdout));
+            child.stderr.on("data", collect(stderr));
+            child.once("error", (error) => fail(error));
+            child.once("close", (code) => finish(() => resolve({
+                code,
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8")
+            })));
         });
     }
-    async lintInProcess(source) {
-        if (!this.linter)
-            throw new Error("Harper is not ready.");
-        const { collectHarperLints } = await import("./harperRuntime.js");
-        return collectHarperLints(this.linter, source);
-    }
-    handleWorkerMessage(message) {
-        if ("type" in message)
-            return;
-        const pending = this.pending.get(message.id);
-        if (!pending)
-            return;
-        this.pending.delete(message.id);
-        if (message.ok)
-            pending.resolve(message.lints);
-        else
-            pending.reject(new Error(message.message));
-    }
-    stopFailedWorker(error) {
-        const worker = this.worker;
-        this.worker = null;
-        if (worker)
-            void worker.terminate().catch(() => undefined);
-        const linter = this.linter;
-        this.linter = null;
-        if (linter)
-            void linter.dispose().catch(() => undefined);
-        this.rejectPending(error);
-    }
-    rejectPending(error) {
-        for (const pending of this.pending.values())
-            pending.reject(error);
-        this.pending.clear();
-    }
 }

package/dist/server/latexSpellMask.js

@@ -0,0 +1,257 @@
+// 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 nonProseEnvironments = new Set([
+    "math", "displaymath", "equation", "equation*", "align", "align*", "alignat", "alignat*", "gather", "gather*", "multline", "multline*", "flalign", "flalign*",
+    "tikzpicture", "axis", "scope", "pgfonlayer", "pgfpicture",
+    "tabular", "tabularx", "tabulary", "longtable", "array", "matrix", "pmatrix", "bmatrix", "vmatrix",
+    "verbatim", "lstlisting", "minted", "comment", "algorithmic"
+]);
+const opaqueArgumentCommands = new Set([
+    "documentclass", "usepackage", "requirepackage", "includegraphics", "tikzset", "pgfplotsset", "hypersetup", "lstset",
+    "label", "hypertarget", "ref", "pageref", "autoref", "nameref", "hyperref", "index", "gls", "glspl",
+    "bibliography", "addbibresource", "input", "include", "url", "path", "setlength", "setcounter", "color", "textcolor", "colorbox", "pagecolor"
+]);
+function addRange(ranges, from, to) {
+    if (to > from)
+        ranges.push({ from, to });
+}
+function isWhitespace(character) {
+    return character === " " || character === "\t" || character === "\r" || character === "\n";
+}
+function isCommandNameCharacter(character) {
+    if (!character)
+        return false;
+    const code = character.charCodeAt(0);
+    return (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || (code >= 48 && code <= 57)
+        || character === "@" || character === ":" || character === "_";
+}
+function balancedArgument(source, start, open, close) {
+    if (source[start] !== open)
+        return null;
+    let depth = 1;
+    for (let index = start + 1; index < source.length; index += 1) {
+        if (source[index] === "\\") {
+            index += 1;
+            continue;
+        }
+        if (source[index] === open)
+            depth += 1;
+        else if (source[index] === close && --depth === 0)
+            return { from: start, to: index + 1 };
+    }
+    return null;
+}
+function skipWhitespace(source, start) {
+    let index = start;
+    while (index < source.length && isWhitespace(source[index]))
+        index += 1;
+    return index;
+}
+function readCommand(source, start) {
+    let end = start + 1;
+    if (isCommandNameCharacter(source[end]))
+        while (isCommandNameCharacter(source[end]))
+            end += 1;
+    else if (end < source.length)
+        end += 1;
+    const name = source.slice(start + 1, end);
+    if (source[end] === "*")
+        end += 1;
+    return { name, end };
+}
+function isCitationCommand(name) {
+    const normalized = name.toLocaleLowerCase("en-US");
+    return normalized === "cite" || normalized.startsWith("cite") || normalized.endsWith("cite");
+}
+function masksOpaqueArguments(name) {
+    const normalized = name.toLocaleLowerCase("en-US");
+    return opaqueArgumentCommands.has(normalized) || isCitationCommand(normalized) || normalized === "definecolor" || normalized === "colorlet" || normalized === "href";
+}
+function maskOpaqueArguments(source, start, name, ranges) {
+    let cursor = start;
+    const normalized = name.toLocaleLowerCase("en-US");
+    const count = normalized === "definecolor" || normalized === "colorlet" ? 3 : 1;
+    for (let index = 0; index < count; index += 1) {
+        const argument = balancedArgument(source, cursor, "{", "}");
+        if (!argument)
+            break;
+        addRange(ranges, argument.from, argument.to);
+        cursor = skipWhitespace(source, argument.to);
+    }
+    return cursor;
+}
+function rawUrlEnd(source, start) {
+    const first = source[start];
+    if (first !== "h" && first !== "H" && first !== "f" && first !== "F")
+        return null;
+    for (const prefix of ["http://", "https://", "ftp://"]) {
+        if (source.slice(start, start + prefix.length).toLowerCase() !== prefix)
+            continue;
+        let end = start + prefix.length;
+        while (end < source.length && !isWhitespace(source[end]))
+            end += 1;
+        return end;
+    }
+    return null;
+}
+function mergeOrderedRanges(ranges) {
+    const merged = [];
+    for (const range of ranges) {
+        const previous = merged.at(-1);
+        if (previous && range.from <= previous.to)
+            previous.to = Math.max(previous.to, range.to);
+        else
+            merged.push({ ...range });
+    }
+    return merged;
+}
+/** Return ordered source spans that should not be sent to a prose checker. */
+export function ignoredLatexRanges(source) {
+    const ranges = [];
+    // Each non-prose environment installs its span at \begin and extends it at
+    // \end. This preserves source order, so final merging stays linear.
+    const nonProseStack = [];
+    // The same technique keeps unmatched $ / \[ delimiters cheap and local.
+    let pendingMath = null;
+    for (let index = 0; index < source.length;) {
+        if (pendingMath?.close.startsWith("\\") && source.startsWith(pendingMath.close, index)) {
+            pendingMath.range.to = index + pendingMath.close.length;
+            index += pendingMath.close.length;
+            pendingMath = null;
+            continue;
+        }
+        if (source[index] === "%") {
+            const end = source.indexOf("\n", index);
+            addRange(ranges, index, end < 0 ? source.length : end);
+            index = end < 0 ? source.length : end + 1;
+            continue;
+        }
+        if (source[index] === "$") {
+            if (pendingMath) {
+                if (pendingMath.close === "$" || (pendingMath.close === "$$" && source.startsWith("$$", index))) {
+                    pendingMath.range.to = index + pendingMath.close.length;
+                    index += pendingMath.close.length;
+                    pendingMath = null;
+                }
+                else {
+                    index += 1;
+                }
+            }
+            else {
+                const delimiter = source[index + 1] === "$" ? "$$" : "$";
+                const range = { from: index, to: index + delimiter.length };
+                ranges.push(range);
+                pendingMath = { close: delimiter, range };
+                index += delimiter.length;
+            }
+            continue;
+        }
+        const urlEnd = rawUrlEnd(source, index);
+        if (urlEnd !== null) {
+            addRange(ranges, index, urlEnd);
+            index = urlEnd;
+            continue;
+        }
+        if (source[index] !== "\\") {
+            index += 1;
+            continue;
+        }
+        const commandStart = index;
+        if (source[index + 1] === "(" || source[index + 1] === "[") {
+            if (pendingMath) {
+                addRange(ranges, commandStart, index + 2);
+            }
+            else {
+                const range = { from: commandStart, to: index + 2 };
+                ranges.push(range);
+                pendingMath = { close: source[index + 1] === "(" ? "\\)" : "\\]", range };
+            }
+            index += 2;
+            continue;
+        }
+        const command = readCommand(source, commandStart);
+        let cursor = skipWhitespace(source, command.end);
+        if (command.name === "verb") {
+            addRange(ranges, commandStart, command.end);
+            const delimiter = source[cursor];
+            if (delimiter && !isWhitespace(delimiter)) {
+                const end = source.indexOf(delimiter, cursor + 1);
+                if (end >= 0) {
+                    addRange(ranges, cursor, end + 1);
+                    cursor = end + 1;
+                }
+            }
+            index = Math.max(command.end, cursor);
+            continue;
+        }
+        if (command.name === "begin" || command.name === "end") {
+            const environment = balancedArgument(source, cursor, "{", "}");
+            if (!environment) {
+                addRange(ranges, commandStart, command.end);
+                index = command.end;
+                continue;
+            }
+            const environmentName = source.slice(environment.from + 1, environment.to - 1).trim().toLocaleLowerCase("en-US");
+            cursor = skipWhitespace(source, environment.to);
+            let options = null;
+            if (command.name === "begin") {
+                options = balancedArgument(source, cursor, "[", "]");
+                if (options)
+                    cursor = skipWhitespace(source, options.to);
+                if (nonProseEnvironments.has(environmentName)) {
+                    const range = { from: commandStart, to: cursor };
+                    ranges.push(range);
+                    nonProseStack.push({ name: environmentName, range });
+                }
+                else {
+                    addRange(ranges, commandStart, command.end);
+                    addRange(ranges, environment.from, environment.to);
+                    if (options)
+                        addRange(ranges, options.from, options.to);
+                }
+            }
+            else {
+                const open = nonProseStack.at(-1);
+                if (open?.name === environmentName) {
+                    nonProseStack.pop();
+                    open.range.to = cursor;
+                }
+                else {
+                    addRange(ranges, commandStart, command.end);
+                    addRange(ranges, environment.from, environment.to);
+                }
+            }
+            index = Math.max(command.end, cursor);
+            continue;
+        }
+        addRange(ranges, commandStart, command.end);
+        const options = balancedArgument(source, cursor, "[", "]");
+        if (options) {
+            addRange(ranges, options.from, options.to);
+            cursor = skipWhitespace(source, options.to);
+        }
+        if (masksOpaqueArguments(command.name))
+            cursor = maskOpaqueArguments(source, cursor, command.name, ranges);
+        index = Math.max(command.end, cursor);
+    }
+    return mergeOrderedRanges(ranges);
+}
+/** Replace syntax with spaces while retaining Unicode-scalar offsets and line breaks. */
+export function maskLatexSource(source) {
+    const ranges = ignoredLatexRanges(source);
+    const chars = [];
+    let offset = 0;
+    let rangeIndex = 0;
+    for (const character of source) {
+        while (rangeIndex < ranges.length && ranges[rangeIndex].to <= offset)
+            rangeIndex += 1;
+        const range = ranges[rangeIndex];
+        const masked = range && range.from <= offset && offset < range.to && character !== "\n" && character !== "\r";
+        // `harper-cli` reports Unicode scalar positions. One space for every
+        // source scalar keeps diagnostics aligned after masked astral characters.
+        chars.push(masked ? " " : character);
+        offset += character.length;
+    }
+    return chars.join("");
+}