fln 1.0.0

package/dist/config/utils.js

@@ -0,0 +1,161 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, join, parse } from "node:path";
+export function normalizeFileToken(rawValue) {
+    return rawValue
+        .trim()
+        .replaceAll("@", "")
+        .replaceAll("/", "-")
+        .replaceAll("\\", "-")
+        .replaceAll(" ", "-")
+        .replaceAll(/[^\w.-]/g, "-")
+        .replaceAll(/-+/g, "-")
+        .replaceAll(/^[.-]+|[.-]+$/g, "");
+}
+async function readTextFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractTomlValue(content, sectionName, key) {
+    const lines = content.split("\n");
+    let isInSection = false;
+    for (const rawLine of lines) {
+        const trimmedLine = rawLine.split("#")[0]?.trim() ?? "";
+        if (trimmedLine === "")
+            continue;
+        if (trimmedLine.startsWith("[") && trimmedLine.endsWith("]")) {
+            isInSection = trimmedLine === `[${sectionName}]`;
+            continue;
+        }
+        if (!isInSection)
+            continue;
+        const match = trimmedLine.match(new RegExp(String.raw `^${key}\s*=\s*["'](.+)["']\s*$`));
+        if (match)
+            return match[1];
+    }
+    return undefined;
+}
+export async function getProjectMetadata(rootDirectory) {
+    const packageJsonContent = await readTextFile(join(rootDirectory, "package.json"));
+    if (packageJsonContent)
+        try {
+            const packageJson = JSON.parse(packageJsonContent);
+            const normalizedName = packageJson.name ? normalizeFileToken(packageJson.name) : "";
+            const normalizedVersion = packageJson.version ? normalizeFileToken(packageJson.version) : "";
+            if (normalizedName)
+                return {
+                    name: normalizedName,
+                    version: normalizedVersion
+                };
+        }
+        catch { }
+    const vcpkgContent = await readTextFile(join(rootDirectory, "vcpkg.json"));
+    if (vcpkgContent)
+        try {
+            const vcpkg = JSON.parse(vcpkgContent);
+            const normalizedName = vcpkg.name ? normalizeFileToken(vcpkg.name) : "";
+            const normalizedVersion = vcpkg.version ? normalizeFileToken(vcpkg.version) : "";
+            if (normalizedName)
+                return {
+                    name: normalizedName,
+                    version: normalizedVersion
+                };
+        }
+        catch { }
+    const pyprojectContent = await readTextFile(join(rootDirectory, "pyproject.toml"));
+    if (pyprojectContent) {
+        const pythonName = extractTomlValue(pyprojectContent, "project", "name") ??
+            extractTomlValue(pyprojectContent, "tool.poetry", "name");
+        const pythonVersion = extractTomlValue(pyprojectContent, "project", "version") ??
+            extractTomlValue(pyprojectContent, "tool.poetry", "version");
+        const normalizedName = pythonName ? normalizeFileToken(pythonName) : "";
+        const normalizedVersion = pythonVersion ? normalizeFileToken(pythonVersion) : "";
+        if (normalizedName)
+            return {
+                name: normalizedName,
+                version: normalizedVersion
+            };
+    }
+    const cargoContent = await readTextFile(join(rootDirectory, "Cargo.toml"));
+    if (cargoContent) {
+        const rustName = extractTomlValue(cargoContent, "package", "name");
+        const rustVersion = extractTomlValue(cargoContent, "package", "version");
+        const normalizedName = rustName ? normalizeFileToken(rustName) : "";
+        const normalizedVersion = rustVersion ? normalizeFileToken(rustVersion) : "";
+        if (normalizedName)
+            return {
+                name: normalizedName,
+                version: normalizedVersion
+            };
+    }
+    const goModContent = await readTextFile(join(rootDirectory, "go.mod"));
+    if (goModContent) {
+        const match = goModContent.match(/^module\s+(.+)$/m);
+        if (match) {
+            const fullPath = match[1].trim();
+            const shortName = fullPath.split("/").pop();
+            const normalizedName = shortName ? normalizeFileToken(shortName) : "";
+            if (normalizedName)
+                return {
+                    name: normalizedName
+                };
+        }
+    }
+    const cmakeContent = await readTextFile(join(rootDirectory, "CMakeLists.txt"));
+    if (cmakeContent) {
+        const nameMatch = cmakeContent.match(/project\s*\(\s*([\w.-]+)/i);
+        const versionMatch = cmakeContent.match(/version\s+([\d.]+)/i);
+        const normalizedName = nameMatch ? normalizeFileToken(nameMatch[1]) : "";
+        const normalizedVersion = versionMatch ? normalizeFileToken(versionMatch[1]) : "";
+        if (normalizedName)
+            return {
+                name: normalizedName,
+                version: normalizedVersion
+            };
+    }
+    return {
+        name: normalizeFileToken(basename(rootDirectory)) || "project"
+    };
+}
+async function tryStat(pathValue) {
+    try {
+        return await stat(pathValue);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveUniquePath(filePath) {
+    const existingStats = await tryStat(filePath);
+    if (!existingStats)
+        return filePath;
+    const parsed = parse(filePath);
+    let counter = 1;
+    while (true) {
+        const candidatePath = join(parsed.dir, `${parsed.name}-${counter}${parsed.ext}`);
+        const candidateStats = await tryStat(candidatePath);
+        if (!candidateStats)
+            return candidatePath;
+        counter += 1;
+    }
+}
+export async function resolveOutputPath(outputValue, rootDirectory, format) {
+    const projectMeta = await getProjectMetadata(rootDirectory);
+    const baseFileName = projectMeta.version ?
+        `${projectMeta.name}-${projectMeta.version}.${format}` :
+        `${projectMeta.name}.${format}`;
+    if (!outputValue)
+        return await resolveUniquePath(join(rootDirectory, baseFileName));
+    if (outputValue === "/dev/null" || outputValue === "nul")
+        return outputValue;
+    const hasTrailingSeparator = /[/\\]+$/.test(outputValue);
+    const outputStats = await tryStat(outputValue);
+    if (hasTrailingSeparator || outputStats?.isDirectory()) {
+        const filePath = join(outputValue, baseFileName);
+        return await resolveUniquePath(filePath);
+    }
+    return await resolveUniquePath(outputValue);
+}

package/dist/core/ignoreMatcher.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "$infra";
+type IgnoreMatcherOptions = {
+    rootDirectory: string;
+    excludePatterns: string[];
+    useGitignore: boolean;
+    logger?: Logger;
+};
+export declare class IgnoreMatcher {
+    #private;
+    constructor(options: IgnoreMatcherOptions);
+    ignores(relativePath: string): boolean;
+    addGitignoreForDirectory(directoryPath: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=ignoreMatcher.d.ts.map

package/dist/core/ignoreMatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignoreMatcher.d.ts","sourceRoot":"","sources":["../../src/core/ignoreMatcher.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,KAAK,oBAAoB,GAAG;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,EAAE,OAAO,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAmEF,qBAAa,aAAa;;gBAOb,OAAO,EAAE,oBAAoB;IASlC,OAAO,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAMhC,wBAAwB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA6B3E"}

package/dist/core/ignoreMatcher.js

@@ -0,0 +1,97 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import ignore from "ignore";
+const defaultIgnorePatterns = [
+    ".fln.json",
+    ".git",
+    ".DS_Store",
+    "Thumbs.db",
+    "node_modules",
+    ".env",
+    "package-lock.json",
+    "bun.lock",
+    "yarn.lock",
+    "pnpm-lock.yaml"
+];
+function normalizeRelativePath(relativePath) {
+    const normalized = relativePath.split(sep).join("/");
+    if (normalized.startsWith("./"))
+        return normalized.slice(2);
+    return normalized;
+}
+function convertGitignorePattern(pattern, relativeDirectory) {
+    const trimmed = pattern.trim();
+    if (trimmed === "" || trimmed.startsWith("#"))
+        return undefined;
+    const isEscaped = trimmed.startsWith("\\") && (trimmed[1] === "!" || trimmed[1] === "#");
+    const rawPattern = isEscaped ? trimmed.slice(1) : trimmed;
+    const isNegated = !isEscaped && rawPattern.startsWith("!");
+    const patternBody = isNegated ? rawPattern.slice(1) : rawPattern;
+    const normalizedDirectory = normalizeRelativePath(relativeDirectory);
+    const prefix = normalizedDirectory === "" ? "" : `${normalizedDirectory}/`;
+    if (patternBody === "")
+        return undefined;
+    const trimmedTrailingSlash = patternBody.endsWith("/") ? patternBody.slice(0, -1) : patternBody;
+    const hasSlash = trimmedTrailingSlash.includes("/");
+    let convertedPattern;
+    if (patternBody.startsWith("/"))
+        convertedPattern = `${prefix}${patternBody.slice(1)}`;
+    else if (hasSlash)
+        convertedPattern = `${prefix}${patternBody}`;
+    else
+        convertedPattern = `${prefix}**/${patternBody}`;
+    return isNegated ? `!${convertedPattern}` : convertedPattern;
+}
+function normalizeExcludePattern(pattern) {
+    const normalized = pattern.trim();
+    const isNegated = normalized.startsWith("!");
+    const body = isNegated ? normalized.slice(1) : normalized;
+    const trimmedTrailingSlash = body.endsWith("/") ? body.slice(0, -1) : body;
+    if (body.startsWith("/"))
+        return isNegated ? `!${body.slice(1)}` : body.slice(1);
+    const result = trimmedTrailingSlash.includes("/") ? body : `**/${body}`;
+    return isNegated ? `!${result}` : result;
+}
+export class IgnoreMatcher {
+    #rootDirectory;
+    #useGitignore;
+    #logger;
+    #processedGitignore = new Set();
+    #matcher = ignore();
+    constructor(options) {
+        this.#rootDirectory = options.rootDirectory;
+        this.#useGitignore = options.useGitignore;
+        this.#logger = options.logger;
+        this.#matcher.add(defaultIgnorePatterns.map(pattern => normalizeExcludePattern(pattern)));
+        this.#matcher.add(options.excludePatterns.map(pattern => normalizeExcludePattern(pattern)));
+    }
+    ignores(relativePath) {
+        const normalized = normalizeRelativePath(relativePath);
+        return normalized !== "" && this.#matcher.ignores(normalized);
+    }
+    async addGitignoreForDirectory(directoryPath) {
+        if (!this.#useGitignore)
+            return;
+        if (this.#processedGitignore.has(directoryPath))
+            return;
+        this.#processedGitignore.add(directoryPath);
+        const gitignorePath = join(directoryPath, ".gitignore");
+        const relativeDirectory = relative(this.#rootDirectory, directoryPath);
+        try {
+            await access(gitignorePath, constants.F_OK);
+        }
+        catch {
+            return;
+        }
+        const content = await readFile(gitignorePath, "utf8");
+        const patterns = content
+            .split("\n")
+            .map(line => convertGitignorePattern(line, relativeDirectory))
+            .filter((line) => line !== undefined);
+        if (patterns.length > 0) {
+            this.#matcher.add(patterns);
+            this.#logger?.debug(`Loaded ${patterns.length} patterns from ${normalizeRelativePath(relativeDirectory) || "."}/.gitignore`);
+        }
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./ignoreMatcher";
+export * from "./renderOutput";
+export * from "./renderTree";
+export * from "./scanTree";
+export * from "./size";
+export * from "./statsCollector";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,7 @@
+export * from "./ignoreMatcher";
+export * from "./renderOutput";
+export * from "./renderTree";
+export * from "./scanTree";
+export * from "./size";
+export * from "./statsCollector";
+export * from "./types";

package/dist/core/renderOutput.d.ts

@@ -0,0 +1,4 @@
+import type { FlnConfig } from "$config";
+import type { ScanResult } from "./types";
+export declare function writeOutput(result: ScanResult, config: FlnConfig): Promise<void>;
+//# sourceMappingURL=renderOutput.d.ts.map

package/dist/core/renderOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderOutput.d.ts","sourceRoot":"","sources":["../../src/core/renderOutput.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAGzC,OAAO,KAAK,EAAY,UAAU,EAAE,MAAM,SAAS,CAAC;AAsQpD,wBAAsB,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAKtF"}

package/dist/core/renderOutput.js

@@ -0,0 +1,218 @@
+import { createReadStream } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { createOutputWriter, formatDateTime } from "$infra";
+import { VERSION } from "$version";
+import { renderTree } from "./renderTree";
+import { formatByteSize } from "./size";
+function getLanguageFromFilename(fileName) {
+    const extension = extname(fileName).replace(".", "");
+    return extension === "" ? "txt" : extension;
+}
+async function findMaxBacktickSequenceInFile(filePath) {
+    const readStream = createReadStream(filePath, { encoding: "utf8" });
+    let maxLength = 0;
+    let currentLength = 0;
+    let carry = "";
+    for await (const chunk of readStream) {
+        const textChunk = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        const combined = carry + textChunk;
+        const safeLength = Math.max(combined.length - 1, 0);
+        for (let i = 0; i < safeLength; i++)
+            if (combined[i] === "`") {
+                currentLength++;
+                maxLength = Math.max(maxLength, currentLength);
+            }
+            else
+                currentLength = 0;
+        carry = combined.slice(safeLength);
+    }
+    for (const char of carry)
+        if (char === "`") {
+            currentLength++;
+            maxLength = Math.max(maxLength, currentLength);
+        }
+        else
+            currentLength = 0;
+    return maxLength;
+}
+async function writeMarkdownContent(writer, filePath) {
+    const readStream = createReadStream(filePath, { encoding: "utf8" });
+    let lastCharacter = "";
+    for await (const chunk of readStream) {
+        const textChunk = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        await writer.write(textChunk);
+        if (textChunk.length > 0)
+            lastCharacter = textChunk.at(-1) ?? "";
+    }
+    if (lastCharacter !== "" && lastCharacter !== "\n")
+        await writer.write("\n");
+}
+function* iterateFileNodes(node) {
+    if (node.type === "file")
+        yield node;
+    if (node.children)
+        for (const child of node.children)
+            yield* iterateFileNodes(child);
+}
+function filterSkippedNodes(node) {
+    if (node.skipReason)
+        return undefined;
+    if (!node.children || node.children.length === 0)
+        return { ...node };
+    const children = node.children
+        .map(child => filterSkippedNodes(child))
+        .filter((child) => child !== undefined);
+    return { ...node, children };
+}
+async function writeMarkdown(result, config) {
+    const writer = await createOutputWriter(config.outputFile, config.maximumTotalSizeBytes);
+    const outputRoot = filterSkippedNodes(result.root);
+    if (!outputRoot)
+        throw new Error("Root directory was skipped.");
+    try {
+        await writer.writeLine(`<!-- 🥞 fln ${VERSION} -->`);
+        await writer.writeLine("");
+        await writer.writeLine(`# Codebase Snapshot: ${result.projectName}`);
+        await writer.writeLine("");
+        await writer.writeLine(`Generated: ${config.generatedDate ?? formatDateTime()}`);
+        await writer.writeLine(`Files: ${result.stats.files} | Directories: ${result.stats.directories}`);
+        await writer.writeLine("");
+        await writer.writeLine("---");
+        await writer.writeLine("");
+        if (config.banner) {
+            await writer.writeLine(config.banner);
+            await writer.writeLine("");
+        }
+        if (config.includeTree) {
+            await writer.writeLine("## Directory Tree");
+            await writer.writeLine("```text");
+            await writer.write(renderTree(outputRoot));
+            await writer.writeLine("```");
+            await writer.writeLine("");
+            await writer.writeLine("---");
+            await writer.writeLine("");
+        }
+        if (config.includeContents)
+            await writeMarkdownFiles(outputRoot, writer, config);
+        if (config.footer) {
+            await writer.writeLine("");
+            await writer.writeLine(config.footer);
+        }
+        ({
+            sizeBytes: result.stats.outputSizeBytes,
+            tokenCount: result.stats.outputTokenCount
+        } = await writer.close());
+    }
+    catch (error) {
+        await writer.close();
+        throw error;
+    }
+}
+async function writeMarkdownFiles(rootNode, outputWriter, renderConfig) {
+    await outputWriter.writeLine("## Source Files");
+    await outputWriter.writeLine("");
+    const fileNodes = Array.from(iterateFileNodes(rootNode));
+    for (let i = 0; i < fileNodes.length; i++) {
+        const node = fileNodes[i];
+        const language = getLanguageFromFilename(node.name);
+        const isLastFile = i === fileNodes.length - 1;
+        const filePath = join(renderConfig.rootDirectory, node.path);
+        let fenceLength = 3;
+        if (!node.isBinary)
+            try {
+                const maxBackticks = await findMaxBacktickSequenceInFile(filePath);
+                if (maxBackticks >= 3)
+                    fenceLength = maxBackticks + 1;
+            }
+            catch { }
+        const fence = "`".repeat(fenceLength);
+        await outputWriter.writeLine(`### ${node.path}`);
+        await outputWriter.writeLine(`${fence}${language}`);
+        if (node.isBinary)
+            await outputWriter.writeLine(`[BINARY FILE: ${formatByteSize(node.size)}]`);
+        else
+            try {
+                await writeMarkdownContent(outputWriter, filePath);
+            }
+            catch {
+                await outputWriter.writeLine("[READ ERROR]");
+            }
+        await outputWriter.writeLine(fence);
+        if (!isLastFile)
+            await outputWriter.writeLine("");
+    }
+}
+async function writeJson(result, config) {
+    const writer = await createOutputWriter(config.outputFile, config.maximumTotalSizeBytes);
+    const outputRoot = filterSkippedNodes(result.root);
+    if (!outputRoot)
+        throw new Error("Root directory was skipped.");
+    try {
+        await writer.write("{");
+        await writer.write(`"version":${JSON.stringify(VERSION)}`);
+        await writer.write(`,"generated":${JSON.stringify(config.generatedDate ?? formatDateTime())}`);
+        await writer.write(`,"projectName":${JSON.stringify(result.projectName)}`);
+        await writer.write(`,"rootDirectory":${JSON.stringify(config.rootDirectory)}`);
+        await writer.write(`,"stats":${JSON.stringify(result.stats)}`);
+        await writer.write(`,"options":${JSON.stringify({
+            includeTree: config.includeTree,
+            includeContents: config.includeContents,
+            format: config.format,
+            maximumFileSizeBytes: config.maximumFileSizeBytes,
+            maximumTotalSizeBytes: config.maximumTotalSizeBytes,
+            includeHidden: config.includeHidden,
+            useGitignore: config.useGitignore,
+            excludePatterns: config.excludePatterns,
+            includePatterns: config.includePatterns,
+            followSymlinks: config.followSymlinks,
+            banner: config.banner,
+            footer: config.footer
+        })}`);
+        await writer.write(`,"tree":${JSON.stringify(outputRoot)}`);
+        await writer.write(`,"stats":${JSON.stringify(result.stats)}`);
+        if (config.includeContents) {
+            await writer.write(",\"files\":[");
+            let isFirst = true;
+            for (const node of iterateFileNodes(outputRoot)) {
+                if (!isFirst)
+                    await writer.write(",");
+                isFirst = false;
+                await writer.write("{");
+                await writer.write(`"path":${JSON.stringify(node.path)}`);
+                await writer.write(`,"language":${JSON.stringify(getLanguageFromFilename(node.name))}`);
+                await writer.write(`,"isBinary":${JSON.stringify(Boolean(node.isBinary))}`);
+                if (node.skipReason)
+                    await writer.write(`,"skipReason":${JSON.stringify(node.skipReason)}`);
+                if (node.isBinary || node.skipReason)
+                    await writer.write(",\"content\":null");
+                else
+                    try {
+                        const filePath = join(config.rootDirectory, node.path);
+                        const content = await readFile(filePath, "utf8");
+                        await writer.write(`,"content":${JSON.stringify(content)}`);
+                    }
+                    catch {
+                        await writer.write(",\"skipReason\":\"readError\",\"content\":null");
+                    }
+                await writer.write("}");
+            }
+            await writer.write("]");
+        }
+        await writer.write("}");
+        ({
+            sizeBytes: result.stats.outputSizeBytes,
+            tokenCount: result.stats.outputTokenCount
+        } = await writer.close());
+    }
+    catch (error) {
+        await writer.close();
+        throw error;
+    }
+}
+export async function writeOutput(result, config) {
+    if (config.format === "json")
+        await writeJson(result, config);
+    else
+        await writeMarkdown(result, config);
+}

package/dist/core/renderTree.d.ts

@@ -0,0 +1,3 @@
+import type { FileNode } from "./types";
+export declare function renderTree(root: FileNode): string;
+//# sourceMappingURL=renderTree.d.ts.map

package/dist/core/renderTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderTree.d.ts","sourceRoot":"","sources":["../../src/core/renderTree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAUxC,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,CAOjD"}

package/dist/core/renderTree.js

@@ -0,0 +1,23 @@
+function formatNodeSuffix(node) {
+    if (node.type === "symlink")
+        return node.target ? ` → ${node.target}` : " → [unknown]";
+    return "";
+}
+export function renderTree(root) {
+    if (!root.children || root.children.length === 0)
+        return "";
+    return root.children
+        .map((child, index) => renderTreeNode(child, "", index === root.children.length - 1))
+        .join("");
+}
+function renderTreeNode(node, prefix, isLast) {
+    const connector = isLast ? "└── " : "├── ";
+    const line = `${prefix}${connector}${node.name}${formatNodeSuffix(node)}\n`;
+    if (!node.children || node.children.length === 0)
+        return line;
+    const childPrefix = `${prefix}${isLast ? "    " : "│   "}`;
+    const childLines = node.children
+        .map((child, index) => renderTreeNode(child, childPrefix, index === node.children.length - 1))
+        .join("");
+    return `${line}${childLines}`;
+}

package/dist/core/scanTree.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from "$infra";
+import type { ScanOptions, ScanResult } from "./types";
+export declare function scanTree(options: ScanOptions, logger: Logger): Promise<ScanResult>;
+//# sourceMappingURL=scanTree.d.ts.map

package/dist/core/scanTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanTree.d.ts","sourceRoot":"","sources":["../../src/core/scanTree.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,OAAO,KAAK,EAEX,WAAW,EACX,UAAU,EAGV,MAAM,SAAS,CAAC;AAgHjB,wBAAsB,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CA4SxF"}