@travisennis/acai 0.0.4 → 0.0.5

package/dist/utils/filetype-detection.js

@@ -0,0 +1,112 @@
+import { basename, extname } from "node:path";
+const extensionToLanguageMap = {
+    ".ts": { name: "TypeScript", codeblock: "typescript" },
+    ".js": { name: "JavaScript", codeblock: "javascript" },
+    ".mjs": { name: "JavaScript", codeblock: "javascript" },
+    ".cjs": { name: "JavaScript", codeblock: "javascript" },
+    ".jsx": { name: "JavaScript", codeblock: "javascript" },
+    ".tsx": { name: "TypeScript", codeblock: "typescript" },
+    ".py": { name: "Python", codeblock: "python" },
+    ".java": { name: "Java", codeblock: "java" },
+    ".go": { name: "Go", codeblock: "go" },
+    ".rb": { name: "Ruby", codeblock: "ruby" },
+    ".php": { name: "PHP", codeblock: "php" },
+    ".phtml": { name: "PHP", codeblock: "php" },
+    ".cs": { name: "C#", codeblock: "csharp" },
+    ".cpp": { name: "C++", codeblock: "cpp" },
+    ".cxx": { name: "C++", codeblock: "cpp" },
+    ".cc": { name: "C++", codeblock: "cpp" },
+    ".c": { name: "C", codeblock: "c" },
+    ".h": { name: "C/C++", codeblock: "cpp" },
+    ".hpp": { name: "C++", codeblock: "cpp" },
+    ".swift": { name: "Swift", codeblock: "swift" },
+    ".kt": { name: "Kotlin", codeblock: "kotlin" },
+    ".rs": { name: "Rust", codeblock: "rust" },
+    ".m": { name: "Objective-C", codeblock: "objectivec" },
+    ".mm": { name: "Objective-C", codeblock: "objectivec" },
+    ".pl": { name: "Perl", codeblock: "perl" },
+    ".pm": { name: "Perl", codeblock: "perl" },
+    ".lua": { name: "Lua", codeblock: "lua" },
+    ".r": { name: "R", codeblock: "r" },
+    ".scala": { name: "Scala", codeblock: "scala" },
+    ".sc": { name: "Scala", codeblock: "scala" },
+    ".sh": { name: "Shell", codeblock: "bash" },
+    ".ps1": { name: "PowerShell", codeblock: "powershell" },
+    ".bat": { name: "Batch", codeblock: "batch" },
+    ".cmd": { name: "Batch", codeblock: "batch" },
+    ".sql": { name: "SQL", codeblock: "sql" },
+    ".html": { name: "HTML", codeblock: "html" },
+    ".htm": { name: "HTML", codeblock: "html" },
+    ".css": { name: "CSS", codeblock: "css" },
+    ".less": { name: "Less", codeblock: "less" },
+    ".sass": { name: "Sass", codeblock: "sass" },
+    ".scss": { name: "Sass", codeblock: "scss" },
+    ".json": { name: "JSON", codeblock: "json" },
+    ".xml": { name: "XML", codeblock: "xml" },
+    ".yaml": { name: "YAML", codeblock: "yaml" },
+    ".yml": { name: "YAML", codeblock: "yaml" },
+    ".md": { name: "Markdown", codeblock: "markdown" },
+    ".markdown": { name: "Markdown", codeblock: "markdown" },
+    ".dockerfile": { name: "Dockerfile", codeblock: "dockerfile" },
+    ".vim": { name: "Vim script", codeblock: "vim" },
+    ".vb": { name: "Visual Basic", codeblock: "vb" },
+    ".fs": { name: "F#", codeblock: "fsharp" },
+    ".clj": { name: "Clojure", codeblock: "clojure" },
+    ".cljs": { name: "Clojure", codeblock: "clojure" },
+    ".dart": { name: "Dart", codeblock: "dart" },
+    ".ex": { name: "Elixir", codeblock: "elixir" },
+    ".erl": { name: "Erlang", codeblock: "erlang" },
+    ".hs": { name: "Haskell", codeblock: "haskell" },
+    ".lisp": { name: "Lisp", codeblock: "lisp" },
+    ".rkt": { name: "Racket", codeblock: "racket" },
+    ".groovy": { name: "Groovy", codeblock: "groovy" },
+    ".jl": { name: "Julia", codeblock: "julia" },
+    ".tex": { name: "LaTeX", codeblock: "latex" },
+    ".ino": { name: "Arduino", codeblock: "arduino" },
+    ".asm": { name: "Assembly", codeblock: "asm" },
+    ".s": { name: "Assembly", codeblock: "asm" },
+    ".toml": { name: "TOML", codeblock: "toml" },
+    ".vue": { name: "Vue", codeblock: "vue" },
+    ".svelte": { name: "Svelte", codeblock: "svelte" },
+    ".gohtml": { name: "Go Template", codeblock: "go" },
+    ".hbs": { name: "Handlebars", codeblock: "handlebars" },
+    ".ejs": { name: "EJS", codeblock: "ejs" },
+    ".erb": { name: "ERB", codeblock: "erb" },
+    ".jsp": { name: "JSP", codeblock: "jsp" },
+    ".dockerignore": { name: "Docker", codeblock: "dockerfile" },
+    ".gitignore": { name: "Git", codeblock: "gitignore" },
+    ".npmignore": { name: "npm", codeblock: "npmignore" },
+    ".editorconfig": { name: "EditorConfig", codeblock: "editorconfig" },
+    ".prettierrc": { name: "Prettier", codeblock: "json" },
+    ".eslintrc": { name: "ESLint", codeblock: "json" },
+    ".babelrc": { name: "Babel", codeblock: "json" },
+    ".tsconfig": { name: "TypeScript", codeblock: "json" },
+    ".flow": { name: "Flow", codeblock: "flow" },
+    ".graphql": { name: "GraphQL", codeblock: "graphql" },
+    ".proto": { name: "Protocol Buffers", codeblock: "protobuf" },
+    ".txt": { name: "Text", codeblock: "text" },
+};
+export function getLanguageFromFilePath(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    const languageInfo = extension
+        ? extensionToLanguageMap[extension]
+        : undefined;
+    if (languageInfo) {
+        return languageInfo.name;
+    }
+    const filename = basename(filePath).toLowerCase();
+    const filenameLanguageInfo = extensionToLanguageMap[`.${filename}`];
+    return filenameLanguageInfo?.name;
+}
+export function getCodeblockFromFilePath(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    const languageInfo = extension
+        ? extensionToLanguageMap[extension]
+        : undefined;
+    if (languageInfo) {
+        return languageInfo.codeblock;
+    }
+    const filename = basename(filePath).toLowerCase();
+    const filenameLanguageInfo = extensionToLanguageMap[`.${filename}`];
+    return filenameLanguageInfo?.codeblock;
+}

package/dist/utils/glob.d.ts

@@ -0,0 +1,52 @@
+import { type Options as FastGlobOptions } from "fast-glob";
+type ExpandDirectoriesOption = boolean | readonly string[] | {
+    files?: readonly string[];
+    extensions?: readonly string[];
+};
+type FastGlobOptionsWithoutCwd = Omit<FastGlobOptions, "cwd">;
+type Options = {
+    /**
+     * If set to `true`, `glob` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.
+     *
+     * Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
+     *
+     * @default true
+     */
+    readonly expandDirectories?: ExpandDirectoriesOption;
+    /**
+     * Respect ignore patterns in `.gitignore` files that apply to the globbed files.
+     *
+     * Performance note: This option searches for all `.gitignore` files in the entire directory tree before globbing, which can be slow. For better performance, use `ignoreFiles: '.gitignore'` to only respect the root `.gitignore` file.
+     *
+     * @default false
+     */
+    readonly gitignore?: boolean;
+    /**
+     * Glob patterns to look for ignore files, which are then used to ignore globbed files.
+     *
+     * This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
+     *
+     * Performance tip: Using a specific path like `'.gitignore'` is much faster than recursive patterns.
+     *
+     * @default undefined
+     */
+    readonly ignoreFiles?: string | readonly string[];
+    /**
+     * The current working directory in which to search.
+     *
+     * @default process.cwd()
+     */
+    readonly cwd?: URL | string;
+} & FastGlobOptionsWithoutCwd;
+/**
+ * Find files and directories using glob patterns.
+ *
+ * Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+ *
+ * @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ * @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+ * @returns The matching paths.
+ */
+export declare const glob: (patterns: string | string[] | readonly string[], options?: Options) => Promise<string[]>;
+export {};
+//# sourceMappingURL=glob.d.ts.map

package/dist/utils/glob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../source/utils/glob.ts"],"names":[],"mappings":"AAIA,OAAW,EAAc,KAAK,OAAO,IAAI,eAAe,EAAE,MAAM,WAAW,CAAC;AAgB5E,KAAK,uBAAuB,GACxB,OAAO,GACP,SAAS,MAAM,EAAE,GACjB;IAAE,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAElE,KAAK,yBAAyB,GAAG,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;AAE9D,KAAK,OAAO,GAAG;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC;IAErD;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAE7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IAElD;;;;OAIG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,MAAM,CAAC;CAC7B,GAAG,yBAAyB,CAAC;AA6U9B;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,8DAtLa,OAAO,sBAoMpC,CAAC"}

package/dist/utils/glob.js

@@ -0,0 +1,376 @@
+import * as fs from "node:fs";
+import { readFile } from "node:fs/promises";
+import path, * as nodePath from "node:path";
+import * as process from "node:process";
+import fg from "fast-glob";
+import { isDirectory, slash, toPath } from "./filesystem.js";
+import { Ignore } from "./ignore.js";
+// Cache for ignore patterns to avoid repeated IO
+const ignoreCache = new Map();
+const CACHE_TTL = 60000; // 1 minute TTL
+const assertPatternsInput = (patterns) => {
+    if (patterns.some((pattern) => typeof pattern !== "string")) {
+        throw new TypeError("Patterns must be a string or an array of strings");
+    }
+};
+// Pre-compiled regexes for performance
+const GLOBSTAR_DIRECTORY_REGEX = /\*\*\/([^/]+)$/;
+const WILDCARD_CHARS_REGEX = /[*?[\]{}]/;
+const EXTENSION_PATTERN_REGEX = /\.[a-zA-Z0-9]{1,5}$/;
+const normalizePathForDirectoryGlob = (filePath, cwd) => {
+    const path = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
+    return nodePath.isAbsolute(path) ? path : nodePath.join(cwd, path);
+};
+const shouldExpandGlobstarDirectory = (pattern) => {
+    const match = pattern?.match(GLOBSTAR_DIRECTORY_REGEX);
+    if (!match) {
+        return false;
+    }
+    const dirname = match[1];
+    const hasWildcards = WILDCARD_CHARS_REGEX.test(dirname);
+    // Only consider it an extension if it looks like a file extension pattern
+    // (e.g., contains common extension chars and doesn't look like a directory name)
+    const hasExtension = EXTENSION_PATTERN_REGEX.test(dirname) && !dirname.startsWith(".");
+    return !hasWildcards && !hasExtension;
+};
+const getDirectoryGlob = ({ directoryPath, files, extensions, }) => {
+    const extensionGlob = extensions && extensions.length > 0
+        ? `.${extensions.length > 1 ? `{${extensions.join(",")}}` : extensions[0]}`
+        : "";
+    return files
+        ? files.map((file) => {
+            // Don't append extension glob if file already has wildcards, extension, or looks like a pattern
+            const hasGlobChars = /[*?[\]{}]/.test(file);
+            const hasExtension = nodePath.extname(file);
+            const shouldAppendExtension = extensionGlob && !hasGlobChars && !hasExtension;
+            return nodePath.posix.join(directoryPath, `**/${shouldAppendExtension ? `${file}${extensionGlob}` : file}`);
+        })
+        : [
+            nodePath.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ""}`),
+        ];
+};
+const directoryToGlob = async (directoryPaths, { cwd = process.cwd(), files, extensions, } = {}) => {
+    const globs = await Promise.all(directoryPaths.map(async (directoryPath) => {
+        // Check pattern without negative prefix
+        const checkPattern = isNegativePattern(directoryPath)
+            ? directoryPath.slice(1)
+            : directoryPath;
+        // Expand globstar directory patterns like **/dirname to **/dirname/**
+        if (shouldExpandGlobstarDirectory(checkPattern)) {
+            return getDirectoryGlob({ directoryPath, files, extensions });
+        }
+        // If pattern contains any glob wildcard, do not stat; leave as-is
+        if (/[*?[\]{}]/.test(checkPattern)) {
+            return directoryPath;
+        }
+        // Original logic for checking actual directories
+        const pathToCheck = normalizePathForDirectoryGlob(directoryPath, cwd);
+        return (await isDirectory(pathToCheck))
+            ? getDirectoryGlob({ directoryPath, files, extensions })
+            : directoryPath;
+    }));
+    return globs.flat();
+};
+const toPatternsArray = (patterns) => {
+    const flattenedPatterns = Array.from(new Set([patterns].flat()));
+    assertPatternsInput(flattenedPatterns);
+    return flattenedPatterns;
+};
+const checkCwdOption = (cwd) => {
+    if (!cwd) {
+        return;
+    }
+    let stat;
+    try {
+        stat = fs.statSync(cwd);
+    }
+    catch (_error) {
+        throw new Error(`The \`cwd\` option must point to an existing directory: ${cwd}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error("The `cwd` option must be a path to a directory");
+    }
+};
+const normalizeOptions = (options = {}) => {
+    const resolvedCwd = options.cwd ? toPath(options.cwd) : undefined;
+    const normalizedOptions = {
+        ...options,
+        ignore: options.ignore ?? [],
+        expandDirectories: options.expandDirectories ?? true,
+        cwd: resolvedCwd,
+    };
+    if (resolvedCwd) {
+        checkCwdOption(resolvedCwd);
+    }
+    return normalizedOptions;
+};
+const normalizeArguments = (fn) => (patterns, options) => fn(toPatternsArray(patterns), normalizeOptions(options || {}));
+const getIgnoreFilesPatterns = (options) => {
+    const { ignoreFiles, gitignore } = options;
+    const patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
+    if (gitignore) {
+        patterns.push(GITIGNORE_FILES_PATTERN);
+    }
+    return patterns;
+};
+const getFilter = async (options) => {
+    const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+    const isIgnoredFn = ignoreFilesPatterns.length > 0
+        ? await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options)
+        : false;
+    return createFilterFunction(isIgnoredFn);
+};
+// No-op predicate for when no ignore filtering is needed
+const noOpPredicate = () => false;
+const createFilterFunction = (isIgnored) => {
+    const seen = new Set();
+    const ignorePredicate = isIgnored === false ? noOpPredicate : isIgnored;
+    return (fastGlobResult) => {
+        let pathKey;
+        if (typeof fastGlobResult === "string") {
+            pathKey = fastGlobResult;
+        }
+        else {
+            const entry = fastGlobResult;
+            if (!entry.path) {
+                // Entry without path is invalid - skip it
+                return false;
+            }
+            pathKey = entry.path;
+        }
+        // Normalize to POSIX for consistent cross-platform behavior
+        pathKey = slash(nodePath.normalize(pathKey));
+        if (seen.has(pathKey) || ignorePredicate(pathKey)) {
+            return false;
+        }
+        seen.add(pathKey);
+        return true;
+    };
+};
+const unionFastGlobResults = (results, filter) => results.flat().filter((fastGlobResult) => filter(fastGlobResult));
+const convertNegativePatterns = (patterns, options) => {
+    const tasks = [];
+    let localPatterns = patterns;
+    while (localPatterns.length > 0) {
+        const index = localPatterns.findIndex((pattern) => isNegativePattern(pattern));
+        if (index === -1) {
+            tasks.push({ patterns: localPatterns, options });
+            break;
+        }
+        const ignorePattern = localPatterns[index].slice(1);
+        // Create immutable copies for all existing tasks
+        for (let i = 0; i < tasks.length; i++) {
+            tasks[i] = {
+                ...tasks[i],
+                options: {
+                    ...tasks[i].options,
+                    ignore: [...(tasks[i].options.ignore ?? []), ignorePattern],
+                },
+            };
+        }
+        if (index !== 0) {
+            tasks.push({
+                patterns: localPatterns.slice(0, index),
+                options: {
+                    ...options,
+                    ignore: [...(options.ignore ?? []), ignorePattern],
+                },
+            });
+        }
+        localPatterns = localPatterns.slice(index + 1);
+    }
+    return tasks;
+};
+const normalizeExpandDirectoriesOption = (options, cwd) => {
+    const result = {};
+    if (cwd) {
+        result.cwd = cwd;
+    }
+    if (Array.isArray(options)) {
+        result.files = options;
+    }
+    else if (typeof options === "object" && options !== null) {
+        if ("files" in options)
+            result.files = options.files;
+        if ("extensions" in options)
+            result.extensions = options.extensions;
+    }
+    return result;
+};
+const generateTasks = async (patterns, options) => {
+    const globTasks = convertNegativePatterns(patterns, options);
+    const { cwd, expandDirectories } = options;
+    if (!expandDirectories) {
+        return globTasks;
+    }
+    const directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd ? toPath(cwd) : cwd);
+    return Promise.all(globTasks.map(async (task) => {
+        let { patterns, options } = task;
+        [patterns, options.ignore] = await Promise.all([
+            directoryToGlob(patterns, directoryToGlobOptions),
+            directoryToGlob(options.ignore, {
+                cwd: cwd ? toPath(cwd) : cwd,
+            }),
+        ]);
+        return { patterns, options };
+    }));
+};
+/**
+ * Find files and directories using glob patterns.
+ *
+ * Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+ *
+ * @param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+ * @param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+ * @returns The matching paths.
+ */
+export const glob = normalizeArguments(async (patterns, options) => {
+    const [tasks, filter] = await Promise.all([
+        generateTasks(patterns, options),
+        getFilter(options),
+    ]);
+    const results = await Promise.all(tasks.map((task) => fg(task.patterns, convertOptionsForFastGlob(task.options))));
+    return unionFastGlobResults(results, filter);
+});
+// Helper function to convert our Options to fast-glob compatible options
+const convertOptionsForFastGlob = (options) => {
+    const { cwd, ...rest } = options;
+    return {
+        ...rest,
+        cwd: cwd ? toPath(cwd) : undefined,
+    };
+};
+const defaultIgnoredDirectories = [
+    "**/node_modules",
+    "**/flow-typed",
+    "**/coverage",
+    "**/.git",
+];
+const ignoreFilesGlobOptions = {
+    absolute: true,
+    dot: true,
+};
+const GITIGNORE_FILES_PATTERN = "**/.gitignore";
+// Apply base path to gitignore patterns based on .gitignore spec 2.22.1
+// https://git-scm.com/docs/gitignore#_pattern_format
+// See also https://github.com/sindresorhus/globby/issues/146
+const applyBaseToPattern = (pattern, base) => {
+    if (!base) {
+        return pattern;
+    }
+    const isNegative = isNegativePattern(pattern);
+    const cleanPattern = isNegative ? pattern.slice(1) : pattern;
+    // Check if pattern has non-trailing slashes
+    const slashIndex = cleanPattern.indexOf("/");
+    const hasNonTrailingSlash = slashIndex !== -1 && slashIndex !== cleanPattern.length - 1;
+    let result;
+    if (!hasNonTrailingSlash) {
+        // "If there is no separator at the beginning or middle of the pattern,
+        // then the pattern may also match at any level below the .gitignore level."
+        // So patterns like '*.log' or 'temp' or 'build/' (trailing slash) match recursively.
+        result = path.posix.join(base, "**", cleanPattern);
+    }
+    else if (cleanPattern.startsWith("/")) {
+        // "If there is a separator at the beginning [...] of the pattern,
+        // then the pattern is relative to the directory level of the particular .gitignore file itself."
+        // Leading slash anchors the pattern to the .gitignore's directory.
+        result = path.posix.join(base, cleanPattern.slice(1));
+    }
+    else {
+        // "If there is a separator [...] middle [...] of the pattern,
+        // then the pattern is relative to the directory level of the particular .gitignore file itself."
+        // Patterns like 'src/foo' are relative to the .gitignore's directory.
+        result = path.posix.join(base, cleanPattern);
+    }
+    return isNegative ? `!${result}` : result;
+};
+const parseIgnoreFile = (file, cwd) => {
+    const base = slash(path.relative(cwd, path.dirname(file.filePath)));
+    const patterns = [];
+    for (const raw of file.content.split(/\r?\n/)) {
+        if (raw === "")
+            continue; // blank line
+        if (raw.startsWith("#"))
+            continue; // comment line (only when not escaped)
+        const line = raw; // preserve escapes like \# and \  for Ignore engine
+        patterns.push(applyBaseToPattern(line, base));
+    }
+    return patterns;
+};
+const toRelativePath = (fileOrDirectory, cwd) => {
+    const abs = path.isAbsolute(fileOrDirectory)
+        ? fileOrDirectory
+        : path.resolve(cwd, fileOrDirectory);
+    const rel = path.relative(cwd, abs);
+    if (rel.startsWith("..") || path.isAbsolute(rel))
+        return undefined;
+    return rel.startsWith("./") ? rel.slice(2) : rel;
+};
+const getIsIgnoredPredicate = (files, cwd) => {
+    // Sort files by path depth (ascending) so deeper .gitignore files override shallower ones
+    const sortedFiles = [...files].sort((a, b) => {
+        const depthA = a.filePath.split(nodePath.sep).length;
+        const depthB = b.filePath.split(nodePath.sep).length;
+        return depthA - depthB;
+    });
+    // Generate cache key using file paths + content hash
+    const hashString = (s) => {
+        // FNV-1a 32-bit
+        let h = 0x811c9dc5;
+        for (let i = 0; i < s.length; i++) {
+            h ^= s.charCodeAt(i);
+            h += (h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24);
+        }
+        // force to uint32 and hex
+        return (h >>> 0).toString(16);
+    };
+    const cacheKey = `${cwd}|` +
+        sortedFiles.map((f) => `${f.filePath}:${hashString(f.content)}`).join("|");
+    const now = Date.now();
+    const cached = ignoreCache.get(cacheKey);
+    let patterns;
+    if (cached && now - cached.timestamp < CACHE_TTL) {
+        patterns = cached.patterns;
+    }
+    else {
+        patterns = sortedFiles.flatMap((file) => parseIgnoreFile(file, cwd));
+        ignoreCache.set(cacheKey, { patterns, timestamp: now });
+    }
+    const ignoreInstance = new Ignore().add(patterns);
+    return (fileOrDirectory) => {
+        let fileOrDirectoryAsPath = toPath(fileOrDirectory);
+        fileOrDirectoryAsPath = toRelativePath(fileOrDirectoryAsPath, cwd);
+        // If path is outside cwd (undefined), it can't be ignored by patterns in cwd
+        if (fileOrDirectoryAsPath === undefined) {
+            return false;
+        }
+        return fileOrDirectoryAsPath
+            ? ignoreInstance.ignores(slash(fileOrDirectoryAsPath))
+            : false;
+    };
+};
+const normalizeIgnoreOptions = (options = {}) => ({
+    cwd: options.cwd ? toPath(options.cwd) : process.cwd(),
+    suppressErrors: Boolean(options.suppressErrors),
+    deep: typeof options.deep === "number" ? options.deep : Number.POSITIVE_INFINITY,
+    ignore: [...(options.ignore ?? []), ...defaultIgnoredDirectories],
+});
+const isIgnoredByIgnoreFiles = async (patterns, options) => {
+    const { cwd, suppressErrors, deep, ignore } = normalizeIgnoreOptions(options);
+    const paths = await fg(patterns, {
+        cwd,
+        suppressErrors,
+        deep,
+        ignore: ignore,
+        ...ignoreFilesGlobOptions,
+    });
+    const files = await Promise.all(paths.map(async (filePath) => ({
+        filePath,
+        content: await readFile(filePath, "utf8"),
+    })));
+    return getIsIgnoredPredicate(files, cwd);
+};
+/**
+ * Check if a pattern is negative (starts with '!')
+ */
+const isNegativePattern = (pattern) => pattern[0] === "!";

package/dist/utils/ignore.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Modern TypeScript implementation of node-ignore
+ * Based on https://github.com/kaelzhang/node-ignore
+ */
+interface TestResult {
+    ignored: boolean;
+    unignored: boolean;
+    rule?: IgnoreRule;
+}
+interface PatternObject {
+    pattern: string;
+    mark?: boolean;
+}
+declare class IgnoreRule {
+    readonly pattern: string;
+    readonly mark?: boolean;
+    readonly negative: boolean;
+    private readonly ignoreCase;
+    private readonly regexPrefix;
+    private _regex?;
+    private _checkRegex?;
+    constructor(pattern: string, mark: boolean | undefined, _body: string, ignoreCase: boolean, negative: boolean, regexPrefix: string);
+    get regex(): RegExp;
+    get checkRegex(): RegExp;
+    private compileRegex;
+}
+interface IgnoreOptions {
+    ignorecase?: boolean;
+    ignoreCase?: boolean;
+    allowRelativePaths?: boolean;
+}
+export declare class Ignore {
+    private readonly _rules;
+    private readonly _strictPathCheck;
+    private _ignoreCache;
+    private _testCache;
+    /**
+     * Create a new Ignore instance
+     * @param options - Configuration options
+     * @param options.ignorecase - Whether to use case-insensitive matching (default: true)
+     * @param options.ignoreCase - Alias for ignorecase
+     * @param options.allowRelativePaths - Allow relative paths like './' and '../' (default: false)
+     */
+    constructor({ ignorecase, ignoreCase, allowRelativePaths, }?: IgnoreOptions);
+    private _initCache;
+    /**
+     * Clear all internal caches
+     */
+    clearCache(): this;
+    /**
+     * Add ignore patterns
+     * @param pattern - Pattern(s) to add
+     * @returns This instance for chaining
+     */
+    add(pattern: string | string[] | Ignore | PatternObject): this;
+    /**
+     * Legacy alias for add()
+     * @deprecated Use add() instead
+     */
+    addPattern(pattern: string | string[] | Ignore | PatternObject): this;
+    private _test;
+    /**
+     * Check if a path is ignored (Git check-ignore compatible)
+     * @param path - The path to check
+     * @returns TestResult with ignored status and matched rule
+     */
+    checkIgnore(path: string): TestResult;
+    private _t;
+    /**
+     * Check if a path is ignored
+     * @param path - The path to check
+     * @returns True if the path is ignored
+     */
+    ignores(path: string): boolean;
+    /**
+     * Create a filter function that returns true for non-ignored paths
+     * @returns Filter function
+     */
+    createFilter(): (path: string) => boolean;
+    /**
+     * Filter an array of paths, returning only non-ignored paths
+     * @param paths - Paths to filter
+     * @returns Array of non-ignored paths
+     */
+    filter(paths: string | string[]): string[];
+    /**
+     * Test if a path is ignored
+     * @param path - The path to test
+     * @returns TestResult with ignored status and matched rule
+     */
+    test(path: string): TestResult;
+    /**
+     * Compile a pattern to a regular expression
+     * @param pattern - The pattern to compile
+     * @returns Compiled regular expression
+     */
+    compile(pattern: string): RegExp;
+}
+declare const factory: {
+    (options?: IgnoreOptions): Ignore;
+    default: /*elided*/ any;
+};
+export default factory;
+//# sourceMappingURL=ignore.d.ts.map

package/dist/utils/ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore.d.ts","sourceRoot":"","sources":["../../source/utils/ignore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqWH,UAAU,UAAU;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,cAAM,UAAU;IACd,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,IAAI,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAgB,QAAQ,EAAE,OAAO,CAAC;IAElC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAGrC,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,WAAW,CAAC,CAAS;gBAG3B,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,OAAO,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,OAAO,EACjB,WAAW,EAAE,MAAM;IASrB,IAAI,KAAK,IAAI,MAAM,CAKlB;IAED,IAAI,UAAU,IAAI,MAAM,CAKvB;IAED,OAAO,CAAC,YAAY;CAWrB;AA0MD,UAAU,aAAa;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAU;IAC3C,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,UAAU,CAAkC;IAEpD;;;;;;OAMG;gBACS,EACV,UAAiB,EACjB,UAAuB,EACvB,kBAA0B,GAC3B,GAAE,aAAkB;IASrB,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,aAAa,GAAG,IAAI;IAW9D;;;OAGG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,GAAG,aAAa,GAAG,IAAI;IAKrE,OAAO,CAAC,KAAK;IAuBb;;;;OAIG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IA0BrC,OAAO,CAAC,EAAE;IAgDV;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI9B;;;OAGG;IACH,YAAY,IAAI,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO;IAIzC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE;IAI1C;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAI9B;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAKjC;AAED,QAAA,MAAM,OAAO;eAAc,aAAa,GAAG,MAAM;;CAAuB,CAAC;AA6BzE,eAAe,OAAO,CAAC"}