v0.4.0 disponible en npm

minimatch-fast

Alternativa directa a minimatch.
Hasta 36x más rápido. Cero vulnerabilidades.

npm install minimatch-fast

Empezar GitHub

motor picomatch
100% compatible con la API
TypeScript
ESM + CJS
402 tests

Licencia MIT

features

¿Por qué minimatch-fast?

La mejora de rendimiento y seguridad que tu coincidencia de globs necesita

Ultrarrápido

hasta 36x más rápido que minimatch. Impulsado por el motor picomatch con caché LRU y rutas rápidas optimizadas para los patrones más comunes.

Seguro

No vulnerable a CVE-2022-3517 (ReDoS). Protección integrada contra el backtracking catastrófico y los ataques DoS.

Estable

Nunca se congela con patrones como {1..1000}. Los límites en la expansión de llaves evitan bloqueos y problemas de memoria.

100% compatible

Alternativa directa con una API idéntica. 402 tests garantizan plena compatibilidad con el comportamiento de minimatch v10.x.

TypeScript listo

Soporte completo de TypeScript con definiciones de tipos incluidas. No hace falta instalar paquetes @types aparte.

Soporte dual de módulos

Funciona tanto con ESM como con CommonJS. Usa import o require(): ambos sistemas de módulos funcionan sin configuración.

benchmark

Benchmarks de rendimiento

Todos los escenarios superan a minimatch v10.x — 3 ejecuciones consecutivas estables, mediana de 21 rondas, corpus de 1000 rutas

Globbing en el mundo real (caché LRU caliente)

La carga de trabajo real de glob: las herramientas de build y los linters comparan un puñado de patrones contra miles de archivos. minimatch recompila en cada llamada; minimatch-fast cachea los patrones compilados. Esta asimetría es una característica del producto, reconocida abiertamente.

Patrón	minimatch	minimatch-fast	Aceleración
`{src,lib}/*/.{js,ts,tsx}`	88.0ms	2.4ms	36x más rápido
`@(foo\|bar\|baz).js`	—	—	~190x más rápido
`*.js`	—	—	~64x más rápido
`*/.js`	—	—	4.3x más rápido

Los números grandes vienen del early rejection: los patrones sin / se rechazan sin compilar para rutas con directorios, porque un segmento no puede cruzar /.

Motor contra motor (precompilado, sin caché)

La comparación más honesta: el mismo patrón precompilado en ambos lados, sin intervención de caché. El motor gana entre 2.4x y 12x en cada forma de patrón medida.

Patrón	minimatch	minimatch-fast
`file[0-9].js`	Referencia	12x más rápido
`@(foo\|bar\|baz).js`	Referencia	12x más rápido
`.js / !.test.js / ???.js`	Referencia	8-9x más rápido
`{src,lib}/*/.{js,ts,tsx}`	Referencia	3.4x más rápido
`*/.js / //*/.js`	Referencia	2.7x más rápido
`{src,lib}/*.js`	Referencia	2.4x más rápido

Compilación y llamadas en frío

El peor caso de uso: llamadas puntuales en las que cada patrón se compila. Incluso ahí, siempre por encima de la paridad.

Escenario	minimatch	minimatch-fast
`Compilar {src,lib}/*/.{js,ts,tsx}`	Referencia	5.7x más rápido
`Compilar @(foo\|bar\|baz).js (extglob)`	Referencia	3x más rápido
`Compilar .js / /.js`	Referencia	1.6-2.3x más rápido
`En frío @(foo\|bar\|baz).js (extglob)`	Referencia	~105x más rápido
`En frío *.js`	Referencia	~20x más rápido
`En frío llaves complejas`	Referencia	~4x más rápido
`En frío */.js`	Referencia	1.1-1.9x más rápido

Comparación de seguridad

Característica	minimatch	minimatch-fast
CVE-2022-3517 (ReDoS)	Vulnerable	No afectado
Patrón {1..1000}	Se congela	Instantáneo
Límite de expansión de llaves	Ninguno	10.000 máx

Node.js 22, Linux. Metodología: A/B/B/A intercalado, 5 rondas de calentamiento, mediana de 21 rondas, corpus determinista de 1000 rutas, 3 ejecuciones consecutivas estables. Reprodúcelo con npm run benchmark.

install

Instalación

Dos formas de migrar desde minimatch

opción 1 Actualizar los imports

Instala el paquete y actualiza tus sentencias de importación:

Terminal

npm uninstall minimatch
npm install minimatch-fast

Después, actualiza tus imports:

- const minimatch = require('minimatch');
+ const minimatch = require('minimatch-fast');

- import minimatch from 'minimatch';
+ import minimatch from 'minimatch-fast';

opción 2 npm aliasing

Sin tocar ni una línea de código. Usa el aliasing de paquetes de npm:

Terminal

npm install minimatch@npm:minimatch-fast

Esto instala minimatch-fast como minimatch, de modo que todos tus imports existentes siguen funcionando sin ningún cambio.

Nota: Esto también actualiza minimatch para todas tus dependencias que lo usan.

usage

Ejemplos de uso

Patrones comunes y casos de uso

Coincidencia básica

javascript

import minimatch from 'minimatch-fast';

// Basic matching
minimatch('foo.js', '*.js');    // true
minimatch('bar.txt', '*.js');   // false

// Globstar (recursive)
minimatch('src/utils/helpers.js', '**/*.js');  // true
minimatch('test/foo/bar.spec.ts', '**/*.ts');  // true

Coincidencia de arrays

javascript

import { minimatch } from 'minimatch-fast';

const files = ['foo.js', 'bar.js', 'baz.txt', 'qux.md'];

// Match array of files
minimatch.match(files, '*.js');
// => ['foo.js', 'bar.js']

minimatch.match(files, '*.{js,md}');
// => ['foo.js', 'bar.js', 'qux.md']

Función de filtro

javascript

import { minimatch } from 'minimatch-fast';

const files = ['src/index.js', 'src/utils.js', 'test/foo.spec.js'];

// Create a filter function
const isSource = minimatch.filter('src/**/*.js');

files.filter(isSource);
// => ['src/index.js', 'src/utils.js']

Clase Minimatch

javascript

import { Minimatch } from 'minimatch-fast';

// Pre-compile pattern for repeated matching
const mm = new Minimatch('**/*.js', { dot: true });

// Match multiple files efficiently
mm.match('src/index.js');     // true
mm.match('.eslintrc.js');     // true (dot: true)
mm.match('README.md');        // false

// Access the compiled regex
console.log(mm.regexp);       // /^(?:(?!...)...$/

Expansión de llaves

javascript

import { minimatch } from 'minimatch-fast';

// Brace expansion
minimatch.braceExpand('{a,b,c}');
// => ['a', 'b', 'c']

minimatch.braceExpand('{1..5}');
// => ['1', '2', '3', '4', '5']

minimatch.braceExpand('file{A,B}.{js,ts}');
// => ['fileA.js', 'fileA.ts', 'fileB.js', 'fileB.ts']

Escape / Unescape

javascript

import { minimatch } from 'minimatch-fast';

// Escape special characters
minimatch.escape('[foo].js');
// => '\\[foo\\].js'

// Unescape
minimatch.unescape('\\[foo\\].js');
// => '[foo].js'

patterns

Referencia de patrones glob

Guía completa de la sintaxis de patrones glob

Patrón	Descripción	Ejemplo
`*`	Coincide con cualquier carácter excepto los separadores de ruta	`*.js coincide con foo.js, bar.js`
`**`	Coincide con cualquier carácter incluidos los separadores de ruta (globstar)	`*/.js coincide con src/foo.js, a/b/c.js`
`?`	Coincide con exactamente un carácter (excepto el separador de ruta)	`?.js coincide con a.js, b.js`
`[abc]`	Coincide con cualquier carácter del conjunto	`[abc].js coincide con a.js, b.js, c.js`
`[a-z]`	Coincide con cualquier carácter del rango	`[a-z].js coincide con a.js hasta z.js`
`[!abc]`	Coincide con cualquier carácter que NO esté en el conjunto	`[!a].js coincide con b.js, c.js (no con a.js)`
`{a,b,c}`	Coincide con cualquiera de los patrones separados por comas	`{foo,bar}.js coincide con foo.js, bar.js`
`{1..5}`	Coincide con un rango numérico	`file{1..3}.js coincide con file1.js, file2.js, file3.js`
`{a..c}`	Coincide con un rango alfabético	`{a..c}.js coincide con a.js, b.js, c.js`
`!pattern`	Niega la coincidencia	`!*.min.js excluye los archivos minificados`
`?(a\|b)`	Coincide con cero o uno de los patrones	`?(foo).js coincide con .js, foo.js`
`*(a\|b)`	Coincide con cero o más de los patrones	`*(a\|b).js coincide con .js, a.js, ab.js, aab.js`
`+(a\|b)`	Coincide con uno o más de los patrones	`+(a\|b).js coincide con a.js, ab.js, aab.js`
`@(a\|b)`	Coincide con exactamente uno de los patrones	`@(foo\|bar).js coincide con foo.js, bar.js`

Clases de caracteres POSIX

Soporte completo de las expresiones de corchetes POSIX

Clase	Descripción	Ejemplo
`[[:alpha:]]`	Caracteres alfabéticos (a-z, A-Z)	`[[:alpha:]]*.txt coincide con file.txt`
`[[:digit:]]`	Dígitos numéricos (0-9)	`file[[:digit:]].js coincide con file1.js`
`[[:alnum:]]`	Alfanuméricos (letras y dígitos)	`[[:alnum:]] coincide con a, Z, 5`
`[[:space:]]`	Caracteres de espacio en blanco	`[[:space:]] coincide con espacio, tabulador`
`[[:upper:]]`	Letras mayúsculas	`[[:upper:]] coincide con A pero no con a`
`[[:lower:]]`	Letras minúsculas	`[[:lower:]] coincide con a pero no con A`
`[[:xdigit:]]`	Dígitos hexadecimales (0-9, a-f, A-F)	`[[:xdigit:]] coincide con 0, a, F`

Soporte Unicode

Soporte completo de Unicode y emoji en patrones y nombres de archivo

Patrón	Descripción	Coincidencias
`*.txt`	Soporte Unicode completo en nombres de archivo	`café.txt, 文件.txt, ファイル.txt`
`文件夹/*.js`	Unicode en los patrones	`coincide con 文件夹/test.js`
`{🎉,🎊}.txt`	Soporte de emoji	`🎉.txt, 🎊.txt`

api

Referencia de la API

Documentación completa de la API

minimatch(path, pattern, [options])

Comprueba una ruta contra un patrón. Devuelve true si la ruta coincide.

Parámetros

pathstringLa ruta a comprobar
patternstringEl patrón glob
optionsMinimatchOptionsConfiguración opcional

Devuelve

boolean

Ejemplo

minimatch('foo.js', '*.js'); // true
minimatch('foo/bar.js', '**/*.js'); // true

minimatch.match(list, pattern, [options])

Filtra un array de rutas y devuelve las que coinciden con el patrón.

Parámetros

liststring[]Array de rutas a filtrar
patternstringEl patrón glob
optionsMinimatchOptionsConfiguración opcional

Devuelve

string[]

Ejemplo

const files = ['a.js', 'b.ts', 'c.js'];
minimatch.match(files, '*.js');
// => ['a.js', 'c.js']

minimatch.filter(pattern, [options])

Crea una función de filtro para usar con Array.filter().

Parámetros

patternstringEl patrón glob
optionsMinimatchOptionsConfiguración opcional

Devuelve

(path: string) => boolean

Ejemplo

const isJS = minimatch.filter('*.js');
['a.js', 'b.ts'].filter(isJS);
// => ['a.js']

minimatch.makeRe(pattern, [options])

Crea una expresión regular a partir del patrón.

Parámetros

patternstringEl patrón glob
optionsMinimatchOptionsConfiguración opcional

Devuelve

RegExp | false

Ejemplo

minimatch.makeRe('*.js');
// => /^(?:(?!\.)...)\.js$/

minimatch.braceExpand(pattern, [options])

Expande los patrones con llaves en un array de patrones.

Parámetros

patternstringPatrón con llaves
optionsMinimatchOptionsConfiguración opcional

Devuelve

string[]

Ejemplo

minimatch.braceExpand('{a,b}{1,2}');
// => ['a1', 'a2', 'b1', 'b2']

minimatch.escape(str, [options])

Escapa los caracteres glob especiales de una cadena.

Parámetros

strstringCadena a escapar
options{ windowsPathsNoEscape?: boolean }Configuración opcional

Devuelve

string

Ejemplo

minimatch.escape('[foo].js');
// => '\\[foo\\].js'

minimatch.unescape(str, [options])

Elimina los caracteres de escape de una cadena.

Parámetros

strstringCadena a desescapar
options{ windowsPathsNoEscape?: boolean }Configuración opcional

Devuelve

string

Ejemplo

minimatch.unescape('\\[foo\\].js');
// => '[foo].js'

minimatch.defaults(options)

Crea una nueva función minimatch con opciones por defecto.

Parámetros

optionsMinimatchOptionsOpciones por defecto a aplicar

Devuelve

typeof minimatch

Ejemplo

const mm = minimatch.defaults({ nocase: true });
mm('FOO.js', '*.js'); // true

new Minimatch(pattern, [options])

Crea un matcher reutilizable para un patrón. Más eficiente al comparar el mismo patrón contra varias rutas.

Parámetros

patternstringEl patrón glob
optionsMinimatchOptionsConfiguración opcional

Devuelve

Minimatch

Ejemplo

const mm = new Minimatch('**/*.js');
mm.match('src/foo.js'); // true
mm.match('test/bar.js'); // true

options

Opciones

Opciones de configuración para afinar la coincidencia de patrones

Opciones principales minimatch compatible

Opción	Tipo	Por defecto	Descripción
`dot`	`boolean`	`false`	Coincide con dotfiles (archivos que empiezan por .). Por defecto, * y ? no coinciden con puntos iniciales.
`nocase`	`boolean`	`false`	Realiza la coincidencia sin distinguir mayúsculas de minúsculas.
`nonegate`	`boolean`	`false`	Suprime el comportamiento de negación con ! inicial.
`nobrace`	`boolean`	`false`	No expande patrones con llaves como {a,b,c}.
`noext`	`boolean`	`false`	Desactiva los patrones extglob como ?(a\|b), *(a\|b), etc.
`noglobstar`	`boolean`	`false`	Desactiva la coincidencia de ** a través de los límites de directorio.
`nocomment`	`boolean`	`false`	Suprime el tratamiento de # como carácter de comentario.
`matchBase`	`boolean`	`false`	Si el patrón no tiene barras, coincide con el basename de la ruta. foo coincide con bar/baz/foo.
`partial`	`boolean`	`false`	Coincidencia parcial: el patrón puede coincidir con una porción de la ruta.
`flipNegate`	`boolean`	`false`	Devuelve true para patrones negados que no coinciden.
`preserveMultipleSlashes`	`boolean`	`false`	No colapsa las barras múltiples (a//b se queda como a//b).
`optimizationLevel`	`number`	`1`	Nivel de optimización de la regex: 0 = ninguna, 1 = segura (por defecto), 2 = agresiva.
`platform`	`string`	`process.platform`	Plataforma para el manejo de rutas: "win32", "darwin", "linux", etc.
`windowsPathsNoEscape`	`boolean`	`false`	En Windows, trata \ como separador de ruta, no como carácter de escape.
`allowWindowsEscape`	`boolean`	`platform !== "win32"`	Permite \ como carácter de escape en Windows.
`nocaseMagicOnly`	`boolean`	`false`	Aplica nocase solo a las porciones mágicas del patrón.
`magicalBraces`	`boolean`	`false`	Trata la expansión de llaves como mágica (afecta a hasMagic()).
`debug`	`boolean`	`false`	Activa la salida de depuración.

Opciones extendidas nuevo en v0.3.0

Opción	Tipo	Por defecto	Descripción
`ignore`	`string \| string[]`	`undefined`	Patrones a excluir de la coincidencia.
`failglob`	`boolean`	`false`	Lanza un error si no se encuentran coincidencias (tiene prioridad sobre nonull).
`maxLength`	`number`	`65536`	Longitud máxima del patrón. Previene ataques ReDoS.
`expandRange`	`function`	`undefined`	Función personalizada para expandir rangos en patrones con llaves.
`bash`	`boolean`	`false`	Sigue las reglas de coincidencia de bash de forma más estricta.
`contains`	`boolean`	`false`	Coincide con el patrón en cualquier parte de la cadena (no solo coincidencia completa).
`format`	`function`	`undefined`	Función personalizada para formatear cadenas antes de la coincidencia.
`flags`	`string`	`undefined`	Flags de regex a usar en la regex generada.
`strictBrackets`	`boolean`	`false`	Lanza un error si hay corchetes, llaves o paréntesis desbalanceados.
`literalBrackets`	`boolean`	`false`	Escapa los corchetes para coincidir con [ y ] literales.
`keepQuotes`	`boolean`	`false`	Conserva las comillas en la regex generada.
`unescape`	`boolean`	`false`	Elimina las barras invertidas que preceden a los caracteres escapados.

Opciones de callback nuevo en v0.3.0

Opción	Tipo	Por defecto	Descripción
`onMatch`	`function`	`undefined`	Se llama cuando un patrón coincide. Recibe el objeto de resultado de la coincidencia.
`onIgnore`	`function`	`undefined`	Se llama cuando un patrón se ignora. Recibe el objeto de resultado de la coincidencia.
`onResult`	`function`	`undefined`	Se llama para todos los resultados. Recibe el objeto de resultado de la coincidencia.

Ejemplos

ignore

const mm = new Minimatch('**/*.js', {
  ignore: ['**/*.test.js', '**/node_modules/**']
});
mm.match('src/app.js');      // true
mm.match('src/app.test.js'); // false

failglob

// Throw if no matches found
minimatch.match(files, '*.ts', { failglob: true });
// Error: No matches found for pattern: *.ts

contains

// Match anywhere in string
minimatch('foobar', 'bar', { contains: true });
// true (matches substring)

format

// Transform paths before matching
const mm = new Minimatch('src/*.js', {
  format: (s) => s.replace(/^\.\//, '')
});
mm.match('./src/app.js'); // true

callbacks

const mm = new Minimatch('*.js', {
  onMatch: (r) => console.log('Match:', r.output),
  onResult: (r) => stats[r.isMatch ? 'hits' : 'miss']++
});

literalBrackets

// Match literal brackets in filenames
const mm = new Minimatch('[file].js', {
  literalBrackets: true
});
mm.match('[file].js'); // true

security

Seguridad

Protección integrada contra las vulnerabilidades más comunes

Protección contra CVE-2022-3517

El minimatch original es vulnerable a Regular Expression Denial of Service (ReDoS) a través de CVE-2022-3517. Los patrones maliciosos pueden provocar backtracking catastrófico y congelar tu aplicación.

minimatch-fast usa picomatch internamente, que está diseñado específicamente para evitar los problemas de backtracking y no es vulnerable a este CVE.

javascript

// CVE-2022-3517 - Vulnerable pattern in minimatch
// This causes catastrophic backtracking (ReDoS)
const pattern = '[!' + 'a'.repeat(50000) + ']';

// In minimatch: hangs for minutes or crashes
minimatch('test', pattern);

// In minimatch-fast: instant, no vulnerability
minimatch('test', pattern); // false, returns immediately

Límites en la expansión de llaves

La expansión de llaves sin restricciones puede explotarse para crear ataques de denegación de servicio. Un patrón como {1..1000000} generaría un millón de patrones, consumiendo toda la memoria disponible.

minimatch-fast limita la expansión de llaves a 10.000 patrones como máximo y la expansión de rangos a 1.000 elementos, previniendo ataques DoS.

javascript

// Dangerous brace expansion in minimatch
// This creates 1,000,000 patterns and freezes

const pattern = '{1..1000000}';
minimatch.braceExpand(pattern); // Hangs

// In minimatch-fast: limited to 10,000 max
// Returns original pattern if limit exceeded

Validación de entradas

El minimatch original acepta entradas inválidas que pueden causar comportamientos inesperados o errores en tiempo de ejecución en lo profundo de la pila de llamadas.

minimatch-fast valida por adelantado los argumentos de ruta y patrón, lanzando TypeErrors descriptivos de inmediato. La longitud del patrón también está limitada para prevenir DoS.

javascript

// minimatch-fast validates input types
// Prevents runtime errors and unexpected behavior

minimatch(null, '*.js');      // TypeError: path must be a string
minimatch('test', undefined); // TypeError: glob pattern must be a string
minimatch(123, '*.js');       // TypeError: path must be a string

// Pattern length limits prevent DoS
const veryLong = 'a'.repeat(100000);
minimatch('test', veryLong);  // TypeError: pattern too long

Características de seguridad

No afectado por CVE-2022-3517 (ReDoS)
Máximo de 10.000 patrones desde la expansión de llaves
Máximo de 1.000 elementos en la expansión de rangos ({1..N})
Sin backtracking catastrófico en las regex
Fallback elegante para patrones demasiado grandes
Validación de tipos de ruta y patrón
Límites de longitud del patrón (máx. 65.536 caracteres)

typescript

Soporte de TypeScript

Definiciones de tipos completas incluidas

minimatch-fast incluye definiciones completas de TypeScript. Todos los tipos se exportan y están listos para usar sin instalar paquetes @types aparte.

typescript

import minimatch, {
  Minimatch,
  MinimatchOptions,
  MMRegExp
} from 'minimatch-fast';

// Options with full type support
const options: MinimatchOptions = {
  dot: true,
  nocase: true,
  noglobstar: false
};

// Basic matching
const matches: boolean = minimatch('foo.js', '*.js', options);

// Minimatch class
const mm: Minimatch = new Minimatch('**/*.ts', options);
const isMatch: boolean = mm.match('src/index.ts');

// Get the compiled regex
const regex: MMRegExp | false = mm.makeRe();

// Filter function
const filter: (p: string) => boolean = minimatch.filter('*.js');

// Match array
const files: string[] = minimatch.match(['a.js', 'b.ts'], '*.js');

// Brace expansion
const expanded: string[] = minimatch.braceExpand('{a,b,c}');

Tipos exportados

minimatch - La función principal
Minimatch - La clase Minimatch
MinimatchOptions - Interfaz de opciones de configuración
MMRegExp - RegExp extendida con información de índice
ParseReturn - Tipo para los segmentos del patrón parseado
AST - Tipo para el árbol de sintaxis abstracta

tests

Testing y compatibilidad

Una suite de tests exhaustiva garantiza la fiabilidad

Tests unitarios

Tests de la funcionalidad principal

196

Tests de compatibilidad

Paridad de comportamiento con minimatch

Tests de casos límite

Rutas de Windows, opciones extendidas, dotfiles

Tests de seguridad

Tests de CVE-2022-3517 y validación de entradas

Tests de verificación

Clases POSIX, Unicode, casos límite de regex

Tests de regresión

Exactitud de la caché, alineación de hasMagic, makeRe y escape

402 tests en total

Cada release se verifica contra la suite de tests del minimatch original más tests adicionales para casos límite, rutas de Windows y vulnerabilidades de seguridad.

Ejecutar los tests

bash

# Run all tests
npm test

# Run with coverage
npm run test:coverage

# Run compatibility tests only
npm run test:compat

Reportar problemas

¿Encontraste un problema de compatibilidad? Abre un issue en GitHub con:

El patrón y la ruta que producen resultados distintos
Comportamiento esperado (lo que devuelve minimatch)
Comportamiento real (lo que devuelve minimatch-fast)
Cualquier opción relevante usada

Abrir un issue en GitHub

changelog

Changelog

Evolución del proyecto e historial de versiones

v0.4.0Actual

20/07/2026

Correcciones de exactitud de la caché
Paridad de hasMagic() y makeRe() con minimatch
Alineación 1:1 de escape/unescape
402 tests

corregidoLa clave de caché ahora incluye todas las opciones que afectan a la coincidencia (contains, bash, flags, ignore, maxLength, strictBrackets, literalBrackets, keepQuotes, unescape, magicalBraces)
corregidohasMagic() devuelve false para patrones literales, igual que minimatch
corregidomakeRe() respeta los patrones negados (!*.js), igual que minimatch
corregidoLa opción nonull ya no se filtra entre llamadas a través de la caché de patrones
cambiadoescape()/unescape() alineados 1:1 con minimatch: las llaves solo se escapan con magicalBraces: true
cambiadoLas rutas rápidas recurren al motor completo cuando hay opciones que no pueden respetar
seguridadmaxLength ahora también se aplica antes de la coincidencia por ruta rápida
seguridadReleases publicadas mediante npm trusted publishing (OIDC) con procedencia Sigstore
añadido24 nuevos tests de regresión (402 en total)

v0.3.0

01/02/2026

15 nuevas opciones de picomatch
Soporte de callbacks
Mejores mensajes de error
378 tests

añadidoOpciones extendidas de picomatch: ignore, failglob, maxLength, expandRange, bash, contains, format, flags
añadidoOpciones de corchetes: strictBrackets, literalBrackets, keepQuotes, unescape
añadidoOpciones de callback: onMatch, onIgnore, onResult
cambiadoMensajes de error de maxLength mejorados con la longitud del patrón y detalles del límite
cambiadofailglob ahora muestra cuántas rutas se buscaron
seguridadmaxLength ahora valida que sea un número finito positivo
añadido22 nuevos tests para las opciones extendidas

v0.2.3

01/02/2026

Validación de la entrada path
Mejoras de limpieza del código
Eliminación de código muerto
356 tests

seguridadAñadida validación de tipos para el parámetro path en minimatch()
cambiadoMensaje de error genérico sustituido por un mensaje descriptivo
eliminadoEliminado console.warn del código de la librería
eliminadoEliminado código muerto (hasMagicChars, escapeRegex, hasBraces)
cambiadoOperadores consistentes (?? en lugar de || para los valores por defecto)
añadidoTests para la validación de path (5 casos)

v0.2.2

31/01/2026

Auditoría de seguridad
Actualización de dependencias
Revisión de limpieza del código

seguridadAuditoría de seguridad completada
cambiadoDependencias actualizadas
cambiadoMejoras de limpieza del código

v0.2.1

19/01/2026

Validación de longitud del patrón
Landing page
Benchmarks

seguridadAñadida validación de longitud del patrón (máx. 65.536 caracteres)
añadidoLanding page con documentación
añadidoSuite de benchmarks comparando con el minimatch original

v0.2.0

29/12/2025

9.4x más rápido de media

Caché LRU de patrones (500 entradas)
Rutas rápidas para patrones simples
Caché de expansión de llaves (200 entradas)
Funciones de utilidad de caché

añadidoCaché de patrones para instancias compiladas de Minimatch
añadidoRutas rápidas para los patrones *, *.js, ???, .*
añadidoCaché de expansión de llaves
añadidoUtilidades clearCache() y getCacheSize()
cambiadoFlags de regex precalculados en la clase Minimatch
cambiadoExtracción de basename optimizada
cambiadoNormalización de rutas de Windows más inteligente

v0.1.0Release inicial

10/11/2025

7-29x más rápido

100% compatible con la API de minimatch
Impulsado por el motor picomatch
Soporte completo de TypeScript
Exports duales ESM/CJS

añadidoRelease inicial de minimatch-fast
añadido100% de compatibilidad con la API de minimatch v10.x
añadidoSoporte completo de TypeScript con definiciones de tipos
añadidoExports duales de módulos ESM y CommonJS
añadidoSuite de tests exhaustiva (302 tests)
añadidoPipeline de CI/CD con GitHub Actions
seguridadNo afectado por CVE-2022-3517 (ReDoS)
seguridadLímites en la expansión de llaves para prevenir DoS