fln 1.1.3 → 1.2.0

package/dist/core/scanTree.js

@@ -2,12 +2,10 @@ import { lstat, open, readdir, readlink, realpath, stat } from "node:fs/promises
 import { cpus } from "node:os";
 import { relative, sep } from "node:path";
 import ignore from "ignore";
+import pLimit from "p-limit";
+import { toCanonicalRelative, toIgnoreSafePath, toPosixPath } from "../path/index.js";
+import { normalizeIncludePattern } from "../pattern/index.js";
 import { IgnoreMatcher } from "./ignoreMatcher.js";
-function normalizePathSegment(pathSegment) {
-    if (sep === "/")
-        return pathSegment;
-    return pathSegment.split(sep).join("/");
-}
 function getFileScore(fileName) {
     const lowerName = fileName.toLowerCase();
     if (lowerName.startsWith("readme"))
@@ -21,6 +19,7 @@ function getFileScore(fileName) {
         lowerName === "makefile" ||
         lowerName === "dockerfile" ||
         lowerName === "vcpkg.json" ||
+        lowerName === "pom.xml" ||
         lowerName.startsWith(".env") ||
         lowerName.includes(".config.") ||
         lowerName.startsWith(".prettier") ||
@@ -55,34 +54,17 @@ function getFileScore(fileName) {
         return 20;
     return 10;
 }
-async function isBinaryFile(filePath, fileSize) {
+async function inspectFile(filePath, fileSize) {
     if (fileSize === 0)
-        return false;
+        return { isGenerated: false, isBinary: false };
     const handle = await open(filePath, "r");
     try {
         const buffer = Buffer.alloc(Math.min(512, fileSize));
         const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        for (let index = 0; index < bytesRead; index++)
-            if (buffer[index] === 0)
-                return true;
-        return false;
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function isGeneratedFile(filePath, fileSize) {
-    if (fileSize === 0)
-        return false;
-    const handle = await open(filePath, "r");
-    try {
-        const buffer = Buffer.alloc(Math.min(100, fileSize));
-        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-        const content = buffer.toString("utf8", 0, bytesRead);
-        return content.includes("<!-- 🥞 fln");
-    }
-    catch {
-        return false;
+        const header = buffer.toString("utf8", 0, Math.min(100, bytesRead));
+        const isGenerated = header.includes("<!-- 🥞 fln");
+        const isBinary = !isGenerated && buffer.slice(0, bytesRead).includes(0);
+        return { isGenerated, isBinary };
     }
     finally {
         await handle.close();
@@ -100,37 +82,52 @@ export async function scanTree(options, logger) {
         outputTokenCount: 0
     };
     const ignoreMatcher = new IgnoreMatcher({
-        rootDirectory: options.rootDirectory,
+        input: options.input,
         excludePatterns: options.excludePatterns,
-        useGitignore: options.useGitignore,
+        gitignore: options.gitignore,
         logger
     });
-    const includeMatcher = ignore().add(options.includePatterns);
+    const normalizedIncludePatterns = options.includePatterns
+        .map(pattern => normalizeIncludePattern(pattern, options.input))
+        .filter((p) => p !== null);
+    const includeMatcher = ignore().add(normalizedIncludePatterns);
     const concurrencyLimit = Math.max(8, Math.min(64, cpus().length * 4));
-    const excludedPathSet = new Set(options.excludedPaths.map(pathItem => normalizePathSegment(pathItem)));
+    const limit = pLimit(concurrencyLimit);
+    const excludedPathSet = new Set(options.excludedPaths
+        .map(path => toCanonicalRelative(path, options.input))
+        .filter((p) => p !== null && p !== ""));
     const visitedRealPaths = new Set();
     let processedItems = 0;
     let totalEstimate = 0;
     if (options.followSymlinks)
         try {
-            const rootRealPath = await realpath(options.rootDirectory);
+            const rootRealPath = await realpath(options.input);
             visitedRealPaths.add(rootRealPath);
         }
         catch {
             logger.debug("Failed to resolve root real path.");
         }
-    const rootNode = await scanEntry(options.rootDirectory, "");
+    const rootNode = await scanEntry(options.input, "");
     if (!rootNode || rootNode.type !== "directory")
         throw new Error("Root directory is empty or all files were excluded.");
     return { projectName: options.projectName, root: rootNode, stats };
     async function scanEntry(currentPath, relativePath, dirent) {
-        const normalizedRelativePath = normalizePathSegment(relativePath);
+        const normalizedRelativePath = toPosixPath(relativePath);
         const name = dirent?.name ?? currentPath.split(sep).pop() ?? "";
         if (normalizedRelativePath !== "" && excludedPathSet.has(normalizedRelativePath))
             return undefined;
-        const isExplicitlyIncluded = normalizedRelativePath !== "" && includeMatcher.ignores(normalizedRelativePath);
-        const pathForIgnoreCheck = normalizedRelativePath === "" ? "" : (dirent?.isDirectory() ? `${normalizedRelativePath}/` : normalizedRelativePath);
-        if (!isExplicitlyIncluded && pathForIgnoreCheck !== "" && ignoreMatcher.ignores(pathForIgnoreCheck))
+        const pathForCheck = normalizedRelativePath === "" ? "" : (dirent?.isDirectory() ? `${normalizedRelativePath}/` : normalizedRelativePath);
+        const safePath = toIgnoreSafePath(pathForCheck, options.input);
+        const isExplicitlyIncluded = safePath !== null &&
+            safePath !== "" &&
+            includeMatcher.ignores(safePath);
+        const isDirectory = pathForCheck.endsWith("/");
+        if (normalizedIncludePatterns.length > 0 &&
+            !isExplicitlyIncluded &&
+            pathForCheck !== "" &&
+            !isDirectory)
+            return undefined;
+        if (!isExplicitlyIncluded && pathForCheck !== "" && ignoreMatcher.ignoresSafePath(safePath))
             return undefined;
         if (!options.includeHidden && name.startsWith(".") && name !== ".")
             return undefined;
@@ -255,20 +252,23 @@ export async function scanTree(options, logger) {
         if (options.onProgress)
             options.onProgress(processedItems, Math.max(totalEstimate, processedItems));
         let skipReason;
-        if (!input.isExplicitlyIncluded && await isGeneratedFile(input.currentPath, input.fileSize))
-            skipReason = "generated";
-        if (!skipReason && input.fileSize > options.maximumFileSizeBytes)
-            skipReason = "tooLarge";
         let isBinary = false;
-        if (!skipReason)
+        const needsRead = input.fileSize > 0 &&
+            (input.fileSize <= options.maxFileSize || !input.isExplicitlyIncluded);
+        if (needsRead)
             try {
-                isBinary = await isBinaryFile(input.currentPath, input.fileSize);
+                const { isGenerated, isBinary: binary } = await inspectFile(input.currentPath, input.fileSize);
+                if (!input.isExplicitlyIncluded && isGenerated)
+                    skipReason = "generated";
+                isBinary = binary;
             }
             catch (error) {
                 stats.errors++;
                 skipReason = "readError";
                 logger.warn(`Failed to read ${input.normalizedRelativePath || "."}: ${String(error)}`);
             }
+        if (!skipReason && input.fileSize > options.maxFileSize)
+            skipReason = "tooLarge";
         if (isBinary)
             stats.binary++;
         if (skipReason) {
@@ -297,11 +297,11 @@ export async function scanTree(options, logger) {
         await ignoreMatcher.addGitignoreForDirectory(input.currentPath);
         const entries = await readdir(input.currentPath, { withFileTypes: true });
         totalEstimate = Math.max(totalEstimate, processedItems + entries.length);
-        const children = (await mapWithConcurrency(entries, concurrencyLimit, async (entry) => {
+        const children = (await Promise.all(entries.map(entry => limit(() => {
             const childPath = `${input.currentPath}${sep}${entry.name}`;
-            const childRelativePath = relative(options.rootDirectory, childPath);
+            const childRelativePath = relative(options.input, childPath);
             return scanEntry(childPath, childRelativePath, entry);
-        }))
+        }))))
             .filter((node) => node !== undefined)
             .sort((left, right) => {
             if (left.type !== right.type)
@@ -324,26 +324,3 @@ export async function scanTree(options, logger) {
         };
     }
 }
-async function mapWithConcurrency(items, concurrency, mapper) {
-    if (items.length === 0)
-        return [];
-    const limit = Math.max(1, Math.min(concurrency, items.length));
-    if (limit === 1) {
-        const results = [];
-        for (const item of items)
-            results.push(await mapper(item));
-        return results;
-    }
-    const results = new Array(items.length);
-    let nextIndex = 0;
-    const workers = Array.from({ length: limit }, async () => {
-        while (true) {
-            const currentIndex = nextIndex++;
-            if (currentIndex >= items.length)
-                return;
-            results[currentIndex] = await mapper(items[currentIndex]);
-        }
-    });
-    await Promise.all(workers);
-    return results;
-}

package/dist/core/size.js

@@ -1,27 +1,13 @@
-const kibibyte = 1024;
-const mebibyte = kibibyte * 1024;
-const gibibyte = mebibyte * 1024;
+import bytes from "bytes";
 export function parseByteSize(input) {
-    const normalizedInput = input.trim().toLowerCase();
-    const match = normalizedInput.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/);
-    if (!match)
+    const result = bytes.parse(input.trim());
+    if (result === null || result < 0)
         throw new Error(`Invalid size: "${input}"`);
-    const value = Number(match[1]);
-    const unit = match[2] ?? "b";
-    const multiplier = unit === "kb" ? kibibyte :
-        unit === "mb" ? mebibyte :
-            unit === "gb" ? gibibyte :
-                1;
-    return Math.floor(value * multiplier);
+    return Math.floor(result);
 }
 export function formatByteSize(sizeBytes) {
-    if (sizeBytes >= gibibyte)
-        return `${(sizeBytes / gibibyte).toFixed(2)} GB`;
-    if (sizeBytes >= mebibyte)
-        return `${(sizeBytes / mebibyte).toFixed(2)} MB`;
-    if (sizeBytes >= kibibyte)
-        return `${(sizeBytes / kibibyte).toFixed(2)} KB`;
-    return `${sizeBytes} B`;
+    const result = bytes(sizeBytes, { unitSeparator: " " });
+    return result ?? `${sizeBytes} B`;
 }
 export function formatTokenCount(count) {
     if (count >= 1_000_000)

package/dist/core/types.d.ts

@@ -30,23 +30,23 @@ export type ScanResult = {
 export type ProgressCallback = (current: number, total: number) => void;
 export type ScanOptions = {
     projectName: string;
-    rootDirectory: string;
+    input: string;
     excludePatterns: string[];
     includePatterns: string[];
     excludedPaths: string[];
     includeHidden: boolean;
-    useGitignore: boolean;
-    maximumFileSizeBytes: number;
-    maximumTotalSizeBytes: number;
+    gitignore: boolean;
+    maxFileSize: number;
+    maxTotalSize: number;
     followSymlinks: boolean;
     onProgress?: ProgressCallback;
 };
 export type RenderOptions = {
-    outputFile: string;
+    output: string;
     format: OutputFormat;
     includeTree: boolean;
     includeContents: boolean;
-    useAnsi: boolean;
+    ansi: boolean;
     banner?: string;
     footer?: string;
 };

package/dist/index.d.ts

@@ -1,3 +1 @@
 export * from "./api/index.js";
-export * from "./core/index.js";
-export * from "./version.js";

package/dist/index.js

@@ -1,3 +1 @@
 export * from "./api/index.js";
-export * from "./core/index.js";
-export * from "./version.js";

package/dist/infra/datetime.js

@@ -1,12 +1,14 @@
 const generatedDateRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/;
 export function formatDateTime() {
     const now = new Date();
-    const year = now.getFullYear();
-    const month = String(now.getMonth() + 1).padStart(2, "0");
-    const day = String(now.getDate()).padStart(2, "0");
-    const hours = String(now.getHours()).padStart(2, "0");
-    const minutes = String(now.getMinutes()).padStart(2, "0");
-    return `${year}-${month}-${day} ${hours}:${minutes}`;
+    return `${[
+        now.getFullYear(),
+        String(now.getMonth() + 1).padStart(2, "0"),
+        String(now.getDate()).padStart(2, "0")
+    ].join("-")} ${[
+        String(now.getHours()).padStart(2, "0"),
+        String(now.getMinutes()).padStart(2, "0")
+    ].join(":")}`;
 }
 export function parseGeneratedDate(value) {
     if (!generatedDateRegex.test(value.trim()))

package/dist/infra/deprecate.d.ts

@@ -0,0 +1,2 @@
+export declare function warnDeprecated(oldName: string, newName: string, context?: string): void;
+export declare function resolveOption<T, O extends Record<string, unknown> = Record<string, unknown>>(options: O, newKey: keyof O, deprecatedKey: keyof O, context: string, parse?: (value: unknown) => T | undefined): T | undefined;

package/dist/infra/deprecate.js

@@ -0,0 +1,14 @@
+export function warnDeprecated(oldName, newName, context) {
+    const message = context ?
+        `fln: "${oldName}" is deprecated, use "${newName}" instead (${context})` :
+        `fln: "${oldName}" is deprecated, use "${newName}" instead`;
+    console.warn(message);
+}
+export function resolveOption(options, newKey, deprecatedKey, context, parse) {
+    const newVal = options[newKey];
+    const deprecatedVal = options[deprecatedKey];
+    if (deprecatedVal !== undefined && newVal === undefined)
+        warnDeprecated(String(deprecatedKey), String(newKey), context);
+    const raw = newVal ?? deprecatedVal;
+    return raw === undefined ? undefined : (parse ? parse(raw) : raw);
+}

package/dist/infra/gitDiff.d.ts

@@ -0,0 +1,2 @@
+export declare function getChangedFilesSince(ref: string, cwd: string): string[];
+export declare function filterPathsUnderBase(gitPaths: string[], cwd: string, inputBase: string): string[];

package/dist/infra/gitDiff.js

@@ -0,0 +1,33 @@
+import { spawnSync } from "node:child_process";
+import { join, relative } from "node:path";
+import { toPosixPath } from "../path/index.js";
+export function getChangedFilesSince(ref, cwd) {
+    const result = spawnSync("git", ["diff", "--name-only", ref], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (result.error)
+        throw new Error(`fln: git not found (${result.error.message}). Install git and ensure it is in PATH.`);
+    if (result.status !== 0) {
+        const stderr = (result.stderr ?? "").trim();
+        throw new Error(stderr ?
+            `fln: git diff failed: ${stderr}` :
+            `fln: git diff failed (exit ${result.status}). Not a git repository or invalid ref: ${ref}`);
+    }
+    const output = (result.stdout ?? "").trim();
+    if (!output)
+        return [];
+    return output.split("\n").filter(Boolean);
+}
+export function filterPathsUnderBase(gitPaths, cwd, inputBase) {
+    return gitPaths
+        .map(gitPath => {
+        const absolutePath = join(cwd, gitPath);
+        const relativeToInput = relative(inputBase, absolutePath);
+        if (relativeToInput.startsWith("..") || relativeToInput === "")
+            return null;
+        return toPosixPath(relativeToInput);
+    })
+        .filter((path) => path !== null && path !== "");
+}

package/dist/infra/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./countTokens.js";
 export * from "./datetime.js";
+export * from "./deprecate.js";
+export * from "./gitDiff.js";
 export * from "./logger.js";
 export * from "./outputWriter.js";
 export * from "./terminal.js";

package/dist/infra/index.js

@@ -1,5 +1,7 @@
 export * from "./countTokens.js";
 export * from "./datetime.js";
+export * from "./deprecate.js";
+export * from "./gitDiff.js";
 export * from "./logger.js";
 export * from "./outputWriter.js";
 export * from "./terminal.js";

package/dist/infra/logger.d.ts

@@ -1,6 +1,6 @@
 import type { LogLevel } from "../core/index.js";
 type LoggerOptions = {
-    useAnsi: boolean;
+    ansi: boolean;
     logLevel: LogLevel;
 };
 export type Logger = {

package/dist/infra/logger.js

@@ -1,14 +1,11 @@
-import { ansi, getTerminalInfo, renderBox, symbols } from "./terminal.js";
+import pc from "picocolors";
+import { getTerminalInfo, renderBox, symbols } from "./terminal.js";
 export function createLogger(options) {
-    const { useAnsi, logLevel } = options;
+    const { ansi: useAnsi, logLevel } = options;
     const { width } = getTerminalInfo();
     const isSilent = logLevel === "silent";
     const isVerbose = logLevel === "verbose" || logLevel === "debug";
-    const formatMessage = (symbol, color, message) => {
-        if (!useAnsi)
-            return `${symbol} ${message}`;
-        return `  ${color}${symbol}${ansi.reset} ${message}`;
-    };
+    const formatMessage = (symbolOrColored, message) => `${useAnsi ? "  " : ""}${symbolOrColored} ${message}`;
     const writeInfo = (formatted) => {
         if (!isSilent)
             console.info(formatted);
@@ -17,24 +14,24 @@ export function createLogger(options) {
         info: (message) => {
             if (!isSilent)
                 if (useAnsi)
-                    console.info(`  ${ansi.dim}${message}${ansi.reset}`);
+                    console.info(`  ${pc.dim(message)}`);
                 else
                     console.info(message);
         },
         success: (message) => {
-            writeInfo(formatMessage(symbols.check, ansi.green, message));
+            writeInfo(formatMessage(useAnsi ? pc.green(symbols.check) : symbols.check, message));
         },
         warn: (message) => {
             if (!isSilent)
-                console.warn(formatMessage(symbols.warning, ansi.yellow, message));
+                console.warn(formatMessage(useAnsi ? pc.yellow(symbols.warning) : symbols.warning, message));
         },
         error: (message) => {
-            console.error(formatMessage(symbols.cross, ansi.red, message));
+            console.error(formatMessage(useAnsi ? pc.red(symbols.cross) : symbols.cross, message));
         },
         debug: (message) => {
             if (!isSilent && isVerbose)
                 if (useAnsi)
-                    console.info(`  ${ansi.dim}${symbols.info} ${message}${ansi.reset}`);
+                    console.info(`  ${pc.dim(`${symbols.info} ${message}`)}`);
                 else
                     console.info(`${symbols.info} ${message}`);
         },
@@ -45,9 +42,9 @@ export function createLogger(options) {
                 const boxWidth = Math.min(width - 4, 60);
                 const paddedText = text.padEnd(boxWidth - 4);
                 console.info("");
-                console.info(`${ansi.dim}${symbols.boxTopLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxTopRight}${ansi.reset}`);
-                console.info(`${ansi.dim}${symbols.boxVertical}${ansi.reset}${ansi.bold}${paddedText}${ansi.reset} ${ansi.dim}${symbols.boxVertical}${ansi.reset}`);
-                console.info(`${ansi.dim}${symbols.boxBottomLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxBottomRight}${ansi.reset}`);
+                console.info(pc.dim(`${symbols.boxTopLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxTopRight}`));
+                console.info(`${pc.dim(symbols.boxVertical)}${pc.bold(paddedText)} ${pc.dim(symbols.boxVertical)}`);
+                console.info(pc.dim(`${symbols.boxBottomLeft}${symbols.boxHorizontal.repeat(boxWidth - 2)}${symbols.boxBottomRight}`));
                 console.info("");
             }
             else {
@@ -61,7 +58,7 @@ export function createLogger(options) {
                 return;
             if (useAnsi) {
                 console.info("");
-                console.info(`${ansi.bold}${title}${ansi.reset}`);
+                console.info(pc.bold(title));
                 console.info("");
             }
             else {
@@ -72,7 +69,7 @@ export function createLogger(options) {
             for (const [key, value] of Object.entries(items)) {
                 const paddedKey = key.padEnd(maxKeyLength);
                 if (useAnsi)
-                    console.info(`  ${ansi.dim}${paddedKey}${ansi.reset}  ${value}`);
+                    console.info(`  ${pc.dim(paddedKey)}  ${value}`);
                 else
                     console.info(`  ${paddedKey}  ${value}`);
             }
@@ -85,7 +82,7 @@ export function createLogger(options) {
                 title,
                 content,
                 width: boxWidth,
-                useAnsi,
+                ansi: useAnsi,
                 showDivider
             });
             console.info("");

package/dist/infra/outputWriter.d.ts

@@ -10,5 +10,5 @@ type OutputWriter = {
         tokenCount: number;
     }>;
 };
-export declare function createOutputWriter(outputFile: string, maxSizeBytes?: number): Promise<OutputWriter>;
+export declare function createOutputWriter(output: string, maxSizeBytes?: number): Promise<OutputWriter>;
 export {};

package/dist/infra/outputWriter.js

@@ -3,11 +3,29 @@ import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
 import { countTokens } from "./countTokens.js";
-export async function createOutputWriter(outputFile, maxSizeBytes = 0) {
-    const outputDirectory = dirname(outputFile);
+export async function createOutputWriter(output, maxSizeBytes = 0) {
+    if (output === "-") {
+        let bytesWritten = 0;
+        let totalTokenCount = 0;
+        const write = async (text) => {
+            const textBytes = Buffer.byteLength(text);
+            if (maxSizeBytes > 0 && bytesWritten + textBytes > maxSizeBytes)
+                throw new Error(`Output size would exceed maximum of ${maxSizeBytes} bytes`);
+            bytesWritten += textBytes;
+            totalTokenCount += countTokens(text);
+            process.stdout.write(text);
+        };
+        return {
+            write,
+            writeLine: (text) => write(`${text}\n`),
+            getStats: () => ({ sizeBytes: bytesWritten, tokenCount: totalTokenCount }),
+            close: async () => ({ sizeBytes: bytesWritten, tokenCount: totalTokenCount })
+        };
+    }
+    const outputDirectory = dirname(output);
     if (outputDirectory !== ".")
         await mkdir(outputDirectory, { recursive: true });
-    const stream = createWriteStream(outputFile, { encoding: "utf8" });
+    const stream = createWriteStream(output, { encoding: "utf8" });
     let bytesWritten = 0;
     let totalTokenCount = 0;
     const write = async (text) => {

package/dist/infra/terminal.d.ts

@@ -5,7 +5,7 @@ type TerminalInfo = {
 export declare function getTerminalInfo(): TerminalInfo;
 export declare function isTTY(): boolean;
 export declare function shouldUseColors(): boolean;
-export declare const ansi: {
+export declare const cursor: {
     cursorHide: string;
     cursorShow: string;
     cursorUp: (lines: number) => string;
@@ -13,34 +13,6 @@ export declare const ansi: {
     cursorTo: (column: number) => string;
     clearLine: string;
     clearLineRight: string;
-    reset: string;
-    bold: string;
-    dim: string;
-    black: string;
-    red: string;
-    green: string;
-    yellow: string;
-    blue: string;
-    magenta: string;
-    cyan: string;
-    white: string;
-    gray: string;
-    bgBlack: string;
-    bgRed: string;
-    bgGreen: string;
-    bgYellow: string;
-    bgBlue: string;
-    bgMagenta: string;
-    bgCyan: string;
-    bgWhite: string;
-    brightBlack: string;
-    brightRed: string;
-    brightGreen: string;
-    brightYellow: string;
-    brightBlue: string;
-    brightMagenta: string;
-    brightCyan: string;
-    brightWhite: string;
 };
 export declare const symbols: {
     dot: string;
@@ -67,7 +39,7 @@ type ProgressBarOptions = {
     total: number;
     current: number;
     width: number;
-    useAnsi: boolean;
+    ansi: boolean;
     label?: string;
     suffix?: string;
 };
@@ -76,7 +48,7 @@ type BoxOptions = {
     title?: string;
     content: string[];
     width?: number;
-    useAnsi: boolean;
+    ansi: boolean;
     showDivider?: boolean;
 };
 export declare function renderBox(options: BoxOptions): string;
@@ -86,5 +58,5 @@ export type ProgressRenderer = {
     finish: (message?: string) => void;
     cleanup: () => void;
 };
-export declare function createProgressRenderer(label: string, useAnsi: boolean, isQuiet: boolean): ProgressRenderer;
+export declare function createProgressRenderer(label: string, ansi: boolean, isQuiet: boolean): ProgressRenderer;
 export {};