gurkencheck 0.0.9 → 0.1.0

package/dist/rules/no-restricted-tags.js

@@ -2,11 +2,13 @@ import { getNodeType } from '../gherkin/keywords.js';
 import { taggedNodesOf } from '../gherkin/traverse.js';
 import { mergeDefaults } from '../util/collections.js';
 import { at } from '../util/location.js';
+import { invalidPatterns } from '../util/patterns.js';
 const name = 'no-restricted-tags';
 const availableConfigs = { tags: [], patterns: [] };
 const rule = {
     name,
     availableConfigs,
+    verifySettings: (settings) => invalidPatterns('patterns', settings['patterns']),
     run(feature, _file, configuration) {
         if (feature === undefined) {
             return [];
@@ -32,4 +34,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-restricted-tags.js.map

package/dist/rules/no-scenario-outlines-without-examples.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-scenario-outlines-without-examples.d.ts.map

package/dist/rules/no-scenario-outlines-without-examples.js

@@ -26,4 +26,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-scenario-outlines-without-examples.js.map

package/dist/rules/no-scenarios-without-then.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-scenarios-without-then.d.ts.map

package/dist/rules/no-scenarios-without-then.js

@@ -47,4 +47,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-scenarios-without-then.js.map

package/dist/rules/no-scenarios-without-when.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-scenarios-without-when.d.ts.map

package/dist/rules/no-scenarios-without-when.js

@@ -47,4 +47,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-scenarios-without-when.js.map

package/dist/rules/no-superfluous-tags.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-superfluous-tags.d.ts.map

package/dist/rules/no-superfluous-tags.js

@@ -37,4 +37,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-superfluous-tags.js.map

package/dist/rules/no-trailing-spaces.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-trailing-spaces.d.ts.map

package/dist/rules/no-trailing-spaces.js

@@ -1,11 +1,21 @@
-import { atLineColumn } from '../util/location.js';
+import { markDocStrings } from '../util/lines.js';
+import { atLineColumn, columnOf } from '../util/location.js';
 const name = 'no-trailing-spaces';
 const TRAILING_WHITESPACE = /[\t ]+$/;
 const rule = {
     name,
-    run(_feature, file) {
+    run(feature, file) {
         const errors = [];
+        const inDocString = markDocStrings(file.lines, feature);
         file.lines.forEach((line, index) => {
+            // The content of a doc string is data - expected output, a request
+            // body - where trailing spaces may be the point. Its delimiters are
+            // layout like any other line.
+            const trimmed = line.trim();
+            const isDelimiter = trimmed.startsWith('"""') || trimmed.startsWith('```');
+            if (inDocString[index] === true && !isDelimiter) {
+                return;
+            }
             const trailing = TRAILING_WHITESPACE.exec(line);
             if (trailing !== null) {
                 errors.push({
@@ -13,7 +23,7 @@ const rule = {
                     rule: name,
                     // Point at the first character of the run, so an editor can
                     // underline exactly what has to go.
-                    ...atLineColumn(index + 1, trailing.index + 1),
+                    ...atLineColumn(index + 1, columnOf(line, trailing.index)),
                 });
             }
         });
@@ -21,4 +31,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-trailing-spaces.js.map

package/dist/rules/no-undeclared-variables.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-undeclared-variables.d.ts.map

package/dist/rules/no-undeclared-variables.js

@@ -14,17 +14,19 @@ const rule = {
             if (scenario.examples.length === 0) {
                 continue;
             }
-            const { declared, used } = variablesOf(scenario);
+            const { declared, tables, used } = variablesOf(scenario);
             for (const [variable, positions] of used) {
-                if (declared.has(variable)) {
-                    continue;
-                }
-                for (const position of positions) {
-                    errors.push({
-                        message: `Step variable "${variable}" does not exist in the examples table`,
-                        rule: name,
-                        ...position,
-                    });
+                // Declared nowhere is one mistake; declared in some tables but not
+                // all is another, and the table leaving it out is worth naming.
+                const messages = !declared.has(variable)
+                    ? [`Step variable "${variable}" does not exist in the examples table`]
+                    : tables
+                        .filter((table) => !table.columns.has(variable))
+                        .map((table) => `Step variable "${variable}" does not exist in the examples table on line ${table.line}`);
+                for (const message of messages) {
+                    for (const position of positions) {
+                        errors.push({ message, rule: name, ...position });
+                    }
                 }
             }
         }
@@ -32,4 +34,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-undeclared-variables.js.map

package/dist/rules/no-unnamed-features.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-unnamed-features.d.ts.map

package/dist/rules/no-unnamed-features.js

@@ -16,4 +16,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-unnamed-features.js.map

package/dist/rules/no-unnamed-scenarios.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-unnamed-scenarios.d.ts.map

package/dist/rules/no-unnamed-scenarios.js

@@ -21,4 +21,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-unnamed-scenarios.js.map

package/dist/rules/no-unused-variables.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=no-unused-variables.d.ts.map

package/dist/rules/no-unused-variables.js

@@ -33,4 +33,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=no-unused-variables.js.map

package/dist/rules/one-space-between-tags.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=one-space-between-tags.d.ts.map

package/dist/rules/one-space-between-tags.js

@@ -8,7 +8,9 @@ function checkTags(tags, errors) {
         for (let index = 0; index < ordered.length - 1; index++) {
             const current = ordered[index];
             const next = ordered[index + 1];
-            const endOfCurrent = (current.location.column ?? 0) + current.name.length;
+            // Gherkin counts columns in characters, not in the UTF-16 units that
+            // .length counts, so a tag holding an emoji is measured the same way.
+            const endOfCurrent = (current.location.column ?? 0) + [...current.name].length;
             if (endOfCurrent < (next.location.column ?? 0) - 1) {
                 errors.push({
                     message: `There is more than one space between the tags ${current.name} and ${next.name}`,
@@ -33,4 +35,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=one-space-between-tags.js.map

package/dist/rules/only-one-when.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=only-one-when.d.ts.map

package/dist/rules/only-one-when.js

@@ -28,15 +28,16 @@ const rule = {
             let firstViolation = { line: 0 };
             for (const step of scenario.steps) {
                 const keyword = getNeutralKeyword(step, feature.language);
-                // An `And` carries on from whichever keyword came before it, however
-                // many of them are chained together.
-                const continuesWhen = keyword === 'and' && lastRealKeyword === 'when';
+                // An `And` or `*` carries on from whichever keyword came before it,
+                // however many of them are chained together.
+                const continues = keyword === 'and' || keyword === 'star';
+                const continuesWhen = continues && lastRealKeyword === 'when';
                 if (keyword !== 'when' && !continuesWhen) {
                     lastRealKeyword = keyword;
                     continue;
                 }
                 lastRealKeyword = 'when';
-                if (keyword === 'and' && !countAnd) {
+                if (continues && !countAnd) {
                     continue;
                 }
                 whenCount++;
@@ -56,4 +57,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=only-one-when.js.map

package/dist/rules/required-tags.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=required-tags.d.ts.map

package/dist/rules/required-tags.js

@@ -2,25 +2,36 @@ import { getNodeType } from '../gherkin/keywords.js';
 import { scenariosOf } from '../gherkin/traverse.js';
 import { mergeDefaults } from '../util/collections.js';
 import { at } from '../util/location.js';
+import { invalidPatterns } from '../util/patterns.js';
 const name = 'required-tags';
 const availableConfigs = { tags: [], ignoreUntagged: true };
 const rule = {
     name,
     availableConfigs,
+    verifySettings: (settings) => invalidPatterns('tags', settings['tags']),
     run(feature, _file, configuration) {
         if (feature === undefined) {
             return [];
         }
         const config = mergeDefaults(availableConfigs, configuration);
         const errors = [];
-        for (const { scenario } of scenariosOf(feature)) {
+        for (const { scenario, rule: parent } of scenariosOf(feature)) {
             if (config.ignoreUntagged && scenario.tags.length === 0) {
                 continue;
             }
+            // A scenario runs with the tags of its Feature and Rule as well as its
+            // own, and each Examples table's rows with that table's tags on top.
+            // Asking for the tag to be repeated on the scenario would only have
+            // no-superfluous-tags complain about it.
+            const inherited = [...feature.tags, ...(parent?.tags ?? []), ...scenario.tags];
+            const tagSets = scenario.examples.length === 0
+                ? [inherited]
+                : scenario.examples.map((examples) => [...inherited, ...examples.tags]);
             const scenarioType = getNodeType(scenario, feature.language);
             for (const required of config.tags) {
                 const pattern = new RegExp(required);
-                if (!scenario.tags.some((tag) => pattern.test(tag.name))) {
+                const found = tagSets.every((tags) => tags.some((tag) => pattern.test(tag.name)));
+                if (!found) {
                     errors.push({
                         message: `No tag found matching ${required} for ${scenarioType}`,
                         rule: name,
@@ -33,4 +44,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=required-tags.js.map

package/dist/rules/scenario-size.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=scenario-size.d.ts.map

package/dist/rules/scenario-size.js

@@ -34,4 +34,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=scenario-size.js.map

package/dist/rules/use-and.d.ts

@@ -1,4 +1,3 @@
 import type { LintRule } from '../types.ts';
 declare const rule: LintRule;
 export default rule;
-//# sourceMappingURL=use-and.d.ts.map

package/dist/rules/use-and.js

@@ -13,7 +13,8 @@ const rule = {
             let previousKeyword;
             for (const step of node.steps) {
                 const keyword = getNeutralKeyword(step, feature.language);
-                if (keyword === 'and') {
+                // And and * already carry on from the step before them.
+                if (keyword === 'and' || keyword === 'star') {
                     continue;
                 }
                 if (keyword === previousKeyword) {
@@ -30,4 +31,3 @@ const rule = {
     },
 };
 export default rule;
-//# sourceMappingURL=use-and.js.map

package/dist/rules.d.ts

@@ -59,4 +59,3 @@ export declare function finishRun(rules: RuleRegistry, configuration: Configurat
  * checking a single file wants.
  */
 export declare function runEnabledRules(feature: Feature | undefined, file: FeatureFile, configuration: Configuration, rules: RuleRegistry, run?: Run): Promise<RuleError[]>;
-//# sourceMappingURL=rules.d.ts.map

package/dist/rules.js

@@ -9,6 +9,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 /**
  * Assembling the set of rules available to a run, and running them.
  */
+import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { BUILT_IN_RULES } from './rules/index.js';
@@ -35,7 +36,21 @@ function extractRule(loaded, source) {
 }
 async function loadRulesFrom(directory) {
     const resolved = path.resolve(directory);
-    const files = globSync(`*.${RULE_EXTENSIONS}`, { cwd: resolved });
+    // A directory that is not there would otherwise contribute no rules and no
+    // complaint, and a run meant to include them would pass without them.
+    let stats;
+    try {
+        stats = fs.statSync(resolved);
+    }
+    catch {
+        throw new Error(`Could not find the rules directory "${directory}".`);
+    }
+    if (!stats.isDirectory()) {
+        throw new Error(`The rules directory "${directory}" is not a directory.`);
+    }
+    // Declaration files sit beside TypeScript rules as a matter of course, and
+    // hold types, not code.
+    const files = globSync(`*.${RULE_EXTENSIONS}`, { cwd: resolved }).filter((file) => !/\.d\.[mc]?ts$/u.test(file));
     const loaded = [];
     for (const file of files) {
         const absolute = path.join(resolved, file);
@@ -136,6 +151,28 @@ export function beginRun(rules, configuration) {
     }
     return run;
 }
+/**
+ * The line a finding names, or 0 - a finding about the whole file - when a
+ * custom rule gave none, or something that is not a line number. Passed on
+ * as it was, it would print as `undefined` where the line belongs.
+ */
+function lineOf(finding) {
+    const { line } = finding;
+    return typeof line === 'number' && Number.isInteger(line) && line >= 0 ? line : 0;
+}
+/**
+ * The finding reported in place of a rule's own when it hands back something
+ * other than a list. Iterating it anyway would throw somewhere far from the
+ * rule, and the message would name whatever happened to be running there.
+ */
+function notAList(ruleName, found) {
+    const what = found === null ? 'null' : typeof found;
+    return {
+        message: `Rule "${ruleName}" returned ${what} instead of an array of findings`,
+        rule: 'unexpected-error',
+        line: 0,
+    };
+}
 /**
  * Ends a run, collecting what could only be worked out once every file had
  * been seen.
@@ -153,8 +190,12 @@ export async function finishRun(rules, configuration, run) {
         const severity = getRuleSeverity(config);
         try {
             const found = await rule.onRunEnd(getRuleSettings(config), run.contextFor(rule.name));
+            if (!Array.isArray(found)) {
+                findings.push(notAList(rule.name, found));
+                continue;
+            }
             for (const finding of found) {
-                findings.push({ severity, ...finding });
+                findings.push({ severity, ...finding, line: lineOf(finding) });
             }
         }
         catch (thrown) {
@@ -190,6 +231,7 @@ export async function runEnabledRules(feature, file, configuration, rules, run =
             continue;
         }
         const severity = getRuleSeverity(config);
+        // Typed as what a custom rule could really hand back, not what it should.
         let found;
         try {
             found = await rule.run(feature, file, getRuleSettings(config), run.contextFor(rule.name));
@@ -206,12 +248,15 @@ export async function runEnabledRules(feature, file, configuration, rules, run =
             });
             continue;
         }
+        if (!Array.isArray(found)) {
+            errors.push(notAList(rule.name, found));
+            continue;
+        }
         for (const error of found) {
             // The configuration decides how loudly a rule reports, so a custom rule
             // needs no say in it - but one that sets a severity itself is respected.
-            errors.push({ severity, ...error });
+            errors.push({ severity, ...error, line: lineOf(error) });
         }
     }
     return errors;
 }
-//# sourceMappingURL=rules.js.map

package/dist/stats/collect.d.ts

@@ -28,4 +28,3 @@ export declare function collectStatistics(parsed: readonly ParseResult[], option
  * suite of any size costs the same as the report it produces.
  */
 export declare function collectStatisticsFrom(parsed: Sequence<ParseResult>, options?: CollectOptions): Promise<Statistics>;
-//# sourceMappingURL=collect.d.ts.map

package/dist/stats/collect.js

@@ -246,4 +246,3 @@ export async function collectStatisticsFrom(parsed, options = {}) {
     }
     return summarise(tally, options);
 }
-//# sourceMappingURL=collect.js.map

package/dist/stats/command.d.ts

@@ -1,4 +1,3 @@
 import type { Diagnostics } from '../diagnostics.ts';
 export declare function statsUsage(): string;
 export declare function runStats(argv: readonly string[], diagnostics?: Diagnostics): Promise<number>;
-//# sourceMappingURL=command.d.ts.map

package/dist/stats/command.js

@@ -6,7 +6,9 @@
  * ever be the reason a build goes red. Only being unable to run at all -
  * an option that makes no sense, a path that names nothing - fails.
  */
+import fs from 'node:fs';
 import { parseArgs } from 'node:util';
+import { DEFAULT_CONFIG_FILE_NAME, readConfiguredLanguage } from '../config-parser.js';
 import { EXIT_OK, EXIT_USAGE } from '../exit-codes.js';
 import { DEFAULT_IGNORE_FILE_NAME, findFeatureFileStream } from '../feature-finder.js';
 import { isKnownLanguage } from '../gherkin/dialects.js';
@@ -24,7 +26,10 @@ export function statsUsage() {
         'Options:',
         `  -f, --format <format>   output format: ${Object.keys(STATS_FORMATTERS).join(', ')}`,
         `                          (default: ${DEFAULT_STATS_FORMAT})`,
-        `  -i, --ignore <globs>    comma separated globs to skip, overriding ${DEFAULT_IGNORE_FILE_NAME}`,
+        `  -c, --config <path>     configuration file to take the language from`,
+        `                          (default: ${DEFAULT_CONFIG_FILE_NAME})`,
+        `  -i, --ignore <globs>    comma separated globs to skip, overriding ${DEFAULT_IGNORE_FILE_NAME};`,
+        '                          may be given more than once',
         '  -l, --language <code>   dialect for files with no "# language:" header',
         `      --top <n>           how many entries each list shows (default: ${DEFAULT_TOP})`,
         '  -h, --help              show this message',
@@ -41,7 +46,8 @@ export async function runStats(argv, diagnostics = SILENT) {
             args: [...argv],
             options: {
                 format: { type: 'string', short: 'f' },
-                ignore: { type: 'string', short: 'i' },
+                config: { type: 'string', short: 'c' },
+                ignore: { type: 'string', short: 'i', multiple: true },
                 language: { type: 'string', short: 'l' },
                 top: { type: 'string' },
                 help: { type: 'boolean', short: 'h' },
@@ -72,8 +78,10 @@ export async function runStats(argv, diagnostics = SILENT) {
     }
     let top = DEFAULT_TOP;
     if (values.top !== undefined) {
-        top = Number(values.top);
-        if (!Number.isInteger(top) || top < 1) {
+        // Digits only: Number() would also take 0x10, 1e3 and ' 3', none of which
+        // anybody means as a count.
+        top = /^\d+$/u.test(values.top) ? Number(values.top) : Number.NaN;
+        if (!Number.isSafeInteger(top) || top < 1) {
             diagnostics.report({
                 level: 'error',
                 message: `--top needs a whole number of at least 1, not "${values.top}".`,
@@ -81,7 +89,16 @@ export async function runStats(argv, diagnostics = SILENT) {
             return EXIT_USAGE;
         }
     }
-    const language = values.language;
+    if (values.config !== undefined && !fs.existsSync(values.config)) {
+        diagnostics.report({
+            level: 'error',
+            message: `Could not find specified config file "${values.config}"`,
+        });
+        return EXIT_USAGE;
+    }
+    // The same dialect the linter would read the files in: --language, or else
+    // the configuration's. Nothing else in the configuration matters here.
+    const language = values.language ?? (await readConfiguredLanguage(values.config));
     if (language !== undefined && !isKnownLanguage(language)) {
         diagnostics.report({
             level: 'error',
@@ -89,7 +106,8 @@ export async function runStats(argv, diagnostics = SILENT) {
         });
         return EXIT_USAGE;
     }
-    const ignore = values.ignore?.split(',').map((pattern) => pattern.trim());
+    // Given more than once, the lists add up rather than the last one winning.
+    const ignore = values.ignore?.flatMap((list) => list.split(',').map((pattern) => pattern.trim()));
     const { files, invalidPatterns } = findFeatureFileStream(positionals, ignore);
     if (invalidPatterns.length > 0) {
         for (const pattern of invalidPatterns) {
@@ -110,4 +128,3 @@ export async function runStats(argv, diagnostics = SILENT) {
     console.log(formatter(statistics, { top }));
     return EXIT_OK;
 }
-//# sourceMappingURL=command.js.map

package/dist/stats/format/index.d.ts

@@ -22,4 +22,3 @@ export declare function getStatsFormatter(format: string | undefined): StatsForm
 export { toJson, toMarkdown, toText };
 export { DEFAULT_TOP } from './shared.ts';
 export type { StatsFormatOptions } from './shared.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/stats/format/index.js

@@ -22,4 +22,3 @@ export function getStatsFormatter(format) {
 }
 export { toJson, toMarkdown, toText };
 export { DEFAULT_TOP } from './shared.js';
-//# sourceMappingURL=index.js.map

package/dist/stats/format/json.d.ts

@@ -7,4 +7,3 @@
 import type { Statistics } from '../types.ts';
 /** The whole report, indented so a diff of two runs is readable. */
 export declare function toJson(statistics: Statistics): string;
-//# sourceMappingURL=json.d.ts.map

package/dist/stats/format/json.js

@@ -2,4 +2,3 @@
 export function toJson(statistics) {
     return JSON.stringify(statistics, null, 2);
 }
-//# sourceMappingURL=json.js.map

package/dist/stats/format/markdown.d.ts

@@ -5,4 +5,3 @@ import type { Statistics } from '../types.ts';
 import type { StatsFormatOptions } from './shared.ts';
 /** The report, as Markdown. */
 export declare function toMarkdown(statistics: Statistics, options: StatsFormatOptions): string;
-//# sourceMappingURL=markdown.d.ts.map

package/dist/stats/format/markdown.js

@@ -1,11 +1,30 @@
 import { andMore, head, location, percent, plural, summarise } from './shared.js';
 /** A pipe inside a cell would start a column of its own. */
-function cell(text) {
+function inCell(text) {
     return text.replace(/\|/gu, '\\|');
 }
-/** ``` `text` ```, so step text keeps its quotes and angle brackets. */
-function code(text) {
-    return `\`${cell(text)}\``;
+/**
+ * Text written into a table cell as it is: Markdown's own characters escaped,
+ * so a scenario called `*important*` is not shown in italics, and a line
+ * break, which would end the row, made a space.
+ */
+function cell(text) {
+    return inCell(text.replace(/[\\`*_{}[\]<>#!~]/gu, '\\$&').replace(/\r?\n/gu, ' '));
+}
+/**
+ * ``` `text` ```, so step text keeps its quotes and angle brackets.
+ *
+ * The fence is one backtick longer than the longest run inside the text, so a
+ * backtick in the step cannot close it early; a space pads a text starting or
+ * ending with one, as CommonMark asks. Pipes are only escaped inside a table,
+ * because anywhere else the backslash would be shown.
+ */
+function code(text, inTable = true) {
+    const longest = Math.max(0, ...(text.match(/`+/gu) ?? []).map((run) => run.length));
+    const fence = '`'.repeat(longest + 1);
+    const padding = text.startsWith('`') || text.endsWith('`') ? ' ' : '';
+    const span = `${fence}${padding}${text}${padding}${fence}`;
+    return inTable ? inCell(span) : span;
 }
 function table(headings, alignments, rows) {
     return [
@@ -106,7 +125,7 @@ export function toMarkdown(statistics, options) {
     }
     if (tags.usedOnce.length > 0) {
         const tagsOnce = head(tags.usedOnce, options.top);
-        lines.push('', '### Tags written exactly once', '', tagsOnce.shown.map(code).join(', '), ...more(tagsOnce.hidden, 'tag'));
+        lines.push('', '### Tags written exactly once', '', tagsOnce.shown.map((tag) => code(tag, false)).join(', '), ...more(tagsOnce.hidden, 'tag'));
     }
     if (languages.length > 1) {
         lines.push('', '## Languages', '', ...table(['Dialect', 'Files'], ['left', 'right'], languages.map((language) => [code(language.code), String(language.files)])));
@@ -120,4 +139,3 @@ export function toMarkdown(statistics, options) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=markdown.js.map

package/dist/stats/format/shared.d.ts

@@ -31,4 +31,3 @@ export declare function head<T>(values: readonly T[], top: number): {
     shown: T[];
     hidden: number;
 };
-//# sourceMappingURL=shared.d.ts.map

package/dist/stats/format/shared.js

@@ -34,4 +34,3 @@ export function andMore(hidden, singular, many = `${singular}s`) {
 export function head(values, top) {
     return { shown: values.slice(0, top), hidden: Math.max(0, values.length - top) };
 }
-//# sourceMappingURL=shared.js.map

package/dist/stats/format/text.d.ts

@@ -2,4 +2,3 @@ import type { Statistics } from '../types.ts';
 import type { StatsFormatOptions } from './shared.ts';
 /** The report, as a block of text. */
 export declare function toText(statistics: Statistics, options: StatsFormatOptions): string;
-//# sourceMappingURL=text.d.ts.map

package/dist/stats/format/text.js

@@ -172,4 +172,3 @@ export function toText(statistics, options) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=text.js.map