minimatch-fast 0.2.1

package/dist/esm/brace-expand.js

@@ -0,0 +1,165 @@
+/**
+ * @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 braces from '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
+ */
+export 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 = braces(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
+ */
+export 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/esm/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/esm/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/esm/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/esm/cache.js

@@ -0,0 +1,86 @@
+/**
+ * @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 { Minimatch } from './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)
+ */
+export 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(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.
+ */
+export function clearCache() {
+    patternCache.clear();
+}
+/**
+ * Get the current cache size.
+ * Useful for monitoring and testing.
+ */
+export function getCacheSize() {
+    return patternCache.size;
+}
+//# sourceMappingURL=cache.js.map

package/dist/esm/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;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,MAAM,UAAU,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,SAAS,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,MAAM,UAAU,UAAU;IACxB,YAAY,CAAC,KAAK,EAAE,CAAC;AACvB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,CAAC,IAAI,CAAC;AAC3B,CAAC"}

package/dist/esm/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/esm/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/esm/escape.js

@@ -0,0 +1,49 @@
+/**
+ * @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
+ */
+/**
+ * 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 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/esm/escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escape.js","sourceRoot":"","sources":["../../src/escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,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/esm/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/esm/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"}

package/dist/esm/fast-paths.js

@@ -0,0 +1,209 @@
+/**
+ * @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
+ */
+// ============================================================================
+// PATTERN DETECTION REGEXES
+// These regexes detect which fast path to use. They are compiled once at
+// module load time and reused for all pattern checks.
+// ============================================================================
+/**
+ * Matches pure star patterns: *, **, ***
+ * Used for "match anything" patterns.
+ */
+const STAR_RE = /^\*+$/;
+/**
+ * Matches star-dot-extension patterns: *.js, *.ts, *.txt
+ * Captures the extension (including the dot).
+ * Excludes patterns with special glob characters in the extension.
+ */
+const STAR_DOT_EXT_RE = /^\*+(\.[^+@!?\*\[\(]+)$/;
+/**
+ * Matches star-dot-star patterns: *.*, **.*
+ * Used for "any file with an extension" matching.
+ */
+const STAR_DOT_STAR_RE = /^\*+\.\*+$/;
+/**
+ * Matches dot-star patterns: .*, .**
+ * Used for dotfile/hidden file matching.
+ */
+const DOT_STAR_RE = /^\.\*+$/;
+/**
+ * Matches question mark patterns: ?, ??, ???, ???.js
+ * Captures optional extension after the question marks.
+ * Used for exact-length matching.
+ */
+const QMARKS_RE = /^(\?+)(\.[^+@!?\*\[\(]+)?$/;
+// ============================================================================
+// FAST PATH IMPLEMENTATION
+// ============================================================================
+/**
+ * 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 function tryFastPath(path, pattern, options) {
+    // Skip if path contains / (need full path matching)
+    if (path.includes('/'))
+        return null;
+    // Skip if pattern has path separators (need full matching)
+    if (pattern.includes('/'))
+        return null;
+    // Skip if negated (need full matching for proper negation handling)
+    if (!options.nonegate && pattern.startsWith('!'))
+        return null;
+    // Skip if pattern has braces (need brace expansion)
+    if (!options.nobrace && pattern.includes('{'))
+        return null;
+    // Skip if pattern has extglob (need extglob handling)
+    if (!options.noext && /[@!?+*]\(/.test(pattern))
+        return null;
+    // Skip if pattern has character class (need regex)
+    if (pattern.includes('['))
+        return null;
+    const dot = options.dot ?? false;
+    const nocase = options.nocase ?? false;
+    let m;
+    // -------------------------------------------------------------------------
+    // Fast path: * (pure star)
+    // Matches any non-empty filename, respecting dot option
+    // -------------------------------------------------------------------------
+    if ((m = pattern.match(STAR_RE))) {
+        if (path.length === 0)
+            return false;
+        if (dot) {
+            // With dot option, match anything except . and ..
+            return path !== '.' && path !== '..';
+        }
+        // Without dot option, don't match dotfiles
+        return !path.startsWith('.');
+    }
+    // -------------------------------------------------------------------------
+    // Fast path: *.ext (star-dot-extension)
+    // Matches files ending with specific extension
+    // -------------------------------------------------------------------------
+    if ((m = pattern.match(STAR_DOT_EXT_RE))) {
+        const ext = m[1]; // Includes the dot, e.g., ".js"
+        if (path.length === 0)
+            return false;
+        if (nocase) {
+            const lpath = path.toLowerCase();
+            const lext = ext.toLowerCase();
+            if (dot)
+                return lpath.endsWith(lext);
+            return !path.startsWith('.') && lpath.endsWith(lext);
+        }
+        if (dot)
+            return path.endsWith(ext);
+        return !path.startsWith('.') && path.endsWith(ext);
+    }
+    // -------------------------------------------------------------------------
+    // Fast path: *.* (star-dot-star)
+    // Matches any file with an extension (contains a dot)
+    // -------------------------------------------------------------------------
+    if ((m = pattern.match(STAR_DOT_STAR_RE))) {
+        if (path.length === 0)
+            return false;
+        if (dot) {
+            // With dot, match anything with a dot except . and ..
+            return path !== '.' && path !== '..' && path.includes('.');
+        }
+        // Without dot, must have extension and not be a dotfile
+        return !path.startsWith('.') && path.includes('.');
+    }
+    // -------------------------------------------------------------------------
+    // Fast path: .* (dot-star)
+    // Matches hidden files (starting with dot)
+    // -------------------------------------------------------------------------
+    if ((m = pattern.match(DOT_STAR_RE))) {
+        // Must start with dot but not be . or ..
+        return path.startsWith('.') && path !== '.' && path !== '..';
+    }
+    // -------------------------------------------------------------------------
+    // Fast path: ??? (question marks with optional extension)
+    // Matches files with exact length
+    // -------------------------------------------------------------------------
+    if ((m = pattern.match(QMARKS_RE))) {
+        const qmarks = m[1]; // The question marks, e.g., "???"
+        const ext = m[2] ?? ''; // Optional extension, e.g., ".js"
+        const qLen = qmarks.length;
+        const expectedLen = qLen + ext.length;
+        if (path.length !== expectedLen)
+            return false;
+        // Never match . or .. (special directories)
+        if (path === '.' || path === '..')
+            return false;
+        if (ext) {
+            // Has extension - check length and extension match
+            if (nocase) {
+                const lpath = path.toLowerCase();
+                const lext = ext.toLowerCase();
+                if (!lpath.endsWith(lext))
+                    return false;
+            }
+            else {
+                if (!path.endsWith(ext))
+                    return false;
+            }
+        }
+        // Check dotfile restriction
+        if (!dot && path.startsWith('.'))
+            return false;
+        return true;
+    }
+    // No fast path available
+    return 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 function mightUseFastPath(pattern) {
+    // Fast paths only work for simple patterns without:
+    // - Path separators
+    // - Braces
+    // - Character classes
+    // - Extglob patterns
+    return (!pattern.includes('/') &&
+        !pattern.includes('{') &&
+        !pattern.includes('[') &&
+        !/[@!?+*]\(/.test(pattern));
+}
+//# sourceMappingURL=fast-paths.js.map