minimatch-fast 0.2.1

package/dist/cjs/brace-expand.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Brace expansion using the 'braces' package
+ *
+ * This module is critical because picomatch does NOT perform full brace expansion.
+ * picomatch only does brace matching, meaning {a,b} will match 'a' or 'b'
+ * but won't expand the pattern into ['a', 'b'].
+ *
+ * minimatch uses brace-expansion to fully expand patterns like:
+ * - {a,b,c} -> ['a', 'b', 'c']
+ * - {1..3} -> ['1', '2', '3']
+ * - {a..c} -> ['a', 'b', 'c']
+ * - a{b,c}d -> ['abd', 'acd']
+ *
+ * We use 'braces' package which is maintained by the same author as picomatch
+ * and is what micromatch uses internally.
+ *
+ * Security considerations:
+ * - Maximum expansion length is limited to prevent DoS attacks
+ * - Range expansion is limited (e.g., {1..1000000} is restricted)
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+/**
+ * Expand brace patterns like {a,b,c} and {1..3}
+ *
+ * Optimized with:
+ * 1. Cache for repeated patterns
+ * 2. Fast path for simple {a,b,c} patterns
+ *
+ * @param pattern - The glob pattern to expand
+ * @param options - Minimatch options
+ * @returns Array of expanded patterns
+ */
+export declare function braceExpand(pattern: string, options?: MinimatchOptions): string[];
+/**
+ * Check if a pattern contains brace expansion syntax
+ */
+export declare function hasBraces(pattern: string): boolean;
+//# sourceMappingURL=brace-expand.d.ts.map

package/dist/cjs/brace-expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-expand.d.ts","sourceRoot":"","sources":["../../src/brace-expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAyCnD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,MAAM,EAAE,CAsEV;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8BlD"}

package/dist/cjs/brace-expand.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * @fileoverview Brace expansion using the 'braces' package
+ *
+ * This module is critical because picomatch does NOT perform full brace expansion.
+ * picomatch only does brace matching, meaning {a,b} will match 'a' or 'b'
+ * but won't expand the pattern into ['a', 'b'].
+ *
+ * minimatch uses brace-expansion to fully expand patterns like:
+ * - {a,b,c} -> ['a', 'b', 'c']
+ * - {1..3} -> ['1', '2', '3']
+ * - {a..c} -> ['a', 'b', 'c']
+ * - a{b,c}d -> ['abd', 'acd']
+ *
+ * We use 'braces' package which is maintained by the same author as picomatch
+ * and is what micromatch uses internally.
+ *
+ * Security considerations:
+ * - Maximum expansion length is limited to prevent DoS attacks
+ * - Range expansion is limited (e.g., {1..1000000} is restricted)
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.braceExpand = braceExpand;
+exports.hasBraces = hasBraces;
+const braces_1 = __importDefault(require("braces"));
+/**
+ * Maximum number of patterns that can be generated from brace expansion
+ * This prevents DoS attacks from patterns like {1..1000000}
+ */
+const MAX_EXPANSION_LENGTH = 10000;
+/**
+ * Cache for brace expansion results.
+ * Key is the pattern, value is the expanded array.
+ * Limited to prevent memory issues.
+ */
+const BRACE_CACHE_SIZE = 200;
+const braceCache = new Map();
+/**
+ * Simple brace pattern regex: prefix{a,b,c}suffix
+ * Matches patterns with a single brace group containing comma-separated values
+ * without nesting or ranges.
+ */
+const SIMPLE_BRACE_RE = /^([^{]*)\{([^{}]+)\}([^{]*)$/;
+/**
+ * Try fast path for simple brace patterns like prefix{a,b,c}suffix
+ * Returns null if pattern is not a simple brace pattern.
+ */
+function trySimpleBraceExpand(pattern) {
+    const m = pattern.match(SIMPLE_BRACE_RE);
+    if (!m)
+        return null;
+    const [, prefix, content, suffix] = m;
+    // Check if it's a range pattern (contains ..)
+    if (content.includes('..'))
+        return null;
+    // Split by comma and expand
+    const items = content.split(',');
+    return items.map(item => prefix + item + suffix);
+}
+/**
+ * Expand brace patterns like {a,b,c} and {1..3}
+ *
+ * Optimized with:
+ * 1. Cache for repeated patterns
+ * 2. Fast path for simple {a,b,c} patterns
+ *
+ * @param pattern - The glob pattern to expand
+ * @param options - Minimatch options
+ * @returns Array of expanded patterns
+ */
+function braceExpand(pattern, options = {}) {
+    // If nobrace is set, return pattern unchanged
+    if (options.nobrace) {
+        return [pattern];
+    }
+    // Quick check: pattern must contain both { and }
+    const braceIdx = pattern.indexOf('{');
+    if (braceIdx === -1 || pattern.indexOf('}', braceIdx) === -1) {
+        return [pattern];
+    }
+    // Check cache first
+    const cached = braceCache.get(pattern);
+    if (cached) {
+        // Return a copy to prevent mutation
+        return [...cached];
+    }
+    // Try fast path for simple brace patterns
+    const fastResult = trySimpleBraceExpand(pattern);
+    if (fastResult !== null) {
+        // Cache and return
+        if (braceCache.size >= BRACE_CACHE_SIZE) {
+            const firstKey = braceCache.keys().next().value;
+            if (firstKey !== undefined) {
+                braceCache.delete(firstKey);
+            }
+        }
+        braceCache.set(pattern, fastResult);
+        return [...fastResult];
+    }
+    try {
+        // Use braces with expand: true for full bash-like expansion
+        const expanded = (0, braces_1.default)(pattern, {
+            expand: true,
+            // Limit range expansion to prevent DoS
+            // e.g., {1..10000} will be limited
+            rangeLimit: 1000,
+        });
+        // Check if expansion is too large (additional safety)
+        if (expanded.length > MAX_EXPANSION_LENGTH) {
+            // Return original pattern if expansion is too large
+            console.warn(`Brace expansion for "${pattern}" produced ${expanded.length} patterns, limiting to original pattern`);
+            return [pattern];
+        }
+        // Remove duplicates using Set (faster than manual loop for larger arrays)
+        const unique = [...new Set(expanded)];
+        const result = unique.length > 0 ? unique : [pattern];
+        // Cache the result
+        if (braceCache.size >= BRACE_CACHE_SIZE) {
+            const firstKey = braceCache.keys().next().value;
+            if (firstKey !== undefined) {
+                braceCache.delete(firstKey);
+            }
+        }
+        braceCache.set(pattern, result);
+        return [...result];
+    }
+    catch (e) {
+        // If expansion fails for any reason, return original pattern
+        // This matches minimatch's behavior of being lenient with invalid patterns
+        return [pattern];
+    }
+}
+/**
+ * Check if a pattern contains brace expansion syntax
+ */
+function hasBraces(pattern) {
+    // Simple check for balanced braces with content
+    let depth = 0;
+    let hasContent = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        const prevChar = i > 0 ? pattern[i - 1] : '';
+        // Skip escaped braces
+        if (prevChar === '\\') {
+            continue;
+        }
+        if (char === '{') {
+            depth++;
+        }
+        else if (char === '}') {
+            if (depth > 0) {
+                depth--;
+                if (depth === 0 && hasContent) {
+                    return true;
+                }
+            }
+        }
+        else if (depth > 0 && (char === ',' || char === '.')) {
+            // Has content (comma for list, dots for range)
+            hasContent = true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=brace-expand.js.map

package/dist/cjs/brace-expand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-expand.js","sourceRoot":"","sources":["../../src/brace-expand.ts"],"names":[],"mappings":"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"}

package/dist/cjs/cache.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview LRU Cache for compiled Minimatch patterns
+ *
+ * This module provides a simple LRU (Least Recently Used) cache for Minimatch
+ * instances. Caching compiled patterns significantly improves performance
+ * when the same pattern is used multiple times with the minimatch() function.
+ *
+ * The cache stores compiled Minimatch instances keyed by a combination of
+ * the pattern string and relevant options that affect compilation.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+import { Minimatch } from './minimatch-class.js';
+/**
+ * Get a cached Minimatch instance or create a new one.
+ * Implements LRU eviction when cache is full.
+ *
+ * @param pattern - The glob pattern
+ * @param options - Minimatch options
+ * @returns A Minimatch instance (cached or new)
+ */
+export declare function getOrCreateMatcher(pattern: string, options: MinimatchOptions): Minimatch;
+/**
+ * Clear the pattern cache.
+ * Useful for testing or when memory pressure is high.
+ */
+export declare function clearCache(): void;
+/**
+ * Get the current cache size.
+ * Useful for monitoring and testing.
+ */
+export declare function getCacheSize(): number;
+//# sourceMappingURL=cache.d.ts.map

package/dist/cjs/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AA4CjD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,SAAS,CA4BX;AAED;;;GAGG;AACH,wBAAgB,UAAU,IAAI,IAAI,CAEjC;AAED;;;GAGG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/cjs/cache.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * @fileoverview LRU Cache for compiled Minimatch patterns
+ *
+ * This module provides a simple LRU (Least Recently Used) cache for Minimatch
+ * instances. Caching compiled patterns significantly improves performance
+ * when the same pattern is used multiple times with the minimatch() function.
+ *
+ * The cache stores compiled Minimatch instances keyed by a combination of
+ * the pattern string and relevant options that affect compilation.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrCreateMatcher = getOrCreateMatcher;
+exports.clearCache = clearCache;
+exports.getCacheSize = getCacheSize;
+const minimatch_class_js_1 = require("./minimatch-class.js");
+/**
+ * Maximum number of patterns to cache.
+ * This prevents unbounded memory growth while still providing
+ * good cache hit rates for typical usage patterns.
+ */
+const CACHE_SIZE = 500;
+/**
+ * LRU cache for compiled Minimatch instances.
+ * Uses Map which maintains insertion order, making it easy
+ * to implement LRU eviction by deleting the oldest entry.
+ */
+const patternCache = new Map();
+/**
+ * Generate a cache key from pattern and options.
+ * Only includes options that affect pattern compilation.
+ *
+ * @param pattern - The glob pattern
+ * @param options - Minimatch options
+ * @returns A unique cache key string
+ */
+function getCacheKey(pattern, options) {
+    // Use null byte as separator (cannot appear in patterns)
+    // Include all options that affect compilation
+    return `${pattern}\0${options.nocase ? '1' : '0'}${options.dot ? '1' : '0'}${options.noglobstar ? '1' : '0'}${options.nobrace ? '1' : '0'}${options.noext ? '1' : '0'}${options.nonegate ? '1' : '0'}${options.nocomment ? '1' : '0'}${options.matchBase ? '1' : '0'}${options.flipNegate ? '1' : '0'}${options.windowsPathsNoEscape ? '1' : '0'}${options.preserveMultipleSlashes ? '1' : '0'}${options.partial ? '1' : '0'}${options.platform ?? ''}`;
+}
+/**
+ * Get a cached Minimatch instance or create a new one.
+ * Implements LRU eviction when cache is full.
+ *
+ * @param pattern - The glob pattern
+ * @param options - Minimatch options
+ * @returns A Minimatch instance (cached or new)
+ */
+function getOrCreateMatcher(pattern, options) {
+    const key = getCacheKey(pattern, options);
+    // Check cache first
+    let mm = patternCache.get(key);
+    if (mm) {
+        // Move to end (most recently used) by re-inserting
+        patternCache.delete(key);
+        patternCache.set(key, mm);
+        return mm;
+    }
+    // Create new Minimatch instance
+    mm = new minimatch_class_js_1.Minimatch(pattern, options);
+    // Evict oldest entry if cache is full
+    if (patternCache.size >= CACHE_SIZE) {
+        const firstKey = patternCache.keys().next().value;
+        if (firstKey !== undefined) {
+            patternCache.delete(firstKey);
+        }
+    }
+    // Add to cache
+    patternCache.set(key, mm);
+    return mm;
+}
+/**
+ * Clear the pattern cache.
+ * Useful for testing or when memory pressure is high.
+ */
+function clearCache() {
+    patternCache.clear();
+}
+/**
+ * Get the current cache size.
+ * Useful for monitoring and testing.
+ */
+function getCacheSize() {
+    return patternCache.size;
+}
+//# sourceMappingURL=cache.js.map

package/dist/cjs/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AAuDH,gDA+BC;AAMD,gCAEC;AAMD,oCAEC;AAnGD,6DAAiD;AAEjD;;;;GAIG;AACH,MAAM,UAAU,GAAG,GAAG,CAAC;AAEvB;;;;GAIG;AACH,MAAM,YAAY,GAAG,IAAI,GAAG,EAAqB,CAAC;AAElD;;;;;;;GAOG;AACH,SAAS,WAAW,CAAC,OAAe,EAAE,OAAyB;IAC7D,yDAAyD;IACzD,8CAA8C;IAC9C,OAAO,GAAG,OAAO,KACf,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GACzB,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GACxB,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC7B,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAC5B,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GACxB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAC7B,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC5B,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAC9B,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC7B,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GACzC,OAAO,CAAC,uBAAuB,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAC1C,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAC5B,OAAO,CAAC,QAAQ,IAAI,EACtB,EAAE,CAAC;AACL,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAChC,OAAe,EACf,OAAyB;IAEzB,MAAM,GAAG,GAAG,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAE1C,oBAAoB;IACpB,IAAI,EAAE,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAE/B,IAAI,EAAE,EAAE,CAAC;QACP,mDAAmD;QACnD,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACzB,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QAC1B,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,gCAAgC;IAChC,EAAE,GAAG,IAAI,8BAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAErC,sCAAsC;IACtC,IAAI,YAAY,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;QAClD,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,YAAY,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,eAAe;IACf,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAE1B,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;GAGG;AACH,SAAgB,UAAU;IACxB,YAAY,CAAC,KAAK,EAAE,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,SAAgB,YAAY;IAC1B,OAAO,YAAY,CAAC,IAAI,CAAC;AAC3B,CAAC"}

package/dist/cjs/escape.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @fileoverview Escape glob magic characters
+ *
+ * This module provides functionality to escape special glob characters in strings,
+ * making them match literally instead of being interpreted as patterns.
+ *
+ * Escape modes:
+ * - Default mode: Uses backslash escaping (\* \? etc.)
+ * - Windows mode: Uses character class escaping ([*] [?] etc.)
+ *
+ * This is useful when you need to match file paths that contain glob
+ * special characters like *, ?, [], {}, etc.
+ *
+ * @example
+ * escape('*.js')           // Returns '\\*.js'
+ * escape('[test].js')      // Returns '\\[test\\].js'
+ * escape('*.js', { windowsPathsNoEscape: true })  // Returns '[*].js'
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+/**
+ * Escape all magic characters in a glob pattern so it matches literally.
+ *
+ * If windowsPathsNoEscape is true, characters are escaped by wrapping in [],
+ * because a magic character wrapped in a character class can only be satisfied
+ * by that exact character. Backslash is NOT escaped in this mode because it
+ * is treated as a path separator.
+ *
+ * If windowsPathsNoEscape is false (default), characters are escaped with
+ * backslash.
+ *
+ * @param str - The string to escape
+ * @param options - Options controlling escape behavior
+ * @returns Escaped string
+ */
+export declare function escape(str: string, options?: Pick<MinimatchOptions, 'windowsPathsNoEscape'>): string;
+//# sourceMappingURL=escape.d.ts.map

package/dist/cjs/escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.d.ts","sourceRoot":"","sources":["../../src/escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CACpB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,gBAAgB,EAAE,sBAAsB,CAAM,GAC3D,MAAM,CAYR"}

package/dist/cjs/escape.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * @fileoverview Escape glob magic characters
+ *
+ * This module provides functionality to escape special glob characters in strings,
+ * making them match literally instead of being interpreted as patterns.
+ *
+ * Escape modes:
+ * - Default mode: Uses backslash escaping (\* \? etc.)
+ * - Windows mode: Uses character class escaping ([*] [?] etc.)
+ *
+ * This is useful when you need to match file paths that contain glob
+ * special characters like *, ?, [], {}, etc.
+ *
+ * @example
+ * escape('*.js')           // Returns '\\*.js'
+ * escape('[test].js')      // Returns '\\[test\\].js'
+ * escape('*.js', { windowsPathsNoEscape: true })  // Returns '[*].js'
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escape = escape;
+/**
+ * Escape all magic characters in a glob pattern so it matches literally.
+ *
+ * If windowsPathsNoEscape is true, characters are escaped by wrapping in [],
+ * because a magic character wrapped in a character class can only be satisfied
+ * by that exact character. Backslash is NOT escaped in this mode because it
+ * is treated as a path separator.
+ *
+ * If windowsPathsNoEscape is false (default), characters are escaped with
+ * backslash.
+ *
+ * @param str - The string to escape
+ * @param options - Options controlling escape behavior
+ * @returns Escaped string
+ */
+function escape(str, options = {}) {
+    const { windowsPathsNoEscape = false } = options;
+    if (windowsPathsNoEscape) {
+        // Escape by wrapping in character class []
+        // Don't escape backslash since it's a path separator in this mode
+        return str.replace(/[?*()[\]{}]/g, '[$&]');
+    }
+    // Default: escape with backslash
+    // Include backslash in the escape set
+    return str.replace(/[?*()[\]{}\\]/g, '\\$&');
+}
+//# sourceMappingURL=escape.js.map

package/dist/cjs/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sourceRoot":"","sources":["../../src/escape.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;;AAmBH,wBAeC;AA9BD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,MAAM,CACpB,GAAW,EACX,UAA0D,EAAE;IAE5D,MAAM,EAAE,oBAAoB,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAEjD,IAAI,oBAAoB,EAAE,CAAC;QACzB,2CAA2C;QAC3C,kEAAkE;QAClE,OAAO,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED,iCAAiC;IACjC,sCAAsC;IACtC,OAAO,GAAG,CAAC,OAAO,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;AAC/C,CAAC"}

package/dist/cjs/fast-paths.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Fast path handlers for common glob patterns
+ *
+ * This module provides optimized matching for the most common glob patterns,
+ * avoiding the overhead of full regex compilation. These fast paths use
+ * simple string operations like startsWith(), endsWith(), and includes()
+ * which are significantly faster than regex matching.
+ *
+ * Supported fast path patterns:
+ * - `*` - Match any single path segment (except dotfiles by default)
+ * - `*.ext` - Match files with specific extension (e.g., `*.js`, `*.ts`)
+ * - `*.*` - Match files with any extension
+ * - `.*` - Match hidden files (dotfiles)
+ * - `???` - Match files with exact length (question mark patterns)
+ *
+ * When a pattern doesn't match any fast path, null is returned and the
+ * caller should fall back to full pattern matching.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+/**
+ * Try to match a path against a pattern using a fast path.
+ *
+ * This function attempts to use optimized string operations for common
+ * glob patterns instead of full regex compilation. If the pattern is not
+ * a simple pattern that can be handled by a fast path, null is returned.
+ *
+ * @param path - The path to match (should be a filename without directory)
+ * @param pattern - The glob pattern to match against
+ * @param options - Minimatch options (dot, nocase are relevant)
+ * @returns true if matches, false if doesn't match, null if no fast path available
+ *
+ * @example
+ * ```typescript
+ * tryFastPath('foo.js', '*.js', {});           // true
+ * tryFastPath('foo.txt', '*.js', {});          // false
+ * tryFastPath('.hidden', '*', {});             // false
+ * tryFastPath('.hidden', '*', { dot: true });  // true
+ * tryFastPath('foo.js', '**\/*.js', {});        // null (has /, need full matching)
+ * ```
+ */
+export declare function tryFastPath(path: string, pattern: string, options: MinimatchOptions): boolean | null;
+/**
+ * Check if a pattern might be eligible for fast path.
+ * This is a quick pre-check to avoid expensive regex tests.
+ *
+ * @param pattern - The glob pattern
+ * @returns true if pattern might use fast path
+ */
+export declare function mightUseFastPath(pattern: string): boolean;
+//# sourceMappingURL=fast-paths.d.ts.map

package/dist/cjs/fast-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-paths.d.ts","sourceRoot":"","sources":["../../src/fast-paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AA4CnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,gBAAgB,GACxB,OAAO,GAAG,IAAI,CAmHhB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAYzD"}