gurkencheck 0.0.10 → 0.1.0

package/dist/stats/index.d.ts

@@ -18,4 +18,3 @@ export { DEFAULT_STATS_FORMAT, DEFAULT_TOP, STATS_FORMATTERS, getStatsFormatter,
 export type { StatsFormatOptions, StatsFormatter } from './format/index.ts';
 export { runStats, statsUsage } from './command.ts';
 export type * from './types.ts';
-//# sourceMappingURL=index.d.ts.map

package/dist/stats/index.js

@@ -14,4 +14,3 @@ export { DEFAULT_SIMILARITY, boundedEditDistance, groupSimilar } from './similar
 export { NUMBER_MARKER, PLACEHOLDER_MARKER, STRING_MARKER, countWords, normaliseStepText, } from './normalise.js';
 export { DEFAULT_STATS_FORMAT, DEFAULT_TOP, STATS_FORMATTERS, getStatsFormatter, toJson as statisticsToJson, toMarkdown, toText, } from './format/index.js';
 export { runStats, statsUsage } from './command.js';
-//# sourceMappingURL=index.js.map

package/dist/stats/normalise.d.ts

@@ -35,4 +35,3 @@ export declare const NUMBER_MARKER = "0";
 export declare function normaliseStepText(text: string): string;
 /** How many words a step is made of, counted before normalisation. */
 export declare function countWords(text: string): number;
-//# sourceMappingURL=normalise.d.ts.map

package/dist/stats/normalise.js

@@ -26,16 +26,34 @@ export const STRING_MARKER = '""';
 /** Stands in for a number, whatever its value. */
 export const NUMBER_MARKER = '0';
 const PLACEHOLDER = /<[^<>]*>/gu;
-const QUOTED = /"[^"]*"/gu;
+/** A double quoted string, which may hold quotes escaped with a backslash. */
+const QUOTED = /"(?:[^"\\]|\\.)*"/gu;
 /**
- * A whole number or decimal standing on its own. The word boundaries keep
- * `1st` and `v2` intact, where the digits are part of a name rather than a
- * value a step definition would capture.
+ * A whole number or decimal standing on its own, with its minus sign. The
+ * word boundaries keep `1st` and `v2` intact, where the digits are part of a
+ * name rather than a value a step definition would capture.
  */
-const NUMBER = /\b\d+(?:[.,]\d+)*\b/gu;
+const NUMBER = /(?:(?<![\p{L}\p{N}_])-)?\b\d+(?:[.,]\d+)*\b/gu;
 const WHITESPACE = /\s+/gu;
-/** A full stop or exclamation mark at the end, which changes nothing. */
-const TRAILING_PUNCTUATION = /[\s.!]*[.!]$/u;
+/**
+ * The text without a full stop or exclamation mark at the end, which changes
+ * nothing, and whatever spaces and further stops sit in front of it: `I own
+ * it .` and `I own it` are one step. A text of nothing but punctuation is
+ * left as it is rather than made empty.
+ *
+ * A loop rather than a regular expression: `/[\s.!]*[.!]$/` is tried from
+ * every position in a long run of ` .`, which takes seconds on one step.
+ */
+function withoutTrailingPunctuation(text) {
+    if (!text.endsWith('.') && !text.endsWith('!')) {
+        return text;
+    }
+    let end = text.length;
+    while (end > 0 && /[\s.!]/u.test(text[end - 1])) {
+        end--;
+    }
+    return end === 0 ? text : text.slice(0, end);
+}
 /**
  * The form of a step text used to decide whether two steps are the same one.
  *
@@ -44,22 +62,17 @@ const TRAILING_PUNCTUATION = /[\s.!]*[.!]$/u;
  * half the sentence. Cucumber's own expressions quote with `"` anyway.
  */
 export function normaliseStepText(text) {
-    return text
+    const normalised = text
         .replace(PLACEHOLDER, PLACEHOLDER_MARKER)
         .replace(QUOTED, STRING_MARKER)
         .replace(NUMBER, NUMBER_MARKER)
         .toLowerCase()
         .replace(WHITESPACE, ' ')
-        .trim()
-        // Whatever sat in front of the full stop goes with it: `I own it .` and
-        // `I own it` are one step, and a step text ending in a space is not one
-        // anybody would recognise in the report.
-        .replace(TRAILING_PUNCTUATION, '')
         .trim();
+    return withoutTrailingPunctuation(normalised);
 }
 /** How many words a step is made of, counted before normalisation. */
 export function countWords(text) {
     const trimmed = text.trim();
     return trimmed === '' ? 0 : trimmed.split(WHITESPACE).length;
 }
-//# sourceMappingURL=normalise.js.map

package/dist/stats/similar.d.ts

@@ -58,4 +58,3 @@ export declare function boundedEditDistance(left: string, right: string, limit:
 export declare function groupSimilar<T extends {
     text: string;
 }>(entries: readonly T[], options?: SimilarityOptions): T[][];
-//# sourceMappingURL=similar.d.ts.map

package/dist/stats/similar.js

@@ -170,4 +170,3 @@ export function groupSimilar(entries, options = DEFAULT_SIMILARITY) {
         .filter((group) => group.length > 1)
         .map((group) => group.sort((a, b) => a.index - b.index).map((member) => member.entry));
 }
-//# sourceMappingURL=similar.js.map

package/dist/stats/types.d.ts

@@ -156,4 +156,3 @@ export interface Statistics {
     /** Dialects in use, most common first. A single stray entry is a bug. */
     languages: LanguageEntry[];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/stats/types.js

@@ -7,4 +7,3 @@
  * report stays short enough to read.
  */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/suppressions.d.ts

@@ -21,6 +21,7 @@
  * breaks one of them cannot be read at all, so hiding the message would leave
  * nothing but silence.
  */
+import type { Feature } from '@cucumber/messages';
 import type { RuleError } from './types.ts';
 export interface Suppressions {
     /** True when a directive in the file covers this error. */
@@ -28,6 +29,8 @@ export interface Suppressions {
     /** True when the file carries no directives at all. */
     readonly isEmpty: boolean;
 }
-/** Reads the directives out of a feature file's lines. */
-export declare function readSuppressions(lines: readonly string[]): Suppressions;
-//# sourceMappingURL=suppressions.d.ts.map
+/**
+ * Reads the directives out of a feature file's lines. Given the parsed
+ * document, it is used to tell where the doc strings are.
+ */
+export declare function readSuppressions(lines: readonly string[], feature?: Feature): Suppressions;

package/dist/suppressions.js

@@ -1,5 +1,10 @@
 import { markDocStrings } from './util/lines.js';
-const DIRECTIVE = /^\s*#\s*gurkencheck-(disable-next-line|disable-file|disable|enable)\b(.*)$/;
+/**
+ * A directive, then the rules it names. Whitespace or the end of the line has
+ * to follow the directive's name: `\b` would also match before a hyphen, and
+ * read `disable-nextline` as a `disable` of every rule named after it.
+ */
+const DIRECTIVE = /^\s*#\s*gurkencheck-(disable-next-line|disable-file|disable|enable)(?=\s|$)(.*)$/;
 /** Stands in for "every rule" when a directive names none. */
 const ALL_RULES = '*';
 function parseRuleNames(rest) {
@@ -9,16 +14,25 @@ function parseRuleNames(rest) {
         .filter((name) => name !== '');
     return names.length > 0 ? names : [ALL_RULES];
 }
-/** Reads the directives out of a feature file's lines. */
-export function readSuppressions(lines) {
-    const inDocString = markDocStrings(lines);
+/**
+ * Reads the directives out of a feature file's lines. Given the parsed
+ * document, it is used to tell where the doc strings are.
+ */
+export function readSuppressions(lines, feature) {
+    const inDocString = markDocStrings(lines, feature);
     const wholeFile = new Set();
     /** Line number -> the rules switched off on that line only. */
     const nextLine = new Map();
-    const ranges = [];
-    /** Rule -> the line its still-open `disable` started on. */
-    const open = new Map();
+    const switches = [];
     let found = false;
+    /**
+     * The first line that is neither blank nor a comment. A finding about the
+     * whole file belongs to no line, so it is taken to sit here: a `disable`
+     * written in the comments at the top of the file covers it, one further
+     * down does not.
+     */
+    const firstContent = lines.findIndex((text) => text.trim() !== '' && !text.trim().startsWith('#'));
+    const wholeFileLine = firstContent === -1 ? lines.length + 1 : firstContent + 1;
     lines.forEach((text, index) => {
         if (inDocString[index] === true) {
             return;
@@ -40,31 +54,11 @@ export function readSuppressions(lines) {
                 onLine.add(name);
                 nextLine.set(line + 1, onLine);
             }
-            else if (kind === 'disable') {
-                if (!open.has(name)) {
-                    open.set(name, line);
-                }
-            }
             else {
-                // enable
-                const from = open.get(name);
-                if (from !== undefined) {
-                    ranges.push({ rule: name, from, to: line });
-                    open.delete(name);
-                }
-                if (name === ALL_RULES) {
-                    // `enable` with no names closes everything that is open.
-                    for (const [openRule, openFrom] of open) {
-                        ranges.push({ rule: openRule, from: openFrom, to: line });
-                    }
-                    open.clear();
-                }
+                switches.push({ line, off: kind === 'disable', rule: name });
             }
         }
     });
-    for (const [rule, from] of open) {
-        ranges.push({ rule, from, to: Infinity });
-    }
     const covers = (rule, candidate) => candidate === ALL_RULES || candidate === rule;
     return {
         isEmpty: !found,
@@ -77,8 +71,20 @@ export function readSuppressions(lines) {
                 if (covers(error.rule, candidate))
                     return true;
             }
-            return ranges.some((range) => covers(error.rule, range.rule) && error.line >= range.from && error.line <= range.to);
+            // Whatever switched this rule on or off last, above the line, decides.
+            // So `enable use-and` after a bare `disable` switches use-and back on
+            // and leaves every other rule off, and `enable` with no names switches
+            // everything back on.
+            const line = error.line === 0 ? wholeFileLine : error.line;
+            let off = false;
+            for (const change of switches) {
+                if (change.line > line)
+                    break;
+                if (covers(error.rule, change.rule)) {
+                    off = change.off;
+                }
+            }
+            return off;
         },
     };
 }
-//# sourceMappingURL=suppressions.js.map

package/dist/types.d.ts

@@ -89,6 +89,13 @@ export interface LintRule {
      * An array lists the allowed values; an object lists the allowed keys.
      */
     readonly availableConfigs?: unknown;
+    /**
+     * Checks what the configuration gives the rule beyond the types of its
+     * settings, which are checked against `availableConfigs` already: that a
+     * pattern is a regular expression, or a value one of a fixed set. Returns
+     * what is wrong, an empty list when nothing is.
+     */
+    verifySettings?(settings: Record<string, unknown>): string[];
     /**
      * Returns the violations found in this file. A rule that needs to wait for
      * something - reading a file, asking a service - may return a promise.
@@ -122,4 +129,3 @@ export interface LintRule {
 }
 /** All rules available to a run, keyed by name. */
 export type RuleRegistry = ReadonlyMap<string, LintRule>;
-//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/util/case.d.ts

@@ -5,7 +5,8 @@
 /**
  * Splits an identifier into words, breaking on separators, on lower-to-upper
  * transitions and between a run of capitals and a following capitalised word
- * (so `XMLHttpRequest` becomes `XML`, `Http`, `Request`).
+ * (so `XMLHttpRequest` becomes `XML`, `Http`, `Request`). Letters outside
+ * ASCII are letters too: `Über` is one word, not `Ber`.
  */
 export declare function words(value: string): string[];
 /** `my fancy feature` -> `My Fancy Feature` */
@@ -18,4 +19,3 @@ export declare function camelCase(value: string): string;
 export declare function kebabCase(value: string): string;
 /** `my fancy feature` -> `my_fancy_feature` */
 export declare function snakeCase(value: string): string;
-//# sourceMappingURL=case.d.ts.map

package/dist/util/case.js

@@ -2,13 +2,28 @@
  * Word splitting and case conversion, as used by the `file-name` rule.
  * Replaces lodash's `startCase`/`camelCase`/`kebabCase`/`snakeCase`.
  */
+/** Capital letters, in any script. */
+const UPPER = String.raw `\p{Lu}\p{Lt}`;
+/**
+ * Small letters, and letters with no case at all - Japanese, Chinese, Arabic
+ * - which carry on a word the way small letters do.
+ */
+const LOWER = String.raw `\p{Ll}\p{Lm}\p{Lo}`;
+const DIGIT = String.raw `\p{Nd}`;
+const WORD = new RegExp([
+    `[${UPPER}]{2,}(?=[${UPPER}][${LOWER}]+[${DIGIT}]*|(?![${UPPER}${LOWER}${DIGIT}]))`,
+    `[${UPPER}]?[${LOWER}]+[${DIGIT}]*`,
+    `[${UPPER}]+[${DIGIT}]*`,
+    `[${DIGIT}]+`,
+].join('|'), 'gu');
 /**
  * Splits an identifier into words, breaking on separators, on lower-to-upper
  * transitions and between a run of capitals and a following capitalised word
- * (so `XMLHttpRequest` becomes `XML`, `Http`, `Request`).
+ * (so `XMLHttpRequest` becomes `XML`, `Http`, `Request`). Letters outside
+ * ASCII are letters too: `Über` is one word, not `Ber`.
  */
 export function words(value) {
-    return value.match(/[A-Z]{2,}(?=[A-Z][a-z]+\d*|\b)|[A-Z]?[a-z]+\d*|[A-Z]+\d*|\d+/g) ?? [];
+    return value.match(WORD) ?? [];
 }
 function upperFirst(word) {
     return word.charAt(0).toUpperCase() + word.slice(1);
@@ -39,4 +54,3 @@ export function snakeCase(value) {
         .map((word) => word.toLowerCase())
         .join('_');
 }
-//# sourceMappingURL=case.js.map

package/dist/util/collections.d.ts

@@ -27,4 +27,3 @@ export declare function intersectionBy<T>(values: readonly T[], other: readonly
  * their overrides back into the shared default config object.
  */
 export declare function mergeDefaults<T>(defaults: T, override: unknown): T;
-//# sourceMappingURL=collections.d.ts.map

package/dist/util/collections.js

@@ -84,4 +84,3 @@ export function mergeDefaults(defaults, override) {
     }
     return merged;
 }
-//# sourceMappingURL=collections.js.map

package/dist/util/glob.d.ts

@@ -3,6 +3,13 @@
  * slash-separated paths.
  */
 export declare function globToRegExp(pattern: string): RegExp;
+/** Escapes every character glob syntax would read, so the text matches only itself. */
+export declare function escapeGlob(literal: string): string;
+/**
+ * The path a pattern names when it holds no glob syntax, with its escapes
+ * removed, or `undefined` when it is a real pattern.
+ */
+export declare function literalPath(pattern: string): string | undefined;
 /**
  * The directory a pattern's search starts from - the leading run of literal
  * segments, resolved against `cwd`. What you would watch to be told about
@@ -13,8 +20,8 @@ export interface GlobOptions {
     /** Directory that relative patterns and returned paths are relative to. */
     cwd?: string;
     /**
-     * Patterns whose matches are dropped from the result. A pattern matching a
-     * directory drops everything below it, as in .gitignore and .eslintignore.
+     * Patterns whose matches are dropped from the result, read as .gitignore
+     * reads them. A pattern matching a directory drops everything below it.
      */
     ignore?: readonly string[];
 }
@@ -35,4 +42,3 @@ export declare function globSync(pattern: string, options?: GlobOptions): string
  * to sort: `byPathOrder` is what makes the two agree.
  */
 export declare function globStream(pattern: string, options?: GlobOptions): AsyncGenerator<string>;
-//# sourceMappingURL=glob.d.ts.map

package/dist/util/glob.js

@@ -10,7 +10,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-const REGEXP_SPECIAL_CHARACTERS = new Set('.+^$()|\\'.split(''));
+const REGEXP_SPECIAL_CHARACTERS = new Set('.+^$()|\\[]{}*?'.split(''));
 /**
  * Translates a glob pattern into an anchored regular expression matching
  * slash-separated paths.
@@ -61,8 +61,15 @@ export function globToRegExp(pattern) {
             }
         }
         else if (character === '{') {
-            braceDepth++;
-            source += '(?:';
+            // A brace with nothing closing it is taken literally, as an unclosed
+            // `[` is, rather than leaving a group open in the regular expression.
+            if (findClosingBrace(pattern, index) === -1) {
+                source += '\\{';
+            }
+            else {
+                braceDepth++;
+                source += '(?:';
+            }
         }
         else if (character === '}' && braceDepth > 0) {
             braceDepth--;
@@ -84,6 +91,23 @@ export function globToRegExp(pattern) {
 function escapeLiteral(character) {
     return REGEXP_SPECIAL_CHARACTERS.has(character) ? `\\${character}` : character;
 }
+/** Where the brace opened just before `from` closes, or -1 when it never does. */
+function findClosingBrace(pattern, from) {
+    let depth = 1;
+    for (let index = from; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === '\\') {
+            index++;
+        }
+        else if (character === '{') {
+            depth++;
+        }
+        else if (character === '}' && --depth === 0) {
+            return index;
+        }
+    }
+    return -1;
+}
 function findClosingBracket(pattern, from) {
     for (let index = from + 1; index < pattern.length; index++) {
         if (pattern[index] === ']')
@@ -91,23 +115,45 @@ function findClosingBracket(pattern, from) {
     }
     return -1;
 }
-/** True when the segment contains glob syntax rather than a literal name. */
-function isDynamic(segment) {
-    return /[*?[\]{}]/.test(segment);
+/** Escapes every character glob syntax would read, so the text matches only itself. */
+export function escapeGlob(literal) {
+    return literal.replace(/[*?[\]{}\\]/g, '\\$&');
+}
+/**
+ * The path a pattern names when it holds no glob syntax, with its escapes
+ * removed, or `undefined` when it is a real pattern.
+ */
+export function literalPath(pattern) {
+    let literal = '';
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern[index];
+        if (character === '\\' && index + 1 < pattern.length) {
+            literal += pattern[++index];
+        }
+        else if ('*?[]{}'.includes(character)) {
+            return undefined;
+        }
+        else {
+            literal += character;
+        }
+    }
+    return literal;
 }
 /**
  * The leading run of literal segments, used as the directory to start walking
- * from so that `a/b/**` does not scan the whole tree.
+ * from so that `a/b/**` does not scan the whole tree, with its escapes
+ * removed - and what is left of the pattern after it.
  */
-function staticPrefix(pattern) {
+function splitPattern(pattern) {
     const segments = pattern.split('/');
     const literal = [];
     for (const segment of segments.slice(0, -1)) {
-        if (isDynamic(segment))
+        const name = literalPath(segment);
+        if (name === undefined)
             break;
-        literal.push(segment);
+        literal.push(name);
     }
-    return literal.join('/');
+    return { prefix: literal.join('/'), rest: segments.slice(literal.length).join('/') };
 }
 /**
  * The directory a pattern's search starts from - the leading run of literal
@@ -115,7 +161,7 @@ function staticPrefix(pattern) {
  * anything the pattern could match.
  */
 export function globRoot(pattern, cwd = process.cwd()) {
-    return path.resolve(cwd, staticPrefix(pattern.split(path.sep).join('/')));
+    return path.resolve(cwd, splitPattern(pattern.split(path.sep).join('/')).prefix);
 }
 function isHidden(name) {
     return name.startsWith('.');
@@ -197,22 +243,48 @@ async function* walkStream(root) {
     }
 }
 /**
- * True when the path, or any directory leading to it, matches one of the
- * patterns.
+ * Reads an ignore pattern as .gitignore does. A pattern with no slash, other
+ * than a trailing one, matches a name at any depth; one with a slash is
+ * anchored to the working directory, whether or not it starts with `./` or
+ * `/`; a trailing slash means directories only; and a leading `!` brings back
+ * what an earlier pattern left out.
+ */
+function toIgnoreRule(pattern) {
+    let text = pattern.split(path.sep).join('/');
+    const negated = text.startsWith('!');
+    if (negated) {
+        text = text.slice(1);
+    }
+    const directoryOnly = text.endsWith('/');
+    text = text.replace(/\/+$/u, '').replace(/^(?:\.\/)+/u, '');
+    const anchored = text.includes('/');
+    text = text.replace(/^\/+/u, '');
+    return { matches: globToRegExp(anchored ? text : `**/${text}`), negated, directoryOnly };
+}
+/**
+ * True when the path, or any directory leading to it, is ignored.
  *
  * Testing the parent directories is what makes an entry like `build` or `o*e`
  * skip the whole directory rather than only a file of that exact name. Without
  * it an ignore file has to spell out `build/**` everywhere, which is not how
- * .gitignore or .eslintignore behave.
+ * .gitignore or .eslintignore behave. As there, the last pattern to match a
+ * path decides, and nothing inside an ignored directory can be brought back.
  */
-function isIgnored(relativePath, ignores) {
-    if (ignores.length === 0) {
+function isIgnored(relativePath, rules) {
+    if (rules.length === 0) {
         return false;
     }
     const segments = relativePath.split('/');
     for (let depth = 1; depth <= segments.length; depth++) {
         const prefix = segments.slice(0, depth).join('/');
-        if (ignores.some((ignore) => ignore.test(prefix))) {
+        const isDirectory = depth < segments.length;
+        let ignored = false;
+        for (const rule of rules) {
+            if ((isDirectory || !rule.directoryOnly) && rule.matches.test(prefix)) {
+                ignored = !rule.negated;
+            }
+        }
+        if (ignored) {
             return true;
         }
     }
@@ -221,18 +293,35 @@ function isIgnored(relativePath, ignores) {
 function newSearch(pattern, options) {
     const cwd = options.cwd ?? process.cwd();
     const normalisedPattern = pattern.split(path.sep).join('/');
-    const matches = globToRegExp(normalisedPattern);
-    const ignores = (options.ignore ?? []).map((ignorePattern) => globToRegExp(ignorePattern.split(path.sep).join('/')));
-    // An absolute pattern is matched against absolute paths: comparing it with
-    // a path relative to cwd can never match, and the search would come back
+    const ignores = (options.ignore ?? []).map(toIgnoreRule);
+    // Matched against absolute paths, with the literal start of the pattern
+    // resolved first. Comparing the pattern as written with a path relative to
+    // cwd goes wrong whenever the two spell the same place differently -
+    // `./features/a.feature` against `features/a.feature`, or `../**` against
+    // a file below cwd, which has no `../` at all - and the search comes back
     // empty rather than wrong, which reads as "nothing to report".
-    const absolutePattern = path.isAbsolute(normalisedPattern);
+    //
+    // A pattern holding no glob syntax names one path, which is looked at
+    // directly rather than searched for, so a file named on purpose is found
+    // even where a search would pass it by: a dotfile, or a symlink.
+    const literal = literalPath(normalisedPattern);
+    let searchRoot;
+    let matches;
+    if (literal !== undefined) {
+        searchRoot = path.resolve(cwd, literal);
+        matches = globToRegExp(escapeGlob(searchRoot.split(path.sep).join('/')));
+    }
+    else {
+        const { prefix, rest } = splitPattern(normalisedPattern);
+        searchRoot = path.resolve(cwd, prefix);
+        const root = searchRoot.split(path.sep).join('/').replace(/\/$/, '');
+        matches = globToRegExp(`${escapeGlob(root)}/${rest}`);
+    }
     return {
-        searchRoot: path.resolve(cwd, staticPrefix(normalisedPattern)),
+        searchRoot,
         match(absolutePath) {
             const relativePath = path.relative(cwd, absolutePath).split(path.sep).join('/');
-            const candidate = absolutePattern ? absolutePath.split(path.sep).join('/') : relativePath;
-            if (!matches.test(candidate))
+            if (!matches.test(absolutePath.split(path.sep).join('/')))
                 return undefined;
             if (isIgnored(relativePath, ignores))
                 return undefined;
@@ -304,4 +393,3 @@ function statOrUndefined(target) {
         return undefined;
     }
 }
-//# sourceMappingURL=glob.js.map

package/dist/util/json.d.ts

@@ -11,4 +11,3 @@
 export declare function stripJsonComments(json: string): string;
 /** Parses JSON that may contain comments. */
 export declare function parseJsonWithComments(json: string): unknown;
-//# sourceMappingURL=json.d.ts.map

package/dist/util/json.js

@@ -60,4 +60,3 @@ export function stripJsonComments(json) {
 export function parseJsonWithComments(json) {
     return JSON.parse(stripJsonComments(json));
 }
-//# sourceMappingURL=json.js.map

package/dist/util/lines.d.ts

@@ -1,6 +1,7 @@
 /**
  * Helpers for looking at a feature file as plain text.
  */
+import type { Feature } from '@cucumber/messages';
 import type { FeatureFile } from '../types.ts';
 /**
  * The lines a person would see in their editor.
@@ -17,8 +18,9 @@ export declare function contentLines(file: FeatureFile): string[];
  * Text inside a doc string is data belonging to the step, not part of the
  * layout of the file, so rules about formatting have to leave it alone.
  *
- * This reads the raw lines rather than the parsed document so that it still
- * works on a file the parser rejected.
+ * Given the parsed document, the doc strings are taken from it, which is
+ * exact. Without one - a file the parser rejected - the raw lines are read
+ * instead, and a line opening with a delimiter is taken to open a doc
+ * string, which a description line starting with `"""` also does.
  */
-export declare function markDocStrings(lines: readonly string[]): boolean[];
-//# sourceMappingURL=lines.d.ts.map
+export declare function markDocStrings(lines: readonly string[], feature?: Feature): boolean[];

package/dist/util/lines.js

@@ -1,3 +1,4 @@
+import { stepContainersOf } from '../gherkin/traverse.js';
 /**
  * The lines a person would see in their editor.
  *
@@ -18,11 +19,29 @@ const DOC_STRING_DELIMITERS = ['"""', '```'];
  * Text inside a doc string is data belonging to the step, not part of the
  * layout of the file, so rules about formatting have to leave it alone.
  *
- * This reads the raw lines rather than the parsed document so that it still
- * works on a file the parser rejected.
+ * Given the parsed document, the doc strings are taken from it, which is
+ * exact. Without one - a file the parser rejected - the raw lines are read
+ * instead, and a line opening with a delimiter is taken to open a doc
+ * string, which a description line starting with `"""` also does.
  */
-export function markDocStrings(lines) {
+export function markDocStrings(lines, feature) {
     const inside = new Array(lines.length).fill(false);
+    if (feature !== undefined) {
+        for (const { node } of stepContainersOf(feature)) {
+            for (const step of node.steps) {
+                if (step.docString === undefined)
+                    continue;
+                const { content, location } = step.docString;
+                const contentLines = content === '' ? 0 : content.split('\n').length;
+                // The opening delimiter, the content, and the closing delimiter.
+                const last = location.line + contentLines + 1;
+                for (let line = location.line; line <= last && line <= lines.length; line++) {
+                    inside[line - 1] = true;
+                }
+            }
+        }
+        return inside;
+    }
     let openDelimiter;
     lines.forEach((line, index) => {
         const trimmed = line.trim();
@@ -42,4 +61,3 @@ export function markDocStrings(lines) {
     });
     return inside;
 }
-//# sourceMappingURL=lines.js.map