text-runner-engine 7.1.0

package/dist/parsers/markdown/md-parser.d.ts

@@ -0,0 +1,50 @@
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+export type MarkdownItAst = MarkdownItNode[];
+export interface MarkdownItNode {
+    /** HTML attributes. Format: `[[name1, value1], [name2, value2]]` */
+    readonly attrs: [string, string][] | null;
+    /** An array of child nodes (inline and img tokens) */
+    readonly children: MarkdownItNode[] | null;
+    /** In a case of self-closing tag (code, html, fence, etc.), it has contents of this tag. */
+    readonly content: string;
+    /** Source map info. Format: `[line_begin, line_end]` */
+    readonly map: [number, number] | null;
+    /** HTML tag name, e.g. "p" */
+    readonly tag: string;
+    /** Type of the token, e.g. "paragraph_open" */
+    readonly type: string;
+}
+export type MarkdownItNodeAttrs = string[][];
+/** MarkdownParser parses Markdown. */
+export declare class MarkdownParser {
+    private readonly closingTagParser;
+    /** parses HTML snippets into ast.NodeLists */
+    private readonly htmlParser;
+    /** MarkdownIt instance */
+    private readonly markdownIt;
+    /** helps map Markdown to HTML node types */
+    private readonly tagMapper;
+    constructor();
+    /** returns the standard AST representing the given Markdown text */
+    parse(text: string, sourceDir: files.SourceDir, file: files.FullFilePath): ast.NodeList;
+    /** Converts the given MarkdownIt AST into the standard AST format */
+    private standardizeAST;
+    private standardizeClosingHTMLTag;
+    private standardizeClosingNode;
+    private standardizeCodeInline;
+    private standardizeEmbeddedCodeblock;
+    private standardizeFence;
+    private standardizeHeadingClose;
+    private standardizeHeadingOpen;
+    private standardizeHTMLBlock;
+    private standardizeImageNode;
+    /** Returns the standardized version of the given MarkdownIt node */
+    private standardizeNode;
+    private standardizeOpeningNode;
+    private standardizeTextNode;
+    private standizeStandaloneTag;
+}
+/** returns the given attributes from a MarkdownIt node in the standard AST format */
+export declare function standardizeMarkdownItAttributes(attrs: MarkdownItNodeAttrs | null): ast.NodeAttributes;
+//# sourceMappingURL=md-parser.d.ts.map

package/dist/parsers/markdown/md-parser.js

@@ -0,0 +1,316 @@
+import MarkdownIt from "markdown-it";
+import * as util from "util";
+import * as ast from "../../ast/index.js";
+import { UserError } from "../../errors/user-error.js";
+import * as files from "../../filesystem/index.js";
+import * as html from "../html/index.js";
+import { TagMapper } from "../tag-mapper.js";
+import { ClosingTagParser } from "./closing-tag-parser.js";
+import { OpenNodeTracker } from "./open-node-tracker.js";
+/** MarkdownParser parses Markdown. */
+export class MarkdownParser {
+    constructor() {
+        this.markdownIt = new MarkdownIt({
+            html: true,
+            linkify: false
+        });
+        this.tagMapper = new TagMapper();
+        this.closingTagParser = new ClosingTagParser(this.tagMapper);
+        this.htmlParser = new html.Parser(this.tagMapper);
+    }
+    /** returns the standard AST representing the given Markdown text */
+    parse(text, sourceDir, file) {
+        const mdAST = this.markdownIt.parse(text, {});
+        return this.standardizeAST(mdAST, new files.Location(sourceDir, file, 1), new OpenNodeTracker());
+    }
+    /** Converts the given MarkdownIt AST into the standard AST format */
+    standardizeAST(mdAST, parentLocation, ont) {
+        const result = new ast.NodeList();
+        let currentLine = parentLocation.line;
+        for (const node of mdAST) {
+            currentLine = Math.max((node.map || [0, 0])[0] + 1, currentLine);
+            if (node.type === "image") {
+                // need to handle images explicitly here because they have a text node as a child
+                // but the AST shouldn't contain it
+                result.push(...this.standardizeImageNode(node, parentLocation.withLine(currentLine)));
+                continue;
+            }
+            if (node.children) {
+                result.push(...this.standardizeAST(node.children, parentLocation.withLine(currentLine), ont));
+                continue;
+            }
+            if (node.type === "softbreak") {
+                currentLine += 1;
+                continue;
+            }
+            result.push(...this.standardizeNode(node, parentLocation.withLine(currentLine), ont));
+        }
+        return result;
+    }
+    standardizeClosingHTMLTag(mdNode, ont, location) {
+        const result = new ast.NodeList();
+        const parsed = this.closingTagParser.parse(mdNode.content, location)[0];
+        if (parsed.tag === "/a") {
+            // </a> could be anchor_close or link_close, figure this out here
+            if (ont.has("link_open")) {
+                parsed.type = "link_close";
+            }
+            else if (ont.has("anchor_open")) {
+                parsed.type = "anchor_close";
+            }
+            else {
+                throw new UserError(`Found neither open link nor anchor for node '${mdNode.content}'`, "I found a </a> tag here but there isn't an opening <a ...> tag above.", location);
+            }
+        }
+        ont.close(parsed.type, location);
+        result.push(parsed);
+        return result;
+    }
+    standardizeClosingNode(mdNode, location, ont) {
+        const result = new ast.NodeList();
+        const openingNodeEndLine = ont.close(mdNode.type, location);
+        let closingTagLine = location.line;
+        if (openingNodeEndLine) {
+            closingTagLine = openingNodeEndLine;
+        }
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: mdNode.content.trim(),
+            location: location.withLine(closingTagLine),
+            tag: this.tagMapper.tagForType(mdNode.type),
+            type: mdNode.type
+        }));
+        return result;
+    }
+    standardizeCodeInline(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: "",
+            location,
+            tag: "code",
+            type: "code_open"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: mdNode.content,
+            location,
+            tag: "",
+            type: "text"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: "",
+            location,
+            tag: "/code",
+            type: "code_close"
+        }));
+        return result;
+    }
+    standardizeEmbeddedCodeblock(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: "",
+            location,
+            tag: "pre",
+            type: "fence_open"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: mdNode.content.trim(),
+            location,
+            tag: "",
+            type: "text"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: "",
+            location: location.withLine((mdNode.map || [0, 0])[1]),
+            tag: "/pre",
+            type: "fence_close"
+        }));
+        return result;
+    }
+    standardizeFence(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: "",
+            location,
+            tag: "pre",
+            type: "fence_open"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: mdNode.content.trim(),
+            location: location.withLine(location.line + 1), // content of fenced blocks has to start on the next line
+            tag: "",
+            type: "text"
+        }));
+        result.push(new ast.Node({
+            attributes: {},
+            content: "",
+            location: location.withLine((mdNode.map || [0, 0])[1]),
+            tag: "/pre",
+            type: "fence_close"
+        }));
+        return result;
+    }
+    standardizeHeadingClose(node, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(node.attrs),
+            content: "",
+            location,
+            tag: ("/" + node.tag),
+            type: `${node.tag}_close`
+        }));
+        return result;
+    }
+    standardizeHeadingOpen(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: "",
+            location,
+            tag: mdNode.tag,
+            type: `${mdNode.tag}_open`
+        }));
+        return result;
+    }
+    standardizeHTMLBlock(mdNode, ont, location) {
+        const result = new ast.NodeList();
+        const parsed = this.htmlParser.parse(mdNode.content, location);
+        for (const node of parsed) {
+            if (node.type.endsWith("_open")) {
+                ont.open(node, (mdNode.map || [0, 0])[1]);
+            }
+            if (node.type.endsWith("_close")) {
+                ont.close(node.type, location);
+            }
+        }
+        result.push(...parsed);
+        return result;
+    }
+    standardizeImageNode(mdNode, location) {
+        const result = new ast.NodeList();
+        const attributes = standardizeMarkdownItAttributes(mdNode.attrs);
+        for (const childNode of mdNode.children || []) {
+            attributes.alt += childNode.content;
+        }
+        result.push(new ast.Node({
+            attributes,
+            content: "",
+            location,
+            tag: "img",
+            type: "image"
+        }));
+        return result;
+    }
+    /** Returns the standardized version of the given MarkdownIt node */
+    standardizeNode(mdNode, location, ont) {
+        // ignore empty text nodes
+        // to avoid having to deal with this edge case later
+        if (mdNode.type === "text" && mdNode.content === "") {
+            return new ast.NodeList();
+        }
+        // special handling for headings to make them compatible with their HTML counterparts:
+        // - they get renamed from heading_open to h1_open etc
+        if (mdNode.type === "heading_open") {
+            return this.standardizeHeadingOpen(mdNode, location);
+        }
+        // special handling for headings to make them compatible with their HTML counterparts:
+        // - they get renamed from heading_close to h1_close etc
+        if (mdNode.type === "heading_close") {
+            return this.standardizeHeadingClose(mdNode, location);
+        }
+        // special handling for embedded code blocks to be compatible with its HTML counterpart:
+        // - it is unrolled to code_open, text, code_close
+        if (mdNode.type === "code_inline") {
+            return this.standardizeCodeInline(mdNode, location);
+        }
+        // special handling for fenced code blocks to be compatible with its HTML counterpart:
+        // - it is unrolled to fence_open, text, fence_close
+        // - the content starts on the line below the opening ```
+        if (mdNode.type === "fence") {
+            return this.standardizeFence(mdNode, location);
+        }
+        // special handling for indented code blocks to be compatible with their HTML counterpart:
+        // - they are expanded to fence_open, text, fence_close
+        if (mdNode.type === "code_block") {
+            return this.standardizeEmbeddedCodeblock(mdNode, location);
+        }
+        // handle embedded HTML
+        if (mdNode.type === "html_inline" || mdNode.type === "html_block") {
+            if (this.closingTagParser.isClosingTag(mdNode.content)) {
+                return this.standardizeClosingHTMLTag(mdNode, ont, location);
+            }
+            else {
+                return this.standardizeHTMLBlock(mdNode, ont, location);
+            }
+        }
+        // handle opening tags
+        if (mdNode.type.endsWith("_open")) {
+            return this.standardizeOpeningNode(mdNode, location, ont);
+        }
+        // handle closing tags
+        if (mdNode.type.endsWith("_close")) {
+            return this.standardizeClosingNode(mdNode, location, ont);
+        }
+        // handle text nodes
+        if (mdNode.type === "text") {
+            return this.standardizeTextNode(mdNode, location);
+        }
+        // handle stand-alone tags
+        if (this.tagMapper.isStandaloneTag(mdNode.tag)) {
+            return this.standizeStandaloneTag(mdNode, location);
+        }
+        throw new Error(`unknown MarkdownIt node: ${util.inspect(mdNode, false, Infinity)}`);
+    }
+    standardizeOpeningNode(mdNode, location, ont) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: mdNode.content.trim(),
+            location,
+            tag: this.tagMapper.tagForType(mdNode.type),
+            type: mdNode.type
+        }));
+        ont.open(result[0], (mdNode.map || [0, 0])[1]);
+        return result;
+    }
+    standardizeTextNode(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: mdNode.content.trim(),
+            location,
+            tag: this.tagMapper.tagForType(mdNode.type),
+            type: mdNode.type
+        }));
+        return result;
+    }
+    standizeStandaloneTag(mdNode, location) {
+        const result = new ast.NodeList();
+        result.push(new ast.Node({
+            attributes: standardizeMarkdownItAttributes(mdNode.attrs),
+            content: mdNode.content.trim(),
+            location,
+            tag: mdNode.tag,
+            type: mdNode.type
+        }));
+        return result;
+    }
+}
+/** returns the given attributes from a MarkdownIt node in the standard AST format */
+export function standardizeMarkdownItAttributes(attrs) {
+    const result = {};
+    if (attrs) {
+        for (const [name, value] of attrs) {
+            result[name] = value;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=md-parser.js.map

package/dist/parsers/markdown/open-node-tracker.d.ts

@@ -0,0 +1,14 @@
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+/** helps find open MarkdownIt AST nodes */
+export declare class OpenNodeTracker {
+    private readonly entries;
+    constructor();
+    /** closes the corresponding open ast.Node and returns its endLine */
+    close(type: ast.NodeType, location: files.Location): number;
+    /** returns whether a node with the given type is open */
+    has(type: ast.NodeType): boolean;
+    /** registers an opening MarkdownIt AST node */
+    open(node: ast.Node, endLine: number): void;
+}
+//# sourceMappingURL=open-node-tracker.d.ts.map

package/dist/parsers/markdown/open-node-tracker.js

@@ -0,0 +1,33 @@
+import { UserError } from "../../errors/user-error.js";
+/** helps find open MarkdownIt AST nodes */
+export class OpenNodeTracker {
+    constructor() {
+        this.entries = [];
+    }
+    /** closes the corresponding open ast.Node and returns its endLine */
+    close(type, location) {
+        const openType = type.replace("_close", "_open");
+        for (let i = this.entries.length - 1; i >= 0; i--) {
+            if (this.entries[i].node.type === openType) {
+                const result = this.entries[i].endLine;
+                this.entries.splice(i, 1);
+                return result;
+            }
+        }
+        throw new UserError(`No opening node '${openType}' found for closing node '${type}'`, `Node </${openType}> does not have a corresponding opening node`, location);
+    }
+    /** returns whether a node with the given type is open */
+    has(type) {
+        for (const entry of this.entries) {
+            if (entry.node.type === type) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** registers an opening MarkdownIt AST node */
+    open(node, endLine) {
+        this.entries.push({ endLine, node });
+    }
+}
+//# sourceMappingURL=open-node-tracker.js.map

package/dist/parsers/markdown/parse.d.ts

@@ -0,0 +1,5 @@
+import * as ast from "../../ast/index.js";
+import * as files from "../../filesystem/index.js";
+/** returns the standard AST for the Markdown files given as paths relative to the given sourceDir */
+export declare function parse(filenames: files.FullFilePath[], sourceDir: files.SourceDir): Promise<ast.NodeList[]>;
+//# sourceMappingURL=parse.d.ts.map

package/dist/parsers/markdown/parse.js

@@ -0,0 +1,15 @@
+import { promises as fs } from "fs";
+import { MarkdownParser } from "./md-parser.js";
+/** returns the standard AST for the Markdown files given as paths relative to the given sourceDir */
+export async function parse(filenames, sourceDir) {
+    const result = [];
+    const parser = new MarkdownParser();
+    for (const filename of filenames) {
+        const content = await fs.readFile(sourceDir.joinStr(filename.platformified()), {
+            encoding: "utf8"
+        });
+        result.push(parser.parse(content, sourceDir, filename));
+    }
+    return result;
+}
+//# sourceMappingURL=parse.js.map

package/dist/parsers/tag-mapper.d.ts

@@ -0,0 +1,31 @@
+import * as ast from "../ast/node.js";
+/**
+ * TagMapper maps MarkdownIt node types to HTML tags and vice versa.
+ *
+ * MarkdownIt node types: bold_open, bold_close, image, explicitly
+ * Tag types: "b", "/b", "img", etc
+ */
+export declare class TagMapper {
+    /** tags that have opening and closing versions */
+    private static readonly OPEN_CLOSE_MAPPINGS;
+    /** tags that stand alone, i.e. have no opening and closing versions */
+    private static readonly STANDALONE_MAPPINGS;
+    /** maps HTML tag names to their corresponding MarkdownIt types */
+    private readonly tagTypeMappings;
+    /** maps MarkdownIt types to their corresponding HTML tags */
+    private readonly typeTagMappings;
+    constructor();
+    isOpenCloseTag(tagName: ast.NodeTag): boolean;
+    isStandaloneTag(tagName: string): boolean;
+    /** Returns the opening MarkdownIt type for the given HTML tag. */
+    openingTypeForTag(tagName: ast.NodeTag, attributes: ast.NodeAttributes): ast.NodeType;
+    /** Returns the HTML tag for the given MarkdownIt type. */
+    tagForType(type: ast.NodeType): ast.NodeTag;
+    /** Returns the Markdown node type for the given HTML tag. */
+    typeForTag(tag: ast.NodeTag, attributes: ast.NodeAttributes): ast.NodeType;
+    /** Calculates the mappings from HTML tags to MarkdownIt types */
+    private createTagTypeMappings;
+    /** Calculates the mappings from MarkdownIt types to HTML tags */
+    private createTypeTagMappings;
+}
+//# sourceMappingURL=tag-mapper.d.ts.map

package/dist/parsers/tag-mapper.js

@@ -0,0 +1,112 @@
+/**
+ * TagMapper maps MarkdownIt node types to HTML tags and vice versa.
+ *
+ * MarkdownIt node types: bold_open, bold_close, image, explicitly
+ * Tag types: "b", "/b", "img", etc
+ */
+export class TagMapper {
+    constructor() {
+        this.typeTagMappings = this.createTypeTagMappings();
+        this.tagTypeMappings = this.createTagTypeMappings();
+    }
+    isOpenCloseTag(tagName) {
+        if (tagName === "") {
+            return false;
+        }
+        return !this.isStandaloneTag(tagName);
+    }
+    isStandaloneTag(tagName) {
+        for (const value of TagMapper.STANDALONE_MAPPINGS.values()) {
+            if (value === tagName) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Returns the opening MarkdownIt type for the given HTML tag. */
+    openingTypeForTag(tagName, attributes) {
+        return this.typeForTag(tagName.replace(/^\//, ""), attributes);
+    }
+    /** Returns the HTML tag for the given MarkdownIt type. */
+    tagForType(type) {
+        // handle text tag
+        if (type === "text") {
+            return "";
+        }
+        // handle explicitly mapped values
+        const result = this.typeTagMappings.get(type);
+        if (result) {
+            return result;
+        }
+        // handle generic opening tag
+        if (type.endsWith("_open")) {
+            return type.substring(0, type.length - 5);
+        }
+        // handle generic closing tag
+        if (type.endsWith("_close")) {
+            return ("/" + type.substring(0, type.length - 6));
+        }
+        // handle generic stand-alone tag
+        return type;
+    }
+    /** Returns the Markdown node type for the given HTML tag. */
+    typeForTag(tag, attributes) {
+        // distinguish anchors from links
+        if (tag === "a" && !attributes.href) {
+            return "anchor_open";
+        }
+        if (tag === "/a" && !attributes.href) {
+            return "anchor_close";
+        }
+        // check for known tags
+        const result = this.tagTypeMappings.get(tag);
+        if (result) {
+            return result;
+        }
+        // here it is an unknown tag, we assume it is opening-closing
+        if (tag.startsWith("/")) {
+            return (tag.substring(1) + "_close");
+        }
+        else {
+            return (tag + "_open");
+        }
+    }
+    /** Calculates the mappings from HTML tags to MarkdownIt types */
+    createTagTypeMappings() {
+        const result = new Map();
+        for (const [type, tag] of this.typeTagMappings) {
+            result.set(tag, type);
+        }
+        return result;
+    }
+    /** Calculates the mappings from MarkdownIt types to HTML tags */
+    createTypeTagMappings() {
+        const result = new Map();
+        for (const [type, tag] of TagMapper.OPEN_CLOSE_MAPPINGS) {
+            result.set((type + "_open"), tag);
+            result.set((type + "_close"), ("/" + tag));
+        }
+        for (const [type, tag] of TagMapper.STANDALONE_MAPPINGS) {
+            result.set(type, tag);
+        }
+        return result;
+    }
+}
+/** tags that have opening and closing versions */
+TagMapper.OPEN_CLOSE_MAPPINGS = new Map([
+    ["bold", "b"],
+    ["bullet_list", "ul"],
+    ["fence", "pre"],
+    ["italic", "i"],
+    ["link", "a"],
+    ["list_item", "li"],
+    ["ordered_list", "ol"],
+    ["paragraph", "p"]
+]);
+/** tags that stand alone, i.e. have no opening and closing versions */
+TagMapper.STANDALONE_MAPPINGS = new Map([
+    ["hr", "hr"],
+    ["image", "img"],
+    ["linebreak", "br"]
+]);
+//# sourceMappingURL=tag-mapper.js.map

package/dist/run/activity-collector.d.ts

@@ -0,0 +1,29 @@
+import { Activity } from "../activities/index.js";
+import { Command } from "../commands/index.js";
+import * as events from "../events/index.js";
+import { StopWatch } from "./stopwatch.js";
+/** Statistics about a run of Text-Runner */
+interface ActivityResult {
+    readonly activity?: Activity;
+    readonly error?: Error;
+    readonly finalName?: string;
+    readonly message?: string;
+    readonly output?: string;
+    readonly status: events.ResultStatus;
+}
+/** ActivityCollector provides statistics about the Text-Runner command it observes. */
+export declare class ActivityCollector {
+    activities: ActivityResult[];
+    stopWatch: StopWatch;
+    constructor(command: Command);
+    onResult(result: events.Result): void;
+    results(): ActivityResults;
+}
+export declare class ActivityResults extends Array<ActivityResult> {
+    readonly duration: string;
+    constructor(results: Array<ActivityResult>, duration: string);
+    errorCount(): number;
+    errors(): Error[];
+}
+export {};
+//# sourceMappingURL=activity-collector.d.ts.map

package/dist/run/activity-collector.js

@@ -0,0 +1,35 @@
+import { StopWatch } from "./stopwatch.js";
+/** ActivityCollector provides statistics about the Text-Runner command it observes. */
+export class ActivityCollector {
+    constructor(command) {
+        this.activities = [];
+        this.stopWatch = new StopWatch();
+        command.on("result", this.onResult.bind(this));
+    }
+    onResult(result) {
+        this.activities.push(result);
+    }
+    results() {
+        return new ActivityResults(this.activities, this.stopWatch.duration());
+    }
+}
+export class ActivityResults extends Array {
+    constructor(results, duration) {
+        super();
+        this.push(...results);
+        this.duration = duration;
+    }
+    errorCount() {
+        return this.errors().length;
+    }
+    errors() {
+        const result = [];
+        for (const res of this) {
+            if (res.error) {
+                result.push(res.error);
+            }
+        }
+        return result;
+    }
+}
+//# sourceMappingURL=activity-collector.js.map

package/dist/run/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./activity-collector.js";
+export * from "./parallel.js";
+export * from "./sequential.js";
+export * from "./stopwatch.js";
+/** LogFn defines the signature of the "log" function available to actions */
+export type LogFn = (message?: any, ...optionalParams: any[]) => void;
+/** signature of the method that allows actions to set a refined name for the current test step */
+export type RefineNameFn = (newName: string) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/run/index.js

@@ -0,0 +1,5 @@
+export * from "./activity-collector.js";
+export * from "./parallel.js";
+export * from "./sequential.js";
+export * from "./stopwatch.js";
+//# sourceMappingURL=index.js.map

package/dist/run/name-refiner.d.ts

@@ -0,0 +1,13 @@
+import { RefineNameFn } from "./index.js";
+/** allows refining the current name of a test step */
+export declare class NameRefiner {
+    private name;
+    constructor(name: string);
+    /** returns the refined name */
+    finalName(): string;
+    /** returns a function that can be called to refine the name */
+    refineFn(): RefineNameFn;
+    /** updates the currently stored name to the given name */
+    private refineName;
+}
+//# sourceMappingURL=name-refiner.d.ts.map