texlite 0.9.1 → 0.9.2

package/dist/shared/latexLiterals.js

@@ -0,0 +1,215 @@
+// Literal TeX syntax used as opaque editor regions. `alltt` does permit a
+// subset of TeX commands, but treating its raw body as opaque prevents its
+// delimiters from leaking into ordinary source highlighting and tooling.
+export const literalEnvironmentNames = [
+    "verbatim", "verbatim*", "Verbatim", "BVerbatim", "LVerbatim", "SaveVerbatim", "VerbatimOut",
+    "bverbatim", "bverbatim*", "lverbatim", "lverbatim*", "saveverbatim", "saveverbatim*", "verbatimout",
+    "verbatimwrite", "lstlisting", "lstlisting*", "minted", "minted*", "tcblisting", "tcblisting*", "pygmented", "alltt",
+    "filecontents", "filecontents*", "luacode", "luacodestar", "comment"
+];
+const literalEnvironments = new Set(literalEnvironmentNames);
+export function isLatexLiteralEnvironment(name) {
+    return literalEnvironments.has(name);
+}
+function skipOptionalArgument(source, position, end) {
+    if (source[position] !== "[")
+        return position;
+    let depth = 1;
+    for (let index = position + 1; index < end; index += 1) {
+        if (source[index] === "\\") {
+            index += 1;
+            continue;
+        }
+        if (source[index] === "[")
+            depth += 1;
+        if (source[index] === "]") {
+            depth -= 1;
+            if (depth === 0)
+                return index + 1;
+        }
+    }
+    return null;
+}
+function skipRequiredArgument(source, position, end) {
+    if (source[position] !== "{")
+        return null;
+    let depth = 1;
+    for (let index = position + 1; index < end; index += 1) {
+        if (source[index] === "\\") {
+            index += 1;
+            continue;
+        }
+        if (source[index] === "{")
+            depth += 1;
+        if (source[index] === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return index + 1;
+        }
+    }
+    return null;
+}
+function inlineLatexLiteralSpan(source, start, end = source.length) {
+    const newline = source.indexOf("\n", start);
+    if (newline >= 0)
+        end = Math.min(end, newline);
+    const command = /^\\(verb\*?|Verb\*?|lstinline\*?|mintinline\*?)(?![A-Za-z@])/.exec(source.slice(start, end));
+    if (!command)
+        return null;
+    const name = command[1].replace(/\*$/, "");
+    let position = start + command[0].length;
+    if (name !== "verb") {
+        const optionalEnd = skipOptionalArgument(source, position, end);
+        if (optionalEnd === null)
+            return null;
+        position = optionalEnd;
+    }
+    if (name === "mintinline") {
+        const languageEnd = skipRequiredArgument(source, position, end);
+        if (languageEnd === null)
+            return null;
+        position = languageEnd;
+    }
+    const delimiter = source[position];
+    if (!delimiter || /\s/.test(delimiter))
+        return null;
+    // For verb, '{' is still a symmetric delimiter, not an argument opener.
+    if (delimiter === "{" && name !== "verb") {
+        const requiredEnd = skipRequiredArgument(source, position, end);
+        return { end: requiredEnd ?? end, closed: requiredEnd !== null };
+    }
+    const closing = source.indexOf(delimiter, position + 1);
+    if (closing < 0 || closing >= end)
+        return { end, closed: false };
+    return { end: closing + 1, closed: true };
+}
+export function inlineLatexLiteralEnd(source, start, end = source.length) {
+    return inlineLatexLiteralSpan(source, start, end)?.end ?? null;
+}
+export function literalEnvironmentEnd(source, start, name) {
+    const escapedName = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(String.raw `\\end\s*\{\s*${escapedName}\s*\}`, "g");
+    pattern.lastIndex = start;
+    const match = pattern.exec(source);
+    return match ? { from: match.index, to: match.index + match[0].length } : null;
+}
+function isEscaped(source, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1)
+        backslashes += 1;
+    return backslashes % 2 === 1;
+}
+function commandEnd(source, start) {
+    let cursor = start + 1;
+    if (/[A-Za-z@]/.test(source[cursor] ?? "")) {
+        while (/[A-Za-z@]/.test(source[cursor] ?? ""))
+            cursor += 1;
+        if (source[cursor] === "*")
+            cursor += 1;
+        return cursor;
+    }
+    return Math.min(source.length, cursor + 1);
+}
+function literalEnvironmentBegin(source, start) {
+    const match = /^\\begin\s*\{\s*([A-Za-z0-9@:_*.\-]+)\s*\}/.exec(source.slice(start));
+    if (!match || !isLatexLiteralEnvironment(match[1]))
+        return null;
+    return { name: match[1], to: start + match[0].length };
+}
+/**
+ * Return whether a position is inside a TeX comment or one of the literal
+ * code forms shared by editor tooling. Positions after a completed literal are
+ * deliberately treated as normal source, including when its delimiter is '%'.
+ */
+export function latexOpaqueContextAt(source, position) {
+    const target = Math.max(0, Math.min(source.length, position));
+    for (let cursor = 0; cursor < target;) {
+        if (source[cursor] === "%" && !isEscaped(source, cursor)) {
+            const newline = source.indexOf("\n", cursor);
+            const end = newline < 0 ? source.length : newline;
+            if (target <= end)
+                return "comment";
+            cursor = end + 1;
+            continue;
+        }
+        if (source[cursor] !== "\\" || isEscaped(source, cursor)) {
+            cursor += 1;
+            continue;
+        }
+        const inline = inlineLatexLiteralSpan(source, cursor);
+        if (inline !== null) {
+            if (target < inline.end || (!inline.closed && target <= inline.end))
+                return "literal";
+            cursor = inline.end;
+            continue;
+        }
+        const environment = literalEnvironmentBegin(source, cursor);
+        if (environment) {
+            const close = literalEnvironmentEnd(source, environment.to, environment.name);
+            const end = close?.to ?? source.length;
+            if (target < end || (!close && target <= end))
+                return "literal";
+            cursor = end;
+            continue;
+        }
+        cursor = commandEnd(source, cursor);
+    }
+    return null;
+}
+function maskRange(source, from, to) {
+    return source.slice(from, to).replace(/[^\r\n]/g, " ");
+}
+/** Mask ordinary TeX comments while preserving every source offset. */
+export function maskLatexComments(source) {
+    const characters = source.split("");
+    for (let cursor = 0; cursor < source.length; cursor += 1) {
+        if (source[cursor] !== "%" || isEscaped(source, cursor))
+            continue;
+        const newline = source.indexOf("\n", cursor);
+        const end = newline < 0 ? source.length : newline;
+        for (let index = cursor; index < end; index += 1)
+            characters[index] = " ";
+        cursor = end;
+    }
+    return characters.join("");
+}
+/**
+ * Mask literal source while preserving offsets and line structure. Callers can
+ * then use lightweight regular expressions without learning project commands
+ * declared inside listings or verbatim examples.
+ */
+export function maskLatexLiteralContent(source) {
+    let result = "";
+    let cursor = 0;
+    while (cursor < source.length) {
+        if (source[cursor] === "%" && !isEscaped(source, cursor)) {
+            const newline = source.indexOf("\n", cursor);
+            const end = newline < 0 ? source.length : newline;
+            result += source.slice(cursor, end);
+            cursor = end;
+            continue;
+        }
+        if (source[cursor] !== "\\" || isEscaped(source, cursor)) {
+            result += source[cursor];
+            cursor += 1;
+            continue;
+        }
+        const inlineEnd = inlineLatexLiteralEnd(source, cursor);
+        if (inlineEnd !== null) {
+            result += maskRange(source, cursor, inlineEnd);
+            cursor = inlineEnd;
+            continue;
+        }
+        const environment = literalEnvironmentBegin(source, cursor);
+        if (environment) {
+            const close = literalEnvironmentEnd(source, environment.to, environment.name);
+            const end = close?.to ?? source.length;
+            result += maskRange(source, cursor, end);
+            cursor = end;
+            continue;
+        }
+        result += source[cursor];
+        cursor += 1;
+    }
+    return result;
+}

package/dist/shared/latexReferenceCommands.js

@@ -0,0 +1,75 @@
+/**
+ * Declarative classification for the small set of LaTeX commands that carry
+ * citation keys or cross-reference labels. The generic fallbacks deliberately
+ * preserve support for package-defined commands such as `\\smartcite` and
+ * `\\myref`, while exact entries cover commands whose arguments differ from
+ * their name-based convention.
+ */
+const singleCitation = {
+    kind: "citation",
+    argumentKind: "mandatory",
+    maximumArguments: 1
+};
+const multipleCitation = {
+    kind: "citation",
+    argumentKind: "mandatory",
+    maximumArguments: Number.MAX_SAFE_INTEGER
+};
+const singleLabel = {
+    kind: "label",
+    argumentKind: "mandatory",
+    maximumArguments: 1
+};
+const rangeLabel = {
+    kind: "label",
+    argumentKind: "mandatory",
+    maximumArguments: 2
+};
+const optionalLabel = {
+    kind: "label",
+    argumentKind: "optional",
+    maximumArguments: 1
+};
+/**
+ * `null` explicitly means a command must never be interpreted as a reference.
+ * Several biblatex setup commands contain “cite”, but their braced arguments
+ * configure rendering or define commands instead of naming bibliography keys.
+ */
+const exactReferenceCommands = {
+    href: null,
+    hyperref: optionalLabel,
+    crefrange: rangeLabel,
+    citestyle: null,
+    setcitestyle: null,
+    newcites: null,
+    citetext: null,
+    declarecitecommand: null,
+    declaremulticitecommand: null,
+    declareautocitecommand: null,
+    declarecitewrappercommand: null,
+    declarecitepunctuation: null,
+    declarecitedelimiter: null,
+    declarecitedriver: null,
+    declarecitealias: null,
+    ateverycite: null,
+    ateverycitekey: null,
+    atnextcite: null,
+    atnextcitekey: null
+};
+/**
+ * Return the key-bearing argument shape for a command, or null when it is not
+ * a reference command. Command names are case-insensitive for classification;
+ * the original spelling remains available to callers for display and links.
+ */
+export function classifyLatexReferenceCommand(name) {
+    const normalized = name.toLowerCase();
+    if (Object.prototype.hasOwnProperty.call(exactReferenceCommands, normalized)) {
+        return exactReferenceCommands[normalized] ?? null;
+    }
+    if (normalized === "nocite" || normalized.includes("cite")) {
+        return normalized.endsWith("cites") ? multipleCitation : singleCitation;
+    }
+    if (normalized === "ref" || normalized.endsWith("ref"))
+        return singleLabel;
+    return null;
+}

package/dist/shared/latexReferences.js

@@ -0,0 +1,193 @@
+/**
+ * Source-level LaTeX reference scanning. Lexical mechanics, dependency
+ * extraction, command classification, and BibTeX key scanning live in their
+ * own focused modules; this file only assembles them into editor-facing
+ * references and definition targets.
+ */
+import { findBibtexEntryKeys } from "./bibtexReferences.js";
+import { maskLatexComments } from "./latexLiterals.js";
+import { forEachLatexCommand, isLatexCommentStart, readLatexBalancedArgument, readLatexMandatoryArguments, readLatexOptionalArguments, skipLatexComment, skipLatexTrivia } from "./latexScanner.js";
+import { classifyLatexReferenceCommand } from "./latexReferenceCommands.js";
+export { findLatexBibliographyFiles, findLatexSourceIncludes } from "./latexDependencies.js";
+export { maskLatexComments } from "./latexLiterals.js";
+function keyRanges(source, argument) {
+    const ranges = [];
+    // Preserve source offsets while treating comments as whitespace. In
+    // particular, a comment after a comma must not become part of the next key.
+    const masked = maskLatexComments(source.slice(argument.contentFrom, argument.contentTo));
+    let segmentStart = 0;
+    for (let index = 0; index <= masked.length; index += 1) {
+        if (index !== masked.length && masked[index] !== ",")
+            continue;
+        let from = segmentStart;
+        let to = index;
+        while (from < to && /\s/.test(masked[from]))
+            from += 1;
+        while (to > from && /\s/.test(masked[to - 1]))
+            to -= 1;
+        if (to > from) {
+            const absoluteFrom = argument.contentFrom + from;
+            const absoluteTo = argument.contentFrom + to;
+            ranges.push({ key: source.slice(absoluteFrom, absoluteTo), from: absoluteFrom, to: absoluteTo });
+        }
+        segmentStart = index + 1;
+    }
+    return ranges;
+}
+/**
+ * Return the unclosed key argument for a known command shape. Mandatory
+ * arguments may be preceded by completed optional arguments; `\\hyperref`
+ * is the notable optional-key form.
+ */
+function unfinishedReferenceArgument(source, start, spec) {
+    let index = start;
+    for (let count = 0; count < spec.maximumArguments; count += 1) {
+        index = skipLatexTrivia(source, index);
+        if (spec.argumentKind === "optional") {
+            if (source[index] !== "[")
+                return null;
+            const optional = readLatexBalancedArgument(source, index, "[", "]");
+            if (!optional)
+                return index + 1;
+            index = optional.to;
+            continue;
+        }
+        while (source[index] === "[") {
+            const optional = readLatexBalancedArgument(source, index, "[", "]");
+            if (!optional)
+                return null;
+            index = skipLatexTrivia(source, optional.to);
+        }
+        if (source[index] !== "{")
+            return null;
+        const mandatory = readLatexBalancedArgument(source, index, "{", "}");
+        if (!mandatory)
+            return index + 1;
+        index = mandatory.to;
+    }
+    return null;
+}
+function currentReferenceKey(source, start) {
+    let itemStart = start;
+    for (let index = start; index < source.length; index += 1) {
+        if (isLatexCommentStart(source, index)) {
+            index = skipLatexComment(source, index) - 1;
+            continue;
+        }
+        if (source[index] === ",")
+            itemStart = index + 1;
+    }
+    const from = skipLatexTrivia(source, itemStart);
+    return { from, query: source.slice(from) };
+}
+function findLatexReferenceCompletion(source, kind) {
+    let argumentStart = null;
+    forEachLatexCommand(source, (command) => {
+        const spec = classifyLatexReferenceCommand(command.name);
+        if (!spec || spec.kind !== kind)
+            return;
+        const active = unfinishedReferenceArgument(source, command.to, spec);
+        if (active !== null)
+            argumentStart = active;
+    });
+    return argumentStart === null ? null : currentReferenceKey(source, argumentStart);
+}
+/**
+ * Return the active key range while a citation command is still being
+ * written. This shares navigation's command classification and lexical rules.
+ */
+export function findLatexCitationCompletion(source) {
+    return findLatexReferenceCompletion(source, "citation");
+}
+/**
+ * Return the active label range while a cross-reference command is being
+ * written, including both arguments of `\\crefrange`.
+ */
+export function findLatexLabelCompletion(source) {
+    return findLatexReferenceCompletion(source, "label");
+}
+/**
+ * Return individual keys inside visible citation and cross-reference commands.
+ * Nested commands remain visible, for example a citation in a caption option.
+ */
+export function findLatexReferences(source) {
+    const references = [];
+    forEachLatexCommand(source, (command) => {
+        const spec = classifyLatexReferenceCommand(command.name);
+        if (!spec)
+            return;
+        const argumentsFound = spec.argumentKind === "optional"
+            ? readLatexOptionalArguments(source, command.to, spec.maximumArguments)
+            : readLatexMandatoryArguments(source, command.to, spec.maximumArguments);
+        for (const argument of argumentsFound) {
+            for (const range of keyRanges(source, argument)) {
+                references.push({ kind: spec.kind, command: command.name, ...range });
+            }
+        }
+    });
+    return references.sort((left, right) => left.from - right.from || left.to - right.to);
+}
+export function latexReferenceAt(source, offset) {
+    return findLatexReferences(source).find((reference) => offset >= reference.from && offset < reference.to) ?? null;
+}
+function definitionsFromLatex(source, kind) {
+    const definitions = [];
+    forEachLatexCommand(source, (command) => {
+        if (kind === "label" && (command.name === "label" || command.name === "hypertarget")) {
+            const argument = readLatexMandatoryArguments(source, command.to, 1)[0];
+            if (!argument)
+                return;
+            for (const range of keyRanges(source, argument)) {
+                definitions.push({
+                    key: range.key,
+                    command: command.name,
+                    targetFrom: command.from,
+                    targetTo: argument.to,
+                    source: "label"
+                });
+            }
+            return;
+        }
+        if (kind === "citation" && command.name === "bibitem") {
+            const argument = readLatexMandatoryArguments(source, command.to, 1)[0];
+            if (!argument)
+                return;
+            for (const range of keyRanges(source, argument)) {
+                definitions.push({
+                    key: range.key,
+                    command: command.name,
+                    targetFrom: command.from,
+                    targetTo: argument.to,
+                    source: "bibitem"
+                });
+            }
+        }
+    });
+    return definitions;
+}
+function definitionsFromBibtex(source) {
+    return findBibtexEntryKeys(source).map((entry) => ({
+        key: entry.key,
+        command: "bibtex",
+        targetFrom: entry.entryFrom,
+        targetTo: entry.entryTo,
+        source: "bibtex"
+    }));
+}
+export function findLatexReferenceDefinitions(source, kind, bibtex = false) {
+    if (bibtex)
+        return kind === "citation" ? definitionsFromBibtex(source) : [];
+    return definitionsFromLatex(source, kind);
+}
+export function lineAndColumnAt(source, offset) {
+    const boundedOffset = Math.max(0, Math.min(offset, source.length));
+    let line = 1;
+    let lineStart = 0;
+    for (let index = 0; index < boundedOffset; index += 1) {
+        if (source[index] !== "\n")
+            continue;
+        line += 1;
+        lineStart = index + 1;
+    }
+    return { line, column: boundedOffset - lineStart + 1 };
+}

package/dist/shared/latexRoot.js

@@ -0,0 +1,21 @@
+import { maskLatexComments, maskLatexLiteralContent } from "./latexLiterals.js";
+function isEscaped(source, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1)
+        backslashes += 1;
+    return backslashes % 2 === 1;
+}
+/**
+ * Return whether source contains a real `\\documentclass` declaration.
+ * Literal code and comments are ignored consistently by browser-side root
+ * selection and server-side ZIP import.
+ */
+export function hasLatexDocumentClass(source) {
+    const visible = maskLatexComments(maskLatexLiteralContent(source));
+    const declaration = /\\documentclass(?![A-Za-z@])\s*(?:\[[^\]]*\]\s*)?\{/g;
+    for (const match of visible.matchAll(declaration)) {
+        if (match.index !== undefined && !isEscaped(visible, match.index))
+            return true;
+    }
+    return false;
+}

package/dist/shared/latexScanner.js

@@ -0,0 +1,183 @@
+/**
+ * Offset-preserving lexical helpers shared by LaTeX reference, dependency,
+ * outline-adjacent, and completion logic. This is intentionally a scanner,
+ * not a TeX expansion engine: it understands comments, literal forms, command
+ * boundaries, and balanced arguments without assigning package semantics.
+ */
+import { inlineLatexLiteralEnd, literalEnvironmentEnd, literalEnvironmentNames } from "./latexLiterals.js";
+const literalEnvironments = new Set(literalEnvironmentNames);
+function isCommandNameCharacter(character) {
+    return /[A-Za-z@0-9:_-]/.test(character);
+}
+export function isLatexEscaped(source, index) {
+    let backslashes = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === "\\"; cursor -= 1)
+        backslashes += 1;
+    return backslashes % 2 === 1;
+}
+export function isLatexCommentStart(source, index) {
+    return source[index] === "%" && !isLatexEscaped(source, index);
+}
+export function skipLatexComment(source, index) {
+    const newline = source.indexOf("\n", index);
+    return newline === -1 ? source.length : newline;
+}
+export function skipLatexTrivia(source, start) {
+    let index = start;
+    while (index < source.length) {
+        if (/\s/.test(source[index])) {
+            index += 1;
+            continue;
+        }
+        if (isLatexCommentStart(source, index)) {
+            index = skipLatexComment(source, index);
+            continue;
+        }
+        break;
+    }
+    return index;
+}
+/** Read one balanced braced or bracketed argument without changing offsets. */
+export function readLatexBalancedArgument(source, start, opening, closing) {
+    if (source[start] !== opening)
+        return null;
+    let depth = 0;
+    let braceDepth = 0;
+    for (let index = start; index < source.length; index += 1) {
+        const character = source[index];
+        if (character === "\\" && index + 1 < source.length) {
+            index += 1;
+            continue;
+        }
+        if (isLatexCommentStart(source, index)) {
+            index = skipLatexComment(source, index) - 1;
+            continue;
+        }
+        // Braced content inside an optional argument can contain literal square
+        // brackets, which must not close its outer option.
+        if (opening === "[") {
+            if (character === "{") {
+                braceDepth += 1;
+                continue;
+            }
+            if (character === "}" && braceDepth > 0) {
+                braceDepth -= 1;
+                continue;
+            }
+            if (braceDepth > 0)
+                continue;
+        }
+        if (character === opening) {
+            depth += 1;
+            continue;
+        }
+        if (character !== closing)
+            continue;
+        depth -= 1;
+        if (depth === 0) {
+            return {
+                from: start,
+                to: index + 1,
+                contentFrom: start + 1,
+                contentTo: index
+            };
+        }
+    }
+    return null;
+}
+export function readLatexMandatoryArguments(source, start, maximum) {
+    const argumentsFound = [];
+    let index = start;
+    while (argumentsFound.length < maximum) {
+        index = skipLatexTrivia(source, index);
+        while (source[index] === "[") {
+            const optional = readLatexBalancedArgument(source, index, "[", "]");
+            if (!optional)
+                return argumentsFound;
+            index = skipLatexTrivia(source, optional.to);
+        }
+        if (source[index] !== "{")
+            break;
+        const mandatory = readLatexBalancedArgument(source, index, "{", "}");
+        if (!mandatory)
+            break;
+        argumentsFound.push(mandatory);
+        index = mandatory.to;
+    }
+    return argumentsFound;
+}
+export function readLatexOptionalArguments(source, start, maximum) {
+    const argumentsFound = [];
+    let index = start;
+    while (argumentsFound.length < maximum) {
+        index = skipLatexTrivia(source, index);
+        if (source[index] !== "[")
+            break;
+        const optional = readLatexBalancedArgument(source, index, "[", "]");
+        if (!optional)
+            break;
+        argumentsFound.push(optional);
+        index = optional.to;
+    }
+    return argumentsFound;
+}
+function readLatexCommand(source, start) {
+    if (source[start] !== "\\" || start + 1 >= source.length)
+        return null;
+    let index = start + 1;
+    if (!/[A-Za-z@]/.test(source[index])) {
+        return { name: source[index], from: start, to: index + 1 };
+    }
+    while (index < source.length && isCommandNameCharacter(source[index]))
+        index += 1;
+    const name = source.slice(start + 1, index);
+    if (source[index] === "*")
+        index += 1;
+    return { name, from: start, to: index };
+}
+function skipLiteralEnvironment(source, command) {
+    if (command.name !== "begin")
+        return command.to;
+    const environment = readLatexMandatoryArguments(source, command.to, 1)[0];
+    if (!environment)
+        return command.to;
+    const name = source.slice(environment.contentFrom, environment.contentTo).trim();
+    if (!literalEnvironments.has(name))
+        return command.to;
+    return literalEnvironmentEnd(source, environment.to, name)?.to ?? source.length;
+}
+/**
+ * Visit visible TeX commands in source order. Commands nested in arguments are
+ * intentionally still visited; commands in comments and literal source forms
+ * are not.
+ */
+export function forEachLatexCommand(source, visitor) {
+    let index = 0;
+    while (index < source.length) {
+        if (isLatexCommentStart(source, index)) {
+            index = skipLatexComment(source, index);
+            continue;
+        }
+        if (source[index] !== "\\") {
+            index += 1;
+            continue;
+        }
+        const command = readLatexCommand(source, index);
+        if (!command) {
+            index += 1;
+            continue;
+        }
+        const literalEnd = inlineLatexLiteralEnd(source, command.from);
+        if (literalEnd !== null && literalEnd > command.to) {
+            index = literalEnd;
+            continue;
+        }
+        const environmentEnd = skipLiteralEnvironment(source, command);
+        if (environmentEnd > command.to) {
+            index = environmentEnd;
+            continue;
+        }
+        visitor(command);
+        index = command.to;
+    }
+}

package/dist/shared/writingChecks.js

@@ -0,0 +1,4 @@
+/** Bibliographies are structured reference data, not prose. */
+export function supportsWritingChecks(path) {
+    return !/\.bib$/i.test(path.trim());
+}